



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


__A							       =		logging.get_logger(__name__)

__A							       =		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'''),
    ]
)

__A							       =		_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)



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






						'''simple docstring'''



						for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
												if class_name in extractors:
																		UpperCAmelCase_=  model_type_to_module_name(lowerCamelCase_							)

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

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

						return None



def 			__a	(       lowerCAmelCase_  :   int     ,lowerCAmelCase_  :   Union[str, Any] = None     ,lowerCAmelCase_  :   Union[str, Any] = False     ,lowerCAmelCase_  :   Dict = False     ,lowerCAmelCase_  :   Any = None     ,lowerCAmelCase_  :   Optional[int] = None     ,lowerCAmelCase_  :   Dict = None     ,lowerCAmelCase_  :   Optional[Any] = False     ,**lowerCAmelCase_  :   str     ,) ->					str:






						'''simple docstring'''



						UpperCAmelCase_=  get_file_from_repo(
						    lowerCamelCase_     ,lowerCamelCase_     ,cache_dir=lowerCamelCase_     ,force_download=lowerCamelCase_     ,resume_download=lowerCamelCase_     ,proxies=lowerCamelCase_     ,use_auth_token=lowerCamelCase_     ,revision=lowerCamelCase_     ,local_files_only=lowerCamelCase_     ,)
						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(lowerCamelCase_     ,encoding="""utf-8"""							) as reader:
												return json.load(lowerCamelCase_							)






class 						lowercase		:






	"""simple docstring"""


	def __init__(      self      :		Union[str, Any]	)     ->					Dict:
							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(__UpperCAmelCase	)
	def     _SCREAMING_SNAKE_CASE						(      cls      :		str		,    __UpperCAmelCase      :		str		,    **__UpperCAmelCase      :		Dict	)     ->					Optional[Any]:
							UpperCAmelCase_=  kwargs.pop("""config"""		,    __UpperCAmelCase	)
							UpperCAmelCase_=  kwargs.pop("""trust_remote_code"""		,    __UpperCAmelCase	)
							UpperCAmelCase_=  True

							UpperCAmelCase_,  UpperCAmelCase_=  FeatureExtractionMixin.get_feature_extractor_dict(__UpperCAmelCase		,    **__UpperCAmelCase	)
							UpperCAmelCase_=  config_dict.get("""feature_extractor_type"""		,    __UpperCAmelCase	)
							UpperCAmelCase_=  None
							if "AutoFeatureExtractor" in config_dict.get("""auto_map"""		,    {}	):
													UpperCAmelCase_=  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(__UpperCAmelCase		,    __UpperCAmelCase	):
																			UpperCAmelCase_=  AutoConfig.from_pretrained(__UpperCAmelCase		,    **__UpperCAmelCase	)
													# It could be in `config.feature_extractor_type``
													UpperCAmelCase_=  getattr(__UpperCAmelCase		,    """feature_extractor_type"""		,    __UpperCAmelCase	)
													if hasattr(__UpperCAmelCase		,    """auto_map"""	) and "AutoFeatureExtractor" in config.auto_map:
																			UpperCAmelCase_=  config.auto_map["""AutoFeatureExtractor"""]

							if feature_extractor_class is not None:
													UpperCAmelCase_=  feature_extractor_class_from_name(__UpperCAmelCase	)

							UpperCAmelCase_=  feature_extractor_auto_map is not None
							UpperCAmelCase_=  feature_extractor_class is not None or type(__UpperCAmelCase	) in FEATURE_EXTRACTOR_MAPPING
							UpperCAmelCase_=  resolve_trust_remote_code(
							    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase	)

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

							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     _SCREAMING_SNAKE_CASE						(      __UpperCAmelCase      :		str		,    __UpperCAmelCase      :		str	)     ->					Dict:
							FEATURE_EXTRACTOR_MAPPING.register(__UpperCAmelCase		,    __UpperCAmelCase	)












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__      :     int       =					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     a     (		lowerCamelCase_							):






				'''simple docstring'''
				if "://" in dataset_path:
								lowercase__  					=     dataset_path.split('''://'''							)[1]
				return dataset_path






def     a     (		lowerCamelCase_							):






				'''simple docstring'''
				if fs is not None and fs.protocol != "file":
								return True
				else:
								return False






def     a     (		lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     not is_remote_filesystem(lowerCamelCase_							)
				if is_local:
								# LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
								shutil.move(fs._strip_protocol(lowerCamelCase_							)						,  fs._strip_protocol(lowerCamelCase_							)							)
				else:
								fs.mv(lowerCamelCase_						,  lowerCamelCase_						,  recursive=lowerCamelCase_							)






def     a     (		):






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




