
"""simple docstring"""




from __future__ import annotations



def 							a__ (				lowerCAmelCase	:       list[int]		):






     '''simple docstring'''
     if len(lowerCAmelCase		) == 0:
          return array

     UpperCAmelCase__							,	UpperCAmelCase__							: Union[str, Any] 							=						min(lowerCAmelCase		), max(lowerCAmelCase		)

     # Compute the variables
     UpperCAmelCase__							: Tuple 							=						_max - _min + 1
     UpperCAmelCase__							,	UpperCAmelCase__							: Dict 							=						[0] * holes_range, [0] * holes_range

     # Make the sorting.
     for i in array:
          UpperCAmelCase__							: List[str] 							=						i - _min
          UpperCAmelCase__							: Union[str, Any] 							=						i
          holes_repeat[index] += 1

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

    # Returns the sorted array.
     return array


if __name__ == "__main__":
    import doctest

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





"""simple docstring"""




import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
    import tensorflow as tf
    from tensorflow.python.framework.errors_impl import ResourceExhaustedError

    from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
    import pyanvml.pyanvml as nvml

A__      :	Optional[Any]          =    logging.get_logger(__name__)



def 							a__ (				lowerCAmelCase	:       bool       ,    lowerCAmelCase	:       bool		):






     '''simple docstring'''
     def run_func(lowerCAmelCase	:       Dict		):
          @wraps(lowerCAmelCase		)
          def run_in_eager_mode(*lowerCAmelCase	:       Optional[Any]       ,    **lowerCAmelCase	:       Dict		):
               return func(*lowerCAmelCase       ,    **lowerCAmelCase		)

          @wraps(lowerCAmelCase		)
          @tf.function(experimental_compile=lowerCAmelCase		)
          def run_in_graph_mode(*lowerCAmelCase	:       Optional[Any]       ,    **lowerCAmelCase	:       Optional[Any]		):
               return func(*lowerCAmelCase       ,    **lowerCAmelCase		)

          if do_eager_mode is True:
               if use_xla is not False:
                    raise ValueError(
                        "Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`."		)
               return run_in_eager_mode
          else:
               return run_in_graph_mode

     return run_func



def 							a__ (				lowerCAmelCase	:       int       ,    lowerCAmelCase	:       int       ,    lowerCAmelCase	:       int		):






     '''simple docstring'''
     UpperCAmelCase__							: Dict 							=						random.Random()
     UpperCAmelCase__							: List[str] 							=						[rng.randint(0       ,    vocab_size - 1		) for i in range(batch_size * sequence_length		)]
     return tf.constant(lowerCAmelCase       ,    shape=(batch_size, sequence_length)       ,    dtype=tf.intaa		)







class   _lowercase						(       lowerCAmelCase_				):


     '''simple docstring'''





     _A								=							42
     _A								=							42
     _A								=							"TensorFlow"



     @property
     def  lowerCAmelCase__       (      self  )->					Optional[int]:
          return tf.__version__



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )->					float:
          # initialize GPU on separate process
          UpperCAmelCase__							: Any 							=						self.args.strategy
          if strategy is None:
               raise ValueError("A device strategy has to be initialized before using TensorFlow."  )
          UpperCAmelCase__							: Union[str, Any] 							=						self._prepare_inference_func(__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )
          return self._measure_speed(_inference  )



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )->					float:
          UpperCAmelCase__							: List[Any] 							=						self.args.strategy
          if strategy is None:
               raise ValueError("A device strategy has to be initialized before using TensorFlow."  )
          UpperCAmelCase__							: List[Any] 							=						self._prepare_train_func(__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )
          return self._measure_speed(_train  )



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )->					[Memory, Optional[MemorySummary]]:
          # initialize GPU on separate process
          if self.args.is_gpu:
               tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx] ,			__UpperCamelCase  )
          UpperCAmelCase__							: List[str] 							=						self.args.strategy
          if strategy is None:
               raise ValueError("A device strategy has to be initialized before using TensorFlow."  )
          UpperCAmelCase__							: Any 							=						self._prepare_inference_func(__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )
          return self._measure_memory(_inference  )



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )->					[Memory, Optional[MemorySummary]]:
          if self.args.is_gpu:
               tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx] ,			__UpperCamelCase  )
          UpperCAmelCase__							: Any 							=						self.args.strategy
          if strategy is None:
               raise ValueError("A device strategy has to be initialized before using TensorFlow."  )

          UpperCAmelCase__							: Optional[Any] 							=						self._prepare_train_func(__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )
          return self._measure_memory(_train  )



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )->					Callable[[], None]:
          UpperCAmelCase__							: Union[str, Any] 							=						self.config_dict[model_name]

          if self.args.fpaa:
               raise NotImplementedError("Mixed precision is currently not supported."  )

          UpperCAmelCase__							: Optional[int] 							=						(
              hasattr(__UpperCamelCase ,			"architectures"  )
              and isinstance(config.architectures ,			__UpperCamelCase  )
              and len(config.architectures  ) > 0
          )
          if not self.args.only_pretrain_model and has_model_class_in_config:
               try:
                    UpperCAmelCase__							: str 							=						"TF" + config.architectures[0]  # prepend 'TF' for tensorflow model
                    UpperCAmelCase__							: Any 							=						__import__("transformers" ,			fromlist=[model_class]  )
                    UpperCAmelCase__							: List[Any] 							=						getattr(__UpperCamelCase ,			__UpperCamelCase  )
                    UpperCAmelCase__							: Dict 							=						model_cls(__UpperCamelCase  )
               except ImportError:
                    raise ImportError(
                        F"{model_class} does not exist. If you just want to test the pretrained model, you might want to"
                        " set `--only_pretrain_model` or `args.only_pretrain_model=True`."  )
          else:
               UpperCAmelCase__							: Any 							=						TF_MODEL_MAPPING[config.__class__](__UpperCamelCase  )

          # encoder-decoder has vocab size saved differently
          UpperCAmelCase__							: int 							=						config.vocab_size if hasattr(__UpperCamelCase ,			"vocab_size"  ) else config.encoder.vocab_size
          UpperCAmelCase__							: Optional[Any] 							=						random_input_ids(__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )

          @run_with_tf_optimizations(self.args.eager_mode ,			self.args.use_xla  )
          def encoder_decoder_forward():
               return model(__UpperCamelCase ,			decoder_input_ids=__UpperCamelCase ,			training=__UpperCamelCase  )

          @run_with_tf_optimizations(self.args.eager_mode ,			self.args.use_xla  )
          def encoder_forward():
               return model(__UpperCamelCase ,			training=__UpperCamelCase  )

          UpperCAmelCase__							: Dict 							=						encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

          return _inference



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )->					Callable[[], None]:
          UpperCAmelCase__							: List[Any] 							=						self.config_dict[model_name]

          if self.args.eager_mode is not False:
               raise ValueError("Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`."  )

          if self.args.fpaa:
               raise NotImplementedError("Mixed precision is currently not supported."  )

          UpperCAmelCase__							: Any 							=						(
              hasattr(__UpperCamelCase ,			"architectures"  )
              and isinstance(config.architectures ,			__UpperCamelCase  )
              and len(config.architectures  ) > 0
          )
          if not self.args.only_pretrain_model and has_model_class_in_config:
               try:
                    UpperCAmelCase__							: Any 							=						"TF" + config.architectures[0]  # prepend 'TF' for tensorflow model
                    UpperCAmelCase__							: int 							=						__import__("transformers" ,			fromlist=[model_class]  )
                    UpperCAmelCase__							: int 							=						getattr(__UpperCamelCase ,			__UpperCamelCase  )
                    UpperCAmelCase__							: Optional[Any] 							=						model_cls(__UpperCamelCase  )
               except ImportError:
                    raise ImportError(
                        F"{model_class} does not exist. If you just want to test the pretrained model, you might want to"
                        " set `--only_pretrain_model` or `args.only_pretrain_model=True`."  )
          else:
               UpperCAmelCase__							: List[str] 							=						TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__UpperCamelCase  )

          # encoder-decoder has vocab size saved differently
          UpperCAmelCase__							: Union[str, Any] 							=						config.vocab_size if hasattr(__UpperCamelCase ,			"vocab_size"  ) else config.encoder.vocab_size
          UpperCAmelCase__							: Dict 							=						random_input_ids(__UpperCamelCase ,			__UpperCamelCase ,			__UpperCamelCase  )

          @run_with_tf_optimizations(self.args.eager_mode ,			self.args.use_xla  )
          def encoder_decoder_train():
               UpperCAmelCase__							: Union[str, Any] 							=						model(__UpperCamelCase ,			decoder_input_ids=__UpperCamelCase ,			labels=__UpperCamelCase ,			training=__UpperCamelCase  )[0]
               UpperCAmelCase__							: Union[str, Any] 							=						tf.gradients(__UpperCamelCase ,			model.trainable_variables  )
               return gradients

          @run_with_tf_optimizations(self.args.eager_mode ,			self.args.use_xla  )
          def encoder_train():
               UpperCAmelCase__							: Union[str, Any] 							=						model(__UpperCamelCase ,			labels=__UpperCamelCase ,			training=__UpperCamelCase  )[0]
               UpperCAmelCase__							: Any 							=						tf.gradients(__UpperCamelCase ,			model.trainable_variables  )
               return gradients

          UpperCAmelCase__							: str 							=						encoder_decoder_train if config.is_encoder_decoder else encoder_train

          return _train



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase  )->					float:
          with self.args.strategy.scope():
               try:
                    if self.args.is_tpu or self.args.use_xla:
                         # run additional 10 times to stabilize compilation for tpu
                         logger.info("Do inference on TPU. Running model 5 times to stabilize compilation"  )
                         timeit.repeat(__UpperCamelCase ,			repeat=1 ,			number=5  )

                    # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
                    UpperCAmelCase__							: Optional[Any] 							=						timeit.repeat(
                        __UpperCamelCase ,			repeat=self.args.repeat ,			number=10 ,			)

                    return min(__UpperCamelCase  ) / 10.0
               except ResourceExhaustedError as e:
                    self.print_fn(F"Doesn't fit on GPU. {e}"  )



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase  )->					[Memory, MemorySummary]:
          logger.info(
              "Note that TensorFlow allocates more memory than "
              "it might need to speed up computation. "
              "The memory reported here corresponds to the memory "
              "reported by `nvidia-smi`, which can vary depending "
              "on total available memory on the GPU that is used."  )
          with self.args.strategy.scope():
               try:
                    if self.args.trace_memory_line_by_line:
                         if not self.args.eager_mode:
                              raise ValueError(
                                  "`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory"
                                  " consumption line by line."  )
                         UpperCAmelCase__							: List[str] 							=						start_memory_tracing("transformers"  )

                    if self.args.is_tpu:
                         # tpu
                         raise NotImplementedError(
                             "Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking"
                             " with `args.memory=False`"  )
                    elif self.args.is_gpu:
                         # gpu
                         if not is_pyanvml_available():
                              logger.warning(
                                  "py3nvml not installed, we won't log GPU memory usage. "
                                  "Install py3nvml (pip install py3nvml) to log information about GPU."  )
                              UpperCAmelCase__							: Optional[int] 							=						"N/A"
                         else:
                              logger.info(
                                  "Measuring total GPU usage on GPU device. Make sure to not have additional processes"
                                  " running on the same GPU."  )
                              # init nvml
                              nvml.nvmlInit()
                              func()
                              UpperCAmelCase__							: Any 							=						nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx  )
                              UpperCAmelCase__							: Optional[int] 							=						nvml.nvmlDeviceGetMemoryInfo(__UpperCamelCase  )
                              UpperCAmelCase__							: str 							=						meminfo.used
                              UpperCAmelCase__							: int 							=						Memory(__UpperCamelCase  )
                              # shutdown nvml
                              nvml.nvmlShutdown()
                    else:
                         # cpu
                         if self.args.trace_memory_line_by_line:
                              logger.info(
                                  "When enabling line by line tracing, the max peak memory for CPU is inaccurate in"
                                  " TensorFlow."  )
                              UpperCAmelCase__							: Any 							=						None
                         else:
                              UpperCAmelCase__							: List[Any] 							=						measure_peak_memory_cpu(__UpperCamelCase  )
                              UpperCAmelCase__							: Optional[Any] 							=						Memory(__UpperCamelCase  ) if isinstance(__UpperCamelCase ,			__UpperCamelCase  ) else memory_bytes
                    if self.args.trace_memory_line_by_line:
                         UpperCAmelCase__							: Optional[Any] 							=						stop_memory_tracing(__UpperCamelCase  )
                         if memory is None:
                              UpperCAmelCase__							: Tuple 							=						summary.total
                    else:
                         UpperCAmelCase__							: int 							=						None

                    return memory, summary
               except ResourceExhaustedError as e:
                    self.print_fn(F"Doesn't fit on GPU. {e}"  )
                    return "N/A", None



