






"""simple docstring"""





from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
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 TFResNetForImageClassification, TFResNetModel
  from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor






class      a						:






    def __init__(       self     :							str       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]       ,						__SCREAMING_SNAKE_CASE     :							List[str]=3       ,						__SCREAMING_SNAKE_CASE     :							str=32       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]=3       ,						__SCREAMING_SNAKE_CASE     :							Any=10       ,						__SCREAMING_SNAKE_CASE     :							Optional[int]=[10, 20, 30, 40]       ,						__SCREAMING_SNAKE_CASE     :							Tuple=[1, 1, 2, 1]       ,						__SCREAMING_SNAKE_CASE     :							Any=True       ,						__SCREAMING_SNAKE_CASE     :							Dict=True       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]="relu"       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]=3       ,						__SCREAMING_SNAKE_CASE     :							Optional[int]=None       ,						)     ->		str:
      lowerCamelCase_         =						parent
      lowerCamelCase_         =						batch_size
      lowerCamelCase_         =						image_size
      lowerCamelCase_         =						num_channels
      lowerCamelCase_         =						embeddings_size
      lowerCamelCase_         =						hidden_sizes
      lowerCamelCase_         =						depths
      lowerCamelCase_         =						is_training
      lowerCamelCase_         =						use_labels
      lowerCamelCase_         =						hidden_act
      lowerCamelCase_         =						num_labels
      lowerCamelCase_         =						scope
      lowerCamelCase_         =						len(_a					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Any:
      lowerCamelCase_         =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

      lowerCamelCase_         =						None
      if self.use_labels:
        lowerCamelCase_         =						ids_tensor([self.batch_size]       ,						self.num_labels					)

      lowerCamelCase_         =						self.get_config()

      return config, pixel_values, labels






    def    UpperCamelCase       (       self     :							Dict					)     ->		Union[str, Any]:
      return ResNetConfig(
          num_channels=self.num_channels       ,						embeddings_size=self.embeddings_size       ,						hidden_sizes=self.hidden_sizes       ,						depths=self.depths       ,						hidden_act=self.hidden_act       ,						num_labels=self.num_labels       ,						image_size=self.image_size       ,						)






    def    UpperCamelCase       (       self     :							List[str]       ,						__SCREAMING_SNAKE_CASE     :							Any       ,						__SCREAMING_SNAKE_CASE     :							int       ,						__SCREAMING_SNAKE_CASE     :							Any					)     ->		str:
      lowerCamelCase_         =						TFResNetModel(config=_a					)
      lowerCamelCase_         =						model(_a					)
      # 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     :							List[Any]       ,						__SCREAMING_SNAKE_CASE     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							str					)     ->		Optional[int]:
      lowerCamelCase_         =						self.num_labels
      lowerCamelCase_         =						TFResNetForImageClassification(_a					)
      lowerCamelCase_         =						model(_a       ,						labels=_a					)
      self.parent.assertEqual(result.logits.shape       ,						(self.batch_size, self.num_labels)					)






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.prepare_config_and_inputs()
      lowerCamelCase_         =						config_and_inputs
      lowerCamelCase_         =						{"pixel_values": pixel_values}
      return config, inputs_dict






@require_tf
class      a						(					a_  ,      a_  ,      unittest.TestCase		):
    SCREAMING_SNAKE_CASE						:     Optional[Any]						= (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
    SCREAMING_SNAKE_CASE						:     List[str]						= (
        {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
        if is_tf_available()
        else {}
    )

    SCREAMING_SNAKE_CASE						:     Tuple						= False
    SCREAMING_SNAKE_CASE						:     List[Any]						= False
    SCREAMING_SNAKE_CASE						:     Union[str, Any]						= False
    SCREAMING_SNAKE_CASE						:     Optional[int]						= False
    SCREAMING_SNAKE_CASE						:     str						= False






    def    UpperCamelCase       (       self     :							Optional[Any]					)     ->		int:
      lowerCamelCase_         =						TFResNetModelTester(self					)
      lowerCamelCase_         =						ConfigTester(self       ,						config_class=_a       ,						has_text_modality=_a					)






    def    UpperCamelCase       (       self     :							int					)     ->		Dict:
      self.create_and_test_config_common_properties()
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()






    def    UpperCamelCase       (       self     :							int					)     ->		List[Any]:
      return






    @unittest.skip(reason='ResNet does not use inputs_embeds'					)
    def    UpperCamelCase       (       self     :							Tuple					)     ->		Optional[Any]:
      pass






    @unittest.skip(reason='ResNet does not support input and output embeddings'					)
    def    UpperCamelCase       (       self     :							int					)     ->		Dict:
      pass






    def    UpperCamelCase       (       self     :							int					)     ->		List[str]:
      lowerCamelCase_         =						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowerCamelCase_         =						model_class(_a					)
        lowerCamelCase_         =						inspect.signature(model.call					)
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        lowerCamelCase_         =						[*signature.parameters.keys()]

        lowerCamelCase_         =						["pixel_values"]
        self.assertListEqual(arg_names[:1]       ,						_a					)






    def    UpperCamelCase       (       self     :							Any					)     ->		str:
      lowerCamelCase_         =						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_a					)






    def    UpperCamelCase       (       self     :							Any					)     ->		Union[str, Any]:
      def check_hidden_states_output(__SCREAMING_SNAKE_CASE     :							List[Any]       ,						__SCREAMING_SNAKE_CASE     :							List[str]       ,						__SCREAMING_SNAKE_CASE     :							Optional[int]					):
        lowerCamelCase_         =						model_class(_a					)
        lowerCamelCase_         =						model(**self._prepare_for_class(_a       ,						_a					)					)

        lowerCamelCase_         =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

        lowerCamelCase_         =						self.model_tester.num_stages
        self.assertEqual(len(_a					)       ,						expected_num_stages + 1					)

        # ResNet'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]       ,						)

      lowerCamelCase_         =						self.model_tester.prepare_config_and_inputs_for_common()
      lowerCamelCase_         =						["basic", "bottleneck"]
      for model_class in self.all_model_classes:
        for layer_type in layers_type:
          lowerCamelCase_         =						layer_type
          lowerCamelCase_         =						True
          check_hidden_states_output(_a       ,						_a       ,						_a					)

          # check that output_hidden_states also work using config
          del inputs_dict["output_hidden_states"]
          lowerCamelCase_         =						True

          check_hidden_states_output(_a       ,						_a       ,						_a					)






    def    UpperCamelCase       (       self     :							Optional[Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_a					)






    @slow
    def    UpperCamelCase       (       self     :							List[str]					)     ->		str:
      for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowerCamelCase_         =						TFResNetModel.from_pretrained(_a					)
        self.assertIsNotNone(_a					)







def      lowerCamelCase__       (							)      ->				int:
  lowerCamelCase_         =						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
  return image






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






    @cached_property
    def    UpperCamelCase       (       self     :							int					)     ->		Dict:
      return (
          AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)
          if is_vision_available()
          else None
      )






    @slow
    def    UpperCamelCase       (       self     :							str					)     ->		Union[str, Any]:
      lowerCamelCase_         =						TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)

      lowerCamelCase_         =						self.default_image_processor
      lowerCamelCase_         =						prepare_img()
      lowerCamelCase_         =						image_processor(images=_a       ,						return_tensors='tf'					)

      # forward pass
      lowerCamelCase_         =						model(**_a					)

      # verify the logits
      lowerCamelCase_         =						tf.TensorShape((1, 1000)					)
      self.assertEqual(outputs.logits.shape       ,						_a					)

      lowerCamelCase_         =						tf.constant([-11.1069, -9.7_877, -8.3_777]					)

      self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()       ,						_a       ,						atol=1e-4					)					)






"""simple docstring"""




from __future__ import annotations


def   __magic_name__	(      __snake_case				:       list[int]  ) ->				list[int]:
       if len(__snake_case  ) == 0:
              return array

       lowercase		,    lowercase    :				Tuple       		=							min(__snake_case  ), max(__snake_case  )

       # Compute the variables
       lowercase    :				Optional[Any]       		=							_max - _min + 1
       lowercase		,    lowercase    :				List[str]       		=							[0] * holes_range, [0] * holes_range

       # Make the sorting.
       for i in array:
              lowercase    :				Tuple       		=							i - _min
              lowercase    :				str       		=							i
              holes_repeat[index] += 1

       # Makes the array back by replacing the numbers.
       lowercase    :				Union[str, Any]       		=							0
       for i in range(__snake_case  ):
              while holes_repeat[i] > 0:
                     lowercase    :				Tuple       		=							holes[i]
                     index += 1
                     holes_repeat[i] -= 1

    # Returns the sorted array.
       return array


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   _A			:       str   		=       input("""Enter numbers separated by comma:\n""")
   _A			:       Optional[Any]   		=       [int(x) for x in user_input.split(""",""")]
   print(pigeon_sort(unsorted))


