

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

  A__        =			True
except ImportError:
  A__        =			False


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





def 							__a       (					__A	):
    # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
    SCREAMING_SNAKE_CASE__					     =						importlib.util.find_spec(__A	) is not None
    if package_exists:
        try:
            SCREAMING_SNAKE_CASE__					     =						importlib.metadata.metadata(__A	)
            return True
        except importlib.metadata.PackageNotFoundError:
            return False





def 							__a       (					):
    return _torch_distributed_available





def 							__a       (					):
    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       (					):
    return importlib.metadata.version("oneccl_bind_pt"	)





def 							__a       (					):
    return _is_package_available("transformer_engine"	)





@lru_cache
def 							__a       (					__A=True	):
    # 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
            SCREAMING_SNAKE_CASE__					     =						xm.xla_device()
            return True
        except RuntimeError:
            return False
    return _tpu_available





def 							__a       (					):
    return _is_package_available("deepspeed"	)





def 							__a       (					__A=False	):
    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       (					):
    SCREAMING_SNAKE_CASE__					     =						_is_package_available("bitsandbytes"	)
    if package_exists:
        SCREAMING_SNAKE_CASE__					     =						version.parse(importlib.metadata.version("bitsandbytes"	)	)
        return compare_versions(__A ,       ">=" ,       "0.39.0"	)
    return False





def 							__a       (					):
    SCREAMING_SNAKE_CASE__					     =						_is_package_available("bitsandbytes"	)
    if package_exists:
        SCREAMING_SNAKE_CASE__					     =						version.parse(importlib.metadata.version("bitsandbytes"	)	)
        return compare_versions(__A ,       ">=" ,       "0.37.2"	)
    return False





def 							__a       (					):
    return _is_package_available("bitsandbytes"	)





def 							__a       (					):
    if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM" ,       "False"	)	) == 1:
        SCREAMING_SNAKE_CASE__					     =						importlib.util.find_spec("megatron"	) is not None
        if package_exists:
            try:
                SCREAMING_SNAKE_CASE__					     =						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 							__a       (					):
    return _is_package_available("safetensors"	)





def 							__a       (					):
    return _is_package_available("transformers"	)





def 							__a       (					):
    return _is_package_available("datasets"	)





def 							__a       (					):
    return _is_package_available("aim"	)





def 							__a       (					):
    return _is_package_available("tensorboard"	) or _is_package_available("tensorboardX"	)





def 							__a       (					):
    return _is_package_available("wandb"	)





def 							__a       (					):
    return _is_package_available("comet_ml"	)





def 							__a       (					):
    return _is_package_available("boto3"	)





def 							__a       (					):
    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 							__a       (					):
    return _is_package_available("sagemaker"	)





def 							__a       (					):
    return _is_package_available("tqdm"	)





def 							__a       (					):
    return _is_package_available("mlflow"	)





def 							__a       (					):
    return is_torch_version(">=" ,       "1.12"	) and torch.backends.mps.is_available() and torch.backends.mps.is_built()





def 							__a       (					):
    def get_major_and_minor_from_version(__A	):
        return str(version.parse(__A	).major	) + "." + str(version.parse(__A	).minor	)

    SCREAMING_SNAKE_CASE__					     =						importlib.metadata.version("torch"	)
    if importlib.util.find_spec("intel_extension_for_pytorch"	) is None:
        return False
    SCREAMING_SNAKE_CASE__					     =						"N/A"
    try:
        SCREAMING_SNAKE_CASE__					     =						importlib.metadata.version("intel_extension_for_pytorch"	)
    except importlib.metadata.PackageNotFoundError:
        return False
    SCREAMING_SNAKE_CASE__					     =						get_major_and_minor_from_version(_torch_version	)
    SCREAMING_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       (					__A=False	):
    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
            SCREAMING_SNAKE_CASE__					     =						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 							__a       (					__A=False	):
    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
            SCREAMING_SNAKE_CASE__					     =						torch.xpu.device_count()
            return torch.xpu.is_available()
        except RuntimeError:
            return False
    return hasattr(__A ,       "xpu"	) and torch.xpu.is_available()





from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


A__        =			logging.get_logger(__name__)

A__        =			{
    "facebook/convnext-tiny-224": "https://huggingface.co/facebook/convnext-tiny-224/resolve/main/config.json",
    # See all ConvNeXT models at https://huggingface.co/models?filter=convnext
}







class    UpperCamelCase_			(  _snake_case		,     _snake_case			):


  """simple docstring"""
  SCREAMING_SNAKE_CASE__				: List[str]										=      """convnext"""



  def __init__(	self    :				Optional[Any]     ,  A_    :				Any=3     ,  A_    :				Tuple=4     ,  A_    :				Optional[int]=4     ,  A_    :				Dict=None     ,  A_    :				List[Any]=None     ,  A_    :				Union[str, Any]="gelu"     ,  A_    :				Optional[Any]=0.02     ,  A_    :				Union[str, Any]=1E-1_2     ,  A_    :				Dict=1E-6     ,  A_    :				List[str]=0.0     ,  A_    :				int=224     ,  A_    :				Optional[Any]=None     ,  A_    :				List[str]=None     ,  **A_    :				Union[str, Any]     ,  )					-> Tuple:
      super().__init__(**A_	)

      SCREAMING_SNAKE_CASE__					     =						num_channels
      SCREAMING_SNAKE_CASE__					     =						patch_size
      SCREAMING_SNAKE_CASE__					     =						num_stages
      SCREAMING_SNAKE_CASE__					     =						[96, 192, 384, 768] if hidden_sizes is None else hidden_sizes
      SCREAMING_SNAKE_CASE__					     =						[3, 3, 9, 3] if depths is None else depths
      SCREAMING_SNAKE_CASE__					     =						hidden_act
      SCREAMING_SNAKE_CASE__					     =						initializer_range
      SCREAMING_SNAKE_CASE__					     =						layer_norm_eps
      SCREAMING_SNAKE_CASE__					     =						layer_scale_init_value
      SCREAMING_SNAKE_CASE__					     =						drop_path_rate
      SCREAMING_SNAKE_CASE__					     =						image_size
      SCREAMING_SNAKE_CASE__					     =						["stem"] + [f"stage{idx}" for idx in range(1     ,  len(self.depths	) + 1	)]
      SCREAMING_SNAKE_CASE__     ,		SCREAMING_SNAKE_CASE__					     =						get_aligned_output_features_output_indices(
          out_features=A_     ,  out_indices=A_     ,  stage_names=self.stage_names	)







class    UpperCamelCase_			(  _snake_case			):


  """simple docstring"""
  SCREAMING_SNAKE_CASE__				: Dict										=      version.parse("""1.11"""			)



  @property
  def      _UpperCamelCase    (	self    :				str	)					-> Mapping[str, Mapping[int, str]]:
      return OrderedDict(
          [
              ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
          ]	)







  @property
  def      _UpperCamelCase    (	self    :				Tuple	)					-> float:
      return 1E-5


