






from __future__ import annotations



def      UpperCAmelCase						( lowerCAmelCase__					,     lowerCAmelCase__	):


		'''simple docstring'''

		__A ,   __A ,   __A    =							"", "", ""
		__A    =							[]

		for character in message_part:
				tmp.append(character_to_number[character]	)

		for each in tmp:
				one += each[0]
				two += each[1]
				three += each[2]

		return one + two + three



def      UpperCAmelCase						( lowerCAmelCase__					,     lowerCAmelCase__	):


		'''simple docstring'''

		__A ,   __A    =							"", ""
		__A    =							[]

		for character in message_part:
				this_part += character_to_number[character]

		for digit in this_part:
				tmp += digit
				if len(lowerCAmelCase__	) == len(lowerCAmelCase__	):
						result.append(lowerCAmelCase__	)
						__A    =							""

		return result[0], result[1], result[2]



def      UpperCAmelCase						( lowerCAmelCase__					,     lowerCAmelCase__	):


		'''simple docstring'''

		__A    =							alphabet.replace(" "					,     ""	).upper()
		__A    =							message.replace(" "					,     ""	).upper()

		# Check length and characters
		if len(lowerCAmelCase__	) != 27:
				raise KeyError("Length of alphabet has to be 27."	)
		for each in message:
				if each not in alphabet:
						raise ValueError("Each message character has to be included in alphabet!"	)

    # Generate dictionares
		__A    =							(
		    "111",
		    "112",
		    "113",
		    "121",
		    "122",
		    "123",
		    "131",
		    "132",
		    "133",
		    "211",
		    "212",
		    "213",
		    "221",
		    "222",
		    "223",
		    "231",
		    "232",
		    "233",
		    "311",
		    "312",
		    "313",
		    "321",
		    "322",
		    "323",
		    "331",
		    "332",
		    "333",
		)
		__A    =							{}
		__A    =							{}
		for letter, number in zip(lowerCAmelCase__					,     lowerCAmelCase__	):
				__A    =							number
				__A    =							letter

		return message, alphabet, character_to_number, number_to_character



def      UpperCAmelCase						( lowerCAmelCase__					,     lowerCAmelCase__ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."					,     lowerCAmelCase__ = 5	):


		'''simple docstring'''

		__A ,   __A ,   __A ,   __A    =							__prepare(
		    lowerCAmelCase__					,     lowerCAmelCase__	)
		__A ,   __A    =							"", ""

		for i in range(0					,     len(lowerCAmelCase__	) + 1					,     lowerCAmelCase__	):
				encrypted_numeric += __encrypt_part(
				    message[i : i + period]					,     lowerCAmelCase__	)

		for i in range(0					,     len(lowerCAmelCase__	)					,     3	):
				encrypted += number_to_character[encrypted_numeric[i : i + 3]]

		return encrypted



def      UpperCAmelCase						( lowerCAmelCase__					,     lowerCAmelCase__ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."					,     lowerCAmelCase__ = 5	):


		'''simple docstring'''

		__A ,   __A ,   __A ,   __A    =							__prepare(
		    lowerCAmelCase__					,     lowerCAmelCase__	)
		__A    =							[]
		__A    =							""

		for i in range(0					,     len(lowerCAmelCase__	) + 1					,     lowerCAmelCase__	):
				__A ,   __A ,   __A    =							__decrypt_part(message[i : i + period]					,     lowerCAmelCase__	)

				for j in range(0					,     len(lowerCAmelCase__	)	):
						decrypted_numeric.append(a[j] + b[j] + c[j]	)

		for each in decrypted_numeric:
				decrypted += number_to_character[each]

		return decrypted


if __name__ == "__main__":
					snake_case_   :	Dict							      ='''DEFEND THE EAST WALL OF THE CASTLE.'''
					snake_case_   :	str							      =encrypt_message(msg, '''EPSDUCVWYM.ZLKXNBTFGORIJHAQ''')
					snake_case_   :	List[str]							      =decrypt_message(encrypted, '''EPSDUCVWYM.ZLKXNBTFGORIJHAQ''')
					print(f"""Encrypted: {encrypted}\nDecrypted: {decrypted}""")





"""simple docstring"""
import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
				import torch_xla.core.xla_model as xm  # noqa: F401

				__SCREAMING_SNAKE_CASE				:     List[Any]		=     True
except ImportError:
				__SCREAMING_SNAKE_CASE				:     Dict		=     False


# Cache this result has it's a C FFI call which can be pretty time-consuming
__SCREAMING_SNAKE_CASE				:     Optional[Any]		=     torch.distributed.is_available()







def     _a					(   _SCREAMING_SNAKE_CASE					)     ->					int:
							# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
							snake_case_     							=		importlib.util.find_spec(_SCREAMING_SNAKE_CASE					) is not None
							if package_exists:
														try:
																					snake_case_     							=		importlib.metadata.metadata(_SCREAMING_SNAKE_CASE					)
																					return True
														except importlib.metadata.PackageNotFoundError:
																					return False







def     _a					(   )     ->					bool:
							return _torch_distributed_available







def     _a					(   )     ->					Union[str, Any]:
							try:
														pass
							except ImportError:
														print(
														    """Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"""
														    """ detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"""
														    """ Bindings for PyTorch*."""					)
							return (
							    importlib.util.find_spec("""torch_ccl"""					) is not None
							    or importlib.util.find_spec("""oneccl_bindings_for_pytorch"""					) is not None
							)







def     _a					(   )     ->					Optional[Any]:
							return importlib.metadata.version("""oneccl_bind_pt"""					)







def     _a					(   )     ->					Optional[Any]:
							return _is_package_available("""transformer_engine"""					)







@lru_cache
def     _a					(   _SCREAMING_SNAKE_CASE=True					)     ->					int:
							# Due to bugs on the amp series GPUs, we disable torch-xla on them
							if torch.cuda.is_available():
														return False
							if _tpu_available and check_device:
														try:
																					# Will raise a RuntimeError if no XLA configuration is found
																					snake_case_     							=		xm.xla_device()
																					return True
														except RuntimeError:
																					return False
							return _tpu_available







def     _a					(   )     ->					List[str]:
							return _is_package_available("""deepspeed"""					)







def     _a					(   _SCREAMING_SNAKE_CASE=False					)     ->					Optional[int]:
							if is_tpu_available():
														return not ignore_tpu
							if torch.cuda.is_available():
														return torch.cuda.is_bfaa_supported()
							if is_npu_available():
														return False
							return True







def     _a					(   )     ->					Any:
							snake_case_     							=		_is_package_available("""bitsandbytes"""					)
							if package_exists:
														snake_case_     							=		version.parse(importlib.metadata.version("""bitsandbytes"""					)					)
														return compare_versions(_SCREAMING_SNAKE_CASE					,			""">="""					,			"""0.39.0"""					)
							return False







def     _a					(   )     ->					List[Any]:
							snake_case_     							=		_is_package_available("""bitsandbytes"""					)
							if package_exists:
														snake_case_     							=		version.parse(importlib.metadata.version("""bitsandbytes"""					)					)
														return compare_versions(_SCREAMING_SNAKE_CASE					,			""">="""					,			"""0.37.2"""					)
							return False







def     _a					(   )     ->					Union[str, Any]:
							return _is_package_available("""bitsandbytes"""					)







def     _a					(   )     ->					Optional[int]:
							if strtobool(os.environ.get("""ACCELERATE_USE_MEGATRON_LM"""					,			"""False"""					)					) == 1:
														snake_case_     							=		importlib.util.find_spec("""megatron"""					) is not None
														if package_exists:
																					try:
																												snake_case_     							=		parse(importlib.metadata.version("""megatron-lm"""					)					)
																												return compare_versions(_SCREAMING_SNAKE_CASE					,			""">="""					,			"""2.2.0"""					)
																					except Exception as e:
																												warnings.warn(f"""Parse Megatron version failed. Exception:{e}"""					)
																												return False







def     _a					(   )     ->					str:
							return _is_package_available("""safetensors"""					)







def     _a					(   )     ->					str:
							return _is_package_available("""transformers"""					)







def     _a					(   )     ->					Union[str, Any]:
							return _is_package_available("""datasets"""					)







def     _a					(   )     ->					List[str]:
							return _is_package_available("""aim"""					)







def     _a					(   )     ->					List[str]:
							return _is_package_available("""tensorboard"""					) or _is_package_available("""tensorboardX"""					)







def     _a					(   )     ->					int:
							return _is_package_available("""wandb"""					)







def     _a					(   )     ->					List[Any]:
							return _is_package_available("""comet_ml"""					)







def     _a					(   )     ->					Union[str, Any]:
							return _is_package_available("""boto3"""					)







def     _a					(   )     ->					Optional[Any]:
							if _is_package_available("""rich"""					):
														if "ACCELERATE_DISABLE_RICH" in os.environ:
																					warnings.warn(
																					    """`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."""					)
																					return not parse_flag_from_env("""ACCELERATE_DISABLE_RICH"""					,			_SCREAMING_SNAKE_CASE					)
														return parse_flag_from_env("""ACCELERATE_ENABLE_RICH"""					,			_SCREAMING_SNAKE_CASE					)
							return False







def     _a					(   )     ->					List[Any]:
							return _is_package_available("""sagemaker"""					)







def     _a					(   )     ->					int:
							return _is_package_available("""tqdm"""					)







def     _a					(   )     ->					List[Any]:
							return _is_package_available("""mlflow"""					)







def     _a					(   )     ->					int:
							return is_torch_version(""">="""					,			"""1.12"""					) and torch.backends.mps.is_available() and torch.backends.mps.is_built()







def     _a					(   )     ->					Any:
							def get_major_and_minor_from_version(_SCREAMING_SNAKE_CASE					):
														return str(version.parse(_SCREAMING_SNAKE_CASE					).major					) + "." + str(version.parse(_SCREAMING_SNAKE_CASE					).minor					)

							snake_case_     							=		importlib.metadata.version("""torch"""					)
							if importlib.util.find_spec("""intel_extension_for_pytorch"""					) is None:
														return False
							snake_case_     							=		"""N/A"""
							try:
														snake_case_     							=		importlib.metadata.version("""intel_extension_for_pytorch"""					)
							except importlib.metadata.PackageNotFoundError:
														return False
							snake_case_     							=		get_major_and_minor_from_version(_torch_version					)
							snake_case_     							=		get_major_and_minor_from_version(_ipex_version					)
							if torch_major_and_minor != ipex_major_and_minor:
														warnings.warn(
														    f"""Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"""
														    f""" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."""					)
														return False
							return True







@lru_cache
def     _a					(   _SCREAMING_SNAKE_CASE=False					)     ->					List[str]:
							if importlib.util.find_spec("""torch"""					) is None or importlib.util.find_spec("""torch_npu"""					) is None:
														return False

							import torch
							import torch_npu  # noqa: F401

							if check_device:
														try:
																					# Will raise a RuntimeError if no NPU is found
																					snake_case_     							=		torch.npu.device_count()
																					return torch.npu.is_available()
														except RuntimeError:
																					return False
							return hasattr(_SCREAMING_SNAKE_CASE					,			"""npu"""					) and torch.npu.is_available()







@lru_cache
def     _a					(   _SCREAMING_SNAKE_CASE=False					)     ->					int:
							if not parse_flag_from_env("""ACCELERATE_USE_XPU"""					,			default=_SCREAMING_SNAKE_CASE					):
														return False
							if is_ipex_available():
														import torch

														if is_torch_version("""<="""					,			"""1.12"""					):
																					return False
							else:
														return False

							import intel_extension_for_pytorch  # noqa: F401

							if check_device:
														try:
																					# Will raise a RuntimeError if no XPU  is found
																					snake_case_     							=		torch.xpu.device_count()
																					return torch.xpu.is_available()
														except RuntimeError:
																					return False
							return hasattr(_SCREAMING_SNAKE_CASE					,			"""xpu"""					) and torch.xpu.is_available()



