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

# 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 ...utils import CONFIG_NAME, 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,
)


SCREAMING_SNAKE_CASE__      						=  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__      						=  OrderedDict(
    [
        ("audio-spectrogram-transformer", "ASTFeatureExtractor"),
        ("beit", "BeitFeatureExtractor"),
        ("chinese_clip", "ChineseCLIPFeatureExtractor"),
        ("clap", "ClapFeatureExtractor"),
        ("clip", "CLIPFeatureExtractor"),
        ("clipseg", "ViTFeatureExtractor"),
        ("conditional_detr", "ConditionalDetrFeatureExtractor"),
        ("convnext", "ConvNextFeatureExtractor"),
        ("cvt", "ConvNextFeatureExtractor"),
        ("data2vec-audio", "Wav2Vec2FeatureExtractor"),
        ("data2vec-vision", "BeitFeatureExtractor"),
        ("deformable_detr", "DeformableDetrFeatureExtractor"),
        ("deit", "DeiTFeatureExtractor"),
        ("detr", "DetrFeatureExtractor"),
        ("dinat", "ViTFeatureExtractor"),
        ("donut-swin", "DonutFeatureExtractor"),
        ("dpt", "DPTFeatureExtractor"),
        ("encodec", "EncodecFeatureExtractor"),
        ("flava", "FlavaFeatureExtractor"),
        ("glpn", "GLPNFeatureExtractor"),
        ("groupvit", "CLIPFeatureExtractor"),
        ("hubert", "Wav2Vec2FeatureExtractor"),
        ("imagegpt", "ImageGPTFeatureExtractor"),
        ("layoutlmv2", "LayoutLMv2FeatureExtractor"),
        ("layoutlmv3", "LayoutLMv3FeatureExtractor"),
        ("levit", "LevitFeatureExtractor"),
        ("maskformer", "MaskFormerFeatureExtractor"),
        ("mctct", "MCTCTFeatureExtractor"),
        ("mobilenet_v1", "MobileNetV1FeatureExtractor"),
        ("mobilenet_v2", "MobileNetV2FeatureExtractor"),
        ("mobilevit", "MobileViTFeatureExtractor"),
        ("nat", "ViTFeatureExtractor"),
        ("owlvit", "OwlViTFeatureExtractor"),
        ("perceiver", "PerceiverFeatureExtractor"),
        ("poolformer", "PoolFormerFeatureExtractor"),
        ("regnet", "ConvNextFeatureExtractor"),
        ("resnet", "ConvNextFeatureExtractor"),
        ("segformer", "SegformerFeatureExtractor"),
        ("sew", "Wav2Vec2FeatureExtractor"),
        ("sew-d", "Wav2Vec2FeatureExtractor"),
        ("speech_to_text", "Speech2TextFeatureExtractor"),
        ("speecht5", "SpeechT5FeatureExtractor"),
        ("swiftformer", "ViTFeatureExtractor"),
        ("swin", "ViTFeatureExtractor"),
        ("swinv2", "ViTFeatureExtractor"),
        ("table-transformer", "DetrFeatureExtractor"),
        ("timesformer", "VideoMAEFeatureExtractor"),
        ("tvlt", "TvltFeatureExtractor"),
        ("unispeech", "Wav2Vec2FeatureExtractor"),
        ("unispeech-sat", "Wav2Vec2FeatureExtractor"),
        ("van", "ConvNextFeatureExtractor"),
        ("videomae", "VideoMAEFeatureExtractor"),
        ("vilt", "ViltFeatureExtractor"),
        ("vit", "ViTFeatureExtractor"),
        ("vit_mae", "ViTFeatureExtractor"),
        ("vit_msn", "ViTFeatureExtractor"),
        ("wav2vec2", "Wav2Vec2FeatureExtractor"),
        ("wav2vec2-conformer", "Wav2Vec2FeatureExtractor"),
        ("wavlm", "Wav2Vec2FeatureExtractor"),
        ("whisper", "WhisperFeatureExtractor"),
        ("xclip", "CLIPFeatureExtractor"),
        ("yolos", "YolosFeatureExtractor"),
    ]
)

SCREAMING_SNAKE_CASE__      						=  _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)





def    lowerCAmelCase__    (			_UpperCamelCase       :				str					)					->				Tuple:





						"""simple docstring"""






						for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
												if class_name in extractors:
																		snake_case								=			model_type_to_module_name(_UpperCamelCase					)

																		snake_case								=			importlib.import_module(f""".{module_name}""" ,			'transformers.models'					)
																		try:
																								return getattr(_UpperCamelCase ,			_UpperCamelCase					)
																		except AttributeError:
																								continue

						for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
												if getattr(_UpperCamelCase ,			'__name__' ,			_UpperCamelCase					) == 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.
						snake_case								=			importlib.import_module('transformers'					)
						if hasattr(_UpperCamelCase ,			_UpperCamelCase					):
												return getattr(_UpperCamelCase ,			_UpperCamelCase					)

						return None





def    lowerCAmelCase__    (			_UpperCamelCase       :				Union[str, os.PathLike] ,			_UpperCamelCase       :				Optional[Union[str, os.PathLike]] = None ,			_UpperCamelCase       :				bool = False ,			_UpperCamelCase       :				bool = False ,			_UpperCamelCase       :				Optional[Dict[str, str]] = None ,			_UpperCamelCase       :				Optional[Union[bool, str]] = None ,			_UpperCamelCase       :				Optional[str] = None ,			_UpperCamelCase       :				bool = False ,			**_UpperCamelCase       :				List[str] ,			)					->				Optional[Any]:





						"""simple docstring"""






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

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



class   lowerCAmelCase_    :



				"""simple docstring"""

				def __init__(				self    ):






										"""simple docstring"""

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

				@classmethod
				@replace_list_option_in_docstrings(_SCREAMING_SNAKE_CASE    )
				def 		snake_case (				cls		,    lowerCAmelCase		,    **lowerCAmelCase    ):






										"""simple docstring"""

										snake_case								=			kwargs.pop('config'		,    _SCREAMING_SNAKE_CASE    )
										snake_case								=			kwargs.pop('trust_remote_code'		,    _SCREAMING_SNAKE_CASE    )
										snake_case								=			True

										snake_case					,snake_case								=			FeatureExtractionMixin.get_feature_extractor_dict(_SCREAMING_SNAKE_CASE		,    **_SCREAMING_SNAKE_CASE    )
										snake_case								=			config_dict.get('feature_extractor_type'		,    _SCREAMING_SNAKE_CASE    )
										snake_case								=			None
										if "AutoFeatureExtractor" in config_dict.get('auto_map'		,    {}    ):
																snake_case								=			config_dict['auto_map']['AutoFeatureExtractor']

										# If we don't find the feature extractor class in the feature extractor config, let's try the model config.
										if feature_extractor_class is None and feature_extractor_auto_map is None:
																if not isinstance(_SCREAMING_SNAKE_CASE		,    _SCREAMING_SNAKE_CASE    ):
																						snake_case								=			AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		,    **_SCREAMING_SNAKE_CASE    )
																# It could be in `config.feature_extractor_type``
																snake_case								=			getattr(_SCREAMING_SNAKE_CASE		,    'feature_extractor_type'		,    _SCREAMING_SNAKE_CASE    )
																if hasattr(_SCREAMING_SNAKE_CASE		,    'auto_map'    ) and "AutoFeatureExtractor" in config.auto_map:
																						snake_case								=			config.auto_map['AutoFeatureExtractor']

										if feature_extractor_class is not None:
																snake_case								=			feature_extractor_class_from_name(_SCREAMING_SNAKE_CASE    )

										snake_case								=			feature_extractor_auto_map is not None
										snake_case								=			feature_extractor_class is not None or type(_SCREAMING_SNAKE_CASE    ) in FEATURE_EXTRACTOR_MAPPING
										snake_case								=			resolve_trust_remote_code(
										    _SCREAMING_SNAKE_CASE		,    _SCREAMING_SNAKE_CASE		,    _SCREAMING_SNAKE_CASE		,    _SCREAMING_SNAKE_CASE    )

										if has_remote_code and trust_remote_code:
																snake_case								=			get_class_from_dynamic_module(
																    _SCREAMING_SNAKE_CASE		,    _SCREAMING_SNAKE_CASE		,    **_SCREAMING_SNAKE_CASE    )
																snake_case								=			kwargs.pop('code_revision'		,    _SCREAMING_SNAKE_CASE    )
																if os.path.isdir(_SCREAMING_SNAKE_CASE    ):
																						feature_extractor_class.register_for_auto_class()
																return feature_extractor_class.from_dict(_SCREAMING_SNAKE_CASE		,    **_SCREAMING_SNAKE_CASE    )
										elif feature_extractor_class is not None:
																return feature_extractor_class.from_dict(_SCREAMING_SNAKE_CASE		,    **_SCREAMING_SNAKE_CASE    )
										# Last try: we use the FEATURE_EXTRACTOR_MAPPING.
										elif type(_SCREAMING_SNAKE_CASE    ) in FEATURE_EXTRACTOR_MAPPING:
																snake_case								=			FEATURE_EXTRACTOR_MAPPING[type(_SCREAMING_SNAKE_CASE    )]
																return feature_extractor_class.from_dict(_SCREAMING_SNAKE_CASE		,    **_SCREAMING_SNAKE_CASE    )

										raise ValueError(
										    F"""Unrecognized feature extractor in {pretrained_model_name_or_path}. Should have a """
										    F"""`feature_extractor_type` key in its {FEATURE_EXTRACTOR_NAME} of {CONFIG_NAME}, or one of the following """
										    F"""`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in FEATURE_EXTRACTOR_MAPPING_NAMES.keys()    )}"""    )

				@staticmethod
				def 		snake_case (				lowerCAmelCase		,    lowerCAmelCase    ):






										"""simple docstring"""

										FEATURE_EXTRACTOR_MAPPING.register(_SCREAMING_SNAKE_CASE		,    _SCREAMING_SNAKE_CASE    )



"""simple docstring"""
import unittest

import numpy as np

from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
					import torch

if is_vision_available():
					from PIL import Image

					from transformers import DonutImageProcessor



class   lowerCAmelCase_    (			unittest.TestCase					):



				"""simple docstring"""

				def __init__(				self		,    lowerCAmelCase		,    lowerCAmelCase=7		,    lowerCAmelCase=3		,    lowerCAmelCase=18		,    lowerCAmelCase=30		,    lowerCAmelCase=4_00		,    lowerCAmelCase=True		,    lowerCAmelCase=None		,    lowerCAmelCase=True		,    lowerCAmelCase=False		,    lowerCAmelCase=True		,    lowerCAmelCase=True		,    lowerCAmelCase=[0.5, 0.5, 0.5]		,    lowerCAmelCase=[0.5, 0.5, 0.5]		,    ):






										"""simple docstring"""

										snake_case								=			parent
										snake_case								=			batch_size
										snake_case								=			num_channels
										snake_case								=			image_size
										snake_case								=			min_resolution
										snake_case								=			max_resolution
										snake_case								=			do_resize
										snake_case								=			size if size is not None else {'height': 18, 'width': 20}
										snake_case								=			do_thumbnail
										snake_case								=			do_align_axis
										snake_case								=			do_pad
										snake_case								=			do_normalize
										snake_case								=			image_mean
										snake_case								=			image_std

				def 		snake_case (				self    ):






										"""simple docstring"""

										return {
										    "do_resize": self.do_resize,
										    "size": self.size,
										    "do_thumbnail": self.do_thumbnail,
										    "do_align_long_axis": self.do_align_axis,
										    "do_pad": self.do_pad,
										    "do_normalize": self.do_normalize,
										    "image_mean": self.image_mean,
										    "image_std": self.image_std,
										}





@require_torch
@require_vision
class   lowerCAmelCase_    (			lowerCAmelCase     ,    unittest.TestCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    str			  =						DonutImageProcessor if is_vision_available() else None

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			DonutImageProcessingTester(self    )

				@property
				def 		snake_case (				self    ):






										"""simple docstring"""

										return self.image_processor_tester.prepare_image_processor_dict()

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			self.image_processing_class(**self.image_processor_dict    )
										self.assertTrue(hasattr(lowerCAmelCase		,    'do_resize'    )    )
										self.assertTrue(hasattr(lowerCAmelCase		,    'size'    )    )
										self.assertTrue(hasattr(lowerCAmelCase		,    'do_thumbnail'    )    )
										self.assertTrue(hasattr(lowerCAmelCase		,    'do_align_long_axis'    )    )
										self.assertTrue(hasattr(lowerCAmelCase		,    'do_pad'    )    )
										self.assertTrue(hasattr(lowerCAmelCase		,    'do_normalize'    )    )
										self.assertTrue(hasattr(lowerCAmelCase		,    'image_mean'    )    )
										self.assertTrue(hasattr(lowerCAmelCase		,    'image_std'    )    )

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			self.image_processing_class.from_dict(self.image_processor_dict    )
										self.assertEqual(image_processor.size		,    {'height': 18, 'width': 20}    )

										snake_case								=			self.image_processing_class.from_dict(self.image_processor_dict		,    size=42    )
										self.assertEqual(image_processor.size		,    {'height': 42, 'width': 42}    )

										# Previous config had dimensions in (width, height) order
										snake_case								=			self.image_processing_class.from_dict(self.image_processor_dict		,    size=(42, 84)    )
										self.assertEqual(image_processor.size		,    {'height': 84, 'width': 42}    )

				def 		snake_case (				self    ):






										"""simple docstring"""

										pass

				@is_flaky()
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			self.image_processing_class(**self.image_processor_dict    )
										# create random PIL images
										snake_case								=			prepare_image_inputs(self.image_processor_tester		,    equal_resolution=lowerCAmelCase    )
										for image in image_inputs:
																self.assertIsInstance(lowerCAmelCase		,    Image.Image    )

										# Test not batched input
										snake_case								=			image_processing(image_inputs[0]		,    return_tensors='pt'    ).pixel_values
										self.assertEqual(
										    encoded_images.shape		,    (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['height'],
										        self.image_processor_tester.size['width'],
										    )		,    )

										# Test batched
										snake_case								=			image_processing(lowerCAmelCase		,    return_tensors='pt'    ).pixel_values
										self.assertEqual(
										    encoded_images.shape		,    (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['height'],
										        self.image_processor_tester.size['width'],
										    )		,    )

				@is_flaky()
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			self.image_processing_class(**self.image_processor_dict    )
										# create random numpy tensors
										snake_case								=			prepare_image_inputs(self.image_processor_tester		,    equal_resolution=lowerCAmelCase		,    numpify=lowerCAmelCase    )
										for image in image_inputs:
																self.assertIsInstance(lowerCAmelCase		,    np.ndarray    )

										# Test not batched input
										snake_case								=			image_processing(image_inputs[0]		,    return_tensors='pt'    ).pixel_values
										self.assertEqual(
										    encoded_images.shape		,    (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['height'],
										        self.image_processor_tester.size['width'],
										    )		,    )

										# Test batched
										snake_case								=			image_processing(lowerCAmelCase		,    return_tensors='pt'    ).pixel_values
										self.assertEqual(
										    encoded_images.shape		,    (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['height'],
										        self.image_processor_tester.size['width'],
										    )		,    )

				@is_flaky()
				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			self.image_processing_class(**self.image_processor_dict    )
										# create random PyTorch tensors
										snake_case								=			prepare_image_inputs(self.image_processor_tester		,    equal_resolution=lowerCAmelCase		,    torchify=lowerCAmelCase    )
										for image in image_inputs:
																self.assertIsInstance(lowerCAmelCase		,    torch.Tensor    )

										# Test not batched input
										snake_case								=			image_processing(image_inputs[0]		,    return_tensors='pt'    ).pixel_values
										self.assertEqual(
										    encoded_images.shape		,    (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['height'],
										        self.image_processor_tester.size['width'],
										    )		,    )

										# Test batched
										snake_case								=			image_processing(lowerCAmelCase		,    return_tensors='pt'    ).pixel_values
										self.assertEqual(
										    encoded_images.shape		,    (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.size['height'],
										        self.image_processor_tester.size['width'],
										    )		,    )


