

import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


sys.path.append(str(Path(__file__).parent.parent.parent.parent / """utils"""))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402







class        a__       (   unittest.TestCase       ):







		"""simple docstring"""




		def  _lowercase      (			self    : Any		)					->Any:
								"""simple docstring"""







								SCREAMING_SNAKE_CASE :      Union[str, Any]       =   0


		def  _lowercase      (			self    : Any		)					->Optional[int]:
								"""simple docstring"""







								SCREAMING_SNAKE_CASE :      int       =   AutoImageProcessor.from_pretrained("""openai/clip-vit-base-patch32"""		)
								self.assertIsInstance(A_				,				A_		)


		def  _lowercase      (			self    : Any		)					->Any:
								"""simple docstring"""







								with tempfile.TemporaryDirectory() as tmpdirname:
														SCREAMING_SNAKE_CASE :      int       =   Path(A_		) / """preprocessor_config.json"""
														SCREAMING_SNAKE_CASE :      Optional[Any]       =   Path(A_		) / """config.json"""
														json.dump(
														    {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}				,				open(A_				,				"""w"""		)				,				)
														json.dump({"""model_type""": """clip"""}				,				open(A_				,				"""w"""		)		)

														SCREAMING_SNAKE_CASE :      Tuple       =   AutoImageProcessor.from_pretrained(A_		)
														self.assertIsInstance(A_				,				A_		)


		def  _lowercase      (			self    : Optional[Any]		)					->Union[str, Any]:
								"""simple docstring"""







								with tempfile.TemporaryDirectory() as tmpdirname:
														SCREAMING_SNAKE_CASE :      List[str]       =   Path(A_		) / """preprocessor_config.json"""
														SCREAMING_SNAKE_CASE :      int       =   Path(A_		) / """config.json"""
														json.dump(
														    {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}				,				open(A_				,				"""w"""		)				,				)
														json.dump({"""model_type""": """clip"""}				,				open(A_				,				"""w"""		)		)

														SCREAMING_SNAKE_CASE :      List[Any]       =   AutoImageProcessor.from_pretrained(A_		)
														self.assertIsInstance(A_				,				A_		)


		def  _lowercase      (			self    : List[str]		)					->Union[str, Any]:
								"""simple docstring"""







								with tempfile.TemporaryDirectory() as tmpdirname:
														SCREAMING_SNAKE_CASE :      Tuple       =   CLIPConfig()

														# Create a dummy config file with image_proceesor_type
														SCREAMING_SNAKE_CASE :      List[str]       =   Path(A_		) / """preprocessor_config.json"""
														SCREAMING_SNAKE_CASE :      Tuple       =   Path(A_		) / """config.json"""
														json.dump(
														    {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}				,				open(A_				,				"""w"""		)				,				)
														json.dump({"""model_type""": """clip"""}				,				open(A_				,				"""w"""		)		)

														# remove image_processor_type to make sure config.json alone is enough to load image processor locally
														SCREAMING_SNAKE_CASE :      int       =   AutoImageProcessor.from_pretrained(A_		).to_dict()

														config_dict.pop("""image_processor_type"""		)
														SCREAMING_SNAKE_CASE :      Optional[Any]       =   CLIPImageProcessor(**A_		)

														# save in new folder
														model_config.save_pretrained(A_		)
														config.save_pretrained(A_		)

														SCREAMING_SNAKE_CASE :      Optional[Any]       =   AutoImageProcessor.from_pretrained(A_		)

														# make sure private variable is not incorrectly saved
														SCREAMING_SNAKE_CASE :      List[str]       =   json.loads(config.to_json_string()		)
														self.assertTrue("""_processor_class""" not in dict_as_saved		)

								self.assertIsInstance(A_				,				A_		)


		def  _lowercase      (			self    : Dict		)					->Union[str, Any]:
								"""simple docstring"""







								with tempfile.TemporaryDirectory() as tmpdirname:
														SCREAMING_SNAKE_CASE :      List[str]       =   Path(A_		) / """preprocessor_config.json"""
														json.dump(
														    {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}				,				open(A_				,				"""w"""		)				,				)

														SCREAMING_SNAKE_CASE :      List[Any]       =   AutoImageProcessor.from_pretrained(A_		)
														self.assertIsInstance(A_				,				A_		)


		def  _lowercase      (			self    : Tuple		)					->Optional[Any]:
								"""simple docstring"""







								with self.assertRaisesRegex(
								    A_				,				"""clip-base is not a local folder and is not a valid model identifier"""		):
														SCREAMING_SNAKE_CASE :      Dict       =   AutoImageProcessor.from_pretrained("""clip-base"""		)


		def  _lowercase      (			self    : List[Any]		)					->Dict:
								"""simple docstring"""







								with self.assertRaisesRegex(
								    A_				,				R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""		):
														SCREAMING_SNAKE_CASE :      str       =   AutoImageProcessor.from_pretrained(A_				,				revision="""aaaaaa"""		)


		def  _lowercase      (			self    : Optional[Any]		)					->int:
								"""simple docstring"""







								with self.assertRaisesRegex(
								    A_				,				"""hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."""				,				):
														SCREAMING_SNAKE_CASE :      List[str]       =   AutoImageProcessor.from_pretrained("""hf-internal-testing/config-no-model"""		)


		def  _lowercase      (			self    : List[Any]		)					->int:
								"""simple docstring"""







								with self.assertRaises(A_		):
														SCREAMING_SNAKE_CASE :      List[Any]       =   AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""		)
								# If remote code is disabled, we can't load this config.
								with self.assertRaises(A_		):
														SCREAMING_SNAKE_CASE :      List[Any]       =   AutoImageProcessor.from_pretrained(
														    """hf-internal-testing/test_dynamic_image_processor"""				,				trust_remote_code=A_		)

								SCREAMING_SNAKE_CASE :      Tuple       =   AutoImageProcessor.from_pretrained(
								    """hf-internal-testing/test_dynamic_image_processor"""				,				trust_remote_code=A_		)
								self.assertEqual(image_processor.__class__.__name__				,				"""NewImageProcessor"""		)

								# Test image processor can be reloaded.
								with tempfile.TemporaryDirectory() as tmp_dir:
														image_processor.save_pretrained(A_		)
														SCREAMING_SNAKE_CASE :      Tuple       =   AutoImageProcessor.from_pretrained(A_				,				trust_remote_code=A_		)
								self.assertEqual(reloaded_image_processor.__class__.__name__				,				"""NewImageProcessor"""		)


		def  _lowercase      (			self    : int		)					->List[str]:
								"""simple docstring"""







								try:
														AutoConfig.register("""custom"""				,				A_		)
														AutoImageProcessor.register(A_				,				A_		)
														# Trying to register something existing in the Transformers library will raise an error
														with self.assertRaises(A_		):
																				AutoImageProcessor.register(A_				,				A_		)

														with tempfile.TemporaryDirectory() as tmpdirname:
																				SCREAMING_SNAKE_CASE :      List[str]       =   Path(A_		) / """preprocessor_config.json"""
																				SCREAMING_SNAKE_CASE :      Optional[Any]       =   Path(A_		) / """config.json"""
																				json.dump(
																				    {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}				,				open(A_				,				"""w"""		)				,				)
																				json.dump({"""model_type""": """clip"""}				,				open(A_				,				"""w"""		)		)

																				SCREAMING_SNAKE_CASE :      Dict       =   CustomImageProcessor.from_pretrained(A_		)

														# Now that the config is registered, it can be used as any other config with the auto-API
														with tempfile.TemporaryDirectory() as tmp_dir:
																				image_processor.save_pretrained(A_		)
																				SCREAMING_SNAKE_CASE :      Tuple       =   AutoImageProcessor.from_pretrained(A_		)
																				self.assertIsInstance(A_				,				A_		)

								finally:
														if "custom" in CONFIG_MAPPING._extra_content:
																				del CONFIG_MAPPING._extra_content["custom"]
														if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
																				del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]




		def  _lowercase      (			self    : Dict		)					->Optional[Any]:
								"""simple docstring"""







								class        a__       (   _lowercase       ):







										"""simple docstring"""




										UpperCAmelCase__      : Optional[Any]			       =True

								try:
														AutoConfig.register("""custom"""				,				A_		)
														AutoImageProcessor.register(A_				,				A_		)
														# If remote code is not set, the default is to use local
														SCREAMING_SNAKE_CASE :      int       =   AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""		)
														self.assertEqual(image_processor.__class__.__name__				,				"""NewImageProcessor"""		)
														self.assertTrue(image_processor.is_local		)

														# If remote code is disabled, we load the local one.
														SCREAMING_SNAKE_CASE :      Union[str, Any]       =   AutoImageProcessor.from_pretrained(
														    """hf-internal-testing/test_dynamic_image_processor"""				,				trust_remote_code=A_		)
														self.assertEqual(image_processor.__class__.__name__				,				"""NewImageProcessor"""		)
														self.assertTrue(image_processor.is_local		)

														# If remote is enabled, we load from the Hub
														SCREAMING_SNAKE_CASE :      Optional[int]       =   AutoImageProcessor.from_pretrained(
														    """hf-internal-testing/test_dynamic_image_processor"""				,				trust_remote_code=A_		)
														self.assertEqual(image_processor.__class__.__name__				,				"""NewImageProcessor"""		)
														self.assertTrue(not hasattr(A_				,				"""is_local"""		)		)

								finally:
														if "custom" in CONFIG_MAPPING._extra_content:
																				del CONFIG_MAPPING._extra_content["custom"]
														if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
																				del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]







from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase__ :     List[Any]				    =    logging.get_logger(__name__)

UpperCAmelCase__ :     int				    =    {
    """unc-nlp/lxmert-base-uncased""": """https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/config.json""",
}







class        a__       (   UpperCAmelCase       ):







  """simple docstring"""




  UpperCAmelCase__      : List[str]			       ="""lxmert"""
  UpperCAmelCase__      : str			       ={}


  def __init__(			self    : int				,				UpperCAmelCase__    : Dict=3_0_5_2_2				,				UpperCAmelCase__    : int=7_6_8				,				UpperCAmelCase__    : Union[str, Any]=1_2				,				UpperCAmelCase__    : int=9_5_0_0				,				UpperCAmelCase__    : Union[str, Any]=1_6_0_0				,				UpperCAmelCase__    : Optional[Any]=4_0_0				,				UpperCAmelCase__    : List[str]=3_0_7_2				,				UpperCAmelCase__    : List[Any]="gelu"				,				UpperCAmelCase__    : int=0.1				,				UpperCAmelCase__    : Optional[Any]=0.1				,				UpperCAmelCase__    : Union[str, Any]=5_1_2				,				UpperCAmelCase__    : int=2				,				UpperCAmelCase__    : List[str]=0.02				,				UpperCAmelCase__    : str=1e-12				,				UpperCAmelCase__    : int=9				,				UpperCAmelCase__    : Optional[int]=5				,				UpperCAmelCase__    : int=5				,				UpperCAmelCase__    : List[str]=2_0_4_8				,				UpperCAmelCase__    : Tuple=4				,				UpperCAmelCase__    : List[str]=6.67				,				UpperCAmelCase__    : Optional[int]=True				,				UpperCAmelCase__    : Dict=True				,				UpperCAmelCase__    : Optional[Any]=True				,				UpperCAmelCase__    : Optional[int]=True				,				UpperCAmelCase__    : List[Any]=True				,				UpperCAmelCase__    : Dict=True				,				UpperCAmelCase__    : Optional[Any]=True				,				**UpperCAmelCase__    : Tuple				,				)					->Optional[Any]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[str]       =   vocab_size
        SCREAMING_SNAKE_CASE :      List[Any]       =   hidden_size
        SCREAMING_SNAKE_CASE :      Any       =   num_attention_heads
        SCREAMING_SNAKE_CASE :      str       =   hidden_act
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   intermediate_size
        SCREAMING_SNAKE_CASE :      List[str]       =   hidden_dropout_prob
        SCREAMING_SNAKE_CASE :      str       =   attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE :      Dict       =   max_position_embeddings
        SCREAMING_SNAKE_CASE :      Any       =   type_vocab_size
        SCREAMING_SNAKE_CASE :      Optional[int]       =   initializer_range
        SCREAMING_SNAKE_CASE :      Optional[int]       =   layer_norm_eps
        SCREAMING_SNAKE_CASE :      Dict       =   num_qa_labels
        SCREAMING_SNAKE_CASE :      str       =   num_object_labels
        SCREAMING_SNAKE_CASE :      str       =   num_attr_labels
        SCREAMING_SNAKE_CASE :      List[str]       =   l_layers
        SCREAMING_SNAKE_CASE :      Optional[int]       =   x_layers
        SCREAMING_SNAKE_CASE :      List[str]       =   r_layers
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   visual_feat_dim
        SCREAMING_SNAKE_CASE :      Dict       =   visual_pos_dim
        SCREAMING_SNAKE_CASE :      List[Any]       =   visual_loss_normalizer
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   task_matched
        SCREAMING_SNAKE_CASE :      int       =   task_mask_lm
        SCREAMING_SNAKE_CASE :      int       =   task_obj_predict
        SCREAMING_SNAKE_CASE :      Optional[int]       =   task_qa
        SCREAMING_SNAKE_CASE :      Any       =   visual_obj_loss
        SCREAMING_SNAKE_CASE :      str       =   visual_attr_loss
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   visual_feat_loss
        SCREAMING_SNAKE_CASE :      List[Any]       =   {"""vision""": r_layers, """cross_encoder""": x_layers, """language""": l_layers}
        super().__init__(**UpperCAmelCase__		)




