



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


lowercase_      :				Optional[Any]   					=    logging.get_logger(__name__)

lowercase_      :				Tuple   					=    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'''),
    ]
)

lowercase_      :				str   					=    _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Dict						):
						for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
												if class_name in extractors:
																		lowercase        =							model_type_to_module_name(_lowerCAmelCase						)

																		lowercase        =							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.
						lowercase        =							importlib.import_module("""transformers"""						)
						if hasattr(_lowerCAmelCase ,  _lowerCAmelCase						):
												return getattr(_lowerCAmelCase ,  _lowerCAmelCase						)

						return None







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Optional[int] ,  lowercase_    :      List[Any] = None ,  lowercase_    :      Optional[Any] = False ,  lowercase_    :      int = False ,  lowercase_    :      Union[str, Any] = None ,  lowercase_    :      List[str] = None ,  lowercase_    :      Dict = None ,  lowercase_    :      Tuple = False ,  **lowercase_    :      Dict ,  ):
						lowercase        =							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      __UpperCamelCase       :







	def __init__(    self						)    ->    Optional[Any]:
							'''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(_lowerCamelCase						)
	def   _a   (    cls ,				_lowerCAmelCase ,				**_lowerCAmelCase						)    ->    List[Any]:
							'''simple docstring'''






							lowercase        =							kwargs.pop("""config""" ,				_lowerCamelCase						)
							lowercase        =							kwargs.pop("""trust_remote_code""" ,				_lowerCamelCase						)
							lowercase        =							True

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

							if feature_extractor_class is not None:
													lowercase        =							feature_extractor_class_from_name(_lowerCamelCase						)

							lowercase        =							feature_extractor_auto_map is not None
							lowercase        =							feature_extractor_class is not None or type(_lowerCamelCase						) in FEATURE_EXTRACTOR_MAPPING
							lowercase        =							resolve_trust_remote_code(
							    _lowerCamelCase ,				_lowerCamelCase ,				_lowerCamelCase ,				_lowerCamelCase						)

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

							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   _a   (    _lowerCAmelCase ,				_lowerCAmelCase						)    ->    Dict:
							'''simple docstring'''






							FEATURE_EXTRACTOR_MAPPING.register(_lowerCamelCase ,				_lowerCamelCase						)










'''simple docstring'''


from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
						from PIL import Image

						from ..image_utils import load_image

if is_tf_available():
						from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING

if is_torch_available():
						import torch

						from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING

lowercase_      :				Union[str, Any]   					=    logging.get_logger(__name__)




@add_end_docstrings(_UpperCAmelCase			)
class      __UpperCamelCase       (_UpperCAmelCase			):







	def __init__(    self ,				*_lowerCAmelCase ,				**_lowerCAmelCase						)    ->    Dict:
							'''simple docstring'''






							super().__init__(*_lowerCAmelCase ,				**_lowerCAmelCase						)
							requires_backends(self ,				"""vision"""						)
							self.check_model_type(
							    TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == """tf""" else MODEL_FOR_VISION_2_SEQ_MAPPING						)







	def   _a   (    self ,				_lowerCAmelCase=None ,				_lowerCAmelCase=None ,				_lowerCAmelCase=None						)    ->    str:
							'''simple docstring'''






							lowercase        =							{}
							lowercase        =							{}

							if prompt is not None:
													lowercase        =							prompt

							if generate_kwargs is not None:
													lowercase        =							generate_kwargs
							if max_new_tokens is not None:
													if "generate_kwargs" not in forward_kwargs:
																			lowercase        =							{}
													if "max_new_tokens" in forward_kwargs["generate_kwargs"]:
																			raise ValueError(
																			    """'max_new_tokens' is defined twice, once in 'generate_kwargs' and once as a direct parameter,"""
																			    """ please use only one"""						)
													lowercase        =							max_new_tokens
							return preprocess_params, forward_kwargs, {}







	def __call__(    self ,				_lowerCAmelCase ,				**_lowerCAmelCase						)    ->    Any:
							'''simple docstring'''






							return super().__call__(_lowerCAmelCase ,				**_lowerCAmelCase						)







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase=None						)    ->    List[str]:
							'''simple docstring'''






							lowercase        =							load_image(_lowerCAmelCase						)

							if prompt is not None:
													if not isinstance(_lowerCAmelCase ,				_lowerCAmelCase						):
																			raise ValueError(
																			    F"""Received an invalid text input, got - {type(_lowerCAmelCase						)} - but expected a single string. """
																			    """Note also that one single text can be provided for conditional image to text generation."""						)

													lowercase        =							self.model.config.model_type

													if model_type == "git":
																			lowercase        =							self.image_processor(images=_lowerCAmelCase ,				return_tensors=self.framework						)
																			lowercase        =							self.tokenizer(text=_lowerCAmelCase ,				add_special_tokens=_lowerCAmelCase						).input_ids
																			lowercase        =							[self.tokenizer.cls_token_id] + input_ids
																			lowercase        =							torch.tensor(_lowerCAmelCase						).unsqueeze(0						)
																			model_inputs.update({"""input_ids""": input_ids}						)

													elif model_type == "pix2struct":
																			lowercase        =							self.image_processor(images=_lowerCAmelCase ,				header_text=_lowerCAmelCase ,				return_tensors=self.framework						)

													elif model_type != "vision-encoder-decoder":
																			# vision-encoder-decoder does not support conditional generation
																			lowercase        =							self.image_processor(images=_lowerCAmelCase ,				return_tensors=self.framework						)
																			lowercase        =							self.tokenizer(_lowerCAmelCase ,				return_tensors=self.framework						)
																			model_inputs.update(_lowerCAmelCase						)

													else:
																			raise ValueError(F"""Model type {model_type} does not support conditional text generation"""						)

							else:
													lowercase        =							self.image_processor(images=_lowerCAmelCase ,				return_tensors=self.framework						)

							if self.model.config.model_type == "git" and prompt is None:
													lowercase        =							None

							return model_inputs







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase=None						)    ->    Union[str, Any]:
							'''simple docstring'''






							if (
							    "input_ids" in model_inputs
							    and isinstance(model_inputs["""input_ids"""] ,				_lowerCAmelCase						)
							    and all(x is None for x in model_inputs["""input_ids"""]						)
							):
													lowercase        =							None

							if generate_kwargs is None:
													lowercase        =							{}
							# FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py`
							#  parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas
							#  the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name`
							#  in the `_prepare_model_inputs` method.
							lowercase        =							model_inputs.pop(self.model.main_input_name						)
							lowercase        =							self.model.generate(_lowerCAmelCase ,				**_lowerCAmelCase ,				**_lowerCAmelCase						)
							return model_outputs







	def   _a   (    self ,				_lowerCAmelCase						)    ->    List[str]:
							'''simple docstring'''






							lowercase        =							[]
							for output_ids in model_outputs:
													lowercase        =							{
													    """generated_text""": self.tokenizer.decode(
													        _lowerCAmelCase ,				skip_special_tokens=_lowerCAmelCase ,				)
													}
													records.append(_lowerCAmelCase						)
							return records


