


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


__UpperCamelCase       :       Tuple						       =				logging.get_logger(__name__)

def 			_a  (				):







 """simple docstring"""



 UpperCamelCase__					:    Union[str, 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[str]          =   json.loads(SCREAMING_SNAKE_CASE     )
  if "partitions" not in smp_options:
   return False
 except json.JSONDecodeError:
  return False

 # Get the sagemaker specific framework parameters from mpi_options variable.
 UpperCamelCase__					:    Optional[int]          =   os.getenv('''SM_FRAMEWORK_PARAMS'''    , '''{}'''     )
 try:
  # Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
  UpperCamelCase__					:    Dict          =   json.loads(SCREAMING_SNAKE_CASE     )
  if not mpi_options.get('''sagemaker_mpi_enabled'''    , SCREAMING_SNAKE_CASE     ):
   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):
     A:		str			=      field(
         default=""					,				metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"}					,				)


     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      str:





      '''simple docstring'''






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


     @cached_property
     def      UpperCAmelCase__	(      self							:     Dict			)  ->      "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__					:    Union[str, Any]          =   torch.device('''cpu'''			)
       UpperCamelCase__					:    Union[str, Any]          =   0
      elif is_sagemaker_model_parallel_available():
       UpperCamelCase__					:    Union[str, Any]          =   smp.local_rank()
       UpperCamelCase__					:    str          =   torch.device('''cuda'''							,	lowerCamelCase__			)
       UpperCamelCase__					:    Tuple          =   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__					:    Optional[int]          =   int(os.getenv('''SMDATAPARALLEL_LOCAL_RANK'''			)			)
       UpperCamelCase__					:    Optional[Any]          =   torch.device('''cuda'''							,	self.local_rank			)
       UpperCamelCase__					:    List[Any]          =   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[str]          =   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__					:    Union[str, 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__					:    Any          =   1

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

      return device


     @property
     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      int:





      '''simple docstring'''






      if is_sagemaker_model_parallel_available():
       return smp.dp_size()

      return super().world_size


     @property
     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      Any:





      '''simple docstring'''






      return not is_sagemaker_model_parallel_available()


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





      '''simple docstring'''






      return False






import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
       from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
       from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
       from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


__UpperCamelCase       :       Dict						       =				DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

__UpperCamelCase       :       Optional[int]						       =				"main"
# Default branch name
__UpperCamelCase       :       Optional[Any]						       =				"f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"
# One particular commit (not the top of `main`)
__UpperCamelCase       :       str						       =				"aaaaaaa"
# This commit does not exist, so we should 404.

__UpperCamelCase       :       Optional[Any]						       =				"d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"
# Sha-1 of config.json on the top of `main`, for checking purposes
__UpperCamelCase       :       Tuple						       =				"4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"

@contextlib.contextmanager
def 			_a  (				):







 """simple docstring"""



 print('''Welcome!'''     )
 yield
 print('''Bye!'''     )

@contextlib.contextmanager
def 			_a  (				):







 """simple docstring"""



 print('''Bonjour!'''     )
 yield
 print('''Au revoir!'''     )

class       __magic_name__	(     unittest.TestCase):


     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      Any:





      '''simple docstring'''






      assert transformers.__spec__ is not None
      assert importlib.util.find_spec('''transformers'''			) is not None



class       __magic_name__	(     unittest.TestCase):


     @unittest.mock.patch('''sys.stdout'''							,	new_callable=io.StringIO			)
     def      UpperCAmelCase__	(      self							:     Union[str, Any]							,	lowerCamelCase__							:     Union[str, Any]			)  ->      Optional[Any]:





      '''simple docstring'''






      with ContextManagers([]			):
       print('''Transformers are awesome!'''			)
      # The print statement adds a new line at the end of the output
      self.assertEqual(mock_stdout.getvalue()							,	'''Transformers are awesome!\n'''			)


     @unittest.mock.patch('''sys.stdout'''							,	new_callable=io.StringIO			)
     def      UpperCAmelCase__	(      self							:     Any							,	lowerCamelCase__							:     Union[str, Any]			)  ->      Dict:





      '''simple docstring'''






      with ContextManagers([context_en()]			):
       print('''Transformers are awesome!'''			)
      # The output should be wrapped with an English welcome and goodbye
      self.assertEqual(mock_stdout.getvalue()							,	'''Welcome!\nTransformers are awesome!\nBye!\n'''			)


     @unittest.mock.patch('''sys.stdout'''							,	new_callable=io.StringIO			)
     def      UpperCAmelCase__	(      self							:     List[Any]							,	lowerCamelCase__							:     List[str]			)  ->      Tuple:





      '''simple docstring'''






      with ContextManagers([context_fr(), context_en()]			):
       print('''Transformers are awesome!'''			)
      # The output should be wrapped with an English and French welcome and goodbye
      self.assertEqual(mock_stdout.getvalue()							,	'''Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n'''			)


     @require_torch
     def      UpperCAmelCase__	(      self							:     Tuple			)  ->      Optional[int]:





      '''simple docstring'''






      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''']			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''', '''next_sentence_label''']			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''start_positions''', '''end_positions''']			)

      class       __magic_name__	(     __lowerCAmelCase):
           pass



      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''']			)


     @require_tf
     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      Tuple:





      '''simple docstring'''






      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''']			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''', '''next_sentence_label''']			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''start_positions''', '''end_positions''']			)

      class       __magic_name__	(     __lowerCAmelCase):
           pass



      self.assertEqual(find_labels(lowerCamelCase__			)							,	['''labels''']			)


     @require_flax
     def      UpperCAmelCase__	(      self							:     str			)  ->      Optional[Any]:





      '''simple docstring'''






      self.assertEqual(find_labels(lowerCamelCase__			)							,	[]			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	[]			)
      self.assertEqual(find_labels(lowerCamelCase__			)							,	[]			)

      class       __magic_name__	(     __lowerCAmelCase):
           pass



      self.assertEqual(find_labels(lowerCamelCase__			)							,	[]			)


