


'''simple docstring'''







import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_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,
)


lowerCAmelCase    :     Tuple					=						logging.get_logger(__name__)

lowerCAmelCase    :     Any					=						OrderedDict(
    [
        ("""align""", """EfficientNetImageProcessor"""),
        ("""beit""", """BeitImageProcessor"""),
        ("""bit""", """BitImageProcessor"""),
        ("""blip""", """BlipImageProcessor"""),
        ("""blip-2""", """BlipImageProcessor"""),
        ("""bridgetower""", """BridgeTowerImageProcessor"""),
        ("""chinese_clip""", """ChineseCLIPImageProcessor"""),
        ("""clip""", """CLIPImageProcessor"""),
        ("""clipseg""", """ViTImageProcessor"""),
        ("""conditional_detr""", """ConditionalDetrImageProcessor"""),
        ("""convnext""", """ConvNextImageProcessor"""),
        ("""convnextv2""", """ConvNextImageProcessor"""),
        ("""cvt""", """ConvNextImageProcessor"""),
        ("""data2vec-vision""", """BeitImageProcessor"""),
        ("""deformable_detr""", """DeformableDetrImageProcessor"""),
        ("""deit""", """DeiTImageProcessor"""),
        ("""deta""", """DetaImageProcessor"""),
        ("""detr""", """DetrImageProcessor"""),
        ("""dinat""", """ViTImageProcessor"""),
        ("""donut-swin""", """DonutImageProcessor"""),
        ("""dpt""", """DPTImageProcessor"""),
        ("""efficientformer""", """EfficientFormerImageProcessor"""),
        ("""efficientnet""", """EfficientNetImageProcessor"""),
        ("""flava""", """FlavaImageProcessor"""),
        ("""focalnet""", """BitImageProcessor"""),
        ("""git""", """CLIPImageProcessor"""),
        ("""glpn""", """GLPNImageProcessor"""),
        ("""groupvit""", """CLIPImageProcessor"""),
        ("""imagegpt""", """ImageGPTImageProcessor"""),
        ("""instructblip""", """BlipImageProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2ImageProcessor"""),
        ("""layoutlmv3""", """LayoutLMv3ImageProcessor"""),
        ("""levit""", """LevitImageProcessor"""),
        ("""mask2former""", """Mask2FormerImageProcessor"""),
        ("""maskformer""", """MaskFormerImageProcessor"""),
        ("""mgp-str""", """ViTImageProcessor"""),
        ("""mobilenet_v1""", """MobileNetV1ImageProcessor"""),
        ("""mobilenet_v2""", """MobileNetV2ImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevitv2""", """MobileViTImageProcessor"""),
        ("""nat""", """ViTImageProcessor"""),
        ("""oneformer""", """OneFormerImageProcessor"""),
        ("""owlvit""", """OwlViTImageProcessor"""),
        ("""perceiver""", """PerceiverImageProcessor"""),
        ("""pix2struct""", """Pix2StructImageProcessor"""),
        ("""poolformer""", """PoolFormerImageProcessor"""),
        ("""regnet""", """ConvNextImageProcessor"""),
        ("""resnet""", """ConvNextImageProcessor"""),
        ("""sam""", """SamImageProcessor"""),
        ("""segformer""", """SegformerImageProcessor"""),
        ("""swiftformer""", """ViTImageProcessor"""),
        ("""swin""", """ViTImageProcessor"""),
        ("""swin2sr""", """Swin2SRImageProcessor"""),
        ("""swinv2""", """ViTImageProcessor"""),
        ("""table-transformer""", """DetrImageProcessor"""),
        ("""timesformer""", """VideoMAEImageProcessor"""),
        ("""tvlt""", """TvltImageProcessor"""),
        ("""upernet""", """SegformerImageProcessor"""),
        ("""van""", """ConvNextImageProcessor"""),
        ("""videomae""", """VideoMAEImageProcessor"""),
        ("""vilt""", """ViltImageProcessor"""),
        ("""vit""", """ViTImageProcessor"""),
        ("""vit_hybrid""", """ViTHybridImageProcessor"""),
        ("""vit_mae""", """ViTImageProcessor"""),
        ("""vit_msn""", """ViTImageProcessor"""),
        ("""xclip""", """CLIPImageProcessor"""),
        ("""yolos""", """YolosImageProcessor"""),
    ]
)

lowerCAmelCase    :     Optional[int]					=						_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)






def 			lowercase				(_A					)     ->   List[Any]:







       """simple docstring"""







       for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
              if class_name in extractors:
                     _lowerCAmelCase    :							int   			=       model_type_to_module_name(_A					)

                     _lowerCAmelCase    :							Tuple   			=       importlib.import_module(f'.{module_name}'   ,						'transformers.models'					)
                     try:
                            return getattr(_A   ,						_A					)
                     except AttributeError:
                            continue

       for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
              if getattr(_A   ,						'__name__'   ,						_A					) == class_name:
                     return extractor

    # 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.
       _lowerCAmelCase    :							List[Any]   			=       importlib.import_module('transformers'					)
       if hasattr(_A   ,						_A					):
              return getattr(_A   ,						_A					)

       return None






def 			lowercase				(_A   ,						_A = None   ,						_A = False   ,						_A = False   ,						_A = None   ,						_A = None   ,						_A = None   ,						_A = False   ,						**_A   ,						)     ->   Any:







       """simple docstring"""







       _lowerCAmelCase    :							Tuple   			=       get_file_from_repo(
           _A   ,						_A   ,						cache_dir=_A   ,						force_download=_A   ,						resume_download=_A   ,						proxies=_A   ,						use_auth_token=_A   ,						revision=_A   ,						local_files_only=_A   ,						)
       if resolved_config_file is None:
              logger.info(
                  'Could not locate the image processor configuration file, will try to use the model config instead.'					)
              return {}

       with open(_A   ,						encoding='utf-8'					) as reader:
              return json.load(_A					)
class 	UpperCamelCase__					:



     """simple docstring"""






     def __init__( self   ):

            '''simple docstring'''

            raise EnvironmentError(
                'AutoImageProcessor is designed to be instantiated '
                'using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.'   )







     @classmethod
     @replace_list_option_in_docstrings(snake_case__   )
     def a	( cls      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

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

            _lowerCAmelCase    :							str   			=       ImageProcessingMixin.get_image_processor_dict(snake_case__      ,	**snake_case__   )
            _lowerCAmelCase    :							Dict   			=       config_dict.get('image_processor_type'      ,	snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       None
            if "AutoImageProcessor" in config_dict.get('auto_map'      ,	{}   ):
                   _lowerCAmelCase    :							List[Any]   			=       config_dict['auto_map']['AutoImageProcessor']

            # If we still don't have the image processor class, check if we're loading from a previous feature extractor config
            # and if so, infer the image processor class from there.
            if image_processor_class is None and image_processor_auto_map is None:
                   _lowerCAmelCase    :							int   			=       config_dict.pop('feature_extractor_type'      ,	snake_case__   )
                   if feature_extractor_class is not None:
                          logger.warning(
                              'Could not find image processor class in the image processor config or the model config. Loading'
                              ' based on pattern matching with the model\'s feature extractor configuration.'   )
                          _lowerCAmelCase    :							List[str]   			=       feature_extractor_class.replace('FeatureExtractor'      ,	'ImageProcessor'   )
                   if "AutoFeatureExtractor" in config_dict.get('auto_map'      ,	{}   ):
                          _lowerCAmelCase    :							Optional[int]   			=       config_dict['auto_map']['AutoFeatureExtractor']
                          _lowerCAmelCase    :							Optional[int]   			=       feature_extractor_auto_map.replace('FeatureExtractor'      ,	'ImageProcessor'   )
                          logger.warning(
                              'Could not find image processor auto map in the image processor config or the model config.'
                              ' Loading based on pattern matching with the model\'s feature extractor configuration.'   )

        # If we don't find the image processor class in the image processor config, let's try the model config.
            if image_processor_class is None and image_processor_auto_map is None:
                   if not isinstance(snake_case__      ,	snake_case__   ):
                          _lowerCAmelCase    :							List[Any]   			=       AutoConfig.from_pretrained(snake_case__      ,	**snake_case__   )
                   # It could be in `config.image_processor_type``
                   _lowerCAmelCase    :							List[Any]   			=       getattr(snake_case__      ,	'image_processor_type'      ,	snake_case__   )
                   if hasattr(snake_case__      ,	'auto_map'   ) and "AutoImageProcessor" in config.auto_map:
                          _lowerCAmelCase    :							Tuple   			=       config.auto_map['AutoImageProcessor']

            if image_processor_class is not None:
                   _lowerCAmelCase    :							Optional[int]   			=       image_processor_class_from_name(snake_case__   )

            _lowerCAmelCase    :							List[str]   			=       image_processor_auto_map is not None
            _lowerCAmelCase    :							Optional[Any]   			=       image_processor_class is not None or type(snake_case__   ) in IMAGE_PROCESSOR_MAPPING
            _lowerCAmelCase    :							List[str]   			=       resolve_trust_remote_code(
                snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__   )

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

            raise ValueError(
                F'Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '
                F'`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '
                F'`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys()   )}'   )







     @staticmethod
     def a	( snake_case__      ,	snake_case__   ):

            '''simple docstring'''

            IMAGE_PROCESSOR_MAPPING.register(snake_case__      ,	snake_case__   )





'''simple docstring'''







import pytest

import datasets


# Import fixture modules as plugins
lowerCAmelCase    :     List[str]					=						["""tests.fixtures.files""", """tests.fixtures.hub""", """tests.fixtures.fsspec"""]






def 			lowercase				(_A   ,						_A					):







       """simple docstring"""







       for item in items:
              if any(marker in item.keywords for marker in ['integration', 'unit']					):
                     continue
              item.add_marker(pytest.mark.unit					)






def 			lowercase				(_A					):







       """simple docstring"""







       config.addinivalue_line('markers'   ,						'torchaudio_latest: mark test to run with torchaudio>=0.12'					)






@pytest.fixture(autouse=_A					)
def 			lowercase				(_A   ,						_A					):







       """simple docstring"""







       _lowerCAmelCase    :							str   			=       tmp_path_factory.getbasetemp() / 'cache'
       _lowerCAmelCase    :							Dict   			=       test_hf_cache_home / 'datasets'
       _lowerCAmelCase    :							List[Any]   			=       test_hf_cache_home / 'metrics'
       _lowerCAmelCase    :							List[Any]   			=       test_hf_cache_home / 'modules'
       monkeypatch.setattr('datasets.config.HF_DATASETS_CACHE'   ,						str(_A					)					)
       monkeypatch.setattr('datasets.config.HF_METRICS_CACHE'   ,						str(_A					)					)
       monkeypatch.setattr('datasets.config.HF_MODULES_CACHE'   ,						str(_A					)					)
       _lowerCAmelCase    :							Dict   			=       test_hf_datasets_cache / 'downloads'
       monkeypatch.setattr('datasets.config.DOWNLOADED_DATASETS_PATH'   ,						str(_A					)					)
       _lowerCAmelCase    :							Union[str, Any]   			=       test_hf_datasets_cache / 'downloads' / 'extracted'
       monkeypatch.setattr('datasets.config.EXTRACTED_DATASETS_PATH'   ,						str(_A					)					)






@pytest.fixture(autouse=_A   ,						scope='session'					)
def 			lowercase				():







       """simple docstring"""







       datasets.disable_progress_bar()






@pytest.fixture(autouse=_A					)
def 			lowercase				(_A					):







       """simple docstring"""







       monkeypatch.setattr('datasets.config.HF_UPDATE_DOWNLOAD_COUNTS'   ,						_A					)






@pytest.fixture
def 			lowercase				(_A					):







       """simple docstring"""







       monkeypatch.setattr('sqlalchemy.util.deprecations.SILENCE_UBER_WARNING'   ,						_A					)

