


"""simple docstring"""







import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
       import torch

       from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
       import pyanvml.pyanvml as nvml


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






class  __A							(			lowerCAmelCase_     ):






 """simple docstring"""




 __lowerCAmelCase					   =    42
 __lowerCAmelCase					   =    42
 __lowerCAmelCase					   =    "PyTorch"


 @property
 def  SCREAMING_SNAKE_CASE				(						self		)   ->	List[str]:
     return torch.__version__


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A					,       __A		)   ->	float:
     a											=self._prepare_inference_func(__A					,       __A					,       __A		)
     return self._measure_speed(_inference		)


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A					,       __A		)   ->	[Memory, Optional[MemorySummary]]:
     a											=self._prepare_inference_func(__A					,       __A					,       __A		)
     return self._measure_memory(_inference		)


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A					,       __A		)   ->	float:
     a											=self._prepare_train_func(__A					,       __A					,       __A		)
     return self._measure_speed(_train		)


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A					,       __A		)   ->	[Memory, Optional[MemorySummary]]:
     a											=self._prepare_train_func(__A					,       __A					,       __A		)
     return self._measure_memory(_train		)


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A					,       __A		)   ->	Callable[[], None]:
     a											=self.config_dict[model_name]

     if self.args.torchscript:
         a											=True

     a											=(
         hasattr(__A					,       '''architectures'''		)
         and isinstance(config.architectures					,       __A		)
         and len(config.architectures		) > 0
     )
     if not self.args.only_pretrain_model and has_model_class_in_config:
         try:
             a											=config.architectures[0]
             a											=__import__('''transformers'''					,       fromlist=[model_class]		)
             a											=getattr(__A					,       __A		)
             a											=model_cls(__A		)
         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:
         a											=MODEL_MAPPING[config.__class__](__A		)

     model.eval()
     model.to(self.args.device		)

     # encoder-decoder has vocab size saved differently
     a											=config.vocab_size if hasattr(__A					,       '''vocab_size'''		) else config.encoder.vocab_size
     a											=torch.randint(__A					,       (batch_size, sequence_length)					,       dtype=torch.long					,       device=self.args.device		)

     if self.args.fpaa:
         logger.info('''Running training in Mixed Precision...'''		)
         if not self.args.is_gpu:
             raise ValueError('''Mixed precision is possible only for GPU.'''		)
         # amp seems to have memory leaks so that memory usage
         # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
         model.half()

     if self.args.torchscript:
         with torch.no_grad():
             a											=torch.jit.trace(__A					,       __A		)
     else:
         a											=model

     def encoder_decoder_forward():
         with torch.no_grad():
             a											=inference_model(__A					,       decoder_input_ids=__A		)
         return outputs

     def encoder_forward():
         with torch.no_grad():
             a											=inference_model(__A		)
         return outputs

     a											=encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
     return _forward


 def  SCREAMING_SNAKE_CASE				(						self					,       __A					,       __A					,       __A		)   ->	Callable[[], None]:
     a											=self.config_dict[model_name]

     a											=(
         hasattr(__A					,       '''architectures'''		)
         and isinstance(config.architectures					,       __A		)
         and len(config.architectures		) > 0
     )
     if not self.args.only_pretrain_model and has_model_class_in_config:
         try:
             a											=config.architectures[0]
             a											=__import__('''transformers'''					,       fromlist=[model_class]		)
             a											=getattr(__A					,       __A		)
             a											=model_cls(__A		)
         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:
         a											=MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__A		)

     if self.args.torchscript:
         raise NotImplementedError('''Training for torchscript is currently not implemented'''		)
     else:
         a											=model

     model.train()
     model.to(self.args.device		)

     # encoder-decoder has vocab size saved differently
     a											=config.vocab_size if hasattr(__A					,       '''vocab_size'''		) else config.encoder.vocab_size
     a											=torch.randint(__A					,       (batch_size, sequence_length)					,       dtype=torch.long					,       device=self.args.device		)

     if self.args.fpaa:
         logger.info('''Running training in Mixed Precision...'''		)
         if not self.args.is_gpu:
             raise ValueError('''Mixed precision is possible only for GPU.'''		)

         # amp seems to have memory leaks so that memory usage
         # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
         model.half()

     def compute_loss_and_backprob_encoder():
         a											=train_model(__A					,       labels=__A		)[0]
         loss.backward()
         return loss

     def compute_loss_and_backprob_encoder_decoder():
         a											=train_model(__A					,       decoder_input_ids=__A					,       labels=__A		)[0]
         loss.backward()
         return loss

     a											=(
         compute_loss_and_backprob_encoder_decoder
         if config.is_encoder_decoder
         else compute_loss_and_backprob_encoder
     )
     return _train


 def  SCREAMING_SNAKE_CASE				(						self					,       __A		)   ->	float:
     try:
         if self.args.is_tpu or self.args.torchscript:
             # run additional 10 times to stabilize compilation for tpu and torchscript
             logger.info('''Do inference on TPU or torchscript. Running model 5 times to stabilize compilation'''		)
             timeit.repeat(
                 __A					,       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
         a											=timeit.repeat(
             __A					,       repeat=self.args.repeat					,       number=10					,       )

         if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
             import torch_xla.debug.metrics as met

             self.print_fn(met.metrics_report()		)

         return min(__A		) / 10.0
     except RuntimeError as e:
         self.print_fn(f'''Doesn\'t fit on GPU. {e}'''		)
         return "N/A"





 def  SCREAMING_SNAKE_CASE				(						self					,       __A		)   ->	[Memory, MemorySummary]:
     try:
         if self.args.trace_memory_line_by_line:
             a											=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'''
                 ''' `--no-memory` or `args.memory=False`'''		)
         elif self.args.is_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.'''		)
                 a											='''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()
                 a											=nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx		)
                 a											=nvml.nvmlDeviceGetMemoryInfo(__A		)
                 a											=meminfo.used
                 a											=Memory(__A		)
                 # shutdown nvml
                 nvml.nvmlShutdown()
         else:
             # cpu
             a											=measure_peak_memory_cpu(__A		)
             a											=Memory(__A		) if isinstance(__A					,       __A		) else memory_bytes

         if self.args.trace_memory_line_by_line:
             a											=stop_memory_tracing(__A		)
         else:
             a											=None

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




"""simple docstring"""






def 	snake_case__  (						__lowerCamelCase							:       str				,						__lowerCamelCase							:       int = 13      ):
			"""simple docstring"""
			lowerCamelCase__						:						List[str]						      =''''''
			for c in s:
						if "A" <= c <= "Z":
									out += chr(ord('''A'''      ) + (ord(__lowerCamelCase      ) - ord('''A'''      ) + n) % 26      )
						elif "a" <= c <= "z":
									out += chr(ord('''a'''      ) + (ord(__lowerCamelCase      ) - ord('''a'''      ) + n) % 26      )
						else:
									out += c
			return out






def 	snake_case__  (						):
			"""simple docstring"""
			lowerCamelCase__						:						List[str]						      =input('''Enter message: '''      )

			lowerCamelCase__						:						str						      =dencrypt(__lowerCamelCase				,						13      )
			print('''Encryption:'''				,						__lowerCamelCase      )

			lowerCamelCase__						:						Any						      =dencrypt(__lowerCamelCase				,						13      )
			print('''Decryption: '''				,						__lowerCamelCase      )


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()




