



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


UpperCamelCase_      			=  logging.get_logger(__name__)

if is_tf_available():
							import tensorflow as tf







@dataclass
class 				a_    (						_snake_case							):
						UpperCamelCase__ :		List[str]										="tf"
						UpperCamelCase__ :		Optional[str]										=field(
						    default=_snake_case   ,					metadata={"help": "Name of TPU"}   ,					)

						UpperCamelCase__ :		Optional[str]										=field(
						    default=_snake_case   ,					metadata={"help": "Zone of TPU"}   ,					)

						UpperCamelCase__ :		Optional[str]										=field(
						    default=_snake_case   ,					metadata={"help": "Name of Cloud TPU-enabled project"}   ,					)

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

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

						@cached_property
						def       __a			(       self      :Optional[int])						->   Tuple["tf.distribute.Strategy", int]:
												requires_backends(self  ,		['''tf'''])
												logger.info('''Tensorflow: setting up strategy''')

												UpperCAmelCase_					=	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:
																		UpperCAmelCase_					=	tf.distribute.OneDeviceStrategy(device='''/cpu:0''')
												else:
																		try:
																								if self.tpu_name:
																														UpperCAmelCase_					=	tf.distribute.cluster_resolver.TPUClusterResolver(
																														    self.tpu_name  ,		zone=self.tpu_zone  ,		project=self.gcp_project)
																								else:
																														UpperCAmelCase_					=	tf.distribute.cluster_resolver.TPUClusterResolver()
																		except ValueError:
																								if self.tpu_name:
																														raise RuntimeError(f"Couldn't connect to TPU {self.tpu_name}!")
																								else:
																														UpperCAmelCase_					=	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(_lowercase)
																								tf.tpu.experimental.initialize_tpu_system(_lowercase)

																								UpperCAmelCase_					=	tf.distribute.TPUStrategy(_lowercase)

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

												return strategy

						@property
						def       __a			(       self      :Tuple)						->   "tf.distribute.Strategy":
												requires_backends(self  ,		['''tf'''])
												return self._setup_strategy

						@property
						def       __a			(       self      :List[Any])						->   int:
												requires_backends(self  ,		['''tf'''])
												return self._setup_strategy.num_replicas_in_sync

						@property
						def       __a			(       self      :Union[str, Any])						->   str:
												return False  # TF Logging is handled by Keras not the Trainer

						@property
						def       __a			(       self      :List[Any])						->   int:
												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.''')
												UpperCAmelCase_					=	self.per_gpu_train_batch_size or self.per_device_train_batch_size
												return per_device_batch_size * self.n_replicas

						@property
						def       __a			(       self      :Optional[Any])						->   int:
												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.''')
												UpperCAmelCase_					=	self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
												return per_device_batch_size * self.n_replicas




						@property
						def       __a			(       self      :Union[str, Any])						->   int:
												requires_backends(self  ,		['''tf'''])
												warnings.warn(
												    '''The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead.'''  ,		_lowercase  ,		)
												return self._setup_strategy.num_replicas_in_sync










import json

import requests

from .fetch_github_info import AUTHENTICATED_USER_ENDPOINT, fetch_github_info







def 							A     (						__UpperCAmelCase      )			->			Dict:



						'''simple docstring'''






						class 				a_    :

												def __init__(       self      :Optional[int]  ,		_lowercase      :Any)						->   None:
																		assert isinstance(_lowercase  ,		(bytes, str))
																		UpperCAmelCase_					=	content




												def       __a			(       self      :List[str])						->   Tuple:
																		return json.loads(self.content)

						def mock_response(*__UpperCAmelCase				,   **__UpperCAmelCase      ):
												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(__UpperCAmelCase				,   '''get'''				,   __UpperCAmelCase      )
						UpperCAmelCase_					=	fetch_github_info('''token'''      )
						assert result["login"] == "test"
						assert result["id"] == 1





