






import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


lowerCamelCase					    =	logging.get_logger(__name__)

if is_tf_available():
   import tensorflow as tf

@dataclass
class        snake_case_				(							lowercase_   ):







   """simple docstring"""



   __lowerCAmelCase  =    """tf"""
   __lowerCAmelCase  =    field(
       default=lowercase_   ,      metadata={"""help""": """Name of TPU"""}   ,      )

   __lowerCAmelCase  =    field(
       default=lowercase_   ,      metadata={"""help""": """Zone of TPU"""}   ,      )

   __lowerCAmelCase  =    field(
       default=lowercase_   ,      metadata={"""help""": """Name of Cloud TPU-enabled project"""}   ,      )

   __lowerCAmelCase  =    field(
       default=1.0   ,      metadata={"""help""": """Power for the Polynomial decay LR scheduler."""}   ,      )

   __lowerCAmelCase  =    field(default=lowercase_   ,      metadata={"""help""": """Whether to activate the XLA compilation or not"""}   )

   @cached_property
   def       SCREAMING_SNAKE_CASE__					(     self:						Optional[int]						)	->		Tuple["tf.distribute.Strategy", int]:


       """simple docstring"""



       requires_backends(self ,							['tf']						)
       logger.info('Tensorflow: setting up strategy'						)

       _lowercase     			=						tf.config.list_physical_devices('GPU'						)

       # Set to float16 at first
       if self.fpaa:
           tf.keras.mixed_precision.set_global_policy('mixed_float16'						)

       if self.no_cuda:
           _lowercase     			=						tf.distribute.OneDeviceStrategy(device='/cpu:0'						)
       else:
           try:
               if self.tpu_name:
                   _lowercase     			=						tf.distribute.cluster_resolver.TPUClusterResolver(
                       self.tpu_name ,							zone=self.tpu_zone ,							project=self.gcp_project						)
               else:
                   _lowercase     			=						tf.distribute.cluster_resolver.TPUClusterResolver()
           except ValueError:
               if self.tpu_name:
                   raise RuntimeError(f'''Couldn\'t connect to TPU {self.tpu_name}!'''						)
               else:
                   _lowercase     			=						None

           if tpu:
               # Set to bfloat16 in case of TPU
               if self.fpaa:
                   tf.keras.mixed_precision.set_global_policy('mixed_bfloat16'						)

               tf.config.experimental_connect_to_cluster(snake_case__						)
               tf.tpu.experimental.initialize_tpu_system(snake_case__						)

               _lowercase     			=						tf.distribute.TPUStrategy(snake_case__						)

           elif len(snake_case__						) == 0:
               _lowercase     			=						tf.distribute.OneDeviceStrategy(device='/cpu:0'						)
           elif len(snake_case__						) == 1:
               _lowercase     			=						tf.distribute.OneDeviceStrategy(device='/gpu:0'						)
           elif len(snake_case__						) > 1:
               # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
               _lowercase     			=						tf.distribute.MirroredStrategy()
           else:
               raise ValueError('Cannot find the proper strategy, please check your environment properties.'						)

       return strategy

   @property
   def       SCREAMING_SNAKE_CASE__					(     self:						Dict						)	->		"tf.distribute.Strategy":


       """simple docstring"""



       requires_backends(self ,							['tf']						)
       return self._setup_strategy

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


       """simple docstring"""



       requires_backends(self ,							['tf']						)
       return self._setup_strategy.num_replicas_in_sync

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


       """simple docstring"""



       return False  # TF Logging is handled by Keras not the Trainer

   @property
   def       SCREAMING_SNAKE_CASE__					(     self:						List[str]						)	->		int:


       """simple docstring"""



       if self.per_gpu_train_batch_size:
           logger.warning(
               'Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future '
               'version. Using `--per_device_train_batch_size` is preferred.'						)
       _lowercase     			=						self.per_gpu_train_batch_size or self.per_device_train_batch_size
       return per_device_batch_size * self.n_replicas

   @property
   def       SCREAMING_SNAKE_CASE__					(     self:						int						)	->		int:


       """simple docstring"""



       if self.per_gpu_eval_batch_size:
           logger.warning(
               'Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future '
               'version. Using `--per_device_eval_batch_size` is preferred.'						)
       _lowercase     			=						self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
       return per_device_batch_size * self.n_replicas

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


       """simple docstring"""



       requires_backends(self ,							['tf']						)
       warnings.warn(
           'The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead.' ,							snake_case__ ,							)
       return self._setup_strategy.num_replicas_in_sync








import json

import requests

from .fetch_github_info import AUTHENTICATED_USER_ENDPOINT, fetch_github_info
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    class        snake_case_				:







       """simple docstring"""



       def __init__(     self:						Tuple ,							snake_case__:						Optional[int]						)	->		None:


           """simple docstring"""



           assert isinstance(snake_case__ ,							(bytes, str)						)
           _lowercase     			=						content

       def       SCREAMING_SNAKE_CASE__					(     self:						Tuple						)	->		str:


           """simple docstring"""



           return json.loads(self.content						)

    def mock_response(*_lowercase,   **_lowercase   ):
        assert args[0] == AUTHENTICATED_USER_ENDPOINT
        assert "Authorization" in kwargs["headers"]
        assert kwargs["headers"]["Authorization"].startswith('token '   )
        assert "Accept" in kwargs["headers"]
        return FakeResponse(b'{"login":"test","id":1}'   )

    monkeypatch.setattr(_lowercase,   'get',   _lowercase   )
    _lowercase     			=						fetch_github_info('token'   )
    assert result["login"] == "test"
    assert result["id"] == 1
