


"""simple docstring"""
import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available


if is_torch_available():
				import numpy as np
				import torch

if is_vision_available():
				from PIL import Image







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE=False					,			_SCREAMING_SNAKE_CASE=False					,			_SCREAMING_SNAKE_CASE=False					)     ->					Tuple:
							assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

							snake_case_     							=		[]
							for i in range(image_processor_tester.batch_size					):
														if equal_resolution:
																					snake_case_     							=		snake_case_     							=		image_processor_tester.max_resolution
														else:
																					# To avoid getting image width/height 0
																					snake_case_     							=		image_processor_tester.min_resolution
																					if getattr(_SCREAMING_SNAKE_CASE					,			"""size_divisor"""					,			_SCREAMING_SNAKE_CASE					):
																												# If `size_divisor` is defined, the image needs to have width/size >= `size_divisor`
																												snake_case_     							=		max(image_processor_tester.size_divisor					,			_SCREAMING_SNAKE_CASE					)
																					snake_case_							,    snake_case_     							=		np.random.choice(np.arange(_SCREAMING_SNAKE_CASE					,			image_processor_tester.max_resolution					)					,			2					)
														image_inputs.append(
														    np.random.randint(255					,			size=(image_processor_tester.num_channels, width, height)					,			dtype=np.uinta					)					)

							if not numpify and not torchify:
														# PIL expects the channel dimension as last dimension
														snake_case_     							=		[Image.fromarray(np.moveaxis(_SCREAMING_SNAKE_CASE					,			0					,			-1					)					) for image in image_inputs]

							if torchify:
														snake_case_     							=		[torch.from_numpy(_SCREAMING_SNAKE_CASE					) for image in image_inputs]

							return image_inputs







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE=10					,			_SCREAMING_SNAKE_CASE=10					,			_SCREAMING_SNAKE_CASE=False					,			_SCREAMING_SNAKE_CASE=False					)     ->					str:
							snake_case_     							=		[]
							for i in range(image_processor_tester.num_frames					):
														video.append(np.random.randint(255					,			size=(image_processor_tester.num_channels, width, height)					,			dtype=np.uinta					)					)

							if not numpify and not torchify:
														# PIL expects the channel dimension as last dimension
														snake_case_     							=		[Image.fromarray(np.moveaxis(_SCREAMING_SNAKE_CASE					,			0					,			-1					)					) for frame in video]

							if torchify:
														snake_case_     							=		[torch.from_numpy(_SCREAMING_SNAKE_CASE					) for frame in video]

							return video







def     _a					(   _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE=False					,			_SCREAMING_SNAKE_CASE=False					,			_SCREAMING_SNAKE_CASE=False					)     ->					Optional[int]:
							assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

							snake_case_     							=		[]
							for i in range(image_processor_tester.batch_size					):
														if equal_resolution:
																					snake_case_     							=		snake_case_     							=		image_processor_tester.max_resolution
														else:
																					snake_case_							,    snake_case_     							=		np.random.choice(
																					    np.arange(image_processor_tester.min_resolution					,			image_processor_tester.max_resolution					)					,			2					)
																					snake_case_     							=		prepare_video(
																					    image_processor_tester=_SCREAMING_SNAKE_CASE					,			width=_SCREAMING_SNAKE_CASE					,			height=_SCREAMING_SNAKE_CASE					,			numpify=_SCREAMING_SNAKE_CASE					,			torchify=_SCREAMING_SNAKE_CASE					,			)
														video_inputs.append(_SCREAMING_SNAKE_CASE					)

							return video_inputs





class   __A  :





							'''simple docstring'''

							__lowercase:		Union[str, Any]				   =     None



							def 		lowerCAmelCase							(					self				:   Dict							)       ->Optional[Any]:



														"""simple docstring"""



														snake_case_     							=		self.image_processing_class(**self.image_processor_dict							)
														snake_case_     							=		json.loads(image_processor.to_json_string()							)
														for key, value in self.image_processor_dict.items():
																					self.assertEqual(obj[key]		,							UpperCAmelCase_							)



							def 		lowerCAmelCase							(					self				:   str							)       ->List[str]:



														"""simple docstring"""



														snake_case_     							=		self.image_processing_class(**self.image_processor_dict							)

														with tempfile.TemporaryDirectory() as tmpdirname:
																					snake_case_     							=		os.path.join(UpperCAmelCase_		,							"""image_processor.json"""							)
																					image_processor_first.to_json_file(UpperCAmelCase_							)
																					snake_case_     							=		self.image_processing_class.from_json_file(UpperCAmelCase_							)

														self.assertEqual(image_processor_second.to_dict()		,							image_processor_first.to_dict()							)



							def 		lowerCAmelCase							(					self				:   int							)       ->Optional[Any]:



														"""simple docstring"""



														snake_case_     							=		self.image_processing_class(**self.image_processor_dict							)

														with tempfile.TemporaryDirectory() as tmpdirname:
																					snake_case_     							=		image_processor_first.save_pretrained(UpperCAmelCase_							)[0]
																					check_json_file_has_correct_format(UpperCAmelCase_							)
																					snake_case_     							=		self.image_processing_class.from_pretrained(UpperCAmelCase_							)

														self.assertEqual(image_processor_second.to_dict()		,							image_processor_first.to_dict()							)



							def 		lowerCAmelCase							(					self				:   str							)       ->Dict:



														"""simple docstring"""



														snake_case_     							=		self.image_processing_class()
														self.assertIsNotNone(UpperCAmelCase_							)



							@require_torch
							@require_vision
							def 		lowerCAmelCase							(					self				:   List[str]							)       ->str:



														"""simple docstring"""



														if self.test_cast_dtype is not None:
																					# Initialize image_processor
																					snake_case_     							=		self.image_processing_class(**self.image_processor_dict							)

																					# create random PyTorch tensors
																					snake_case_     							=		prepare_image_inputs(self.image_processor_tester		,							equal_resolution=UpperCAmelCase_		,							torchify=UpperCAmelCase_							)

																					snake_case_     							=		image_processor(UpperCAmelCase_		,							return_tensors="""pt"""							)
																					# for layoutLM compatiblity
																					self.assertEqual(encoding.pixel_values.device		,							torch.device("""cpu"""							)							)
																					self.assertEqual(encoding.pixel_values.dtype		,							torch.floataa							)

																					snake_case_     							=		image_processor(UpperCAmelCase_		,							return_tensors="""pt"""							).to(torch.floataa							)
																					self.assertEqual(encoding.pixel_values.device		,							torch.device("""cpu"""							)							)
																					self.assertEqual(encoding.pixel_values.dtype		,							torch.floataa							)

																					snake_case_     							=		image_processor(UpperCAmelCase_		,							return_tensors="""pt"""							).to("""cpu"""		,							torch.bfloataa							)
																					self.assertEqual(encoding.pixel_values.device		,							torch.device("""cpu"""							)							)
																					self.assertEqual(encoding.pixel_values.dtype		,							torch.bfloataa							)

																					with self.assertRaises(UpperCAmelCase_							):
																												snake_case_     							=		image_processor(UpperCAmelCase_		,							return_tensors="""pt"""							).to(torch.bfloataa		,							"""cpu"""							)

																					# Try with text + image feature
																					snake_case_     							=		image_processor(UpperCAmelCase_		,							return_tensors="""pt"""							)
																					encoding.update({"""input_ids""": torch.LongTensor([[1, 2, 3], [4, 5, 6]]							)}							)
																					snake_case_     							=		encoding.to(torch.floataa							)

																					self.assertEqual(encoding.pixel_values.device		,							torch.device("""cpu"""							)							)
																					self.assertEqual(encoding.pixel_values.dtype		,							torch.floataa							)
																					self.assertEqual(encoding.input_ids.dtype		,							torch.long							)







"""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()



