



'''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

				_lowercase       :						Optional[int]						=True
except ImportError:
				_lowercase       :						Union[str, Any]						=False


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


def 							__UpperCAmelCase				(				UpperCamelCase__				:Tuple			)		->						int:
				# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
				snake_case__      :   Union[str, Any]      =    importlib.util.find_spec(UpperCamelCase__			) is not None
				if package_exists:
								try:
												snake_case__      :   List[Any]      =    importlib.metadata.metadata(UpperCamelCase__			)
												return True
								except importlib.metadata.PackageNotFoundError:
												return False


def 							__UpperCAmelCase				(				)		->						bool:
				return _torch_distributed_available


def 							__UpperCAmelCase				(				)		->						Optional[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 							__UpperCAmelCase				(				)		->						Tuple:
				return importlib.metadata.version('''oneccl_bind_pt'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''transformer_engine'''			)


@lru_cache
def 							__UpperCAmelCase				(				UpperCamelCase__				:Union[str, Any]=True			)		->						Optional[Any]:
				# 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__      :   Dict      =    xm.xla_device()
												return True
								except RuntimeError:
												return False
				return _tpu_available


def 							__UpperCAmelCase				(				)		->						Optional[Any]:
				return _is_package_available('''deepspeed'''			)


def 							__UpperCAmelCase				(				UpperCamelCase__				:Any=False			)		->						List[str]:
				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				(				)		->						Union[str, Any]:
				snake_case__      :   Tuple      =    _is_package_available('''bitsandbytes'''			)
				if package_exists:
								snake_case__      :   List[str]      =    version.parse(importlib.metadata.version('''bitsandbytes'''			)			)
								return compare_versions(UpperCamelCase__   ,				'''>='''   ,				'''0.39.0'''			)
				return False


def 							__UpperCAmelCase				(				)		->						str:
				snake_case__      :   str      =    _is_package_available('''bitsandbytes'''			)
				if package_exists:
								snake_case__      :   List[Any]      =    version.parse(importlib.metadata.version('''bitsandbytes'''			)			)
								return compare_versions(UpperCamelCase__   ,				'''>='''   ,				'''0.37.2'''			)
				return False


def 							__UpperCAmelCase				(				)		->						Tuple:
				return _is_package_available('''bitsandbytes'''			)


def 							__UpperCAmelCase				(				)		->						Optional[int]:
				if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM'''   ,				'''False'''			)			) == 1:
								snake_case__      :   Any      =    importlib.util.find_spec('''megatron'''			) is not None
								if package_exists:
												try:
																snake_case__      :   List[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				(				)		->						Optional[int]:
				return _is_package_available('''safetensors'''			)


def 							__UpperCAmelCase				(				)		->						List[Any]:
				return _is_package_available('''transformers'''			)


def 							__UpperCAmelCase				(				)		->						Tuple:
				return _is_package_available('''datasets'''			)


def 							__UpperCAmelCase				(				)		->						str:
				return _is_package_available('''aim'''			)


def 							__UpperCAmelCase				(				)		->						Any:
				return _is_package_available('''tensorboard'''			) or _is_package_available('''tensorboardX'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''wandb'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''comet_ml'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''boto3'''			)


def 							__UpperCAmelCase				(				)		->						Union[str, 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'''   ,				UpperCamelCase__			)
								return parse_flag_from_env('''ACCELERATE_ENABLE_RICH'''   ,				UpperCamelCase__			)
				return False


def 							__UpperCAmelCase				(				)		->						int:
				return _is_package_available('''sagemaker'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''tqdm'''			)


def 							__UpperCAmelCase				(				)		->						List[Any]:
				return _is_package_available('''mlflow'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return is_torch_version('''>='''   ,				'''1.12'''			) and torch.backends.mps.is_available() and torch.backends.mps.is_built()


def 							__UpperCAmelCase				(				)		->						List[Any]:
				def get_major_and_minor_from_version(UpperCamelCase__				:List[Any]			):
								return str(version.parse(UpperCamelCase__			).major			) + "." + str(version.parse(UpperCamelCase__			).minor			)

				snake_case__      :   Any      =    importlib.metadata.version('''torch'''			)
				if importlib.util.find_spec('''intel_extension_for_pytorch'''			) is None:
								return False
				snake_case__      :   List[str]      =    '''N/A'''
				try:
								snake_case__      :   Optional[Any]      =    importlib.metadata.version('''intel_extension_for_pytorch'''			)
				except importlib.metadata.PackageNotFoundError:
								return False
				snake_case__      :   Optional[Any]      =    get_major_and_minor_from_version(_torch_version			)
				snake_case__      :   Optional[int]      =    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__				:Tuple=False			)		->						Tuple:
				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__      :   Union[str, Any]      =    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__				:Tuple=False			)		->						Optional[Any]:
				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
												snake_case__      :   Tuple      =    torch.xpu.device_count()
												return torch.xpu.is_available()
								except RuntimeError:
												return False
				return hasattr(UpperCamelCase__   ,				'''xpu'''			) and torch.xpu.is_available()





"""simple docstring"""






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
						import PIL


lowerCAmelCase__    :    Tuple			=      logging.get_logger(__name__)
class 							snake_case			(					__UpperCAmelCase							):




					"""simple docstring"""

					snake_case__							       =					["pixel_values"]







					def __init__(							self  :      str       ,lowerCamelCase__  :      bool = True       ,lowerCamelCase__  :      Dict[str, int] = None       ,lowerCamelCase__  :      bool = True       ,lowerCamelCase__  :      Dict[str, int] = None       ,lowerCamelCase__  :      PILImageResampling = PILImageResampling.BICUBIC       ,lowerCamelCase__  :      bool = True       ,lowerCamelCase__  :      Union[int, float] = 1 / 255       ,lowerCamelCase__  :      bool = True       ,lowerCamelCase__  :      Optional[Union[float, List[float]]] = None       ,lowerCamelCase__  :      Optional[Union[float, List[float]]] = None       ,**lowerCamelCase__  :      List[Any]       ,):
									super().__init__(**lowerCamelCase__     )
									UpperCAmelCase__			 =				crop_size if crop_size is not None else {'height': 256, 'width': 256}
									UpperCAmelCase__			 =				get_size_dict(lowerCamelCase__       ,param_name='crop_size'     )
									UpperCAmelCase__			 =				size if size is not None else {'height': 224, 'width': 224}
									UpperCAmelCase__			 =				get_size_dict(lowerCamelCase__     )

									UpperCAmelCase__			 =				do_center_crop
									UpperCAmelCase__			 =				crop_size
									UpperCAmelCase__			 =				do_resize
									UpperCAmelCase__			 =				size
									UpperCAmelCase__			 =				resample
									UpperCAmelCase__			 =				do_rescale
									UpperCAmelCase__			 =				rescale_factor
									UpperCAmelCase__			 =				do_normalize
									UpperCAmelCase__			 =				image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
									UpperCAmelCase__			 =				image_std if image_std is not None else IMAGENET_DEFAULT_STD







					def 						__lowerCAmelCase		(							self  :      Optional[int]       ,lowerCamelCase__  :      np.ndarray       ,lowerCamelCase__  :      Dict[str, int]       ,lowerCamelCase__  :      Optional[int] = None       ,lowerCamelCase__  :      Optional[Union[str, ChannelDimension]] = None       ,**lowerCamelCase__  :      List[str]       ,):
									UpperCAmelCase__			 =				self.size if size is None else size
									UpperCAmelCase__			 =				get_size_dict(lowerCamelCase__     )
									UpperCAmelCase__			 =				get_size_dict(lowerCamelCase__       ,param_name='crop_size'     )

									UpperCAmelCase__ ,      UpperCAmelCase__			 =				get_image_size(lowerCamelCase__     )
									UpperCAmelCase__			 =				min(lowerCamelCase__       ,lowerCamelCase__     )
									UpperCAmelCase__			 =				(size['height'] / crop_size['height']) * min_dim
									UpperCAmelCase__			 =				(size['width'] / crop_size['width']) * min_dim
									return center_crop(lowerCamelCase__       ,size=(cropped_height, cropped_width)       ,data_format=lowerCamelCase__       ,**lowerCamelCase__     )







					def 						__lowerCAmelCase		(							self  :      Any       ,lowerCamelCase__  :      np.ndarray       ,lowerCamelCase__  :      Dict[str, int]       ,lowerCamelCase__  :      PILImageResampling = PIL.Image.BICUBIC       ,lowerCamelCase__  :      Optional[Union[str, ChannelDimension]] = None       ,**lowerCamelCase__  :      Any       ,):
									UpperCAmelCase__			 =				get_size_dict(lowerCamelCase__     )
									if "height" not in size or "width" not in size:
													raise ValueError(f'''The size dictionary must contain the keys \'height\' and \'width\'. Got {size.keys()}'''     )
									return resize(
									    lowerCamelCase__       ,size=(size['height'], size['width'])       ,resample=lowerCamelCase__       ,data_format=lowerCamelCase__       ,**lowerCamelCase__     )







					def 						__lowerCAmelCase		(							self  :      Optional[int]       ,lowerCamelCase__  :      np.ndarray       ,lowerCamelCase__  :      Union[int, float]       ,lowerCamelCase__  :      Optional[Union[str, ChannelDimension]] = None       ,**lowerCamelCase__  :      int       ,):
									return rescale(lowerCamelCase__       ,scale=lowerCamelCase__       ,data_format=lowerCamelCase__       ,**lowerCamelCase__     )







					def 						__lowerCAmelCase		(							self  :      int       ,lowerCamelCase__  :      np.ndarray       ,lowerCamelCase__  :      Union[float, List[float]]       ,lowerCamelCase__  :      Union[float, List[float]]       ,lowerCamelCase__  :      Optional[Union[str, ChannelDimension]] = None       ,**lowerCamelCase__  :      List[Any]       ,):
									return normalize(lowerCamelCase__       ,mean=lowerCamelCase__       ,std=lowerCamelCase__       ,data_format=lowerCamelCase__       ,**lowerCamelCase__     )







					def 						__lowerCAmelCase		(							self  :      Optional[Any]       ,lowerCamelCase__  :      ImageInput       ,lowerCamelCase__  :      Optional[bool] = None       ,lowerCamelCase__  :      Optional[Dict[str, int]] = None       ,lowerCamelCase__  :      Optional[bool] = None       ,lowerCamelCase__  :      Optional[Dict[str, int]] = None       ,lowerCamelCase__  :      PILImageResampling = None       ,lowerCamelCase__  :      Optional[bool] = None       ,lowerCamelCase__  :      Optional[float] = None       ,lowerCamelCase__  :      Optional[bool] = None       ,lowerCamelCase__  :      Optional[Union[float, List[float]]] = None       ,lowerCamelCase__  :      Optional[Union[float, List[float]]] = None       ,lowerCamelCase__  :      Optional[Union[str, TensorType]] = None       ,lowerCamelCase__  :      ChannelDimension = ChannelDimension.FIRST       ,**lowerCamelCase__  :      Optional[int]       ,):
									UpperCAmelCase__			 =				do_center_crop if do_center_crop is not None else self.do_center_crop
									UpperCAmelCase__			 =				crop_size if crop_size is not None else self.crop_size
									UpperCAmelCase__			 =				get_size_dict(lowerCamelCase__       ,param_name='crop_size'     )
									UpperCAmelCase__			 =				do_resize if do_resize is not None else self.do_resize
									UpperCAmelCase__			 =				size if size is not None else self.size
									UpperCAmelCase__			 =				get_size_dict(lowerCamelCase__     )
									UpperCAmelCase__			 =				resample if resample is not None else self.resample
									UpperCAmelCase__			 =				do_rescale if do_rescale is not None else self.do_rescale
									UpperCAmelCase__			 =				rescale_factor if rescale_factor is not None else self.rescale_factor
									UpperCAmelCase__			 =				do_normalize if do_normalize is not None else self.do_normalize
									UpperCAmelCase__			 =				image_mean if image_mean is not None else self.image_mean
									UpperCAmelCase__			 =				image_std if image_std is not None else self.image_std

									UpperCAmelCase__			 =				make_list_of_images(lowerCamelCase__     )

									if not valid_images(lowerCamelCase__     ):
													raise ValueError(
													    'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
													    'torch.Tensor, tf.Tensor or jax.ndarray.'     )

									if do_center_crop and crop_size is None:
													raise ValueError('If `do_center_crop` is set to `True`, `crop_size` must be provided.'     )

									if do_resize and size is None:
													raise ValueError('Size must be specified if do_resize is True.'     )

									if do_rescale and rescale_factor is None:
													raise ValueError('Rescale factor must be specified if do_rescale is True.'     )

									if do_normalize and (image_mean is None or image_std is None):
													raise ValueError('Image mean and image standard deviation must be specified if do_normalize is True.'     )

									# All transformations expect numpy arrays.
									UpperCAmelCase__			 =				[to_numpy_array(lowerCamelCase__     ) for image in images]

									if do_center_crop:
													UpperCAmelCase__			 =				[self.center_crop(lowerCamelCase__       ,lowerCamelCase__       ,size=lowerCamelCase__     ) for image in images]

									if do_resize:
													UpperCAmelCase__			 =				[self.resize(image=lowerCamelCase__       ,size=lowerCamelCase__       ,resample=lowerCamelCase__     ) for image in images]

									if do_rescale:
													UpperCAmelCase__			 =				[self.rescale(image=lowerCamelCase__       ,scale=lowerCamelCase__     ) for image in images]

									if do_normalize:
													UpperCAmelCase__			 =				[self.normalize(image=lowerCamelCase__       ,mean=lowerCamelCase__       ,std=lowerCamelCase__     ) for image in images]

									UpperCAmelCase__			 =				[to_channel_dimension_format(lowerCamelCase__       ,lowerCamelCase__     ) for image in images]

									UpperCAmelCase__			 =				{'pixel_values': images}
									return BatchFeature(data=lowerCamelCase__       ,tensor_type=lowerCamelCase__     )



