


"""simple docstring"""






from collections import Counter
from pathlib import Path
from typing import Optional, Tuple

import yaml


class     __lowerCamelCase  (							yaml.SafeLoader				):

     '''simple docstring'''


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase							)       ->							Optional[Any]:
          _a    	=				[self.constructed_objects[key_node] for key_node, _ in node.value]
          _a    	=				[tuple(__UpperCAmelCase							) if isinstance(__UpperCAmelCase    ,				__UpperCAmelCase							) else key for key in keys]
          _a    	=				Counter(__UpperCAmelCase							)
          _a    	=				[key for key in counter if counter[key] > 1]
          if duplicate_keys:
               raise TypeError(F'Got duplicate yaml keys: {duplicate_keys}'							)





     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase=False							)       ->							Any:
          _a    	=				super().construct_mapping(__UpperCAmelCase    ,				deep=__UpperCAmelCase							)
          self._check_no_duplicates_on_constructed_node(__UpperCAmelCase							)
          return mapping







def       A_   (   _lowerCAmelCase     :					str       ):






     """simple docstring"""

     _a    	=				list(readme_content.splitlines()       )
     if full_content and full_content[0] == "---" and "---" in full_content[1:]:
          _a    	=				full_content[1:].index('''---'''       ) + 1
          _a    	=				'''\n'''.join(full_content[1:sep_idx]       )
          return yamlblock, "\n".join(full_content[sep_idx + 1 :]       )

     return None, "\n".join(_lowerCAmelCase       )


class     __lowerCamelCase  (							a__				):

     '''simple docstring'''
     A_       :	Union[str, Any]    =		{'train_eval_index'}  # train-eval-index in the YAML metadata


     @classmethod
     def 							_UpperCAmelCase      (      cls    ,				__UpperCAmelCase							)       ->							"DatasetMetadata":
          with open(__UpperCAmelCase    ,				encoding='''utf-8'''							) as readme_file:
               _a	,      _a    	=				_split_yaml_from_readme(readme_file.read()							)
          if yaml_string is not None:
               return cls.from_yaml_string(__UpperCAmelCase							)
          else:
               return cls()


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase							)       ->							Optional[Any]:
          if path.exists():
               with open(__UpperCAmelCase    ,				encoding='''utf-8'''							) as readme_file:
                    _a    	=				readme_file.read()
          else:
               _a    	=				None
          _a    	=				self._to_readme(__UpperCAmelCase							)
          with open(__UpperCAmelCase    ,				'''w'''    ,				encoding='''utf-8'''							) as readme_file:
               readme_file.write(__UpperCAmelCase							)


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase = None							)       ->							str:
          if readme_content is not None:
               _a	,      _a    	=				_split_yaml_from_readme(__UpperCAmelCase							)
               _a    	=				'''---\n''' + self.to_yaml_string() + '''---\n''' + content
          else:
               _a    	=				'''---\n''' + self.to_yaml_string() + '''---\n'''
          return full_content


     @classmethod
     def 							_UpperCAmelCase      (      cls    ,				__UpperCAmelCase							)       ->							"DatasetMetadata":
          _a    	=				yaml.load(__UpperCAmelCase    ,				Loader=_NoDuplicateSafeLoader							) or {}

          # Convert the YAML keys to DatasetMetadata fields
          _a    	=				{
              (key.replace('''-'''    ,				'''_'''							) if key.replace('''-'''    ,				'''_'''							) in cls._FIELDS_WITH_DASHES else key): value
              for key, value in metadata_dict.items()
          }
          return cls(**__UpperCAmelCase							)





     def 							_UpperCAmelCase      (      self							)       ->							str:
          return yaml.safe_dump(
              {
                  (key.replace('''_'''    ,				'''-'''							) if key in self._FIELDS_WITH_DASHES else key): value
                  for key, value in self.items()
              }    ,				sort_keys=__UpperCAmelCase    ,				allow_unicode=__UpperCAmelCase    ,				encoding='''utf-8'''    ,				).decode('''utf-8'''							)







__snake_case		=       {
    '''image-classification''': [],
    '''translation''': [],
    '''image-segmentation''': [],
    '''fill-mask''': [],
    '''automatic-speech-recognition''': [],
    '''token-classification''': [],
    '''sentence-similarity''': [],
    '''audio-classification''': [],
    '''question-answering''': [],
    '''summarization''': [],
    '''zero-shot-classification''': [],
    '''table-to-text''': [],
    '''feature-extraction''': [],
    '''other''': [],
    '''multiple-choice''': [],
    '''text-classification''': [],
    '''text-to-image''': [],
    '''text2text-generation''': [],
    '''zero-shot-image-classification''': [],
    '''tabular-classification''': [],
    '''tabular-regression''': [],
    '''image-to-image''': [],
    '''tabular-to-text''': [],
    '''unconditional-image-generation''': [],
    '''text-retrieval''': [],
    '''text-to-speech''': [],
    '''object-detection''': [],
    '''audio-to-audio''': [],
    '''text-generation''': [],
    '''conversational''': [],
    '''table-question-answering''': [],
    '''visual-question-answering''': [],
    '''image-to-text''': [],
    '''reinforcement-learning''': [],
    '''voice-activity-detection''': [],
    '''time-series-forecasting''': [],
    '''document-question-answering''': [],
}


if __name__ == "__main__":
   from argparse import ArgumentParser

   __snake_case		=       ArgumentParser(usage='''Validate the yaml metadata block of a README.md file.''')
   ap.add_argument('''readme_filepath''')
   __snake_case		=       ap.parse_args()

   __snake_case		=       Path(args.readme_filepath)
   __snake_case		=       DatasetMetadata.from_readme(readme_filepath)
   print(dataset_metadata)
   dataset_metadata.to_readme(readme_filepath)



"""simple docstring"""






import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class     __lowerCamelCase  (					a__				):

     '''simple docstring'''
     A_       :	Optional[int]    =		['image_processor', 'tokenizer']
     A_       :	Union[str, Any]    =		'ChineseCLIPImageProcessor'
     A_       :	Union[str, Any]    =		('BertTokenizer', 'BertTokenizerFast')


     def __init__(      self    ,				__UpperCAmelCase=None    ,				__UpperCAmelCase=None    ,				**__UpperCAmelCase							)       ->							List[str]:
          _a    	=				None
          if "feature_extractor" in kwargs:
               warnings.warn(
                   '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
                   ''' instead.'''    ,				__UpperCAmelCase    ,				)
               _a    	=				kwargs.pop('''feature_extractor'''							)

          _a    	=				image_processor if image_processor is not None else feature_extractor
          if image_processor is None:
               raise ValueError('''You need to specify an `image_processor`.'''							)
          if tokenizer is None:
               raise ValueError('''You need to specify a `tokenizer`.'''							)

          super().__init__(__UpperCAmelCase    ,				__UpperCAmelCase							)
          _a    	=				self.image_processor


     def __call__(      self    ,				__UpperCAmelCase=None    ,				__UpperCAmelCase=None    ,				__UpperCAmelCase=None    ,				**__UpperCAmelCase							)       ->							List[str]:

          if text is None and images is None:
               raise ValueError('''You have to specify either text or images. Both cannot be none.'''							)

          if text is not None:
               _a    	=				self.tokenizer(__UpperCAmelCase    ,				return_tensors=__UpperCAmelCase    ,				**__UpperCAmelCase							)

          if images is not None:
               _a    	=				self.image_processor(__UpperCAmelCase    ,				return_tensors=__UpperCAmelCase    ,				**__UpperCAmelCase							)

          if text is not None and images is not None:
               _a    	=				image_features.pixel_values
               return encoding
          elif text is not None:
               return encoding
          else:
               return BatchEncoding(data=dict(**__UpperCAmelCase							)    ,				tensor_type=__UpperCAmelCase							)


     def 							_UpperCAmelCase      (      self    ,				*__UpperCAmelCase    ,				**__UpperCAmelCase							)       ->							List[str]:
          return self.tokenizer.batch_decode(*__UpperCAmelCase    ,				**__UpperCAmelCase							)


     def 							_UpperCAmelCase      (      self    ,				*__UpperCAmelCase    ,				**__UpperCAmelCase							)       ->							Optional[int]:
          return self.tokenizer.decode(*__UpperCAmelCase    ,				**__UpperCAmelCase							)


     @property
     def 							_UpperCAmelCase      (      self							)       ->							List[str]:
          _a    	=				self.tokenizer.model_input_names
          _a    	=				self.image_processor.model_input_names
          return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names							)							)





     @property
     def 							_UpperCAmelCase      (      self							)       ->							Tuple:
          warnings.warn(
              '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''    ,				__UpperCAmelCase    ,				)
          return self.image_processor_class