



"""simple docstring"""






from typing import Dict

from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    get_torch_dist_unique_port,
    require_torch_multi_gpu,
    require_torch_neuroncore,
)
from transformers.training_args import ParallelMode
from transformers.utils import logging


lowerCAmelCase__        =				logging.get_logger(__name__)


if is_torch_available():
   import torch
   from torch import nn
   from torch.utils.data import Dataset

   from transformers import Trainer






   class        __snake_case       (	_lowercase):




     def __init__( self     :						List[Any]						,					__lowerCAmelCase     :						int = 1_0_1		):






            """simple docstring"""






            _lowerCamelCase						:				Dict    			= length




     def __len__( self     :						Dict		):






            """simple docstring"""






            return self.length




     def __getitem__( self     :						List[Any]						,					__lowerCAmelCase     :						str		):






            """simple docstring"""






            return i






   class        __snake_case       :




     def __call__( self     :						str						,					__lowerCAmelCase     :						Optional[Any]		):






            """simple docstring"""






            return {"input_ids": torch.tensor(__lowerCAmelCase		), "labels": torch.tensor(__lowerCAmelCase		)}






   class        __snake_case       (	nn.Module):




     def __init__( self     :						str		):






            """simple docstring"""






            super().__init__()
            # Add some (unused) params otherwise DDP will complain.
            _lowerCamelCase						:				List[Any]    			= nn.Linear(1_2_0						,					8_0		)




     def 						SCREAMING_SNAKE_CASE				( self     :						Optional[int]						,					__lowerCAmelCase     :						Optional[int]						,					__lowerCAmelCase     :						str=None		):






            """simple docstring"""






            if labels is not None:
                   return torch.tensor(0.0						,					device=input_ids.device		), input_ids
            else:
                   return input_ids






class        __snake_case       (	_lowercase):




  @require_torch_neuroncore
  def 						SCREAMING_SNAKE_CASE				( self     :						str		):






         """simple docstring"""






         _lowerCamelCase						:				Optional[int]    			= f'''--nproc_per_node=2
            --master_port={get_torch_dist_unique_port()}
            {self.test_file_dir}/test_trainer_distributed.py
        '''.split()
         _lowerCamelCase						:				int    			= self.get_auto_remove_tmp_dir()
         _lowerCamelCase						:				Optional[int]    			= f'''--output_dir {output_dir}'''.split()
         _lowerCamelCase						:				int    			= ['''torchrun'''] + distributed_args + args
         execute_subprocess_async(__lowerCAmelCase						,					env=self.get_env()		)
         # successful return here == success - any errors would have caused an error in the sub-call






class        __snake_case       (	_lowercase):




  @require_torch_multi_gpu
  def 						SCREAMING_SNAKE_CASE				( self     :						Union[str, Any]		):






         """simple docstring"""






         _lowerCamelCase						:				int    			= f'''--nproc_per_node={torch.cuda.device_count()}
            --master_port={get_torch_dist_unique_port()}
            {self.test_file_dir}/test_trainer_distributed.py
        '''.split()
         _lowerCamelCase						:				Optional[int]    			= self.get_auto_remove_tmp_dir()
         _lowerCamelCase						:				Tuple    			= f'''--output_dir {output_dir}'''.split()
         _lowerCamelCase						:				str    			= ['''torchrun'''] + distributed_args + args
         execute_subprocess_async(__lowerCAmelCase						,					env=self.get_env()		)
         # successful return here == success - any errors would have caused an error in the sub-call


if __name__ == "__main__":
   # The script below is meant to be run under torch.distributed, on a machine with multiple GPUs:
   #
   # PYTHONPATH="src" python -m torch.distributed.run --nproc_per_node 2 --output_dir output_dir ./tests/test_trainer_distributed.py

   lowerCAmelCase__        =				HfArgumentParser((TrainingArguments,))
   lowerCAmelCase__        =				parser.parse_args_into_dataclasses()[0]

   logger.warning(
       F"""Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, """
       F"""distributed training: {training_args.parallel_mode != ParallelMode.NOT_DISTRIBUTED}"""
   )

   # Essentially, what we want to verify in the distributed case is that we get all samples back,
   # in the right order. (this is crucial for prediction for instance)
   for dataset_length in [101, 40, 7]:
      lowerCAmelCase__        =				DummyDataset(dataset_length)






      def        snake_case_  (      A_					:		EvalPrediction						):


             '''simple docstring'''





             _lowerCamelCase						:				str    			= list(range(len(A_						)						)						)
             _lowerCamelCase						:				List[Any]    			= p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
             if not success and training_args.local_rank == 0:
                    logger.warning(
                        '''Predictions and/or labels do not match expected results:\n  - predictions: '''
                        F'''{p.predictions.tolist()}\n  - labels: {p.label_ids.tolist()}\n  - expected: {sequential}'''						)
             return {"success": success}

      lowerCAmelCase__        =				Trainer(
          model=DummyModel(),
          args=training_args,
          data_collator=DummyDataCollator(),
          eval_dataset=dataset,
          compute_metrics=compute_metrics,
      )
      lowerCAmelCase__        =				trainer.evaluate()
      logger.info(metrics)
      if metrics["eval_success"] is not True:
         logger.error(metrics)
         exit(1)

      lowerCAmelCase__        =				trainer.predict(dataset)
      logger.info(p.metrics)
      if p.metrics["test_success"] is not True:
         logger.error(p.metrics)
         exit(1)

      lowerCAmelCase__        =				2

      lowerCAmelCase__        =				trainer.evaluate()
      logger.info(metrics)
      if metrics["eval_success"] is not True:
         logger.error(metrics)
         exit(1)

      lowerCAmelCase__        =				trainer.predict(dataset)
      logger.info(p.metrics)
      if p.metrics["test_success"] is not True:
         logger.error(p.metrics)
         exit(1)







      lowerCAmelCase__        =				None









from __future__ import annotations

import math


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->bool:

       if 1 < number < 4:
              # 2 and 3 are primes
              return True
       elif number < 2 or number % 2 == 0 or number % 3 == 0:
              # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
              return False

       # All primes number are in format of 6k +/- 1
       for i in range(5 ,     int(math.sqrt(UpperCamelCase__  ) + 1  ) ,     6  ):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->list[int]:
       A__											=						str(UpperCamelCase__  )
       A__											=						[n]
       for i in range(1 ,     len(UpperCamelCase__  )  ):
              list_nums.append(int(str_num[i:]  )  )
              list_nums.append(int(str_num[:-i]  )  )
       return list_nums


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->bool:
       if len(str(UpperCamelCase__  )  ) > 3:
              if not is_prime(int(str(UpperCamelCase__  )[-3:]  )  ) or not is_prime(int(str(UpperCamelCase__  )[:3]  )  ):
                     return False
       return True


def 	UpperCamelCase__(       UpperCamelCase__			:       int = 11  )->list[int]:
       A__											=						[]
       A__											=						13
       while len(UpperCamelCase__  ) != count:
              if validate(UpperCamelCase__  ):
                     A__											=						list_truncated_nums(UpperCamelCase__  )
                     if all(is_prime(UpperCamelCase__  ) for i in list_nums  ):
                            list_truncated_primes.append(UpperCamelCase__  )
              num += 2
       return list_truncated_primes


def 	UpperCamelCase__(       )->int:
       return sum(compute_truncated_primes(11  )  )


if __name__ == "__main__":
       print(F"{sum(compute_truncated_primes(11)) = }")





