
import importlib
import inspect
import json
import os
from collections import OrderedDict

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


__snake_case					:							Tuple           =							logging.get_logger(__name__)

__snake_case					:							Any           =							OrderedDict(
    [
        ('align', 'AlignProcessor'),
        ('altclip', 'AltCLIPProcessor'),
        ('bark', 'BarkProcessor'),
        ('blip', 'BlipProcessor'),
        ('blip-2', 'Blip2Processor'),
        ('bridgetower', 'BridgeTowerProcessor'),
        ('chinese_clip', 'ChineseCLIPProcessor'),
        ('clap', 'ClapProcessor'),
        ('clip', 'CLIPProcessor'),
        ('clipseg', 'CLIPSegProcessor'),
        ('flava', 'FlavaProcessor'),
        ('git', 'GitProcessor'),
        ('groupvit', 'CLIPProcessor'),
        ('hubert', 'Wav2Vec2Processor'),
        ('instructblip', 'InstructBlipProcessor'),
        ('layoutlmv2', 'LayoutLMv2Processor'),
        ('layoutlmv3', 'LayoutLMv3Processor'),
        ('markuplm', 'MarkupLMProcessor'),
        ('mctct', 'MCTCTProcessor'),
        ('mgp-str', 'MgpstrProcessor'),
        ('oneformer', 'OneFormerProcessor'),
        ('owlvit', 'OwlViTProcessor'),
        ('pix2struct', 'Pix2StructProcessor'),
        ('sam', 'SamProcessor'),
        ('sew', 'Wav2Vec2Processor'),
        ('sew-d', 'Wav2Vec2Processor'),
        ('speech_to_text', 'Speech2TextProcessor'),
        ('speech_to_text_2', 'Speech2Text2Processor'),
        ('speecht5', 'SpeechT5Processor'),
        ('trocr', 'TrOCRProcessor'),
        ('tvlt', 'TvltProcessor'),
        ('unispeech', 'Wav2Vec2Processor'),
        ('unispeech-sat', 'Wav2Vec2Processor'),
        ('vilt', 'ViltProcessor'),
        ('vision-text-dual-encoder', 'VisionTextDualEncoderProcessor'),
        ('wav2vec2', 'Wav2Vec2Processor'),
        ('wav2vec2-conformer', 'Wav2Vec2Processor'),
        ('wavlm', 'Wav2Vec2Processor'),
        ('whisper', 'WhisperProcessor'),
        ('xclip', 'XCLIPProcessor'),
    ]
)

__snake_case					:							str           =							_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)




def 		A						(  SCREAMING_SNAKE_CASE							):




			"""simple docstring"""


			for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
						if class_name in processors:
									UpperCAmelCase__		:List[str] 		=    model_type_to_module_name(SCREAMING_SNAKE_CASE							)

									UpperCAmelCase__		:Optional[int] 		=    importlib.import_module(f""".{module_name}"""     ,						'transformers.models'							)
									try:
												return getattr(SCREAMING_SNAKE_CASE     ,						SCREAMING_SNAKE_CASE							)
									except AttributeError:
												continue

			for processor in PROCESSOR_MAPPING._extra_content.values():
						if getattr(SCREAMING_SNAKE_CASE     ,						'__name__'     ,						SCREAMING_SNAKE_CASE							) == class_name:
									return processor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
			UpperCAmelCase__		:Dict 		=    importlib.import_module('transformers'							)
			if hasattr(SCREAMING_SNAKE_CASE     ,						SCREAMING_SNAKE_CASE							):
						return getattr(SCREAMING_SNAKE_CASE     ,						SCREAMING_SNAKE_CASE							)

			return None




class 	UpperCamelCase__       :

						'''simple docstring'''



						def __init__(  self	)  ->Optional[Any]:
									raise EnvironmentError(
									    'AutoProcessor is designed to be instantiated '
									    'using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method.'	)


						@classmethod
						@replace_list_option_in_docstrings(lowerCamelCase_	)
						def    A__       (  cls  , A  , **A	)  ->Optional[int]:
									UpperCAmelCase__		:Dict 		=    kwargs.pop('config'  , lowerCamelCase_	)
									UpperCAmelCase__		:List[Any] 		=    kwargs.pop('trust_remote_code'  , lowerCamelCase_	)
									UpperCAmelCase__		:Optional[Any] 		=    True

									UpperCAmelCase__		:Union[str, Any] 		=    None
									UpperCAmelCase__		:Optional[Any] 		=    None

									# First, let's see if we have a preprocessor config.
									# Filter the kwargs for `get_file_from_repo`.
									UpperCAmelCase__		:int 		=    {
									    key: kwargs[key] for key in inspect.signature(lowerCamelCase_	).parameters.keys() if key in kwargs
									}
									# Let's start by checking whether the processor class is saved in an image processor
									UpperCAmelCase__		:Union[str, Any] 		=    get_file_from_repo(
									    lowerCamelCase_  , lowerCamelCase_  , **lowerCamelCase_	)
									if preprocessor_config_file is not None:
												UpperCAmelCase__		,       UpperCAmelCase__		:Optional[Any] 		=    ImageProcessingMixin.get_image_processor_dict(lowerCamelCase_  , **lowerCamelCase_	)
												UpperCAmelCase__		:Any 		=    config_dict.get('processor_class'  , lowerCamelCase_	)
												if "AutoProcessor" in config_dict.get('auto_map'  , {}	):
															UpperCAmelCase__		:Any 		=    config_dict['auto_map']['AutoProcessor']

        # If not found, let's check whether the processor class is saved in a feature extractor config
									if preprocessor_config_file is not None and processor_class is None:
												UpperCAmelCase__		,       UpperCAmelCase__		:List[Any] 		=    FeatureExtractionMixin.get_feature_extractor_dict(lowerCamelCase_  , **lowerCamelCase_	)
												UpperCAmelCase__		:Dict 		=    config_dict.get('processor_class'  , lowerCamelCase_	)
												if "AutoProcessor" in config_dict.get('auto_map'  , {}	):
															UpperCAmelCase__		:Dict 		=    config_dict['auto_map']['AutoProcessor']

									if processor_class is None:
												# Next, let's check whether the processor class is saved in a tokenizer
												UpperCAmelCase__		:Optional[Any] 		=    get_file_from_repo(
												    lowerCamelCase_  , lowerCamelCase_  , **lowerCamelCase_	)
												if tokenizer_config_file is not None:
															with open(lowerCamelCase_  , encoding='utf-8'	) as reader:
																		UpperCAmelCase__		:Dict 		=    json.load(lowerCamelCase_	)

															UpperCAmelCase__		:Optional[int] 		=    config_dict.get('processor_class'  , lowerCamelCase_	)
															if "AutoProcessor" in config_dict.get('auto_map'  , {}	):
																		UpperCAmelCase__		:int 		=    config_dict['auto_map']['AutoProcessor']

									if processor_class is None:
												# Otherwise, load config, if it can be loaded.
												if not isinstance(lowerCamelCase_  , lowerCamelCase_	):
															UpperCAmelCase__		:Any 		=    AutoConfig.from_pretrained(
															    lowerCamelCase_  , trust_remote_code=lowerCamelCase_  , **lowerCamelCase_	)

												# And check if the config contains the processor class.
												UpperCAmelCase__		:Tuple 		=    getattr(lowerCamelCase_  , 'processor_class'  , lowerCamelCase_	)
												if hasattr(lowerCamelCase_  , 'auto_map'	) and "AutoProcessor" in config.auto_map:
															UpperCAmelCase__		:Optional[int] 		=    config.auto_map['AutoProcessor']

									if processor_class is not None:
												UpperCAmelCase__		:Union[str, Any] 		=    processor_class_from_name(lowerCamelCase_	)

									UpperCAmelCase__		:Union[str, Any] 		=    processor_auto_map is not None
									UpperCAmelCase__		:int 		=    processor_class is not None or type(lowerCamelCase_	) in PROCESSOR_MAPPING
									UpperCAmelCase__		:Union[str, Any] 		=    resolve_trust_remote_code(
									    lowerCamelCase_  , lowerCamelCase_  , lowerCamelCase_  , lowerCamelCase_	)

									if has_remote_code and trust_remote_code:
												UpperCAmelCase__		:Dict 		=    get_class_from_dynamic_module(
												    lowerCamelCase_  , lowerCamelCase_  , **lowerCamelCase_	)
												UpperCAmelCase__		:List[Any] 		=    kwargs.pop('code_revision'  , lowerCamelCase_	)
												if os.path.isdir(lowerCamelCase_	):
															processor_class.register_for_auto_class()
												return processor_class.from_pretrained(
												    lowerCamelCase_  , trust_remote_code=lowerCamelCase_  , **lowerCamelCase_	)
									elif processor_class is not None:
												return processor_class.from_pretrained(
												    lowerCamelCase_  , trust_remote_code=lowerCamelCase_  , **lowerCamelCase_	)
									# Last try: we use the PROCESSOR_MAPPING.
									elif type(lowerCamelCase_	) in PROCESSOR_MAPPING:
												return PROCESSOR_MAPPING[type(lowerCamelCase_	)].from_pretrained(lowerCamelCase_  , **lowerCamelCase_	)

									# At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
									# tokenizer.
									try:
												return AutoTokenizer.from_pretrained(
												    lowerCamelCase_  , trust_remote_code=lowerCamelCase_  , **lowerCamelCase_	)
									except Exception:
												try:
															return AutoImageProcessor.from_pretrained(
															    lowerCamelCase_  , trust_remote_code=lowerCamelCase_  , **lowerCamelCase_	)
												except Exception:
															pass

												try:
															return AutoFeatureExtractor.from_pretrained(
															    lowerCamelCase_  , trust_remote_code=lowerCamelCase_  , **lowerCamelCase_	)
												except Exception:
															pass

									raise ValueError(
									    F"""Unrecognized processing class in {pretrained_model_name_or_path}. Can\'t instantiate a processor, a """
									    'tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains'
									    'the files of at least one of those processing classes.'	)


						@staticmethod
						def    A__       (  A  , A	)  ->Union[str, Any]:
									PROCESSOR_MAPPING.register(lowerCamelCase_  , lowerCamelCase_	)










import platform
from argparse import ArgumentParser

import huggingface_hub
import pandas
import pyarrow

from datasets import __version__ as version
from datasets.commands import BaseDatasetsCLICommand






def        a( A			:       Dict			)						->			Optional[int]:
					"""simple docstring"""





					return EnvironmentCommand()







class       _lowercase				(  lowerCAmelCase      ):





	"""simple docstring"""




	@staticmethod
	def 	UpperCamelCase_			(lowerCamelCase_						):
						"""simple docstring"""

						a   	=  parser.add_parser("env"						,			help="Print relevant system environment info."						)
						download_parser.set_defaults(func=lowerCamelCase_						)




	def 	UpperCamelCase_			(self						):
						"""simple docstring"""

						a   	=  {
						    "`datasets` version": version,
						    "Platform": platform.platform(),
						    "Python version": platform.python_version(),
						    "Huggingface_hub version": huggingface_hub.__version__,
						    "PyArrow version": pyarrow.__version__,
						    "Pandas version": pandas.__version__,
						}

						print("\nCopy-and-paste the text below in your GitHub issue.\n"						)
						print(self.format_dict(lowerCamelCase_						)						)

						return info




	@staticmethod
	def 	UpperCamelCase_			(lowerCamelCase_						):
						"""simple docstring"""

						return "\n".join([F'''- {prop}: {val}''' for prop, val in d.items()]						) + "\n"
