


'''simple docstring'''






import importlib.util
import json
import os
import warnings
from dataclasses import dataclass, field

import torch

from ..training_args import TrainingArguments
from ..utils import cached_property, is_sagemaker_dp_enabled, logging


lowercase							=logging.get_logger(__name__)





def lowerCamelCase__      (						):







   '''simple docstring'''




   _UpperCAmelCase       :       Optional[Any]							   =os.getenv('SM_HP_MP_PARAMETERS'	,   '{}'							)
   try:
      # Parse it and check the field "partitions" is included, it is required for model parallel.
      _UpperCAmelCase       :       List[Any]							   =json.loads(__lowerCamelCase							)
      if "partitions" not in smp_options:
         return False
   except json.JSONDecodeError:
      return False

   # Get the sagemaker specific framework parameters from mpi_options variable.
   _UpperCAmelCase       :       List[Any]							   =os.getenv('SM_FRAMEWORK_PARAMS'	,   '{}'							)
   try:
      # Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
      _UpperCAmelCase       :       Dict							   =json.loads(__lowerCamelCase							)
      if not mpi_options.get('sagemaker_mpi_enabled'	,   __lowerCamelCase							):
         return False
   except json.JSONDecodeError:
      return False
   # Lastly, check if the `smdistributed` module is present.
   return importlib.util.find_spec('smdistributed'							) is not None


if is_sagemaker_model_parallel_available():
 import smdistributed.modelparallel.torch as smp

 smp.init()






@dataclass
class  __magic_name__							(		lowerCAmelCase    ):
       UpperCAmelCase										=field(
           default="" ,metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"} ,)






       def       lowerCAmelCase		(      self)						->  List[Any]:




          '''simple docstring'''
          super().__post_init__()
          warnings.warn(
              '`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '
              '`TrainingArguments` instead.'  ,							snake_case  ,							)






       @cached_property
       def       lowerCAmelCase		(      self)						->  "torch.device":




          '''simple docstring'''
          logger.info('PyTorch: setting up devices')
          if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1:
             logger.warning(
                 'torch.distributed process group is initialized, but local_rank == -1. '
                 'In order to use Torch DDP, launch your script with `python -m torch.distributed.launch')
          if self.no_cuda:
             _UpperCAmelCase       :       List[Any]							   =torch.device('cpu')
             _UpperCAmelCase       :       Any							   =0
          elif is_sagemaker_model_parallel_available():
             _UpperCAmelCase       :       Optional[Any]							   =smp.local_rank()
             _UpperCAmelCase       :       Optional[int]							   =torch.device('cuda'  ,							snake_case)
             _UpperCAmelCase       :       Dict							   =1
          elif is_sagemaker_dp_enabled():
             import smdistributed.dataparallel.torch.torch_smddp  # noqa: F401

             torch.distributed.init_process_group(backend='smddp'  ,							timeout=self.ddp_timeout_delta)
             _UpperCAmelCase       :       Union[str, Any]							   =int(os.getenv('SMDATAPARALLEL_LOCAL_RANK'))
             _UpperCAmelCase       :       int							   =torch.device('cuda'  ,							self.local_rank)
             _UpperCAmelCase       :       Optional[int]							   =1
          elif self.local_rank == -1:
             # if n_gpu is > 1 we'll use nn.DataParallel.
             # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
             # Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will
             # trigger an error that a device index is missing. Index 0 takes into account the
             # GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0`
             # will use the first GPU in that env, i.e. GPU#1
             _UpperCAmelCase       :       List[Any]							   =torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
             # Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at
             # the default value.
             _UpperCAmelCase       :       List[Any]							   =torch.cuda.device_count()
          else:
             # Here, we'll use torch.distributed.
             # Initializes the distributed backend which will take care of synchronizing nodes/GPUs
             if not torch.distributed.is_initialized():
                torch.distributed.init_process_group(backend='nccl'  ,							timeout=self.ddp_timeout_delta)
             _UpperCAmelCase       :       Any							   =torch.device('cuda'  ,							self.local_rank)
             _UpperCAmelCase       :       List[str]							   =1

          if device.type == "cuda":
             torch.cuda.set_device(snake_case)

          return device






       @property
       def       lowerCAmelCase		(      self)						->  Union[str, Any]:




          '''simple docstring'''
          if is_sagemaker_model_parallel_available():
             return smp.dp_size()

          return super().world_size






       @property
       def       lowerCAmelCase		(      self)						->  Optional[int]:




          '''simple docstring'''
          return not is_sagemaker_model_parallel_available()






       @property
       def       lowerCAmelCase		(      self)						->  Tuple:




          '''simple docstring'''
          return False





'''simple docstring'''






from string import ascii_uppercase

lowercase							={str(ord(c) - 55): c for c in ascii_uppercase}





def lowerCamelCase__      (						__lowerCamelCase	:							int	,   __lowerCamelCase	:							int							):







   '''simple docstring'''




   if isinstance(__lowerCamelCase	,   __lowerCamelCase							):
      raise TypeError('int() can\'t convert non-string with explicit base'							)
   if num < 0:
      raise ValueError('parameter must be positive int'							)
   if isinstance(__lowerCamelCase	,   __lowerCamelCase							):
      raise TypeError('\'str\' object cannot be interpreted as an integer'							)
   if isinstance(__lowerCamelCase	,   __lowerCamelCase							):
      raise TypeError('\'float\' object cannot be interpreted as an integer'							)
   if base in (0, 1):
      raise ValueError('base must be >= 2'							)
   if base > 3_6:
      raise ValueError('base must be <= 36'							)
   _UpperCAmelCase       :       Union[str, Any]							   =''
   _UpperCAmelCase       :       Optional[int]							   =0
   _UpperCAmelCase       :       str							   =0
   while div != 1:
      _UpperCAmelCase   ,	_UpperCAmelCase       :       int							   =divmod(__lowerCamelCase	,   __lowerCamelCase							)
      if base >= 1_1 and 9 < mod < 3_6:
         _UpperCAmelCase       :       str							   =ALPHABET_VALUES[str(__lowerCamelCase							)]
      else:
         _UpperCAmelCase       :       Any							   =str(__lowerCamelCase							)
      new_value += actual_value
      _UpperCAmelCase       :       Union[str, Any]							   =num // base
      _UpperCAmelCase       :       Dict							   =div
      if div == 0:
         return str(new_value[::-1]							)
      elif div == 1:
         new_value += str(__lowerCamelCase							)
         return str(new_value[::-1]							)

   return new_value[::-1]


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 for base in range(2, 37):
  for num in range(1000):
   assert int(decimal_to_any(num, base), base) == num, (
       num,
       base,
       decimal_to_any(num, base),
       int(decimal_to_any(num, base), base),
   )

