


'''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       :   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       :   Union[str, Any]        = torch.distributed.is_available()



def 						_UpperCamelCase							( UpperCamelCase__		):






				"""simple docstring"""



				__magic_name__				:					str						       =       importlib.util.find_spec(UpperCamelCase__		) is not None
				if package_exists:
								try:
												__magic_name__				:					List[str]						       =       importlib.metadata.metadata(UpperCamelCase__		)
												return True
								except importlib.metadata.PackageNotFoundError:
												return False



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _torch_distributed_available



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				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 						_UpperCamelCase							( ):






				"""simple docstring"""



				return importlib.metadata.version("oneccl_bind_pt"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("transformer_engine"		)



@lru_cache
def 						_UpperCamelCase							( UpperCamelCase__=True		):






				"""simple docstring"""



				if torch.cuda.is_available():
								return False
				if _tpu_available and check_device:
								try:
												# Will raise a RuntimeError if no XLA configuration is found
												__magic_name__				:					Union[str, Any]						       =       xm.xla_device()
												return True
								except RuntimeError:
												return False
				return _tpu_available



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("deepspeed"		)



def 						_UpperCamelCase							( UpperCamelCase__=False		):






				"""simple docstring"""



				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 						_UpperCamelCase							( ):






				"""simple docstring"""



				__magic_name__				:					List[str]						       =       _is_package_available("bitsandbytes"		)
				if package_exists:
								__magic_name__				:					Any						       =       version.parse(importlib.metadata.version("bitsandbytes"		)		)
								return compare_versions(UpperCamelCase__     ,   ">="     ,   "0.39.0"		)
				return False



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				__magic_name__				:					Optional[Any]						       =       _is_package_available("bitsandbytes"		)
				if package_exists:
								__magic_name__				:					Dict						       =       version.parse(importlib.metadata.version("bitsandbytes"		)		)
								return compare_versions(UpperCamelCase__     ,   ">="     ,   "0.37.2"		)
				return False



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("bitsandbytes"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



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



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("safetensors"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("transformers"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("datasets"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("aim"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("tensorboard"		) or _is_package_available("tensorboardX"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("wandb"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("comet_ml"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("boto3"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				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"     ,   UpperCamelCase__		)
								return parse_flag_from_env("ACCELERATE_ENABLE_RICH"     ,   UpperCamelCase__		)
				return False



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("sagemaker"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("tqdm"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("mlflow"		)



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return is_torch_version(">="     ,   "1.12"		) and torch.backends.mps.is_available() and torch.backends.mps.is_built()



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				def get_major_and_minor_from_version(UpperCamelCase__		):
								return str(version.parse(UpperCamelCase__		).major		) + "." + str(version.parse(UpperCamelCase__		).minor		)

				__magic_name__				:					Any						       =       importlib.metadata.version("torch"		)
				if importlib.util.find_spec("intel_extension_for_pytorch"		) is None:
								return False
				__magic_name__				:					Any						       =       "N/A"
				try:
								__magic_name__				:					Tuple						       =       importlib.metadata.version("intel_extension_for_pytorch"		)
				except importlib.metadata.PackageNotFoundError:
								return False
				__magic_name__				:					Union[str, Any]						       =       get_major_and_minor_from_version(_torch_version		)
				__magic_name__				:					Tuple						       =       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 						_UpperCamelCase							( UpperCamelCase__=False		):






				"""simple docstring"""



				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
												__magic_name__				:					Optional[int]						       =       torch.npu.device_count()
												return torch.npu.is_available()
								except RuntimeError:
												return False
				return hasattr(UpperCamelCase__     ,   "npu"		) and torch.npu.is_available()




@lru_cache
def 						_UpperCamelCase							( UpperCamelCase__=False		):






				"""simple docstring"""



				if not parse_flag_from_env("ACCELERATE_USE_XPU"     ,   default=UpperCamelCase__		):
								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
												__magic_name__				:					Optional[Any]						       =       torch.xpu.device_count()
												return torch.xpu.is_available()
								except RuntimeError:
												return False
				return hasattr(UpperCamelCase__     ,   "xpu"		) and torch.xpu.is_available()



'''simple docstring'''







import unittest

from transformers import BlenderbotTokenizer, BlenderbotTokenizerFast
from transformers.utils import cached_property






class 		_snake_case    (				unittest.TestCase		):






						'''simple docstring'''







						@cached_property
						def lowerCAmelCase__ (  self:	Optional[Any]     )							->	List[Any]:
										return BlenderbotTokenizer.from_pretrained("facebook/blenderbot-3B"     )







						@cached_property
						def lowerCAmelCase__ (  self:	Optional[Any]     )							->	Optional[int]:
										return BlenderbotTokenizerFast.from_pretrained("facebook/blenderbot-3B"     )







						def lowerCAmelCase__ (  self:	Optional[Any]     )							->	Optional[int]:
										__magic_name__				:					Tuple						       =       self.tokenizer_ab
										__magic_name__				:					Optional[int]						       =       " I am a small frog."
										__magic_name__				:					Optional[int]						       =       tok([src_text]      ,							padding=__UpperCamelCase      ,							truncation=__UpperCamelCase     )["input_ids"]
										__magic_name__				:					int						       =       tok.batch_decode(__UpperCamelCase      ,							skip_special_tokens=__UpperCamelCase      ,							clean_up_tokenization_spaces=__UpperCamelCase     )[0]
										assert src_text == decoded







						def lowerCAmelCase__ (  self:	Optional[int]     )							->	Any:
										__magic_name__				:					Tuple						       =       self.rust_tokenizer_ab
										__magic_name__				:					str						       =       " I am a small frog."
										__magic_name__				:					Union[str, Any]						       =       tok([src_text]      ,							padding=__UpperCamelCase      ,							truncation=__UpperCamelCase     )["input_ids"]
										__magic_name__				:					Any						       =       tok.batch_decode(__UpperCamelCase      ,							skip_special_tokens=__UpperCamelCase      ,							clean_up_tokenization_spaces=__UpperCamelCase     )[0]
										assert src_text == decoded







						def lowerCAmelCase__ (  self:	Optional[Any]     )							->	str:
										assert self.tokenizer_ab.add_prefix_space
										assert self.tokenizer_ab([" Sam", "Sam"]     ).input_ids == [[5502, 2], [5502, 2]]







						def lowerCAmelCase__ (  self:	List[str]     )							->	List[Any]:
										assert self.rust_tokenizer_ab.add_prefix_space
										assert self.rust_tokenizer_ab([" Sam", "Sam"]     ).input_ids == [[5502, 2], [5502, 2]]