






"""simple docstring"""
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      UpperCamelCase_			(unittest.TestCase	):





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     List[str]:
				UpperCAmelCase_	:					Optional[Any]     	=   0





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     Optional[int]:
				UpperCAmelCase_	:					Optional[int]     	=   AutoImageProcessor.from_pretrained("openai/clip-vit-base-patch32"		)
				self.assertIsInstance(lowerCAmelCase_      ,      lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]		)		->     Any:
				with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase_	:					Tuple     	=   Path(lowerCAmelCase_		) / "preprocessor_config.json"
							UpperCAmelCase_	:					Optional[Any]     	=   Path(lowerCAmelCase_		) / "config.json"
							json.dump(
							    {"image_processor_type": "CLIPImageProcessor", "processor_class": "CLIPProcessor"}      ,      open(lowerCAmelCase_      ,      "w"		)      ,      )
							json.dump({"model_type": "clip"}      ,      open(lowerCAmelCase_      ,      "w"		)		)

							UpperCAmelCase_	:					Optional[Any]     	=   AutoImageProcessor.from_pretrained(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_      ,      lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple		)		->     List[Any]:
				# Ensure we can load the image processor from the feature extractor config
				with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase_	:					List[Any]     	=   Path(lowerCAmelCase_		) / "preprocessor_config.json"
							UpperCAmelCase_	:					Dict     	=   Path(lowerCAmelCase_		) / "config.json"
							json.dump(
							    {"feature_extractor_type": "CLIPFeatureExtractor", "processor_class": "CLIPProcessor"}      ,      open(lowerCAmelCase_      ,      "w"		)      ,      )
							json.dump({"model_type": "clip"}      ,      open(lowerCAmelCase_      ,      "w"		)		)

							UpperCAmelCase_	:					List[Any]     	=   AutoImageProcessor.from_pretrained(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_      ,      lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					str		)		->     Union[str, Any]:
				with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase_	:					str     	=   CLIPConfig()

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

							# remove image_processor_type to make sure config.json alone is enough to load image processor locally
							UpperCAmelCase_	:					str     	=   AutoImageProcessor.from_pretrained(lowerCAmelCase_		).to_dict()

							config_dict.pop("image_processor_type"		)
							UpperCAmelCase_	:					Dict     	=   CLIPImageProcessor(**lowerCAmelCase_		)

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

							UpperCAmelCase_	:					List[Any]     	=   AutoImageProcessor.from_pretrained(lowerCAmelCase_		)

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

				self.assertIsInstance(lowerCAmelCase_      ,      lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					str		)		->     Optional[int]:
				with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase_	:					Optional[Any]     	=   Path(lowerCAmelCase_		) / "preprocessor_config.json"
							json.dump(
							    {"image_processor_type": "CLIPImageProcessor", "processor_class": "CLIPProcessor"}      ,      open(lowerCAmelCase_      ,      "w"		)      ,      )

							UpperCAmelCase_	:					Optional[int]     	=   AutoImageProcessor.from_pretrained(lowerCAmelCase_		)
							self.assertIsInstance(lowerCAmelCase_      ,      lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					str		)		->     str:
				with self.assertRaisesRegex(
				    lowerCAmelCase_      ,      "clip-base is not a local folder and is not a valid model identifier"		):
							UpperCAmelCase_	:					Any     	=   AutoImageProcessor.from_pretrained("clip-base"		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     Union[str, Any]:
				with self.assertRaisesRegex(
				    lowerCAmelCase_      ,      R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"		):
							UpperCAmelCase_	:					Optional[Any]     	=   AutoImageProcessor.from_pretrained(lowerCAmelCase_      ,      revision="aaaaaa"		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple		)		->     Dict:
				with self.assertRaisesRegex(
				    lowerCAmelCase_      ,      "hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."      ,      ):
							UpperCAmelCase_	:					List[Any]     	=   AutoImageProcessor.from_pretrained("hf-internal-testing/config-no-model"		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[Any]		)		->     Union[str, Any]:
				# If remote code is not set, we will time out when asking whether to load the model.
				with self.assertRaises(lowerCAmelCase_		):
							UpperCAmelCase_	:					List[str]     	=   AutoImageProcessor.from_pretrained("hf-internal-testing/test_dynamic_image_processor"		)
				# If remote code is disabled, we can't load this config.
				with self.assertRaises(lowerCAmelCase_		):
							UpperCAmelCase_	:					Dict     	=   AutoImageProcessor.from_pretrained(
							    "hf-internal-testing/test_dynamic_image_processor"      ,      trust_remote_code=lowerCAmelCase_		)

				UpperCAmelCase_	:					str     	=   AutoImageProcessor.from_pretrained(
				    "hf-internal-testing/test_dynamic_image_processor"      ,      trust_remote_code=lowerCAmelCase_		)
				self.assertEqual(image_processor.__class__.__name__      ,      "NewImageProcessor"		)

				# Test image processor can be reloaded.
				with tempfile.TemporaryDirectory() as tmp_dir:
							image_processor.save_pretrained(lowerCAmelCase_		)
							UpperCAmelCase_	:					Union[str, Any]     	=   AutoImageProcessor.from_pretrained(lowerCAmelCase_      ,      trust_remote_code=lowerCAmelCase_		)
				self.assertEqual(reloaded_image_processor.__class__.__name__      ,      "NewImageProcessor"		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     Union[str, Any]:
				try:
							AutoConfig.register("custom"      ,      lowerCAmelCase_		)
							AutoImageProcessor.register(lowerCAmelCase_      ,      lowerCAmelCase_		)
							# Trying to register something existing in the Transformers library will raise an error
							with self.assertRaises(lowerCAmelCase_		):
										AutoImageProcessor.register(lowerCAmelCase_      ,      lowerCAmelCase_		)

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

										UpperCAmelCase_	:					Tuple     	=   CustomImageProcessor.from_pretrained(lowerCAmelCase_		)

							# 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(lowerCAmelCase_		)
										UpperCAmelCase_	:					Any     	=   AutoImageProcessor.from_pretrained(lowerCAmelCase_		)
										self.assertIsInstance(lowerCAmelCase_      ,      lowerCAmelCase_		)

				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 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]		)		->     List[str]:







				class      UpperCamelCase_			(__A	):
					__magic_name__       =							True

				try:
							AutoConfig.register("custom"      ,      lowerCAmelCase_		)
							AutoImageProcessor.register(lowerCAmelCase_      ,      lowerCAmelCase_		)
							# If remote code is not set, the default is to use local
							UpperCAmelCase_	:					Tuple     	=   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.
							UpperCAmelCase_	:					Optional[int]     	=   AutoImageProcessor.from_pretrained(
							    "hf-internal-testing/test_dynamic_image_processor"      ,      trust_remote_code=lowerCAmelCase_		)
							self.assertEqual(image_processor.__class__.__name__      ,      "NewImageProcessor"		)
							self.assertTrue(image_processor.is_local		)

							# If remote is enabled, we load from the Hub
							UpperCAmelCase_	:					str     	=   AutoImageProcessor.from_pretrained(
							    "hf-internal-testing/test_dynamic_image_processor"      ,      trust_remote_code=lowerCAmelCase_		)
							self.assertEqual(image_processor.__class__.__name__      ,      "NewImageProcessor"		)
							self.assertTrue(not hasattr(lowerCAmelCase_      ,      "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]











"""simple docstring"""
import warnings
from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType







class      UpperCamelCase_			(__A	):
	__magic_name__       =							['''image_processor''', '''tokenizer''']
	__magic_name__       =							'''FlavaImageProcessor'''
	__magic_name__       =							('''BertTokenizer''', '''BertTokenizerFast''')





	def __init__( self   :					Optional[int]      ,      lowerCAmelCase_   :					Tuple=None      ,      lowerCAmelCase_   :					List[str]=None      ,      **lowerCAmelCase_   :					Union[str, Any]		)		->     List[Any]:
				UpperCAmelCase_	:					Any     	=   None
				if "feature_extractor" in kwargs:
							warnings.warn(
							    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
							    " instead."      ,      lowerCAmelCase_      ,      )
							UpperCAmelCase_	:					Tuple     	=   kwargs.pop("feature_extractor"		)

				UpperCAmelCase_	:					Optional[Any]     	=   image_processor if image_processor is not None else feature_extractor
				if image_processor is None:
							raise ValueError("You need to specify an `image_processor`."		)
				if tokenizer is None:
							raise ValueError("You need to specify a `tokenizer`."		)

				super().__init__(lowerCAmelCase_      ,      lowerCAmelCase_		)
				UpperCAmelCase_	:					List[str]     	=   self.image_processor





	def __call__( self   :					List[Any]      ,      lowerCAmelCase_   :					Optional[ImageInput] = None      ,      lowerCAmelCase_   :					Optional[Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None      ,      lowerCAmelCase_   :					bool = True      ,      lowerCAmelCase_   :					Union[bool, str, PaddingStrategy] = False      ,      lowerCAmelCase_   :					Union[bool, str, TruncationStrategy] = False      ,      lowerCAmelCase_   :					Optional[int] = None      ,      lowerCAmelCase_   :					int = 0      ,      lowerCAmelCase_   :					Optional[int] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = True      ,      lowerCAmelCase_   :					Optional[Union[str, TensorType]] = None      ,      **lowerCAmelCase_   :					Optional[int]      ,      )		->     List[Any]:

				if text is None and images is None:
							raise ValueError("You have to specify either text or images. Both cannot be none."		)

				if text is not None:
							UpperCAmelCase_	:					Union[str, Any]     	=   self.tokenizer(
							    text=lowerCAmelCase_      ,      add_special_tokens=lowerCAmelCase_      ,      padding=lowerCAmelCase_      ,      truncation=lowerCAmelCase_      ,      max_length=lowerCAmelCase_      ,      stride=lowerCAmelCase_      ,      pad_to_multiple_of=lowerCAmelCase_      ,      return_token_type_ids=lowerCAmelCase_      ,      return_attention_mask=lowerCAmelCase_      ,      return_overflowing_tokens=lowerCAmelCase_      ,      return_special_tokens_mask=lowerCAmelCase_      ,      return_offsets_mapping=lowerCAmelCase_      ,      return_length=lowerCAmelCase_      ,      verbose=lowerCAmelCase_      ,      return_tensors=lowerCAmelCase_      ,      **lowerCAmelCase_      ,      )
				if images is not None:
							UpperCAmelCase_	:					Optional[Any]     	=   self.image_processor(
							    lowerCAmelCase_      ,      return_image_mask=lowerCAmelCase_      ,      return_codebook_pixels=lowerCAmelCase_      ,      return_tensors=lowerCAmelCase_      ,      **lowerCAmelCase_      ,      )

				if text is not None and images is not None:
							encoding.update(lowerCAmelCase_		)
							return encoding
				elif text is not None:
							return encoding
				else:
							return BatchEncoding(data=dict(**lowerCAmelCase_		)      ,      tensor_type=lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[int]      ,      *lowerCAmelCase_   :					int      ,      **lowerCAmelCase_   :					List[str]		)		->     Any:
				return self.tokenizer.batch_decode(*lowerCAmelCase_      ,      **lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[Any]      ,      *lowerCAmelCase_   :					List[str]      ,      **lowerCAmelCase_   :					Optional[int]		)		->     List[Any]:
				return self.tokenizer.decode(*lowerCAmelCase_      ,      **lowerCAmelCase_		)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[Any]		)		->     int:
				UpperCAmelCase_	:					List[Any]     	=   self.tokenizer.model_input_names
				UpperCAmelCase_	:					Any     	=   self.image_processor.model_input_names
				return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names		)		)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple		)		->     Optional[Any]:
				warnings.warn(
				    "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."      ,      lowerCAmelCase_      ,      )
				return self.image_processor_class





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					str		)		->     int:
				warnings.warn(
				    "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."      ,      lowerCAmelCase_      ,      )
				return self.image_processor



