code: 
  
  
  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
  
  
  lowercase_								=    logging.get_logger(__name__)
  
  lowercase_								=    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'),
      ]
  )
  
  lowercase_								=    _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  Tuple:
  						for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
  												if class_name in processors:
  																		_a     =			model_type_to_module_name(_UpperCAmelCase				)
  
  																		_a     =			importlib.import_module(f""".{module_name}"""							,     'transformers.models'				)
  																		try:
  																								return getattr(_UpperCAmelCase							,     _UpperCAmelCase				)
  																		except AttributeError:
  																								continue
  
  						for processor in PROCESSOR_MAPPING._extra_content.values():
  												if getattr(_UpperCAmelCase							,     '__name__'							,     _UpperCAmelCase				) == 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.
  						_a     =			importlib.import_module('transformers'				)
  						if hasattr(_UpperCAmelCase							,     _UpperCAmelCase				):
  												return getattr(_UpperCAmelCase							,     _UpperCAmelCase				)
  
  						return None
  
  
  
  
  
  
  class 					_UpperCamelCase :
  
  
  
  
  
  
  
  							'''simple docstring'''
  
  
  
  
  
  
  
  							def __init__(		self  :				List[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(SCREAMING_SNAKE_CASE_		)
  							def 		_UpperCAmelCase	(		cls  :				Optional[int]		,				SCREAMING_SNAKE_CASE_  :				Tuple		,				**SCREAMING_SNAKE_CASE_  :				List[Any]		):
  													_a     =			kwargs.pop('config'		,				SCREAMING_SNAKE_CASE_		)
  													_a     =			kwargs.pop('trust_remote_code'		,				SCREAMING_SNAKE_CASE_		)
  													_a     =			True
  
  													_a     =			None
  													_a     =			None
  
  													# First, let's see if we have a preprocessor config.
  													# Filter the kwargs for `get_file_from_repo`.
  													_a     =			{
  													    key: kwargs[key] for key in inspect.signature(SCREAMING_SNAKE_CASE_		).parameters.keys() if key in kwargs
  													}
  													# Let's start by checking whether the processor class is saved in an image processor
  													_a     =			get_file_from_repo(
  													    SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  													if preprocessor_config_file is not None:
  																			_a ,	_a     =			ImageProcessingMixin.get_image_processor_dict(SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  																			_a     =			config_dict.get('processor_class'		,				SCREAMING_SNAKE_CASE_		)
  																			if "AutoProcessor" in config_dict.get('auto_map'		,				{}		):
  																									_a     =			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:
  																			_a ,	_a     =			FeatureExtractionMixin.get_feature_extractor_dict(SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  																			_a     =			config_dict.get('processor_class'		,				SCREAMING_SNAKE_CASE_		)
  																			if "AutoProcessor" in config_dict.get('auto_map'		,				{}		):
  																									_a     =			config_dict['auto_map']['AutoProcessor']
  
  													if processor_class is None:
  																			# Next, let's check whether the processor class is saved in a tokenizer
  																			_a     =			get_file_from_repo(
  																			    SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  																			if tokenizer_config_file is not None:
  																									with open(SCREAMING_SNAKE_CASE_		,				encoding='utf-8'		) as reader:
  																															_a     =			json.load(SCREAMING_SNAKE_CASE_		)
  
  																									_a     =			config_dict.get('processor_class'		,				SCREAMING_SNAKE_CASE_		)
  																									if "AutoProcessor" in config_dict.get('auto_map'		,				{}		):
  																															_a     =			config_dict['auto_map']['AutoProcessor']
  
  													if processor_class is None:
  																			# Otherwise, load config, if it can be loaded.
  																			if not isinstance(SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		):
  																									_a     =			AutoConfig.from_pretrained(
  																									    SCREAMING_SNAKE_CASE_		,				trust_remote_code=SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  
  																			# And check if the config contains the processor class.
  																			_a     =			getattr(SCREAMING_SNAKE_CASE_		,				'processor_class'		,				SCREAMING_SNAKE_CASE_		)
  																			if hasattr(SCREAMING_SNAKE_CASE_		,				'auto_map'		) and "AutoProcessor" in config.auto_map:
  																									_a     =			config.auto_map['AutoProcessor']
  
  													if processor_class is not None:
  																			_a     =			processor_class_from_name(SCREAMING_SNAKE_CASE_		)
  
  													_a     =			processor_auto_map is not None
  													_a     =			processor_class is not None or type(SCREAMING_SNAKE_CASE_		) in PROCESSOR_MAPPING
  													_a     =			resolve_trust_remote_code(
  													    SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		)
  
  													if has_remote_code and trust_remote_code:
  																			_a     =			get_class_from_dynamic_module(
  																			    SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  																			_a     =			kwargs.pop('code_revision'		,				SCREAMING_SNAKE_CASE_		)
  																			if os.path.isdir(SCREAMING_SNAKE_CASE_		):
  																									processor_class.register_for_auto_class()
  																			return processor_class.from_pretrained(
  																			    SCREAMING_SNAKE_CASE_		,				trust_remote_code=SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  													elif processor_class is not None:
  																			return processor_class.from_pretrained(
  																			    SCREAMING_SNAKE_CASE_		,				trust_remote_code=SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  													# Last try: we use the PROCESSOR_MAPPING.
  													elif type(SCREAMING_SNAKE_CASE_		) in PROCESSOR_MAPPING:
  																			return PROCESSOR_MAPPING[type(SCREAMING_SNAKE_CASE_		)].from_pretrained(SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  
  													# 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(
  																			    SCREAMING_SNAKE_CASE_		,				trust_remote_code=SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  													except Exception:
  																			try:
  																									return AutoImageProcessor.from_pretrained(
  																									    SCREAMING_SNAKE_CASE_		,				trust_remote_code=SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  																			except Exception:
  																									pass
  
  																			try:
  																									return AutoFeatureExtractor.from_pretrained(
  																									    SCREAMING_SNAKE_CASE_		,				trust_remote_code=SCREAMING_SNAKE_CASE_		,				**SCREAMING_SNAKE_CASE_		)
  																			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	(		SCREAMING_SNAKE_CASE_  :				Optional[int]		,				SCREAMING_SNAKE_CASE_  :				int		):
  													PROCESSOR_MAPPING.register(SCREAMING_SNAKE_CASE_		,				SCREAMING_SNAKE_CASE_		)
  
  
  
style_context: 
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  bool:
  						# must be
  						_a     =			[list(_UpperCAmelCase				) for row in matrix]
  						if matrix and isinstance(_UpperCAmelCase							,     _UpperCAmelCase				):
  												if isinstance(matrix[0]							,     _UpperCAmelCase				):
  																		_a     =			0
  																		for row in matrix:
  																								if prev_len == 0:
  																														_a     =			len(_UpperCAmelCase				)
  																														_a     =			True
  																								else:
  																														_a     =			prev_len == len(_UpperCAmelCase				)
  												else:
  																		_a     =			True
  						else:
  												_a     =			False
  
  						return result
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  None:
  						if check_matrix(_UpperCAmelCase				) and len(_UpperCAmelCase				) > 0:
  												_a     =			[list(_UpperCAmelCase				) for row in a]
  												_a     =			len(_UpperCAmelCase				)
  												if isinstance(a[0]							,     _UpperCAmelCase				):
  																		_a     =			len(a[0]				)
  												else:
  																		for dat in a:
  																								print(_UpperCAmelCase				)
  																		return
  
  												# horizotal printing increasing
  												for i in range(0							,     _UpperCAmelCase				):
  																		print(a[0][i]				)
  												# vertical printing down
  												for i in range(1							,     _UpperCAmelCase				):
  																		print(a[i][mat_col - 1]				)
  												# horizotal printing decreasing
  												if mat_row > 1:
  																		for i in range(mat_col - 2							,     -1							,     -1				):
  																								print(a[mat_row - 1][i]				)
          # vertical printing up
  												for i in range(mat_row - 2							,     0							,     -1				):
  																		print(a[i][0]				)
  												_a     =			[row[1 : mat_col - 1] for row in a[1 : mat_row - 1]]
  												if len(_UpperCAmelCase				) > 0:
  																		spiral_print_clockwise(_UpperCAmelCase				)
  												else:
  																		return
  						else:
  												print('Not a valid matrix'				)
  												return
  
  
  def 							SCREAMING_SNAKE_CASE					(  _UpperCAmelCase				)    ->  list[int]:
  						if matrix:
  												return list(matrix.pop(0				)				) + spiral_traversal(list(zip(*_UpperCAmelCase				)				)[::-1]				)
  						else:
  												return []
  
  
  # driver code
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  		lowercase_								=    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
  		spiral_print_clockwise(a)
  
  
  