

from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import numpy
	import tensorflow as tf

	from transformers import (
	    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
	    BertConfig,
	    DPRConfig,
	    TFDPRContextEncoder,
	    TFDPRQuestionEncoder,
	    TFDPRReader,
	)



class        A__:
						"""simple docstring"""






						def __init__(    self  ,      _lowercase  ,      _lowercase=13  ,      _lowercase=7  ,      _lowercase=True  ,      _lowercase=True  ,      _lowercase=True  ,      _lowercase=True  ,      _lowercase=99  ,      _lowercase=32  ,      _lowercase=2  ,      _lowercase=4  ,      _lowercase=37  ,      _lowercase="gelu"  ,      _lowercase=0.1  ,      _lowercase=0.1  ,      _lowercase=512  ,      _lowercase=16  ,      _lowercase=2  ,      _lowercase=0.0_2  ,      _lowercase=3  ,      _lowercase=4  ,      _lowercase=None  ,      _lowercase=0  ,      )     -> str:
									a_						:						Optional[int] 							= parent
									a_						:						Any 							= batch_size
									a_						:						int 							= seq_length
									a_						:						List[Any] 							= is_training
									a_						:						str 							= use_input_mask
									a_						:						Optional[Any] 							= use_token_type_ids
									a_						:						Optional[int] 							= use_labels
									a_						:						Dict 							= vocab_size
									a_						:						Dict 							= hidden_size
									a_						:						Dict 							= num_hidden_layers
									a_						:						Tuple 							= num_attention_heads
									a_						:						str 							= intermediate_size
									a_						:						int 							= hidden_act
									a_						:						List[Any] 							= hidden_dropout_prob
									a_						:						List[Any] 							= attention_probs_dropout_prob
									a_						:						Optional[Any] 							= max_position_embeddings
									a_						:						Optional[Any] 							= type_vocab_size
									a_						:						Any 							= type_sequence_label_size
									a_						:						Optional[Any] 							= initializer_range
									a_						:						Union[str, Any] 							= num_labels
									a_						:						Union[str, Any] 							= num_choices
									a_						:						Optional[Any] 							= scope
									a_						:						Any 							= projection_dim





						def 			UpperCamelCase__					(    self    )     -> str:
									a_						:						Any 							= ids_tensor([self.batch_size, self.seq_length]  ,      self.vocab_size    )

									a_						:						Dict 							= None
									if self.use_input_mask:
												# follow test_modeling_tf_ctrl.py
												a_						:						Union[str, Any] 							= random_attention_mask([self.batch_size, self.seq_length]    )

									a_						:						int 							= None
									if self.use_token_type_ids:
												a_						:						List[Any] 							= ids_tensor([self.batch_size, self.seq_length]  ,      self.type_vocab_size    )

									a_						:						Dict 							= None
									a_						:						Optional[Any] 							= None
									a_						:						Union[str, Any] 							= None
									if self.use_labels:
												a_						:						List[Any] 							= ids_tensor([self.batch_size]  ,      self.type_sequence_label_size    )
												a_						:						Any 							= ids_tensor([self.batch_size, self.seq_length]  ,      self.num_labels    )
												a_						:						Any 							= ids_tensor([self.batch_size]  ,      self.num_choices    )

									a_						:						List[str] 							= BertConfig(
									    vocab_size=self.vocab_size  ,      hidden_size=self.hidden_size  ,      num_hidden_layers=self.num_hidden_layers  ,      num_attention_heads=self.num_attention_heads  ,      intermediate_size=self.intermediate_size  ,      hidden_act=self.hidden_act  ,      hidden_dropout_prob=self.hidden_dropout_prob  ,      attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,      max_position_embeddings=self.max_position_embeddings  ,      type_vocab_size=self.type_vocab_size  ,      is_decoder=_lowercase  ,      initializer_range=self.initializer_range  ,      )
									a_						:						Union[str, Any] 							= DPRConfig(projection_dim=self.projection_dim  ,      **config.to_dict()    )

									return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





						def 			UpperCamelCase__					(    self  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase    )     -> List[str]:
									a_						:						Union[str, Any] 							= TFDPRContextEncoder(config=_lowercase    )
									a_						:						Any 							= model(_lowercase  ,      attention_mask=_lowercase  ,      token_type_ids=_lowercase    )
									a_						:						Union[str, Any] 							= model(_lowercase  ,      token_type_ids=_lowercase    )
									a_						:						Tuple 							= model(_lowercase    )
									self.parent.assertEqual(result.pooler_output.shape  ,      (self.batch_size, self.projection_dim or self.hidden_size)    )





						def 			UpperCamelCase__					(    self  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase    )     -> List[Any]:
									a_						:						Tuple 							= TFDPRQuestionEncoder(config=_lowercase    )
									a_						:						Tuple 							= model(_lowercase  ,      attention_mask=_lowercase  ,      token_type_ids=_lowercase    )
									a_						:						Any 							= model(_lowercase  ,      token_type_ids=_lowercase    )
									a_						:						Union[str, Any] 							= model(_lowercase    )
									self.parent.assertEqual(result.pooler_output.shape  ,      (self.batch_size, self.projection_dim or self.hidden_size)    )





						def 			UpperCamelCase__					(    self  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase    )     -> Tuple:
									a_						:						Union[str, Any] 							= TFDPRReader(config=_lowercase    )
									a_						:						Any 							= model(_lowercase  ,      attention_mask=_lowercase    )

									self.parent.assertEqual(result.start_logits.shape  ,      (self.batch_size, self.seq_length)    )
									self.parent.assertEqual(result.end_logits.shape  ,      (self.batch_size, self.seq_length)    )
									self.parent.assertEqual(result.relevance_logits.shape  ,      (self.batch_size,)    )





						def 			UpperCamelCase__					(    self    )     -> List[Any]:
									a_						:						Optional[int] 							= self.prepare_config_and_inputs()
									(
									    (
									    a_
									)							,					(
									    a_
									)							,					(
									    a_
									)							,					(
									    a_
									)							,					(
									    a_
									)							,					(
									    a_
									)							,					(
									    a_
									)							,					
									)						:						Dict 							= config_and_inputs
									a_						:						Optional[Any] 							= {"""input_ids""": input_ids}
									return config, inputs_dict







@require_tf
class        A__(a_,  a_,  unittest.TestCase							):
						"""simple docstring"""






						_A    :				List[str]       					=			(
						    (
						        TFDPRContextEncoder,
						        TFDPRQuestionEncoder,
						        TFDPRReader,
						    )
						    if is_tf_available()
						    else ()
						)
						_A    :				Union[str, Any]       					=			{'''feature-extraction''': TFDPRQuestionEncoder} if is_tf_available() else {}

						_A    :				Union[str, Any]       					=			False
						_A    :				int       					=			False
						_A    :				int       					=			False
						_A    :				Tuple       					=			False
						_A    :				Tuple       					=			False





						def 			UpperCamelCase__					(    self    )     -> int:
									a_						:						Tuple 							= TFDPRModelTester(self    )
									a_						:						str 							= ConfigTester(self  ,      config_class=_lowercase  ,      hidden_size=37    )





						def 			UpperCamelCase__					(    self    )     -> List[str]:
									self.config_tester.run_common_tests()





						def 			UpperCamelCase__					(    self    )     -> Optional[int]:
									a_						:						Tuple 							= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_dpr_context_encoder(*_lowercase    )





						def 			UpperCamelCase__					(    self    )     -> Optional[Any]:
									a_						:						Optional[Any] 							= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_dpr_question_encoder(*_lowercase    )





						def 			UpperCamelCase__					(    self    )     -> int:
									a_						:						Optional[Any] 							= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_dpr_reader(*_lowercase    )





						@slow
						def 			UpperCamelCase__					(    self    )     -> Optional[int]:
									for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												a_						:						List[str] 							= TFDPRContextEncoder.from_pretrained(_lowercase    )
												self.assertIsNotNone(_lowercase    )

									for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												a_						:						Tuple 							= TFDPRContextEncoder.from_pretrained(_lowercase    )
												self.assertIsNotNone(_lowercase    )

									for model_name in TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												a_						:						Optional[int] 							= TFDPRQuestionEncoder.from_pretrained(_lowercase    )
												self.assertIsNotNone(_lowercase    )

									for model_name in TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												a_						:						Optional[Any] 							= TFDPRReader.from_pretrained(_lowercase    )
												self.assertIsNotNone(_lowercase    )







@require_tf
class        A__(unittest.TestCase							):
						"""simple docstring"""






						@slow
						def 			UpperCamelCase__					(    self    )     -> Any:
									a_						:						Optional[int] 							= TFDPRQuestionEncoder.from_pretrained("""facebook/dpr-question_encoder-single-nq-base"""    )

									a_						:						List[Any] 							= tf.constant(
									    [[101, 7_592, 1_010, 2_003, 2_026, 3_899, 10_140, 1_029, 102]]    )  # [CLS] hello, is my dog cute? [SEP]
									a_						:						str 							= model(_lowercase    )[0]  # embedding shape = (1, 768)
									# compare the actual values for a slice.
									a_						:						Optional[int] 							= tf.constant(
									    [
									        [
									            0.0_3_2_3_6_2_5_3,
									            0.1_2_7_5_3_3_3_5,
									            0.1_6_8_1_8_5_0_9,
									            0.0_0_2_7_9_7_8_6,
									            0.3_8_9_6_9_3_3,
									            0.2_4_2_6_4_9_4_5,
									            0.2_1_7_8_9_7_1,
									            -0.0_2_3_3_5_2_2_7,
									            -0.0_8_4_8_1_9_5_9,
									            -0.1_4_3_2_4_1_1_7,
									        ]
									    ]    )
									self.assertTrue(numpy.allclose(output[:, :10].numpy()  ,      expected_slice.numpy()  ,      atol=1e-4    )    )





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


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

__snake_case				:      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"""),
    ]
)

__snake_case				:      List[Any]   		=			_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)


def 					_UpperCAmelCase				(						a__):

			'''simple docstring'''



			for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
						if class_name in extractors:
									a_						:						Tuple 							= model_type_to_module_name(a__)

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

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

			return None


def 					_UpperCAmelCase				(						a__  ,	a__ = None  ,	a__ = False  ,	a__ = False  ,	a__ = None  ,	a__ = None  ,	a__ = None  ,	a__ = False  ,	**a__  ,	):

			'''simple docstring'''



			a_						:						List[str] 							= get_file_from_repo(
			    a__  ,	a__  ,	cache_dir=a__  ,	force_download=a__  ,	resume_download=a__  ,	proxies=a__  ,	use_auth_token=a__  ,	revision=a__  ,	local_files_only=a__  ,	)
			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(a__  ,	encoding="""utf-8""") as reader:
						return json.load(a__)



class        A__:
						"""simple docstring"""






						def __init__(    self    )     -> List[str]:
									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 			UpperCamelCase__					(    cls  ,      _lowercase  ,      **_lowercase    )     -> Dict:
									a_						:						Tuple 							= kwargs.pop("""config"""  ,      _lowercase    )
									a_						:						Dict 							= kwargs.pop("""trust_remote_code"""  ,      _lowercase    )
									a_						:						Dict 							= True

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

									if feature_extractor_class is not None:
												a_						:						int 							= feature_extractor_class_from_name(_lowercase    )

									a_						:						Dict 							= feature_extractor_auto_map is not None
									a_						:						Union[str, Any] 							= feature_extractor_class is not None or type(_lowercase    ) in FEATURE_EXTRACTOR_MAPPING
									a_						:						Optional[Any] 							= resolve_trust_remote_code(
									    _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase    )

									if has_remote_code and trust_remote_code:
												a_						:						int 							= get_class_from_dynamic_module(
												    _lowercase  ,      _lowercase  ,      **_lowercase    )
												a_						:						Tuple 							= 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_						:						List[str] 							= 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 			UpperCamelCase__					(    _lowercase  ,      _lowercase    )     -> List[Any]:
									FEATURE_EXTRACTOR_MAPPING.register(_lowercase  ,      _lowercase    )


