






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


__A      =				logging.get_logger(__name__)




def      __A					(     ):

					'''simple docstring'''







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

					# Get the sagemaker specific framework parameters from mpi_options variable.
					_A								= os.getenv('''SM_FRAMEWORK_PARAMS'''					,			'''{}''' )
					try:
										# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
										_A								= json.loads(_lowercase )
										if not mpi_options.get('''sagemaker_mpi_enabled'''					,			_lowercase ):
															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 						SCREAMING_SNAKE_CASE				( snake_case					):





							"""simple docstring"""

							A_						  =					field(
							    default=""  ,	metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"}  ,	)

							def       __A (  self:   Dict   )    ->				Tuple:
												super().__post_init__()
												warnings.warn(
												    '''`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '''
												    '''`TrainingArguments` instead.'''		,     __A		,     )

							@cached_property
							def       __A (  self:   Any   )    ->				"torch.device":
												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:
																	_A								= torch.device('''cpu'''   )
																	_A								= 0
												elif is_sagemaker_model_parallel_available():
																	_A								= smp.local_rank()
																	_A								= torch.device('''cuda'''		,     __A   )
																	_A								= 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   )
																	_A								= int(os.getenv('''SMDATAPARALLEL_LOCAL_RANK'''   )   )
																	_A								= torch.device('''cuda'''		,     self.local_rank   )
																	_A								= 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
																	_A								= 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.
																	_A								= 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   )
																	_A								= torch.device('''cuda'''		,     self.local_rank   )
																	_A								= 1

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

												return device

							@property
							def       __A (  self:   List[Any]   )    ->				Tuple:
												if is_sagemaker_model_parallel_available():
																	return smp.dp_size()

												return super().world_size

							@property
							def       __A (  self:   Dict   )    ->				Any:
												return not is_sagemaker_model_parallel_available()



							@property
							def       __A (  self:   int   )    ->				Optional[Any]:
												return False











import itertools
import string
from collections.abc import Generator, Iterable




def      __A					(     _lowercase					,			_lowercase ):

					'''simple docstring'''







					_A								= iter(_lowercase )
					while True:
										_A								= tuple(itertools.islice(_lowercase					,			_lowercase ) )
										if not chunk:
															return
										yield chunk




def      __A					(     _lowercase ):

					'''simple docstring'''







					_A								= ''''''.join([c.upper() for c in dirty if c in string.ascii_letters] )
					_A								= ''''''

					if len(_lowercase ) < 2:
										return dirty

					for i in range(len(_lowercase ) - 1 ):
										clean += dirty[i]

										if dirty[i] == dirty[i + 1]:
															clean += "X"

					clean += dirty[-1]

					if len(_lowercase ) & 1:
										clean += "X"

					return clean




def      __A					(     _lowercase ):

					'''simple docstring'''







					_A								= '''ABCDEFGHIKLMNOPQRSTUVWXYZ'''
					# we're using a list instead of a '2d' array because it makes the math
					# for setting up the table and doing the actual encoding/decoding simpler
					_A								= []

					# copy key chars into the table if they are in `alphabet` ignoring duplicates
					for char in key.upper():
										if char not in table and char in alphabet:
															table.append(_lowercase )

    # fill the rest of the table in with the remaining alphabet chars
					for char in alphabet:
										if char not in table:
															table.append(_lowercase )

					return table




def      __A					(     _lowercase					,			_lowercase ):

					'''simple docstring'''







					_A								= generate_table(_lowercase )
					_A								= prepare_input(_lowercase )
					_A								= ''''''

					# https://en.wikipedia.org/wiki/Playfair_cipher#Description
					for chara, chara in chunker(_lowercase					,			2 ):
										_A							,_A								= divmod(table.index(_lowercase )					,			5 )
										_A							,_A								= divmod(table.index(_lowercase )					,			5 )

										if rowa == rowa:
															ciphertext += table[rowa * 5 + (cola + 1) % 5]
															ciphertext += table[rowa * 5 + (cola + 1) % 5]
										elif cola == cola:
															ciphertext += table[((rowa + 1) % 5) * 5 + cola]
															ciphertext += table[((rowa + 1) % 5) * 5 + cola]
										else:  # rectangle
															ciphertext += table[rowa * 5 + cola]
															ciphertext += table[rowa * 5 + cola]

					return ciphertext




def      __A					(     _lowercase					,			_lowercase ):

					'''simple docstring'''







					_A								= generate_table(_lowercase )
					_A								= ''''''

					# https://en.wikipedia.org/wiki/Playfair_cipher#Description
					for chara, chara in chunker(_lowercase					,			2 ):
										_A							,_A								= divmod(table.index(_lowercase )					,			5 )
										_A							,_A								= divmod(table.index(_lowercase )					,			5 )

										if rowa == rowa:
															plaintext += table[rowa * 5 + (cola - 1) % 5]
															plaintext += table[rowa * 5 + (cola - 1) % 5]
										elif cola == cola:
															plaintext += table[((rowa - 1) % 5) * 5 + cola]
															plaintext += table[((rowa - 1) % 5) * 5 + cola]
										else:  # rectangle
															plaintext += table[rowa * 5 + cola]
															plaintext += table[rowa * 5 + cola]

					return plaintext



