






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

   _UpperCamelCase   :						Any     						= True
except ImportError:
   _UpperCamelCase   :						Optional[Any]     						= False


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




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




def 				a (     )  ->		Optional[int]:
 return _torch_distributed_available




def 				a (     )  ->		int:
 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 (     )  ->		Dict:
 return importlib.metadata.version('oneccl_bind_pt'		)




def 				a (     )  ->		Optional[Any]:
 return _is_package_available('transformer_engine'		)




@lru_cache
def 				a (     UpperCamelCase_							:				Dict=True		)  ->		List[str]:
 # 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
   __A	:       int       =	xm.xla_device()
   return True
  except RuntimeError:
   return False
 return _tpu_available




def 				a (     )  ->		Union[str, Any]:
 return _is_package_available('deepspeed'		)




def 				a (     UpperCamelCase_							:				List[str]=False		)  ->		Optional[Any]:
 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 (     )  ->		Optional[int]:
 __A	:       Any       =	_is_package_available('bitsandbytes'		)
 if package_exists:
  __A	:       Dict       =	version.parse(importlib.metadata.version('bitsandbytes'		)		)
  return compare_versions(lowercase__     ,	'>='     ,	'0.39.0'		)
 return False




def 				a (     )  ->		Any:
 __A	:       int       =	_is_package_available('bitsandbytes'		)
 if package_exists:
  __A	:       Tuple       =	version.parse(importlib.metadata.version('bitsandbytes'		)		)
  return compare_versions(lowercase__     ,	'>='     ,	'0.37.2'		)
 return False




def 				a (     )  ->		Union[str, Any]:
 return _is_package_available('bitsandbytes'		)




def 				a (     )  ->		Any:
 if strtobool(os.environ.get('ACCELERATE_USE_MEGATRON_LM'     ,	'False'		)		) == 1:
  __A	:       Any       =	importlib.util.find_spec('megatron'		) is not None
  if package_exists:
   try:
    __A	:       str       =	parse(importlib.metadata.version('megatron-lm'		)		)
    return compare_versions(lowercase__     ,	'>='     ,	'2.2.0'		)
   except Exception as e:
    warnings.warn(F"Parse Megatron version failed. Exception:{e}"		)
    return False




def 				a (     )  ->		Tuple:
 return _is_package_available('safetensors'		)




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




def 				a (     )  ->		str:
 return _is_package_available('datasets'		)




def 				a (     )  ->		Any:
 return _is_package_available('aim'		)




def 				a (     )  ->		Optional[Any]:
 return _is_package_available('tensorboard'		) or _is_package_available('tensorboardX'		)




def 				a (     )  ->		Optional[int]:
 return _is_package_available('wandb'		)




def 				a (     )  ->		Tuple:
 return _is_package_available('comet_ml'		)




def 				a (     )  ->		Union[str, Any]:
 return _is_package_available('boto3'		)




def 				a (     )  ->		str:
 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'     ,	lowercase__		)
  return parse_flag_from_env('ACCELERATE_ENABLE_RICH'     ,	lowercase__		)
 return False




def 				a (     )  ->		List[Any]:
 return _is_package_available('sagemaker'		)




def 				a (     )  ->		str:
 return _is_package_available('tqdm'		)




def 				a (     )  ->		str:
 return _is_package_available('mlflow'		)




def 				a (     )  ->		Optional[int]:
 return is_torch_version('>='     ,	'1.12'		) and torch.backends.mps.is_available() and torch.backends.mps.is_built()




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

 __A	:       int       =	importlib.metadata.version('torch'		)
 if importlib.util.find_spec('intel_extension_for_pytorch'		) is None:
  return False
 __A	:       Tuple       =	'N/A'
 try:
  __A	:       Dict       =	importlib.metadata.version('intel_extension_for_pytorch'		)
 except importlib.metadata.PackageNotFoundError:
  return False
 __A	:       List[Any]       =	get_major_and_minor_from_version(_torch_version		)
 __A	:       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 				a (     UpperCamelCase_							:				List[Any]=False		)  ->		int:
 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
   __A	:       Optional[int]       =	torch.npu.device_count()
   return torch.npu.is_available()
  except RuntimeError:
   return False
 return hasattr(lowercase__     ,	'npu'		) and torch.npu.is_available()




@lru_cache
def 				a (     UpperCamelCase_							:				Optional[Any]=False		)  ->		Dict:
 if not parse_flag_from_env('ACCELERATE_USE_XPU'     ,	default=lowercase__		):
  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
   __A	:       List[str]       =	torch.xpu.device_count()
   return torch.xpu.is_available()
  except RuntimeError:
   return False
 return hasattr(lowercase__     ,	'xpu'		) and torch.xpu.is_available()













"""simple docstring"""


import warnings

from ...utils import logging
from .image_processing_layoutlmva import LayoutLMvaImageProcessor


_UpperCamelCase   :						str     						= logging.get_logger(__name__)






class __a   (   snake_case_				):



  def __init__(self  :		Union[str, Any]				,			*lowercase_  :		Any				,			**lowercase_  :		Optional[Any]   )		->							None:
   warnings.warn(
       'The class LayoutLMv3FeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
       ' Please use LayoutLMv3ImageProcessor instead.'				,			lowercase_				,			)
   super().__init__(*lowercase_				,			**lowercase_   )





