

import os
import warnings
from pathlib import Path
from typing import Optional, Union

from .dynamic_module_utils import custom_object_save
from .tokenization_utils_base import PreTrainedTokenizerBase
from .utils import PushToHubMixin, copy_func, direct_transformers_import, logging


_a			=       logging.get_logger(__name__)

# Dynamically import the Transformers module to grab the attribute classes of the processor form their names.
_a			=       direct_transformers_import(Path(__file__).parent)


_a			=       {
    '''AutoTokenizer''': '''PreTrainedTokenizerBase''',
    '''AutoFeatureExtractor''': '''FeatureExtractionMixin''',
    '''AutoImageProcessor''': '''ImageProcessingMixin''',
}






class 							A_			(		snake_case__ ):
     _lowercase      :					Tuple       =     ['feature_extractor', 'tokenizer']
     # Names need to be attr_class for attr in attributes
     _lowercase      :					Union[str, Any]       =     None
     _lowercase      :					Tuple       =     None
     _lowercase      :					Optional[Any]       =     None


     def __init__(							self      :		Union[str, Any]      ,  *UpperCAmelCase      :		str      ,  **UpperCAmelCase      :		str )							->     Any:
      # Sanitize args and kwargs
      for key in kwargs:
       if key not in self.attributes:
        raise TypeError(F'''Unexpected keyword argument {key}.''' )
      for arg, attribute_name in zip(UpperCAmelCase      ,  self.attributes ):
       if attribute_name in kwargs:
        raise TypeError(F'''Got multiple values for argument {attribute_name}.''' )
       else:
        __lowerCAmelCase:       Optional[int]            =				arg

      if len(UpperCAmelCase ) != len(self.attributes ):
       raise ValueError(
           F'''This processor requires {len(self.attributes )} arguments: {', '.join(self.attributes )}. Got '''
           F'''{len(UpperCAmelCase )} arguments instead.''' )

      # Check each arg is of the proper class (this will also catch a user initializing in the wrong order)
      for attribute_name, arg in kwargs.items():
       __lowerCAmelCase:       List[str]            =				getattr(self      ,  F'''{attribute_name}_class''' )
       # Nothing is ever going to be an instance of "AutoXxx", in that case we check the base class.
       __lowerCAmelCase:       List[str]            =				AUTO_TO_BASE_CLASS_MAPPING.get(UpperCAmelCase      ,  UpperCAmelCase )
       if isinstance(UpperCAmelCase      ,  UpperCAmelCase ):
        __lowerCAmelCase:       Any            =				tuple(getattr(UpperCAmelCase      ,  UpperCAmelCase ) for n in class_name if n is not None )
       else:
        __lowerCAmelCase:       Optional[int]            =				getattr(UpperCAmelCase      ,  UpperCAmelCase )

       if not isinstance(UpperCAmelCase      ,  UpperCAmelCase ):
        raise ValueError(
            F'''Received a {type(UpperCAmelCase ).__name__} for argument {attribute_name}, but a {class_name} was expected.''' )

       setattr(self      ,  UpperCAmelCase      ,  UpperCAmelCase )


     def __repr__(							self      :		str )							->     str:
      __lowerCAmelCase:       Optional[Any]            =				[F'''- {name}: {repr(getattr(self      ,  UpperCAmelCase ) )}''' for name in self.attributes]
      __lowerCAmelCase:       Tuple            =				'\n'.join(UpperCAmelCase )
      return F'''{self.__class__.__name__}:\n{attributes_repr}'''


     def   UpperCAmelCase  (							self      :		Any      ,  UpperCAmelCase      :		Optional[int]      ,  UpperCAmelCase      :		bool = False      ,  **UpperCAmelCase      :		Any )							->     List[str]:
      os.makedirs(UpperCAmelCase      ,  exist_ok=UpperCAmelCase )

      if push_to_hub:
       __lowerCAmelCase:       Any            =				kwargs.pop('commit_message'      ,  UpperCAmelCase )
       __lowerCAmelCase:       Union[str, Any]            =				kwargs.pop('repo_id'      ,  save_directory.split(os.path.sep )[-1] )
       __lowerCAmelCase:       Any            =				self._create_repo(UpperCAmelCase      ,  **UpperCAmelCase )
       __lowerCAmelCase:       Dict            =				self._get_files_timestamps(UpperCAmelCase )
      # If we have a custom config, we copy the file defining it in the folder and set the attributes so it can be
      # loaded from the Hub.
      if self._auto_class is not None:
       __lowerCAmelCase:       Any            =				[getattr(self      ,  UpperCAmelCase ) for attribute_name in self.attributes]
       __lowerCAmelCase:       Any            =				[(a.init_kwargs if isinstance(UpperCAmelCase      ,  UpperCAmelCase ) else a) for a in attrs]
       custom_object_save(self      ,  UpperCAmelCase      ,  config=UpperCAmelCase )

      for attribute_name in self.attributes:
       __lowerCAmelCase:       List[str]            =				getattr(self      ,  UpperCAmelCase )
       # Include the processor class in the attribute config so this processor can then be reloaded with the
       # `AutoProcessor` API.
       if hasattr(UpperCAmelCase      ,  '_set_processor_class' ):
        attribute._set_processor_class(self.__class__.__name__ )
       attribute.save_pretrained(UpperCAmelCase )

      if self._auto_class is not None:
       # We added an attribute to the init_kwargs of the tokenizers, which needs to be cleaned up.
       for attribute_name in self.attributes:
        __lowerCAmelCase:       Any            =				getattr(self      ,  UpperCAmelCase )
        if isinstance(UpperCAmelCase      ,  UpperCAmelCase ):
         del attribute.init_kwargs["auto_map"]

      if push_to_hub:
       self._upload_modified_files(
           UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase      ,  commit_message=UpperCAmelCase      ,  token=kwargs.get('use_auth_token' )      ,  )


     @classmethod
     def   UpperCAmelCase  (							cls      :		List[str]      ,  UpperCAmelCase      :		Union[str, os.PathLike]      ,  UpperCAmelCase      :		Optional[Union[str, os.PathLike]] = None      ,  UpperCAmelCase      :		bool = False      ,  UpperCAmelCase      :		bool = False      ,  UpperCAmelCase      :		Optional[Union[str, bool]] = None      ,  UpperCAmelCase      :		str = "main"      ,  **UpperCAmelCase      :		Tuple      ,  )							->     Tuple:
      __lowerCAmelCase:       List[str]            =				cache_dir
      __lowerCAmelCase:       List[str]            =				force_download
      __lowerCAmelCase:       Optional[int]            =				local_files_only
      __lowerCAmelCase:       Optional[int]            =				revision

      __lowerCAmelCase:       str            =				kwargs.pop('use_auth_token'      ,  UpperCAmelCase )
      if use_auth_token is not None:
       warnings.warn(
           'The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers.'      ,  UpperCAmelCase )
       if token is not None:
        raise ValueError(
            '`token` and `use_auth_token` are both specified. Please set only the argument `token`.' )
       __lowerCAmelCase:       Dict            =				use_auth_token

      if token is not None:
       # change to `token` in a follow-up PR
       __lowerCAmelCase:       Optional[int]            =				token

      __lowerCAmelCase:       Tuple            =				cls._get_arguments_from_pretrained(UpperCAmelCase      ,  **UpperCAmelCase )
      return cls(*UpperCAmelCase )


     @classmethod
     def   UpperCAmelCase  (							cls      :		Dict      ,  UpperCAmelCase      :		Optional[int]="AutoProcessor" )							->     Optional[int]:
      if not isinstance(UpperCAmelCase      ,  UpperCAmelCase ):
       __lowerCAmelCase:       Optional[Any]            =				auto_class.__name__

      import transformers.models.auto as auto_module

      if not hasattr(UpperCAmelCase      ,  UpperCAmelCase ):
       raise ValueError(F'''{auto_class} is not a valid auto class.''' )

      __lowerCAmelCase:       Dict            =				auto_class


     @classmethod
     def   UpperCAmelCase  (							cls      :		int      ,  UpperCAmelCase      :		Tuple      ,  **UpperCAmelCase      :		Tuple )							->     int:
      __lowerCAmelCase:       str            =				[]
      for attribute_name in cls.attributes:
       __lowerCAmelCase:       List[Any]            =				getattr(cls      ,  F'''{attribute_name}_class''' )
       if isinstance(UpperCAmelCase      ,  UpperCAmelCase ):
        __lowerCAmelCase:       str            =				tuple(getattr(UpperCAmelCase      ,  UpperCAmelCase ) if n is not None else None for n in class_name )
        __lowerCAmelCase:       List[Any]            =				kwargs.get('use_fast'      ,  UpperCAmelCase )
        if use_fast and classes[1] is not None:
         __lowerCAmelCase:       Any            =				classes[1]
        else:
         __lowerCAmelCase:       Dict            =				classes[0]
       else:
        __lowerCAmelCase:       Optional[Any]            =				getattr(UpperCAmelCase      ,  UpperCAmelCase )

       args.append(attribute_class.from_pretrained(UpperCAmelCase      ,  **UpperCAmelCase ) )
      return args


     @property
     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     str:
      __lowerCAmelCase:       int            =				getattr(self      ,  self.attributes[0] )
      return getattr(UpperCAmelCase      ,  'model_input_names'      ,  UpperCAmelCase )







_a			=       copy_func(ProcessorMixin.push_to_hub)
if ProcessorMixin.push_to_hub.__doc__ is not None:
  _a			=       ProcessorMixin.push_to_hub.__doc__.format(
      object='''processor''', object_class='''AutoProcessor''', object_files='''processor files'''
  )








import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
  from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import PoolFormerImageProcessor






class 							A_			(		snake_case__ ):


     def   UpperCAmelCase  (							self      :		int )							->     Tuple:
      __lowerCAmelCase:       Optional[Any]            =				self.config_class(**self.inputs_dict )
      self.parent.assertTrue(hasattr(UpperCAmelCase      ,  'hidden_sizes' ) )
      self.parent.assertTrue(hasattr(UpperCAmelCase      ,  'num_encoder_blocks' ) )







class 							A_			:


     def __init__(							self      :		Optional[int]      ,  UpperCAmelCase      :		Any      ,  UpperCAmelCase      :		List[str]=1_3      ,  UpperCAmelCase      :		Optional[Any]=6_4      ,  UpperCAmelCase      :		Union[str, Any]=3      ,  UpperCAmelCase      :		Optional[Any]=4      ,  UpperCAmelCase      :		Any=[2, 2, 2, 2]      ,  UpperCAmelCase      :		Optional[Any]=[8, 4, 2, 1]      ,  UpperCAmelCase      :		str=[1_6, 3_2, 6_4, 1_2_8]      ,  UpperCAmelCase      :		str=[1, 4, 8, 1_6]      ,  UpperCAmelCase      :		Optional[Any]=False      ,  UpperCAmelCase      :		str=True      ,  UpperCAmelCase      :		Optional[int]="gelu"      ,  UpperCAmelCase      :		Union[str, Any]=0.1      ,  UpperCAmelCase      :		Optional[Any]=0.02      ,  UpperCAmelCase      :		List[Any]=3      ,  UpperCAmelCase      :		Optional[int]=None      ,  )							->     Any:
      __lowerCAmelCase:       List[str]            =				parent
      __lowerCAmelCase:       Union[str, Any]            =				batch_size
      __lowerCAmelCase:       Union[str, Any]            =				image_size
      __lowerCAmelCase:       str            =				num_channels
      __lowerCAmelCase:       Tuple            =				num_encoder_blocks
      __lowerCAmelCase:       Optional[int]            =				sr_ratios
      __lowerCAmelCase:       Union[str, Any]            =				depths
      __lowerCAmelCase:       int            =				hidden_sizes
      __lowerCAmelCase:       List[Any]            =				downsampling_rates
      __lowerCAmelCase:       List[Any]            =				is_training
      __lowerCAmelCase:       Union[str, Any]            =				use_labels
      __lowerCAmelCase:       Union[str, Any]            =				hidden_act
      __lowerCAmelCase:       Any            =				hidden_dropout_prob
      __lowerCAmelCase:       List[Any]            =				initializer_range
      __lowerCAmelCase:       Dict            =				num_labels
      __lowerCAmelCase:       List[Any]            =				scope


     def   UpperCAmelCase  (							self      :		Optional[int] )							->     List[str]:
      __lowerCAmelCase:       Dict            =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

      __lowerCAmelCase:       str            =				None
      if self.use_labels:
       __lowerCAmelCase:       int            =				ids_tensor([self.batch_size, self.image_size, self.image_size]      ,  self.num_labels )

      __lowerCAmelCase:       Dict            =				PoolFormerConfig(
          image_size=self.image_size      ,  num_channels=self.num_channels      ,  num_encoder_blocks=self.num_encoder_blocks      ,  depths=self.depths      ,  hidden_sizes=self.hidden_sizes      ,  hidden_act=self.hidden_act      ,  hidden_dropout_prob=self.hidden_dropout_prob      ,  initializer_range=self.initializer_range      ,  )

      return config, pixel_values, labels


     def   UpperCAmelCase  (							self      :		str      ,  UpperCAmelCase      :		Tuple      ,  UpperCAmelCase      :		int      ,  UpperCAmelCase      :		List[Any] )							->     str:
      __lowerCAmelCase:       Any            =				PoolFormerModel(config=UpperCAmelCase )
      model.to(UpperCAmelCase )
      model.eval()
      __lowerCAmelCase:       List[str]            =				model(UpperCAmelCase )
      __lowerCAmelCase:       Union[str, Any]            =				self.image_size // 32.0
      self.parent.assertEqual(
          result.last_hidden_state.shape      ,  (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width) )


     def   UpperCAmelCase  (							self      :		Any )							->     int:
      __lowerCAmelCase:       List[str]            =				self.prepare_config_and_inputs()
      __lowerCAmelCase     ,							__lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				config_and_inputs
      __lowerCAmelCase:       List[str]            =				{'pixel_values': pixel_values}
      return config, inputs_dict







@require_torch
class 							A_			(		snake_case__							,     snake_case__							,     unittest.TestCase ):
     _lowercase      :					Optional[Any]       =     (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
     _lowercase      :					List[Any]       =     (
         {'feature-extraction': PoolFormerModel, 'image-classification': PoolFormerForImageClassification}
         if is_torch_available()
         else {}
     )

     _lowercase      :					Tuple       =     False
     _lowercase      :					Tuple       =     False
     _lowercase      :					List[Any]       =     False
     _lowercase      :					Any       =     False
     _lowercase      :					List[Any]       =     False


     def   UpperCAmelCase  (							self      :		str )							->     Any:
      __lowerCAmelCase:       int            =				PoolFormerModelTester(self )
      __lowerCAmelCase:       int            =				PoolFormerConfigTester(self      ,  config_class=UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     int:
      self.config_tester.run_common_tests()


     def   UpperCAmelCase  (							self      :		int )							->     int:
      __lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*UpperCAmelCase )


     @unittest.skip('PoolFormer does not use inputs_embeds' )
     def   UpperCAmelCase  (							self      :		Optional[int] )							->     Union[str, Any]:
      pass


     @unittest.skip('PoolFormer does not have get_input_embeddings method and get_output_embeddings methods' )
     def   UpperCAmelCase  (							self      :		int )							->     List[str]:
      pass


     def   UpperCAmelCase  (							self      :		List[str] )							->     List[str]:
      def check_hidden_states_output(UpperCAmelCase      :		List[str]      ,  UpperCAmelCase      :		int      ,  UpperCAmelCase      :		List[Any] ):
       __lowerCAmelCase:       Union[str, Any]            =				model_class(UpperCAmelCase )
       model.to(UpperCAmelCase )
       model.eval()

       with torch.no_grad():
        __lowerCAmelCase:       Dict            =				model(**self._prepare_for_class(UpperCAmelCase      ,  UpperCAmelCase ) )

       __lowerCAmelCase:       int            =				outputs.hidden_states

       __lowerCAmelCase:       Optional[int]            =				self.model_tester.num_encoder_blocks
       self.assertEqual(len(UpperCAmelCase )      ,  UpperCAmelCase )

       # verify the first hidden states (first block)
       self.assertListEqual(
           list(hidden_states[0].shape[-3:] )      ,  [
               self.model_tester.hidden_sizes[0],
               self.model_tester.image_size // 4,
               self.model_tester.image_size // 4,
           ]      ,  )

      __lowerCAmelCase     ,							__lowerCAmelCase:       Dict            =				self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __lowerCAmelCase:       Optional[int]            =				True
       check_hidden_states_output(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       __lowerCAmelCase:       Optional[Any]            =				True

       check_hidden_states_output(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		List[Any] )							->     Optional[int]:
      if not self.model_tester.is_training:
       return

      __lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs_for_common()
      __lowerCAmelCase:       Optional[int]            =				True

      for model_class in self.all_model_classes:
       if model_class in get_values(UpperCAmelCase ):
        continue
       __lowerCAmelCase:       str            =				model_class(UpperCAmelCase )
       model.to(UpperCAmelCase )
       model.train()
       __lowerCAmelCase:       Any            =				self._prepare_for_class(UpperCAmelCase      ,  UpperCAmelCase      ,  return_labels=UpperCAmelCase )
       __lowerCAmelCase:       str            =				model(**UpperCAmelCase ).loss
       loss.backward()


     def   UpperCAmelCase  (							self      :		Dict )							->     Tuple:
      __lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __lowerCAmelCase:       Union[str, Any]            =				model_class(UpperCAmelCase )
       __lowerCAmelCase:       Dict            =				inspect.signature(model.forward )
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       __lowerCAmelCase:       List[str]            =				[*signature.parameters.keys()]

       __lowerCAmelCase:       List[Any]            =				['pixel_values']
       self.assertListEqual(arg_names[:1]      ,  UpperCAmelCase )


     @slow
     def   UpperCAmelCase  (							self      :		int )							->     str:
      for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __lowerCAmelCase:       List[str]            =				PoolFormerModel.from_pretrained(UpperCAmelCase )
       self.assertIsNotNone(UpperCAmelCase )







def _a			(	)   ->   Any:

 """simple docstring"""






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






@require_torch
class 							A_			(		unittest.TestCase ):


     @slow
     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     int:
      __lowerCAmelCase:       Optional[int]            =				PoolFormerImageProcessor()
      __lowerCAmelCase:       Any            =				PoolFormerForImageClassification.from_pretrained('sail/poolformer_s12' ).to(UpperCAmelCase )

      __lowerCAmelCase:       int            =				image_processor(images=prepare_img()      ,  return_tensors='pt' ).to(UpperCAmelCase )

      # forward pass
      with torch.no_grad():
       __lowerCAmelCase:       List[Any]            =				model(**UpperCAmelCase )

      # verify the logits
      __lowerCAmelCase:       List[Any]            =				torch.Size((1, 1_0_0_0) )
      self.assertEqual(outputs.logits.shape      ,  UpperCAmelCase )

      __lowerCAmelCase:       Union[str, Any]            =				torch.tensor([-0.6113, 0.1685, -0.0492] ).to(UpperCAmelCase )
      self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,  UpperCAmelCase      ,  atol=1E-4 ) )





