code: 
  
  
  
  """simple docstring"""
  
  
  
  
  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 			UpperCAmelCase_						(       _UpperCamelCase		):
  
  
  
        def 		snake_case_      (  self  :			Dict		):
             _UpperCAmelCase    :			int              =					self.config_class(**self.inputs_dict		)
             self.parent.assertTrue(hasattr(A  ,			"hidden_sizes"		)		)
             self.parent.assertTrue(hasattr(A  ,			"num_encoder_blocks"		)		)
  
  
  
  
  
  
  
  class 			UpperCAmelCase_						:
  
  
  
        def __init__(  self  :			Tuple  ,			A  :			str  ,			A  :			List[str]=1_3  ,			A  :			Optional[Any]=6_4  ,			A  :			Optional[Any]=3  ,			A  :			List[str]=4  ,			A  :			List[str]=[2, 2, 2, 2]  ,			A  :			List[str]=[8, 4, 2, 1]  ,			A  :			Dict=[1_6, 3_2, 6_4, 1_2_8]  ,			A  :			int=[1, 4, 8, 1_6]  ,			A  :			Any=False  ,			A  :			Optional[int]=True  ,			A  :			Any="gelu"  ,			A  :			List[str]=0.1  ,			A  :			List[Any]=0.02  ,			A  :			Union[str, Any]=3  ,			A  :			str=None  ,			):
             _UpperCAmelCase    :			Union[str, Any]              =					parent
             _UpperCAmelCase    :			Optional[Any]              =					batch_size
             _UpperCAmelCase    :			Optional[int]              =					image_size
             _UpperCAmelCase    :			Optional[Any]              =					num_channels
             _UpperCAmelCase    :			Any              =					num_encoder_blocks
             _UpperCAmelCase    :			str              =					sr_ratios
             _UpperCAmelCase    :			Dict              =					depths
             _UpperCAmelCase    :			List[Any]              =					hidden_sizes
             _UpperCAmelCase    :			Optional[int]              =					downsampling_rates
             _UpperCAmelCase    :			Dict              =					is_training
             _UpperCAmelCase    :			List[str]              =					use_labels
             _UpperCAmelCase    :			Tuple              =					hidden_act
             _UpperCAmelCase    :			Tuple              =					hidden_dropout_prob
             _UpperCAmelCase    :			int              =					initializer_range
             _UpperCAmelCase    :			List[Any]              =					num_labels
             _UpperCAmelCase    :			List[str]              =					scope
  
  
  
        def 		snake_case_      (  self  :			Dict		):
             _UpperCAmelCase    :			Dict              =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)
  
             _UpperCAmelCase    :			Optional[int]              =					None
             if self.use_labels:
                  _UpperCAmelCase    :			Tuple              =					ids_tensor([self.batch_size, self.image_size, self.image_size]  ,			self.num_labels		)
  
             _UpperCAmelCase    :			Optional[int]              =					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 		snake_case_      (  self  :			List[str]  ,			A  :			Dict  ,			A  :			Tuple  ,			A  :			List[str]		):
             _UpperCAmelCase    :			Optional[int]              =					PoolFormerModel(config=A		)
             model.to(A		)
             model.eval()
             _UpperCAmelCase    :			str              =					model(A		)
             _UpperCAmelCase    :			Dict              =					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 		snake_case_      (  self  :			Tuple		):
             _UpperCAmelCase    :			str              =					self.prepare_config_and_inputs()
             _UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase    :			str              =					config_and_inputs
             _UpperCAmelCase    :			Union[str, Any]              =					{"pixel_values": pixel_values}
             return config, inputs_dict
  
  
  
  
  
  
  
  @require_torch
  class 			UpperCAmelCase_						(       _UpperCamelCase ,    _UpperCamelCase ,    unittest.TestCase		):
        __SCREAMING_SNAKE_CASE		:     List[str]				  =				(PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
        __SCREAMING_SNAKE_CASE		:     List[Any]				  =				(
            {'feature-extraction': PoolFormerModel, 'image-classification': PoolFormerForImageClassification}
            if is_torch_available()
            else {}
        )
  
        __SCREAMING_SNAKE_CASE		:     Tuple				  =				False
        __SCREAMING_SNAKE_CASE		:     Dict				  =				False
        __SCREAMING_SNAKE_CASE		:     Optional[int]				  =				False
        __SCREAMING_SNAKE_CASE		:     Dict				  =				False
        __SCREAMING_SNAKE_CASE		:     str				  =				False
  
  
  
        def 		snake_case_      (  self  :			Union[str, Any]		):
             _UpperCAmelCase    :			List[Any]              =					PoolFormerModelTester(self		)
             _UpperCAmelCase    :			Tuple              =					PoolFormerConfigTester(self  ,			config_class=A		)
  
  
  
        def 		snake_case_      (  self  :			List[Any]		):
             self.config_tester.run_common_tests()
  
  
  
        def 		snake_case_      (  self  :			List[str]		):
             _UpperCAmelCase    :			Tuple              =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*A		)
  
  
  
        @unittest.skip("PoolFormer does not use inputs_embeds"		)
        def 		snake_case_      (  self  :			int		):
             pass
  
  
  
        @unittest.skip("PoolFormer does not have get_input_embeddings method and get_output_embeddings methods"		)
        def 		snake_case_      (  self  :			str		):
             pass
  
  
  
        def 		snake_case_      (  self  :			Any		):
             def check_hidden_states_output(A  :			List[str]  ,			A  :			Optional[Any]  ,			A  :			int		):
                  _UpperCAmelCase    :			List[Any]              =					model_class(A		)
                  model.to(A		)
                  model.eval()
  
                  with torch.no_grad():
                       _UpperCAmelCase    :			Dict              =					model(**self._prepare_for_class(A  ,			A		)		)
  
                  _UpperCAmelCase    :			Any              =					outputs.hidden_states
  
                  _UpperCAmelCase    :			Any              =					self.model_tester.num_encoder_blocks
                  self.assertEqual(len(A		)  ,			A		)
  
                  # 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,
                      ]  ,			)
  
             _UpperCAmelCase       , _UpperCAmelCase    :			Any              =					self.model_tester.prepare_config_and_inputs_for_common()
  
             for model_class in self.all_model_classes:
                  _UpperCAmelCase    :			Union[str, Any]              =					True
                  check_hidden_states_output(A  ,			A  ,			A		)
  
                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  _UpperCAmelCase    :			Optional[int]              =					True
  
                  check_hidden_states_output(A  ,			A  ,			A		)
  
  
  
        def 		snake_case_      (  self  :			Optional[Any]		):
             if not self.model_tester.is_training:
                  return
  
             _UpperCAmelCase       , _UpperCAmelCase    :			List[str]              =					self.model_tester.prepare_config_and_inputs_for_common()
             _UpperCAmelCase    :			List[str]              =					True
  
             for model_class in self.all_model_classes:
                  if model_class in get_values(A		):
                       continue
                  _UpperCAmelCase    :			int              =					model_class(A		)
                  model.to(A		)
                  model.train()
                  _UpperCAmelCase    :			Optional[int]              =					self._prepare_for_class(A  ,			A  ,			return_labels=A		)
                  _UpperCAmelCase    :			Union[str, Any]              =					model(**A		).loss
                  loss.backward()
  
  
  
        def 		snake_case_      (  self  :			Tuple		):
             _UpperCAmelCase       , _UpperCAmelCase    :			Union[str, Any]              =					self.model_tester.prepare_config_and_inputs_for_common()
  
             for model_class in self.all_model_classes:
                  _UpperCAmelCase    :			Optional[int]              =					model_class(A		)
                  _UpperCAmelCase    :			Union[str, Any]              =					inspect.signature(model.forward		)
                  # signature.parameters is an OrderedDict => so arg_names order is deterministic
                  _UpperCAmelCase    :			List[str]              =					[*signature.parameters.keys()]
  
                  _UpperCAmelCase    :			Any              =					["pixel_values"]
                  self.assertListEqual(arg_names[:1]  ,			A		)
  
  
  
        @slow
        def 		snake_case_      (  self  :			List[str]		):
             for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  _UpperCAmelCase    :			Tuple              =					PoolFormerModel.from_pretrained(A		)
                  self.assertIsNotNone(A		)
  
  
  
  
  
  
  
  def 		__snake_case		(   )						->     Dict:
  
  
  
  
  
       '''simple docstring'''
  
       _UpperCAmelCase    :			Any              =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
       return image
  
  
  
  
  
  
  @require_torch
  class 			UpperCAmelCase_						(       unittest.TestCase		):
  
  
  
        @slow
        def 		snake_case_      (  self  :			Optional[int]		):
             _UpperCAmelCase    :			Union[str, Any]              =					PoolFormerImageProcessor()
             _UpperCAmelCase    :			Dict              =					PoolFormerForImageClassification.from_pretrained("sail/poolformer_s12"		).to(A		)
  
             _UpperCAmelCase    :			Union[str, Any]              =					image_processor(images=prepare_img()  ,			return_tensors="pt"		).to(A		)
  
             # forward pass
             with torch.no_grad():
                  _UpperCAmelCase    :			int              =					model(**A		)
  
             # verify the logits
             _UpperCAmelCase    :			Union[str, Any]              =					torch.Size((1, 1_0_0_0)		)
             self.assertEqual(outputs.logits.shape  ,			A		)
  
             _UpperCAmelCase    :			Union[str, Any]              =					torch.tensor([-0.6_113, 0.1_685, -0.0_492]		).to(A		)
             self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,			A  ,			atol=1e-4		)		)
  
style_context: 
  
  
  
  """simple docstring"""
  
  
  
  
  import sys
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		int		,						SCREAMING_SNAKE_CASE__			:		list[int]       )						->     int:
  
  
  
  
  
       '''simple docstring'''
  
       if not numbers:
            return 0
       if target == 0 and target in numbers:
            return 0
       if not isinstance(SCREAMING_SNAKE_CASE__		,						(list, tuple)       ) or not all(
           isinstance(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       ) for number in numbers       ):
            raise ValueError("numbers must be an iterable of integers"       )
  
       _UpperCAmelCase    :			List[Any]              =					0
       _UpperCAmelCase    :			str              =					sys.maxsize
  
       while right < len(SCREAMING_SNAKE_CASE__       ):
            curr_sum += numbers[right]
            while curr_sum >= target and left <= right:
                 _UpperCAmelCase    :			Any              =					min(SCREAMING_SNAKE_CASE__		,						right - left + 1       )
                 curr_sum -= numbers[left]
                 left += 1
            right += 1
  
       return 0 if min_len == sys.maxsize else min_len
  