






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 :    int								=				True
except ImportError:
  __a :    Dict								=				False


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



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     List[str]      )  -> List[Any]:





       """simple docstring"""

       __A             =		importlib.util.find_spec(A_      ) is not None
       if package_exists:
              try:
                     __A             =		importlib.metadata.metadata(A_      )
                     return True
              except importlib.metadata.PackageNotFoundError:
                     return False



def      _SCREAMING_SNAKE_CASE  (	)  -> Optional[int]:





       """simple docstring"""

       return _torch_distributed_available



def      _SCREAMING_SNAKE_CASE  (	)  -> List[Any]:





       """simple docstring"""

       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      _SCREAMING_SNAKE_CASE  (	)  -> List[str]:





       """simple docstring"""

       return importlib.metadata.version("""oneccl_bind_pt"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> Optional[int]:





       """simple docstring"""

       return _is_package_available("""transformer_engine"""      )



@lru_cache
def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     Any=True      )  -> Tuple:





       """simple docstring"""

       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             =		xm.xla_device()
                     return True
              except RuntimeError:
                     return False
       return _tpu_available



def      _SCREAMING_SNAKE_CASE  (	)  -> Any:





       """simple docstring"""

       return _is_package_available("""deepspeed"""      )



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     Union[str, Any]=False      )  -> Tuple:





       """simple docstring"""

       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      _SCREAMING_SNAKE_CASE  (	)  -> Optional[int]:





       """simple docstring"""

       __A             =		_is_package_available("""bitsandbytes"""      )
       if package_exists:
              __A             =		version.parse(importlib.metadata.version("""bitsandbytes"""      )      )
              return compare_versions(A_     ,			""">="""     ,			"""0.39.0"""      )
       return False



def      _SCREAMING_SNAKE_CASE  (	)  -> int:





       """simple docstring"""

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



def      _SCREAMING_SNAKE_CASE  (	)  -> str:





       """simple docstring"""

       return _is_package_available("""bitsandbytes"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> Dict:





       """simple docstring"""

       if strtobool(os.environ.get("""ACCELERATE_USE_MEGATRON_LM"""     ,			"""False"""      )      ) == 1:
              __A             =		importlib.util.find_spec("""megatron"""      ) is not None
              if package_exists:
                     try:
                            __A             =		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      _SCREAMING_SNAKE_CASE  (	)  -> int:





       """simple docstring"""

       return _is_package_available("""safetensors"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> Any:





       """simple docstring"""

       return _is_package_available("""transformers"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> str:





       """simple docstring"""

       return _is_package_available("""datasets"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> Optional[int]:





       """simple docstring"""

       return _is_package_available("""aim"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> List[Any]:





       """simple docstring"""

       return _is_package_available("""tensorboard"""      ) or _is_package_available("""tensorboardX"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> Dict:





       """simple docstring"""

       return _is_package_available("""wandb"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> List[str]:





       """simple docstring"""

       return _is_package_available("""comet_ml"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> str:





       """simple docstring"""

       return _is_package_available("""boto3"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> Union[str, Any]:





       """simple docstring"""

       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      _SCREAMING_SNAKE_CASE  (	)  -> Any:





       """simple docstring"""

       return _is_package_available("""sagemaker"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> List[str]:





       """simple docstring"""

       return _is_package_available("""tqdm"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> Any:





       """simple docstring"""

       return _is_package_available("""mlflow"""      )



def      _SCREAMING_SNAKE_CASE  (	)  -> Optional[Any]:





       """simple docstring"""

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



def      _SCREAMING_SNAKE_CASE  (	)  -> Any:





       """simple docstring"""

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

       __A             =		importlib.metadata.version("""torch"""      )
       if importlib.util.find_spec("""intel_extension_for_pytorch"""      ) is None:
              return False
       __A             =		"""N/A"""
       try:
              __A             =		importlib.metadata.version("""intel_extension_for_pytorch"""      )
       except importlib.metadata.PackageNotFoundError:
              return False
       __A             =		get_major_and_minor_from_version(_torch_version      )
       __A             =		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      _SCREAMING_SNAKE_CASE  (	__lowercase				:     List[str]=False      )  -> Tuple:





       """simple docstring"""

       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             =		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      _SCREAMING_SNAKE_CASE  (	__lowercase				:     Any=False      )  -> int:





       """simple docstring"""

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












import copy

from transformers.configuration_utils import PretrainedConfig
from transformers.utils import logging


__a :    Tuple								=				logging.get_logger(__name__)


class  __lowercase (		lowercase_					):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE				  =			"hybrid-clip"
     SCREAMING_SNAKE_CASE				  =			True




     def __init__(			self    :     Optional[Any]	,		UpperCamelCase_    :     Optional[Any]=512	,		**UpperCamelCase_    :     List[Any]			):


         """simple docstring"""



         super().__init__(**UpperCamelCase_			)

         if "text_config" not in kwargs:
             raise ValueError("""`text_config` can not be `None`."""			)

         if "vision_config" not in kwargs:
             raise ValueError("""`vision_config` can not be `None`."""			)

         __A             =		kwargs.pop("""text_config"""			)
         __A             =		kwargs.pop("""vision_config"""			)

         __A             =		text_config.pop("""model_type"""			)
         __A             =		vision_config.pop("""model_type"""			)

         from transformers import AutoConfig

         __A             =		AutoConfig.for_model(UpperCamelCase_	,		**UpperCamelCase_			)

         if vision_model_type == "clip":
             __A             =		AutoConfig.for_model(UpperCamelCase_	,		**UpperCamelCase_			).vision_config
         elif vision_model_type == "clip_vision_model":
             from transformers import CLIPVisionConfig

             __A             =		CLIPVisionConfig(**UpperCamelCase_			)
         else:
             __A             =		AutoConfig.for_model(UpperCamelCase_	,		**UpperCamelCase_			)

         __A             =		projection_dim
         __A             =		1.0




     @classmethod
     def 						lowerCAmelCase_       (			cls    :     int	,		UpperCamelCase_    :     PretrainedConfig	,		UpperCamelCase_    :     PretrainedConfig	,		**UpperCamelCase_    :     Union[str, Any]			):


         """simple docstring"""



         return cls(text_config=text_config.to_dict()	,		vision_config=vision_config.to_dict()	,		**UpperCamelCase_			)





     def 						lowerCAmelCase_       (			self    :     Tuple			):


         """simple docstring"""



         __A             =		copy.deepcopy(self.__dict__			)
         __A             =		self.text_config.to_dict()
         __A             =		self.vision_config.to_dict()
         __A             =		self.__class__.model_type
         return output




