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


lowerCAmelCase__					:       Tuple		=       logging.get_logger(__name__)

lowerCAmelCase__					:       str		=       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'''),
    ]
)

lowerCAmelCase__					:       List[Any]		=       _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
def 			UpperCamelCase__						(    A__   )       -> int:
				for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
								if class_name in processors:
												snake_case__ :     List[Any] 							=				model_type_to_module_name(A__   )

												snake_case__ :     Any 							=				importlib.import_module(F""".{module_name}"""      ,			'transformers.models'   )
												try:
																return getattr(A__      ,			A__   )
												except AttributeError:
																continue

				for processor in PROCESSOR_MAPPING._extra_content.values():
								if getattr(A__      ,			'__name__'      ,			A__   ) == 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.
				snake_case__ :     Optional[int] 							=				importlib.import_module('transformers'   )
				if hasattr(A__      ,			A__   ):
								return getattr(A__      ,			A__   )

				return None





class 			__snake_case  :




					def __init__(       self		)					->  Any:



									'''simple docstring'''







									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(__UpperCamelCase		)
					def       __a      (       cls   ,	__UpperCamelCase   ,	**__UpperCamelCase		)					->  Any:



									'''simple docstring'''







									snake_case__ :     Any 							=				kwargs.pop('config'   ,	__UpperCamelCase		)
									snake_case__ :     Optional[int] 							=				kwargs.pop('trust_remote_code'   ,	__UpperCamelCase		)
									snake_case__ :     Tuple 							=				True

									snake_case__ :     List[Any] 							=				None
									snake_case__ :     Optional[int] 							=				None

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

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

																	snake_case__ :     List[str] 							=				config_dict.get('processor_class'   ,	__UpperCamelCase		)
																	if "AutoProcessor" in config_dict.get('auto_map'   ,	{}		):
																					snake_case__ :     Optional[Any] 							=				config_dict['auto_map']['AutoProcessor']

									if processor_class is None:
													# Otherwise, load config, if it can be loaded.
													if not isinstance(__UpperCamelCase   ,	__UpperCamelCase		):
																	snake_case__ :     Optional[int] 							=				AutoConfig.from_pretrained(
																	    __UpperCamelCase   ,	trust_remote_code=__UpperCamelCase   ,	**__UpperCamelCase		)

													# And check if the config contains the processor class.
													snake_case__ :     Optional[Any] 							=				getattr(__UpperCamelCase   ,	'processor_class'   ,	__UpperCamelCase		)
													if hasattr(__UpperCamelCase   ,	'auto_map'		) and "AutoProcessor" in config.auto_map:
																	snake_case__ :     str 							=				config.auto_map['AutoProcessor']

									if processor_class is not None:
													snake_case__ :     Optional[int] 							=				processor_class_from_name(__UpperCamelCase		)

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

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

									# 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(
													    __UpperCamelCase   ,	trust_remote_code=__UpperCamelCase   ,	**__UpperCamelCase		)
									except Exception:
													try:
																	return AutoImageProcessor.from_pretrained(
																	    __UpperCamelCase   ,	trust_remote_code=__UpperCamelCase   ,	**__UpperCamelCase		)
													except Exception:
																	pass

													try:
																	return AutoFeatureExtractor.from_pretrained(
																	    __UpperCamelCase   ,	trust_remote_code=__UpperCamelCase   ,	**__UpperCamelCase		)
													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      (       __UpperCamelCase   ,	__UpperCamelCase		)					->  List[str]:



									'''simple docstring'''







									PROCESSOR_MAPPING.register(__UpperCamelCase   ,	__UpperCamelCase		)



import inspect
import os
import unittest

import torch

import accelerate
from accelerate import debug_launcher
from accelerate.test_utils import (
    execute_subprocess_async,
    require_cpu,
    require_multi_gpu,
    require_single_gpu,
    test_sync,
)
from accelerate.utils import patch_environment





class 			__snake_case  (      unittest.TestCase     ):




					def       __a      (       self		)					->  Union[str, Any]:



									'''simple docstring'''







									snake_case__ :     List[Any] 							=				inspect.getfile(accelerate.test_utils		)
									snake_case__ :     Tuple 							=				os.path.sep.join(mod_file.split(os.path.sep		)[:-1] + ['scripts', 'test_sync.py']		)




					@require_cpu
					def       __a      (       self		)					->  int:



									'''simple docstring'''







									debug_launcher(test_sync.main   ,	num_processes=1		)




					@require_cpu
					def       __a      (       self		)					->  Dict:



									'''simple docstring'''







									debug_launcher(test_sync.main		)




					@require_single_gpu
					def       __a      (       self		)					->  int:



									'''simple docstring'''







									test_sync.main()




					@require_multi_gpu
					def       __a      (       self		)					->  str:



									'''simple docstring'''







									print(F"""Found {torch.cuda.device_count()} devices."""		)
									snake_case__ :     Any 							=				['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", self.test_file_path]
									with patch_environment(omp_num_threads=1		):
													execute_subprocess_async(__UpperCamelCase   ,	env=os.environ.copy()		)


