

"""simple docstring"""
from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

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


if is_tf_available():
 import tensorflow as tf

 from transformers import TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
 from PIL import Image

 from transformers import ConvNextImageProcessor

class        _UpperCamelCase	:


  """simple docstring"""





  def __init__( self					: str       ,       snake_case					: Optional[Any]       ,       snake_case					: Tuple=13       ,       snake_case					: Any=32       ,       snake_case					: Dict=3       ,       snake_case					: Union[str, Any]=4       ,       snake_case					: Union[str, Any]=[10, 20, 30, 40]       ,       snake_case					: Dict=[2, 2, 3, 2]       ,       snake_case					: int=True       ,       snake_case					: List[str]=True       ,       snake_case					: Optional[int]=37       ,       snake_case					: Tuple="gelu"       ,       snake_case					: int=10       ,       snake_case					: Union[str, Any]=0.02       ,       snake_case					: Dict=3       ,       snake_case					: Tuple=None       ,       )	->			int:


         '''simple docstring'''





         __magic_name__			:		str        =     parent
         __magic_name__			:		Optional[int]        =     batch_size
         __magic_name__			:		Dict        =     image_size
         __magic_name__			:		List[str]        =     num_channels
         __magic_name__			:		Optional[Any]        =     num_stages
         __magic_name__			:		str        =     hidden_sizes
         __magic_name__			:		str        =     depths
         __magic_name__			:		List[str]        =     is_training
         __magic_name__			:		Tuple        =     use_labels
         __magic_name__			:		Optional[int]        =     intermediate_size
         __magic_name__			:		List[Any]        =     hidden_act
         __magic_name__			:		Dict        =     type_sequence_label_size
         __magic_name__			:		int        =     initializer_range
         __magic_name__			:		Any        =     scope



  def 							_UpperCAmelCase      ( self					: str      )	->			Optional[int]:


         '''simple docstring'''





         __magic_name__			:		int        =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

         __magic_name__			:		Optional[Any]        =     None
         if self.use_labels:
                __magic_name__			:		Dict        =     ids_tensor([self.batch_size]       ,       self.type_sequence_label_size      )

         __magic_name__			:		Optional[Any]        =     self.get_config()

         return config, pixel_values, labels



  def 							_UpperCAmelCase      ( self					: Union[str, Any]      )	->			str:


         '''simple docstring'''





         return ConvNextConfig(
             num_channels=self.num_channels       ,       hidden_sizes=self.hidden_sizes       ,       depths=self.depths       ,       num_stages=self.num_stages       ,       hidden_act=self.hidden_act       ,       is_decoder=lowercase_       ,       initializer_range=self.initializer_range       ,       )



  def 							_UpperCAmelCase      ( self					: Dict       ,       snake_case					: Dict       ,       snake_case					: Tuple       ,       snake_case					: Optional[Any]      )	->			Any:


         '''simple docstring'''





         __magic_name__			:		List[str]        =     TFConvNextModel(config=lowercase_      )
         __magic_name__			:		Optional[Any]        =     model(lowercase_       ,       training=lowercase_      )
         # expected last hidden states: B, C, H // 32, W // 32
         self.parent.assertEqual(
             result.last_hidden_state.shape       ,       (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)       ,       )



  def 							_UpperCAmelCase      ( self					: Optional[Any]       ,       snake_case					: Optional[int]       ,       snake_case					: List[Any]       ,       snake_case					: Optional[Any]      )	->			Optional[int]:


         '''simple docstring'''





         __magic_name__			:		Tuple        =     self.type_sequence_label_size
         __magic_name__			:		Optional[int]        =     TFConvNextForImageClassification(lowercase_      )
         __magic_name__			:		Optional[int]        =     model(lowercase_       ,       labels=lowercase_       ,       training=lowercase_      )
         self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.type_sequence_label_size)      )




  def 							_UpperCAmelCase      ( self					: int      )	->			Dict:


         '''simple docstring'''





         __magic_name__			:		List[str]        =     self.prepare_config_and_inputs()
         __magic_name__       ,							__magic_name__       ,							__magic_name__			:		List[str]        =     config_and_inputs
         __magic_name__			:		Any        =     {'''pixel_values''': pixel_values}
         return config, inputs_dict

@require_tf
class        _UpperCamelCase	(						SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				unittest.TestCase	):


  """simple docstring"""





  snake_case_        =    (TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
  snake_case_        =    (
      {'feature-extraction': TFConvNextModel, 'image-classification': TFConvNextForImageClassification}
      if is_tf_available()
      else {}
  )

  snake_case_        =    False
  snake_case_        =    False
  snake_case_        =    False
  snake_case_        =    False
  snake_case_        =    False



  def 							_UpperCAmelCase      ( self					: List[Any]      )	->			str:


         '''simple docstring'''





         __magic_name__			:		Union[str, Any]        =     TFConvNextModelTester(self      )
         __magic_name__			:		List[Any]        =     ConfigTester(
             self       ,       config_class=lowercase_       ,       has_text_modality=lowercase_       ,       hidden_size=37       ,       )



  @unittest.skip(reason='''ConvNext does not use inputs_embeds'''      )
  def 							_UpperCAmelCase      ( self					: Any      )	->			Optional[int]:


         '''simple docstring'''





         pass



  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''      )      ) == 0       ,       reason='''TF does not support backprop for grouped convolutions on CPU.'''       ,       )
  @slow
  def 							_UpperCAmelCase      ( self					: Any      )	->			Optional[int]:


         '''simple docstring'''





         super().test_keras_fit()



  @unittest.skip(reason='''ConvNext does not support input and output embeddings'''      )
  def 							_UpperCAmelCase      ( self					: List[str]      )	->			List[Any]:


         '''simple docstring'''





         pass



  def 							_UpperCAmelCase      ( self					: str      )	->			Optional[int]:


         '''simple docstring'''





         __magic_name__       ,							__magic_name__			:		Optional[int]        =     self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                __magic_name__			:		Union[str, Any]        =     model_class(lowercase_      )
                __magic_name__			:		int        =     inspect.signature(model.call      )
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                __magic_name__			:		int        =     [*signature.parameters.keys()]

                __magic_name__			:		List[str]        =     ['''pixel_values''']
                self.assertListEqual(arg_names[:1]       ,       lowercase_      )



  def 							_UpperCAmelCase      ( self					: List[Any]      )	->			Dict:


         '''simple docstring'''





         __magic_name__			:		Dict        =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowercase_      )



  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''      )      ) == 0       ,       reason='''TF does not support backprop for grouped convolutions on CPU.'''       ,       )
  def 							_UpperCAmelCase      ( self					: List[str]      )	->			str:


         '''simple docstring'''





         super().test_dataset_conversion()



  def 							_UpperCAmelCase      ( self					: Dict      )	->			Any:


         '''simple docstring'''





         def check_hidden_states_output(snake_case					: Dict       ,       snake_case					: str       ,       snake_case					: Optional[Any]      ):
                __magic_name__			:		Optional[Any]        =     model_class(lowercase_      )

                __magic_name__			:		List[Any]        =     model(**self._prepare_for_class(lowercase_       ,       lowercase_      )      )
                __magic_name__			:		Union[str, Any]        =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                __magic_name__			:		Dict        =     self.model_tester.num_stages
                self.assertEqual(len(lowercase_      )       ,       expected_num_stages + 1      )

                # ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
                self.assertListEqual(
                    list(hidden_states[0].shape[-2:]      )       ,       [self.model_tester.image_size // 4, self.model_tester.image_size // 4]       ,       )

         __magic_name__       ,							__magic_name__			:		Optional[Any]        =     self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                __magic_name__			:		Tuple        =     True
                check_hidden_states_output(lowercase_       ,       lowercase_       ,       lowercase_      )

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                __magic_name__			:		Tuple        =     True

                check_hidden_states_output(lowercase_       ,       lowercase_       ,       lowercase_      )



  def 							_UpperCAmelCase      ( self					: Optional[int]      )	->			Optional[int]:


         '''simple docstring'''





         __magic_name__       ,							__magic_name__			:		int        =     self.model_tester.prepare_config_and_inputs_for_common()

         def check_equivalence(snake_case					: Union[str, Any]       ,       snake_case					: str       ,       snake_case					: Optional[Any]       ,       snake_case					: Tuple={}      ):
                __magic_name__			:		Optional[Any]        =     model(lowercase_       ,       return_dict=lowercase_       ,       **lowercase_      )
                __magic_name__			:		Union[str, Any]        =     model(lowercase_       ,       return_dict=lowercase_       ,       **lowercase_      ).to_tuple()

                def recursive_check(snake_case					: Optional[int]       ,       snake_case					: Union[str, Any]      ):
                       if isinstance(lowercase_       ,       (List, Tuple)      ):
                              for tuple_iterable_value, dict_iterable_value in zip(lowercase_       ,       lowercase_      ):
                                     recursive_check(lowercase_       ,       lowercase_      )
                       elif tuple_object is None:
                              return
                       else:
                              self.assertTrue(
                                  all(tf.equal(lowercase_       ,       lowercase_      )      )       ,       msg=(
                                      '''Tuple and dict output are not equal. Difference:'''
                                      f""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object      )      )}"""
                                  )       ,       )

                       recursive_check(lowercase_       ,       lowercase_      )

         for model_class in self.all_model_classes:
                __magic_name__			:		List[str]        =     model_class(lowercase_      )

                __magic_name__			:		List[Any]        =     self._prepare_for_class(lowercase_       ,       lowercase_      )
                __magic_name__			:		List[str]        =     self._prepare_for_class(lowercase_       ,       lowercase_      )
                check_equivalence(lowercase_       ,       lowercase_       ,       lowercase_      )

                __magic_name__			:		Tuple        =     self._prepare_for_class(lowercase_       ,       lowercase_       ,       return_labels=lowercase_      )
                __magic_name__			:		Optional[Any]        =     self._prepare_for_class(lowercase_       ,       lowercase_       ,       return_labels=lowercase_      )
                check_equivalence(lowercase_       ,       lowercase_       ,       lowercase_      )

                __magic_name__			:		Optional[Any]        =     self._prepare_for_class(lowercase_       ,       lowercase_      )
                __magic_name__			:		Dict        =     self._prepare_for_class(lowercase_       ,       lowercase_      )
                check_equivalence(lowercase_       ,       lowercase_       ,       lowercase_       ,       {'''output_hidden_states''': True}      )

                __magic_name__			:		Optional[Any]        =     self._prepare_for_class(lowercase_       ,       lowercase_       ,       return_labels=lowercase_      )
                __magic_name__			:		Any        =     self._prepare_for_class(lowercase_       ,       lowercase_       ,       return_labels=lowercase_      )
                check_equivalence(lowercase_       ,       lowercase_       ,       lowercase_       ,       {'''output_hidden_states''': True}      )



  def 							_UpperCAmelCase      ( self					: Tuple      )	->			List[str]:


         '''simple docstring'''





         __magic_name__			:		Union[str, Any]        =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*lowercase_      )




  @slow
  def 							_UpperCAmelCase      ( self					: Tuple      )	->			Union[str, Any]:


         '''simple docstring'''





         __magic_name__			:		Dict        =     TFConvNextModel.from_pretrained('''facebook/convnext-tiny-224'''      )
         self.assertIsNotNone(lowercase_      )







def       UpperCamelCase_					(     )						->     Optional[Any]:



       """simple docstring"""







       __magic_name__			:		Optional[Any]        =     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
       return image



@require_tf
@require_vision
class        _UpperCamelCase	(						unittest.TestCase	):


  """simple docstring"""





  @cached_property
  def 							_UpperCAmelCase      ( self					: Union[str, Any]      )	->			Dict:


         '''simple docstring'''





         return ConvNextImageProcessor.from_pretrained('''facebook/convnext-tiny-224'''      ) if is_vision_available() else None




  @slow
  def 							_UpperCAmelCase      ( self					: Any      )	->			Optional[Any]:


         '''simple docstring'''





         __magic_name__			:		Union[str, Any]        =     TFConvNextForImageClassification.from_pretrained('''facebook/convnext-tiny-224'''      )

         __magic_name__			:		Optional[int]        =     self.default_image_processor
         __magic_name__			:		int        =     prepare_img()
         __magic_name__			:		Union[str, Any]        =     image_processor(images=lowercase_       ,       return_tensors='''tf'''      )

         # forward pass
         __magic_name__			:		Tuple        =     model(**lowercase_      )

         # verify the logits
         __magic_name__			:		Optional[int]        =     tf.TensorShape((1, 1000)      )
         self.assertEqual(outputs.logits.shape       ,       lowercase_      )

         __magic_name__			:		Tuple        =     tf.constant([-0.0260, -0.4739, 0.1911]      )

         tf.debugging.assert_near(outputs.logits[0, :3]       ,       lowercase_       ,       atol=1e-4      )





"""simple docstring"""


import importlib
import inspect
import json
import os
from collections import OrderedDict

# 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 ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import 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,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


snake_case_								=			logging.get_logger(__name__)

snake_case_								=			OrderedDict(
    [
        ("""align""", """AlignProcessor"""),
        ("""altclip""", """AltCLIPProcessor"""),
        ("""bark""", """BarkProcessor"""),
        ("""blip""", """BlipProcessor"""),
        ("""blip-2""", """Blip2Processor"""),
        ("""bridgetower""", """BridgeTowerProcessor"""),
        ("""chinese_clip""", """ChineseCLIPProcessor"""),
        ("""clap""", """ClapProcessor"""),
        ("""clip""", """CLIPProcessor"""),
        ("""clipseg""", """CLIPSegProcessor"""),
        ("""flava""", """FlavaProcessor"""),
        ("""git""", """GitProcessor"""),
        ("""groupvit""", """CLIPProcessor"""),
        ("""hubert""", """Wav2Vec2Processor"""),
        ("""instructblip""", """InstructBlipProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2Processor"""),
        ("""layoutlmv3""", """LayoutLMv3Processor"""),
        ("""markuplm""", """MarkupLMProcessor"""),
        ("""mctct""", """MCTCTProcessor"""),
        ("""mgp-str""", """MgpstrProcessor"""),
        ("""oneformer""", """OneFormerProcessor"""),
        ("""owlvit""", """OwlViTProcessor"""),
        ("""pix2struct""", """Pix2StructProcessor"""),
        ("""sam""", """SamProcessor"""),
        ("""sew""", """Wav2Vec2Processor"""),
        ("""sew-d""", """Wav2Vec2Processor"""),
        ("""speech_to_text""", """Speech2TextProcessor"""),
        ("""speech_to_text_2""", """Speech2Text2Processor"""),
        ("""speecht5""", """SpeechT5Processor"""),
        ("""trocr""", """TrOCRProcessor"""),
        ("""tvlt""", """TvltProcessor"""),
        ("""unispeech""", """Wav2Vec2Processor"""),
        ("""unispeech-sat""", """Wav2Vec2Processor"""),
        ("""vilt""", """ViltProcessor"""),
        ("""vision-text-dual-encoder""", """VisionTextDualEncoderProcessor"""),
        ("""wav2vec2""", """Wav2Vec2Processor"""),
        ("""wav2vec2-conformer""", """Wav2Vec2Processor"""),
        ("""wavlm""", """Wav2Vec2Processor"""),
        ("""whisper""", """WhisperProcessor"""),
        ("""xclip""", """XCLIPProcessor"""),
    ]
)

snake_case_								=			_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)

def 					_lowerCAmelCase (  lowercase_		):
						for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
												if class_name in processors:
																		UpperCAmelCase			 =					model_type_to_module_name(lowercase_		)

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

						for processor in PROCESSOR_MAPPING._extra_content.values():
												if getattr(lowercase_						,      '__name__'						,      lowercase_		) == class_name:
																		return processor

    # 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(lowercase_						,      lowercase_		):
												return getattr(lowercase_						,      lowercase_		)

						return None







class  A_     :



						"""simple docstring"""






						def __init__(   self					:Optional[Any]   )							->     str:
												raise EnvironmentError(
												    'AutoProcessor is designed to be instantiated '
												    'using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method.'   )






						@classmethod
						@replace_list_option_in_docstrings(lowercase_   )
						def       UpperCAmelCase__	(   cls					:Optional[int]  ,    lowercase_					:Tuple  ,    **lowercase_					:int   )							->     Optional[int]:
												UpperCAmelCase			 =					kwargs.pop('config'  ,    lowercase_   )
												UpperCAmelCase			 =					kwargs.pop('trust_remote_code'  ,    lowercase_   )
												UpperCAmelCase			 =					True

												UpperCAmelCase			 =					None
												UpperCAmelCase			 =					None

												# First, let's see if we have a preprocessor config.
												# Filter the kwargs for `get_file_from_repo`.
												UpperCAmelCase			 =					{
												    key: kwargs[key] for key in inspect.signature(lowercase_   ).parameters.keys() if key in kwargs
												}
												# Let's start by checking whether the processor class is saved in an image processor
												UpperCAmelCase			 =					get_file_from_repo(
												    lowercase_  ,    lowercase_  ,    **lowercase_   )
												if preprocessor_config_file is not None:
																		UpperCAmelCase ,       UpperCAmelCase			 =					ImageProcessingMixin.get_image_processor_dict(lowercase_  ,    **lowercase_   )
																		UpperCAmelCase			 =					config_dict.get('processor_class'  ,    lowercase_   )
																		if "AutoProcessor" in config_dict.get('auto_map'  ,    {}   ):
																								UpperCAmelCase			 =					config_dict['auto_map']['AutoProcessor']

        # If not found, let's check whether the processor class is saved in a feature extractor config
												if preprocessor_config_file is not None and processor_class is None:
																		UpperCAmelCase ,       UpperCAmelCase			 =					FeatureExtractionMixin.get_feature_extractor_dict(lowercase_  ,    **lowercase_   )
																		UpperCAmelCase			 =					config_dict.get('processor_class'  ,    lowercase_   )
																		if "AutoProcessor" in config_dict.get('auto_map'  ,    {}   ):
																								UpperCAmelCase			 =					config_dict['auto_map']['AutoProcessor']

												if processor_class is None:
																		# Next, let's check whether the processor class is saved in a tokenizer
																		UpperCAmelCase			 =					get_file_from_repo(
																		    lowercase_  ,    lowercase_  ,    **lowercase_   )
																		if tokenizer_config_file is not None:
																								with open(lowercase_  ,    encoding='utf-8'   ) as reader:
																														UpperCAmelCase			 =					json.load(lowercase_   )

																								UpperCAmelCase			 =					config_dict.get('processor_class'  ,    lowercase_   )
																								if "AutoProcessor" in config_dict.get('auto_map'  ,    {}   ):
																														UpperCAmelCase			 =					config_dict['auto_map']['AutoProcessor']

												if processor_class is None:
																		# Otherwise, load config, if it can be loaded.
																		if not isinstance(lowercase_  ,    lowercase_   ):
																								UpperCAmelCase			 =					AutoConfig.from_pretrained(
																								    lowercase_  ,    trust_remote_code=lowercase_  ,    **lowercase_   )

																		# And check if the config contains the processor class.
																		UpperCAmelCase			 =					getattr(lowercase_  ,    'processor_class'  ,    lowercase_   )
																		if hasattr(lowercase_  ,    'auto_map'   ) and "AutoProcessor" in config.auto_map:
																								UpperCAmelCase			 =					config.auto_map['AutoProcessor']

												if processor_class is not None:
																		UpperCAmelCase			 =					processor_class_from_name(lowercase_   )

												UpperCAmelCase			 =					processor_auto_map is not None
												UpperCAmelCase			 =					processor_class is not None or type(lowercase_   ) in PROCESSOR_MAPPING
												UpperCAmelCase			 =					resolve_trust_remote_code(
												    lowercase_  ,    lowercase_  ,    lowercase_  ,    lowercase_   )

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

												# At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
												# tokenizer.
												try:
																		return AutoTokenizer.from_pretrained(
																		    lowercase_  ,    trust_remote_code=lowercase_  ,    **lowercase_   )
												except Exception:
																		try:
																								return AutoImageProcessor.from_pretrained(
																								    lowercase_  ,    trust_remote_code=lowercase_  ,    **lowercase_   )
																		except Exception:
																								pass

																		try:
																								return AutoFeatureExtractor.from_pretrained(
																								    lowercase_  ,    trust_remote_code=lowercase_  ,    **lowercase_   )
																		except Exception:
																								pass

												raise ValueError(
												    f"""Unrecognized processing class in {pretrained_model_name_or_path}. Can't instantiate a processor, a """
												    'tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains'
												    'the files of at least one of those processing classes.'   )






						@staticmethod
						def       UpperCAmelCase__	(   lowercase_					:int  ,    lowercase_					:Union[str, Any]   )							->     Tuple:
												PROCESSOR_MAPPING.register(lowercase_  ,    lowercase_   )





