


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


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

UpperCAmelCase_			:  Optional[int]										=   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'),
    ]
)

UpperCAmelCase_			:  Optional[int]										=   _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)


def       _lowercase							(					UpperCamelCase__							:       str      ):
 for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
  if class_name in extractors:
   __A	:		List[Any]	  =      model_type_to_module_name(UpperCamelCase__      )

   __A	:		Optional[int]	  =      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.
 __A	:		List[Any]	  =      importlib.import_module('transformers'      )
 if hasattr(UpperCamelCase__,					UpperCamelCase__      ):
  return getattr(UpperCamelCase__,					UpperCamelCase__      )

 return None


def       _lowercase							(					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],					):
 __A	:		Union[str, Any]	  =      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(__lowercase    )
 def 			snake_case__ (   cls   ,   __lowercase   ,   **__lowercase    ):

  """simple docstring"""







  __A	:		Tuple	  =      kwargs.pop('config'   ,   __lowercase    )
  __A	:		str	  =      kwargs.pop('trust_remote_code'   ,   __lowercase    )
  __A	:		str	  =      True

  __A  ,__A	:		Union[str, Any]	  =      FeatureExtractionMixin.get_feature_extractor_dict(__lowercase   ,   **__lowercase    )
  __A	:		Tuple	  =      config_dict.get('feature_extractor_type'   ,   __lowercase    )
  __A	:		str	  =      None
  if "AutoFeatureExtractor" in config_dict.get('auto_map'   ,   {}    ):
   __A	:		Union[str, Any]	  =      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(__lowercase   ,   __lowercase    ):
    __A	:		Optional[int]	  =      AutoConfig.from_pretrained(__lowercase   ,   **__lowercase    )
   # It could be in `config.feature_extractor_type``
   __A	:		int	  =      getattr(__lowercase   ,   'feature_extractor_type'   ,   __lowercase    )
   if hasattr(__lowercase   ,   'auto_map'    ) and "AutoFeatureExtractor" in config.auto_map:
    __A	:		List[Any]	  =      config.auto_map['AutoFeatureExtractor']

  if feature_extractor_class is not None:
   __A	:		List[str]	  =      feature_extractor_class_from_name(__lowercase    )

  __A	:		Tuple	  =      feature_extractor_auto_map is not None
  __A	:		Any	  =      feature_extractor_class is not None or type(__lowercase    ) in FEATURE_EXTRACTOR_MAPPING
  __A	:		str	  =      resolve_trust_remote_code(
      __lowercase   ,   __lowercase   ,   __lowercase   ,   __lowercase    )

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

  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__ (   __lowercase   ,   __lowercase    ):

  """simple docstring"""







  FEATURE_EXTRACTOR_MAPPING.register(__lowercase   ,   __lowercase    )










'''simple docstring'''
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

import torch

from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
 from PIL import Image

class     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''
 __lowercase					:		int     				=    '''dandelin/vilt-b32-finetuned-vqa'''
 __lowercase					:		int     				=    (
     '''This is a tool that answers a question about an image. It takes an input named `image` which should be the '''
     '''image containing the information, as well as a `question` which should be the question in English. It '''
     '''returns a text that is the answer to the question.'''
 )
 __lowercase					:		Union[str, Any]     				=    '''image_qa'''
 __lowercase					:		Optional[Any]     				=    AutoProcessor
 __lowercase					:		Tuple     				=    AutoModelForVisualQuestionAnswering

 __lowercase					:		Tuple     				=    ['''image''', '''text''']
 __lowercase					:		List[str]     				=    ['''text''']


 def __init__(   self   ,   *__lowercase   ,   **__lowercase    ):

  """simple docstring"""







  requires_backends(self   ,   ['vision']    )
  super().__init__(*__lowercase   ,   **__lowercase    )


 def 			snake_case__ (   self   ,   __lowercase   ,   __lowercase    ):

  """simple docstring"""







  return self.pre_processor(__lowercase   ,   __lowercase   ,   return_tensors='pt'    )


 def 			snake_case__ (   self   ,   __lowercase    ):

  """simple docstring"""







  with torch.no_grad():
   return self.model(**__lowercase    ).logits







 def 			snake_case__ (   self   ,   __lowercase    ):

  """simple docstring"""







  __A	:		List[str]	  =      outputs.argmax(-1    ).item()
  return self.model.config.idalabel[idx]






