



import unittest

from transformers.image_processing_utils import get_size_dict







class       _snake_case				(     unittest.TestCase ):






   '''simple docstring'''






   def       A__    (    self:     int							)	->      List[str]:
       # Test a dict with the wrong keys raises an error
       UpperCAmelCase_     :       Optional[Any]  		=					{"""wrong_key""": 224}
       with self.assertRaises(lowerCamelCase_							):
           get_size_dict(lowerCamelCase_							)

       UpperCAmelCase_     :       List[Any]  		=					{"""height""": 224}
       with self.assertRaises(lowerCamelCase_							):
           get_size_dict(lowerCamelCase_							)

       UpperCAmelCase_     :       Optional[int]  		=					{"""width""": 224, """shortest_edge""": 224}
       with self.assertRaises(lowerCamelCase_							):
           get_size_dict(lowerCamelCase_							)

       # Test a dict with the correct keys is returned as is
       UpperCAmelCase_     :       List[str]  		=					{"""height""": 224, """width""": 224}
       UpperCAmelCase_     :       Optional[int]  		=					get_size_dict(lowerCamelCase_							)
       self.assertEqual(lowerCamelCase_  ,lowerCamelCase_							)

       UpperCAmelCase_     :       Union[str, Any]  		=					{"""shortest_edge""": 224}
       UpperCAmelCase_     :       Dict  		=					get_size_dict(lowerCamelCase_							)
       self.assertEqual(lowerCamelCase_  ,{"""shortest_edge""": 224}							)

       UpperCAmelCase_     :       Optional[int]  		=					{"""longest_edge""": 224, """shortest_edge""": 224}
       UpperCAmelCase_     :       Dict  		=					get_size_dict(lowerCamelCase_							)
       self.assertEqual(lowerCamelCase_  ,{"""longest_edge""": 224, """shortest_edge""": 224}							)

       # Test a single int value which  represents (size, size)
       UpperCAmelCase_     :       Optional[Any]  		=					get_size_dict(224							)
       self.assertEqual(lowerCamelCase_  ,{"""height""": 224, """width""": 224}							)

       # Test a single int value which represents the shortest edge
       UpperCAmelCase_     :       int  		=					get_size_dict(224  ,default_to_square=lowerCamelCase_							)
       self.assertEqual(lowerCamelCase_  ,{"""shortest_edge""": 224}							)

       # Test a tuple of ints which represents (height, width)
       UpperCAmelCase_     :       List[Any]  		=					get_size_dict((150, 200)							)
       self.assertEqual(lowerCamelCase_  ,{"""height""": 150, """width""": 200}							)

       # Test a tuple of ints which represents (width, height)
       UpperCAmelCase_     :       int  		=					get_size_dict((150, 200)  ,height_width_order=lowerCamelCase_							)
       self.assertEqual(lowerCamelCase_  ,{"""height""": 200, """width""": 150}							)

       # Test an int representing the shortest edge and max_size which represents the longest edge
       UpperCAmelCase_     :       Optional[Any]  		=					get_size_dict(224  ,max_size=256  ,default_to_square=lowerCamelCase_							)
       self.assertEqual(lowerCamelCase_  ,{"""shortest_edge""": 224, """longest_edge""": 256}							)

       # Test int with default_to_square=True and max_size fails
       with self.assertRaises(lowerCamelCase_							):
           get_size_dict(224  ,max_size=256  ,default_to_square=lowerCamelCase_							)




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



