





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    =	True
except ImportError:
     _UpperCamelCase    =	False


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







def  lowerCAmelCase__(		lowercase    :      List[Any]			)	->      Optional[int]:
  __snake_case				:			List[Any]            =    importlib.util.find_spec(A_			) is not None
  if package_exists:
    try:
      __snake_case				:			Dict            =    importlib.metadata.metadata(A_			)
      return True
    except importlib.metadata.PackageNotFoundError:
      return False







def  lowerCAmelCase__(		)	->      List[Any]:
  return _torch_distributed_available







def  lowerCAmelCase__(		)	->      Dict:





  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  lowerCAmelCase__(		)	->      Union[str, Any]:
  return importlib.metadata.version("oneccl_bind_pt"			)







def  lowerCAmelCase__(		)	->      List[Any]:
  return _is_package_available("transformer_engine"			)







@lru_cache
def  lowerCAmelCase__(		lowercase    :      List[str]=True			)	->      Optional[Any]:





  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				:			Union[str, Any]            =    xm.xla_device()
      return True
    except RuntimeError:
      return False
  return _tpu_available







def  lowerCAmelCase__(		)	->      List[str]:
  return _is_package_available("deepspeed"			)







def  lowerCAmelCase__(		lowercase    :      List[str]=False			)	->      Tuple:





  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  lowerCAmelCase__(		)	->      int:
  __snake_case				:			Optional[Any]            =    _is_package_available("bitsandbytes"			)
  if package_exists:
    __snake_case				:			int            =    version.parse(importlib.metadata.version("bitsandbytes"			)			)
    return compare_versions(A_				,       ">="				,       "0.39.0"			)
  return False







def  lowerCAmelCase__(		)	->      int:
  __snake_case				:			List[Any]            =    _is_package_available("bitsandbytes"			)
  if package_exists:
    __snake_case				:			Optional[int]            =    version.parse(importlib.metadata.version("bitsandbytes"			)			)
    return compare_versions(A_				,       ">="				,       "0.37.2"			)
  return False







def  lowerCAmelCase__(		)	->      List[Any]:
  return _is_package_available("bitsandbytes"			)







def  lowerCAmelCase__(		)	->      Optional[int]:





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







def  lowerCAmelCase__(		)	->      List[Any]:
  return _is_package_available("safetensors"			)







def  lowerCAmelCase__(		)	->      str:
  return _is_package_available("transformers"			)







def  lowerCAmelCase__(		)	->      Optional[Any]:
  return _is_package_available("datasets"			)







def  lowerCAmelCase__(		)	->      Union[str, Any]:
  return _is_package_available("aim"			)







def  lowerCAmelCase__(		)	->      Optional[int]:
  return _is_package_available("tensorboard"			) or _is_package_available("tensorboardX"			)







def  lowerCAmelCase__(		)	->      Any:
  return _is_package_available("wandb"			)







def  lowerCAmelCase__(		)	->      int:
  return _is_package_available("comet_ml"			)







def  lowerCAmelCase__(		)	->      Dict:
  return _is_package_available("boto3"			)







def  lowerCAmelCase__(		)	->      int:





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







def  lowerCAmelCase__(		)	->      List[Any]:
  return _is_package_available("sagemaker"			)







def  lowerCAmelCase__(		)	->      Union[str, Any]:
  return _is_package_available("tqdm"			)







def  lowerCAmelCase__(		)	->      Optional[int]:
  return _is_package_available("mlflow"			)







def  lowerCAmelCase__(		)	->      List[Any]:
  return is_torch_version(">="				,       "1.12"			) and torch.backends.mps.is_available() and torch.backends.mps.is_built()







def  lowerCAmelCase__(		)	->      Any:





  def get_major_and_minor_from_version(lowercase    :      Optional[Any]			):
    return str(version.parse(A_			).major			) + "." + str(version.parse(A_			).minor			)

  __snake_case				:			Dict            =    importlib.metadata.version("torch"			)
  if importlib.util.find_spec("intel_extension_for_pytorch"			) is None:
    return False
  __snake_case				:			Union[str, Any]            =    "N/A"
  try:
    __snake_case				:			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[Any]            =    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  lowerCAmelCase__(		lowercase    :      Optional[int]=False			)	->      Any:





  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				:			Any            =    torch.npu.device_count()
      return torch.npu.is_available()
    except RuntimeError:
      return False
  return hasattr(A_				,       "npu"			) and torch.npu.is_available()







@lru_cache
def  lowerCAmelCase__(		lowercase    :      Dict=False			)	->      Union[str, Any]:





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








import warnings

from ...utils import logging
from .image_processing_maskformer import MaskFormerImageProcessor


_UpperCamelCase    =	logging.get_logger(__name__)




class 			_lowerCamelCase	(      a      ):



      """simple docstring"""






      def __init__(	self			,  *UpperCAmelCase			,  **UpperCAmelCase				)    ->				None:






        '''simple docstring'''






        warnings.warn(
            "The class MaskFormerFeatureExtractor is deprecated and will be removed in version 5 of Transformers."
            " Please use MaskFormerImageProcessor instead."			,  UpperCAmelCase			,  )
        super().__init__(*UpperCAmelCase			,  **UpperCAmelCase				)

