




'''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,
)


__A						:							Tuple							=  logging.get_logger(__name__)

__A						:							Union[str, 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"""),
    ]
)

__A						:							Union[str, Any]							=  _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
						if class_name in extractors:
									SCREAMING_SNAKE_CASE           =					model_type_to_module_name(SCREAMING_SNAKE_CASE   )

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

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

			return None
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE = None					,	SCREAMING_SNAKE_CASE = False					,	SCREAMING_SNAKE_CASE = False					,	SCREAMING_SNAKE_CASE = None					,	SCREAMING_SNAKE_CASE = None					,	SCREAMING_SNAKE_CASE = None					,	SCREAMING_SNAKE_CASE = False					,	**SCREAMING_SNAKE_CASE					,	):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					get_file_from_repo(
			    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	cache_dir=SCREAMING_SNAKE_CASE					,	force_download=SCREAMING_SNAKE_CASE					,	resume_download=SCREAMING_SNAKE_CASE					,	proxies=SCREAMING_SNAKE_CASE					,	use_auth_token=SCREAMING_SNAKE_CASE					,	revision=SCREAMING_SNAKE_CASE					,	local_files_only=SCREAMING_SNAKE_CASE					,	)
			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(SCREAMING_SNAKE_CASE					,	encoding="""utf-8"""   ) as reader:
						return json.load(SCREAMING_SNAKE_CASE   )




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	List[Any]			)			->					Optional[int]:
										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(a			)
							def    _UpperCAmelCase     (					cls       :	List[str]       ,     a       :	Dict       ,     **a       :	List[str]			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					kwargs.pop("""config"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					kwargs.pop("""trust_remote_code"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					True

										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					ImageProcessingMixin.get_image_processor_dict(a       ,     **a			)
										SCREAMING_SNAKE_CASE           =					config_dict.get("""image_processor_type"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					None
										if "AutoImageProcessor" in config_dict.get("""auto_map"""       ,     {}			):
													SCREAMING_SNAKE_CASE           =					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:
													SCREAMING_SNAKE_CASE           =					config_dict.pop("""feature_extractor_type"""       ,     a			)
													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."""			)
																SCREAMING_SNAKE_CASE           =					feature_extractor_class.replace("""FeatureExtractor"""       ,     """ImageProcessor"""			)
													if "AutoFeatureExtractor" in config_dict.get("""auto_map"""       ,     {}			):
																SCREAMING_SNAKE_CASE           =					config_dict["""auto_map"""]["""AutoFeatureExtractor"""]
																SCREAMING_SNAKE_CASE           =					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(a       ,     a			):
																SCREAMING_SNAKE_CASE           =					AutoConfig.from_pretrained(a       ,     **a			)
													# It could be in `config.image_processor_type``
													SCREAMING_SNAKE_CASE           =					getattr(a       ,     """image_processor_type"""       ,     a			)
													if hasattr(a       ,     """auto_map"""			) and "AutoImageProcessor" in config.auto_map:
																SCREAMING_SNAKE_CASE           =					config.auto_map["""AutoImageProcessor"""]

										if image_processor_class is not None:
													SCREAMING_SNAKE_CASE           =					image_processor_class_from_name(a			)

										SCREAMING_SNAKE_CASE           =					image_processor_auto_map is not None
										SCREAMING_SNAKE_CASE           =					image_processor_class is not None or type(a			) in IMAGE_PROCESSOR_MAPPING
										SCREAMING_SNAKE_CASE           =					resolve_trust_remote_code(
										    a       ,     a       ,     a       ,     a			)

										if has_remote_code and trust_remote_code:
													SCREAMING_SNAKE_CASE           =					get_class_from_dynamic_module(
													    a       ,     a       ,     **a			)
													SCREAMING_SNAKE_CASE           =					kwargs.pop("""code_revision"""       ,     a			)
													if os.path.isdir(a			):
																image_processor_class.register_for_auto_class()
													return image_processor_class.from_dict(a       ,     **a			)
										elif image_processor_class is not None:
													return image_processor_class.from_dict(a       ,     **a			)
										# Last try: we use the IMAGE_PROCESSOR_MAPPING.
										elif type(a			) in IMAGE_PROCESSOR_MAPPING:
													SCREAMING_SNAKE_CASE           =					IMAGE_PROCESSOR_MAPPING[type(a			)]
													return image_processor_class.from_dict(a       ,     **a			)

										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    _UpperCAmelCase     (					a       :	str       ,     a       :	int			)			->					Union[str, Any]:
										IMAGE_PROCESSOR_MAPPING.register(a       ,     a			)












import importlib
import shutil
import threading
import warnings
from typing import List

import fsspec
import fsspec.asyn

from . import compression
from .hffilesystem import HfFileSystem


__A						:							Tuple							=  importlib.util.find_spec("""s3fs""") is not None

if _has_safs:
		from .safilesystem import SaFileSystem  # noqa: F401

__A						:							List[compression.BaseCompressedFileFileSystem]							=  [
    compression.BzaFileSystem,
    compression.GzipFileSystem,
    compression.LzaFileSystem,
    compression.XzFileSystem,
    compression.ZstdFileSystem,
]

# Register custom filesystems
for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]:
		if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class:
				warnings.warn(f'''A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.''')
		fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True)
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if "://" in dataset_path:
						SCREAMING_SNAKE_CASE           =					dataset_path.split("""://"""   )[1]
			return dataset_path
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if fs is not None and fs.protocol != "file":
						return True
			else:
						return False
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					not is_remote_filesystem(SCREAMING_SNAKE_CASE   )
			if is_local:
						# LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
						shutil.move(fs._strip_protocol(SCREAMING_SNAKE_CASE   )					,	fs._strip_protocol(SCREAMING_SNAKE_CASE   )   )
			else:
						fs.mv(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	recursive=SCREAMING_SNAKE_CASE   )




def 					lowerCamelCase_    (    ):
			'''simple docstring'''
			if hasattr(fsspec.asyn					,	"""reset_lock"""   ):
						# for future fsspec>2022.05.0
						fsspec.asyn.reset_lock()
			else:
						SCREAMING_SNAKE_CASE           =					None
						SCREAMING_SNAKE_CASE           =					None
						SCREAMING_SNAKE_CASE           =					threading.Lock()






