





import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_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,
)


__A							:       Tuple         =  logging.get_logger(__name__)

__A							:       Optional[Any]         =  OrderedDict(
    [
        ("align", "EfficientNetImageProcessor"),
        ("beit", "BeitImageProcessor"),
        ("bit", "BitImageProcessor"),
        ("blip", "BlipImageProcessor"),
        ("blip-2", "BlipImageProcessor"),
        ("bridgetower", "BridgeTowerImageProcessor"),
        ("chinese_clip", "ChineseCLIPImageProcessor"),
        ("clip", "CLIPImageProcessor"),
        ("clipseg", "ViTImageProcessor"),
        ("conditional_detr", "ConditionalDetrImageProcessor"),
        ("convnext", "ConvNextImageProcessor"),
        ("convnextv2", "ConvNextImageProcessor"),
        ("cvt", "ConvNextImageProcessor"),
        ("data2vec-vision", "BeitImageProcessor"),
        ("deformable_detr", "DeformableDetrImageProcessor"),
        ("deit", "DeiTImageProcessor"),
        ("deta", "DetaImageProcessor"),
        ("detr", "DetrImageProcessor"),
        ("dinat", "ViTImageProcessor"),
        ("donut-swin", "DonutImageProcessor"),
        ("dpt", "DPTImageProcessor"),
        ("efficientformer", "EfficientFormerImageProcessor"),
        ("efficientnet", "EfficientNetImageProcessor"),
        ("flava", "FlavaImageProcessor"),
        ("focalnet", "BitImageProcessor"),
        ("git", "CLIPImageProcessor"),
        ("glpn", "GLPNImageProcessor"),
        ("groupvit", "CLIPImageProcessor"),
        ("imagegpt", "ImageGPTImageProcessor"),
        ("instructblip", "BlipImageProcessor"),
        ("layoutlmv2", "LayoutLMv2ImageProcessor"),
        ("layoutlmv3", "LayoutLMv3ImageProcessor"),
        ("levit", "LevitImageProcessor"),
        ("mask2former", "Mask2FormerImageProcessor"),
        ("maskformer", "MaskFormerImageProcessor"),
        ("mgp-str", "ViTImageProcessor"),
        ("mobilenet_v1", "MobileNetV1ImageProcessor"),
        ("mobilenet_v2", "MobileNetV2ImageProcessor"),
        ("mobilevit", "MobileViTImageProcessor"),
        ("mobilevit", "MobileViTImageProcessor"),
        ("mobilevitv2", "MobileViTImageProcessor"),
        ("nat", "ViTImageProcessor"),
        ("oneformer", "OneFormerImageProcessor"),
        ("owlvit", "OwlViTImageProcessor"),
        ("perceiver", "PerceiverImageProcessor"),
        ("pix2struct", "Pix2StructImageProcessor"),
        ("poolformer", "PoolFormerImageProcessor"),
        ("regnet", "ConvNextImageProcessor"),
        ("resnet", "ConvNextImageProcessor"),
        ("sam", "SamImageProcessor"),
        ("segformer", "SegformerImageProcessor"),
        ("swiftformer", "ViTImageProcessor"),
        ("swin", "ViTImageProcessor"),
        ("swin2sr", "Swin2SRImageProcessor"),
        ("swinv2", "ViTImageProcessor"),
        ("table-transformer", "DetrImageProcessor"),
        ("timesformer", "VideoMAEImageProcessor"),
        ("tvlt", "TvltImageProcessor"),
        ("upernet", "SegformerImageProcessor"),
        ("van", "ConvNextImageProcessor"),
        ("videomae", "VideoMAEImageProcessor"),
        ("vilt", "ViltImageProcessor"),
        ("vit", "ViTImageProcessor"),
        ("vit_hybrid", "ViTHybridImageProcessor"),
        ("vit_mae", "ViTImageProcessor"),
        ("vit_msn", "ViTImageProcessor"),
        ("xclip", "CLIPImageProcessor"),
        ("yolos", "YolosImageProcessor"),
    ]
)

__A							:       Optional[Any]         =  _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)





def 		__SCREAMING_SNAKE_CASE    (							UpperCamelCase__					)    ->							Optional[int]:







			'''simple docstring'''

			for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
						if class_name in extractors:
									UpperCAmelCase  						=							model_type_to_module_name(SCREAMING_SNAKE_CASE_					)

									UpperCAmelCase  						=							importlib.import_module(F""".{module_name}"""     ,     '''transformers.models'''					)
									try:
												return getattr(SCREAMING_SNAKE_CASE_     ,     SCREAMING_SNAKE_CASE_					)
									except AttributeError:
												continue

			for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
						if getattr(SCREAMING_SNAKE_CASE_     ,     '''__name__'''     ,     SCREAMING_SNAKE_CASE_					) == 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.
			UpperCAmelCase  						=							importlib.import_module('''transformers'''					)
			if hasattr(SCREAMING_SNAKE_CASE_     ,     SCREAMING_SNAKE_CASE_					):
						return getattr(SCREAMING_SNAKE_CASE_     ,     SCREAMING_SNAKE_CASE_					)

			return None





def 		__SCREAMING_SNAKE_CASE    (							UpperCamelCase__     ,     UpperCamelCase__ = None     ,     UpperCamelCase__ = False     ,     UpperCamelCase__ = False     ,     UpperCamelCase__ = None     ,     UpperCamelCase__ = None     ,     UpperCamelCase__ = None     ,     UpperCamelCase__ = False     ,     **UpperCamelCase__     ,     )    ->							Tuple:







			'''simple docstring'''

			UpperCAmelCase  						=							get_file_from_repo(
			    SCREAMING_SNAKE_CASE_     ,     SCREAMING_SNAKE_CASE_     ,     cache_dir=SCREAMING_SNAKE_CASE_     ,     force_download=SCREAMING_SNAKE_CASE_     ,     resume_download=SCREAMING_SNAKE_CASE_     ,     proxies=SCREAMING_SNAKE_CASE_     ,     use_auth_token=SCREAMING_SNAKE_CASE_     ,     revision=SCREAMING_SNAKE_CASE_     ,     local_files_only=SCREAMING_SNAKE_CASE_     ,     )
			if resolved_config_file is None:
						logger.info(
						    '''Could not locate the image processor configuration file, will try to use the model config instead.'''					)
						return {}

			with open(SCREAMING_SNAKE_CASE_     ,     encoding='''utf-8'''					) as reader:
						return json.load(SCREAMING_SNAKE_CASE_					)






class       A_			:
	def __init__(       self						):






				'''simple docstring'''







				raise EnvironmentError(
				    '''AutoImageProcessor is designed to be instantiated '''
				    '''using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.'''						)
	@classmethod
	@replace_list_option_in_docstrings(_UpperCamelCase						)
	def 	_lowercase							(       cls				,   _A				,   **_A						):






				'''simple docstring'''







				UpperCAmelCase  						=							kwargs.pop('''config'''				,   _UpperCamelCase						)
				UpperCAmelCase  						=							kwargs.pop('''trust_remote_code'''				,   _UpperCamelCase						)
				UpperCAmelCase  						=							True

				UpperCAmelCase						,     UpperCAmelCase  						=							ImageProcessingMixin.get_image_processor_dict(_UpperCamelCase				,   **_UpperCamelCase						)
				UpperCAmelCase  						=							config_dict.get('''image_processor_type'''				,   _UpperCamelCase						)
				UpperCAmelCase  						=							None
				if "AutoImageProcessor" in config_dict.get('''auto_map'''				,   {}						):
							UpperCAmelCase  						=							config_dict['''auto_map''']['''AutoImageProcessor''']

				# If we still don't have the image processor class, check if we're loading from a previous feature extractor config
				# and if so, infer the image processor class from there.
				if image_processor_class is None and image_processor_auto_map is None:
							UpperCAmelCase  						=							config_dict.pop('''feature_extractor_type'''				,   _UpperCamelCase						)
							if feature_extractor_class is not None:
										logger.warning(
										    '''Could not find image processor class in the image processor config or the model config. Loading'''
										    ''' based on pattern matching with the model\'s feature extractor configuration.'''						)
										UpperCAmelCase  						=							feature_extractor_class.replace('''FeatureExtractor'''				,   '''ImageProcessor'''						)
							if "AutoFeatureExtractor" in config_dict.get('''auto_map'''				,   {}						):
										UpperCAmelCase  						=							config_dict['''auto_map''']['''AutoFeatureExtractor''']
										UpperCAmelCase  						=							feature_extractor_auto_map.replace('''FeatureExtractor'''				,   '''ImageProcessor'''						)
										logger.warning(
										    '''Could not find image processor auto map in the image processor config or the model config.'''
										    ''' Loading based on pattern matching with the model\'s feature extractor configuration.'''						)

        # If we don't find the image processor class in the image processor config, let's try the model config.
				if image_processor_class is None and image_processor_auto_map is None:
							if not isinstance(_UpperCamelCase				,   _UpperCamelCase						):
										UpperCAmelCase  						=							AutoConfig.from_pretrained(_UpperCamelCase				,   **_UpperCamelCase						)
							# It could be in `config.image_processor_type``
							UpperCAmelCase  						=							getattr(_UpperCamelCase				,   '''image_processor_type'''				,   _UpperCamelCase						)
							if hasattr(_UpperCamelCase				,   '''auto_map'''						) and "AutoImageProcessor" in config.auto_map:
										UpperCAmelCase  						=							config.auto_map['''AutoImageProcessor''']

				if image_processor_class is not None:
							UpperCAmelCase  						=							image_processor_class_from_name(_UpperCamelCase						)

				UpperCAmelCase  						=							image_processor_auto_map is not None
				UpperCAmelCase  						=							image_processor_class is not None or type(_UpperCamelCase						) in IMAGE_PROCESSOR_MAPPING
				UpperCAmelCase  						=							resolve_trust_remote_code(
				    _UpperCamelCase				,   _UpperCamelCase				,   _UpperCamelCase				,   _UpperCamelCase						)

				if has_remote_code and trust_remote_code:
							UpperCAmelCase  						=							get_class_from_dynamic_module(
							    _UpperCamelCase				,   _UpperCamelCase				,   **_UpperCamelCase						)
							UpperCAmelCase  						=							kwargs.pop('''code_revision'''				,   _UpperCamelCase						)
							if os.path.isdir(_UpperCamelCase						):
										image_processor_class.register_for_auto_class()
							return image_processor_class.from_dict(_UpperCamelCase				,   **_UpperCamelCase						)
				elif image_processor_class is not None:
							return image_processor_class.from_dict(_UpperCamelCase				,   **_UpperCamelCase						)
				# Last try: we use the IMAGE_PROCESSOR_MAPPING.
				elif type(_UpperCamelCase						) in IMAGE_PROCESSOR_MAPPING:
							UpperCAmelCase  						=							IMAGE_PROCESSOR_MAPPING[type(_UpperCamelCase						)]
							return image_processor_class.from_dict(_UpperCamelCase				,   **_UpperCamelCase						)

				raise ValueError(
				    F"""Unrecognized image processor in {pretrained_model_name_or_path}. Should have a """
				    F"""`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following """
				    F"""`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys()						)}"""						)







	@staticmethod
	def 	_lowercase							(       _A				,   _A						):






				'''simple docstring'''







				IMAGE_PROCESSOR_MAPPING.register(_UpperCamelCase				,   _UpperCamelCase						)










import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       LiltForQuestionAnswering,
       LiltForSequenceClassification,
       LiltForTokenClassification,
       LiltModel,
   )
   from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST




class 			__UpperCamelCase    :





     def __init__(     self				,							_UpperCamelCase				,							_UpperCamelCase=13				,							_UpperCamelCase=7				,							_UpperCamelCase=True				,							_UpperCamelCase=True				,							_UpperCamelCase=True				,							_UpperCamelCase=True				,							_UpperCamelCase=99				,							_UpperCamelCase=24				,							_UpperCamelCase=2				,							_UpperCamelCase=6				,							_UpperCamelCase=37				,							_UpperCamelCase="gelu"				,							_UpperCamelCase=0.1				,							_UpperCamelCase=0.1				,							_UpperCamelCase=512				,							_UpperCamelCase=16				,							_UpperCamelCase=2				,							_UpperCamelCase=0.02				,							_UpperCamelCase=3				,							_UpperCamelCase=None				,							_UpperCamelCase=1000				,							):
        _UpperCAmelCase           =   parent
        _UpperCAmelCase           =   batch_size
        _UpperCAmelCase           =   seq_length
        _UpperCAmelCase           =   is_training
        _UpperCAmelCase           =   use_input_mask
        _UpperCAmelCase           =   use_token_type_ids
        _UpperCAmelCase           =   use_labels
        _UpperCAmelCase           =   vocab_size
        _UpperCAmelCase           =   hidden_size
        _UpperCAmelCase           =   num_hidden_layers
        _UpperCAmelCase           =   num_attention_heads
        _UpperCAmelCase           =   intermediate_size
        _UpperCAmelCase           =   hidden_act
        _UpperCAmelCase           =   hidden_dropout_prob
        _UpperCAmelCase           =   attention_probs_dropout_prob
        _UpperCAmelCase           =   max_position_embeddings
        _UpperCAmelCase           =   type_vocab_size
        _UpperCAmelCase           =   type_sequence_label_size
        _UpperCAmelCase           =   initializer_range
        _UpperCAmelCase           =   num_labels
        _UpperCAmelCase           =   scope
        _UpperCAmelCase           =   range_bbox





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   ids_tensor([self.batch_size, self.seq_length]				,							self.vocab_size					)

        _UpperCAmelCase           =   ids_tensor([self.batch_size, self.seq_length, 4]				,							self.range_bbox					)
        # Ensure that bbox is legal
        for i in range(bbox.shape[0]					):
           for j in range(bbox.shape[1]					):
              if bbox[i, j, 3] < bbox[i, j, 1]:
                 _UpperCAmelCase           =   bbox[i, j, 3]
                 _UpperCAmelCase           =   bbox[i, j, 1]
                 _UpperCAmelCase           =   t
              if bbox[i, j, 2] < bbox[i, j, 0]:
                 _UpperCAmelCase           =   bbox[i, j, 2]
                 _UpperCAmelCase           =   bbox[i, j, 0]
                 _UpperCAmelCase           =   t

        _UpperCAmelCase           =   None
        if self.use_input_mask:
           _UpperCAmelCase           =   ids_tensor([self.batch_size, self.seq_length]				,							vocab_size=2					)

        _UpperCAmelCase           =   None
        if self.use_token_type_ids:
           _UpperCAmelCase           =   ids_tensor([self.batch_size, self.seq_length]				,							self.type_vocab_size					)

        _UpperCAmelCase           =   None
        _UpperCAmelCase           =   None
        if self.use_labels:
           _UpperCAmelCase           =   ids_tensor([self.batch_size]				,							self.type_sequence_label_size					)
           _UpperCAmelCase           =   ids_tensor([self.batch_size, self.seq_length]				,							self.num_labels					)

        _UpperCAmelCase           =   self.get_config()

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





     def 		UpperCamelCase(     self					):
        return LiltConfig(
            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				,							initializer_range=self.initializer_range				,							)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							):
        _UpperCAmelCase           =   LiltModel(config=_UpperCamelCase					)
        model.to(_UpperCamelCase					)
        model.eval()
        _UpperCAmelCase           =   model(_UpperCamelCase				,							bbox=_UpperCamelCase				,							attention_mask=_UpperCamelCase				,							token_type_ids=_UpperCamelCase					)
        _UpperCAmelCase           =   model(_UpperCamelCase				,							bbox=_UpperCamelCase				,							token_type_ids=_UpperCamelCase					)
        _UpperCAmelCase           =   model(_UpperCamelCase				,							bbox=_UpperCamelCase					)

        self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, self.seq_length, self.hidden_size)					)
        self.parent.assertEqual(result.pooler_output.shape				,							(self.batch_size, self.hidden_size)					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							):
        _UpperCAmelCase           =   self.num_labels
        _UpperCAmelCase           =   LiltForTokenClassification(config=_UpperCamelCase					)
        model.to(_UpperCamelCase					)
        model.eval()
        _UpperCAmelCase           =   model(
            _UpperCamelCase				,							bbox=_UpperCamelCase				,							attention_mask=_UpperCamelCase				,							token_type_ids=_UpperCamelCase				,							labels=_UpperCamelCase					)
        self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.seq_length, self.num_labels)					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							):
        _UpperCAmelCase           =   LiltForQuestionAnswering(config=_UpperCamelCase					)
        model.to(_UpperCamelCase					)
        model.eval()
        _UpperCAmelCase           =   model(
            _UpperCamelCase				,							bbox=_UpperCamelCase				,							attention_mask=_UpperCamelCase				,							token_type_ids=_UpperCamelCase				,							start_positions=_UpperCamelCase				,							end_positions=_UpperCamelCase				,							)
        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)					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.prepare_config_and_inputs()
        (
            (
            _UpperCAmelCase
        )       ,      (
            _UpperCAmelCase
        )       ,      (
            _UpperCAmelCase
        )       ,      (
            _UpperCAmelCase
        )       ,      (
            _UpperCAmelCase
        )       ,      (
            _UpperCAmelCase
        )       ,      (
            _UpperCAmelCase
        )       ,      
        )           =   config_and_inputs
        _UpperCAmelCase           =   {
            '''input_ids''': input_ids,
            '''bbox''': bbox,
            '''token_type_ids''': token_type_ids,
            '''attention_mask''': input_mask,
        }
        return config, inputs_dict




@require_torch
class 			__UpperCamelCase    (							A__	, A__	, A__	, unittest.TestCase    ):
     __A	:  Dict							  =   (
         (
             LiltModel,
             LiltForSequenceClassification,
             LiltForTokenClassification,
             LiltForQuestionAnswering,
         )
         if is_torch_available()
         else ()
     )
     __A	:  Optional[Any]							  =   (
         {
             """feature-extraction""": LiltModel,
             """question-answering""": LiltForQuestionAnswering,
             """text-classification""": LiltForSequenceClassification,
             """token-classification""": LiltForTokenClassification,
             """zero-shot""": LiltForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     __A	:  List[Any]							  =   False
     __A	:  Optional[int]							  =   False





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					):
        return True





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   LiltModelTester(self					)
        _UpperCAmelCase           =   ConfigTester(self				,							config_class=_UpperCamelCase				,							hidden_size=37					)





     def 		UpperCamelCase(     self					):
        self.config_tester.run_common_tests()





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
           _UpperCAmelCase           =   type
           self.model_tester.create_and_check_model(*_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase					)





     @slow
     def 		UpperCamelCase(     self					):
        for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _UpperCAmelCase           =   LiltModel.from_pretrained(_UpperCamelCase					)
           self.assertIsNotNone(_UpperCamelCase					)




@require_torch
@slow
class 			__UpperCamelCase    (							unittest.TestCase    ):





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   LiltModel.from_pretrained('''SCUT-DLVCLab/lilt-roberta-en-base'''					).to(_UpperCamelCase					)

        _UpperCAmelCase           =   torch.tensor([[1, 2]]				,							device=_UpperCamelCase					)
        _UpperCAmelCase           =   torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]				,							device=_UpperCamelCase					)

        # forward pass
        with torch.no_grad():
           _UpperCAmelCase           =   model(input_ids=_UpperCamelCase				,							bbox=_UpperCamelCase					)

        _UpperCAmelCase           =   torch.Size([1, 2, 768]					)
        _UpperCAmelCase           =   torch.tensor(
            [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]				,							device=_UpperCamelCase				,							)

        self.assertTrue(outputs.last_hidden_state.shape				,							_UpperCamelCase					)
        self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]				,							_UpperCamelCase				,							atol=1e-3					)					)