




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__			(		A__			:   Optional[Any]      ):





       '''simple docstring'''



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




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _torch_distributed_available




def    lowerCamelCase__			(		):





       '''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    lowerCamelCase__			(		):





       '''simple docstring'''



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




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""transformer_engine"""      )




@lru_cache
def    lowerCamelCase__			(		A__			:   str=True      ):





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




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""deepspeed"""      )




def    lowerCamelCase__			(		A__			:   Optional[Any]=False      ):





       '''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    lowerCamelCase__			(		):





       '''simple docstring'''



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




def    lowerCamelCase__			(		):





       '''simple docstring'''



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




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""bitsandbytes"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



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




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""safetensors"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""transformers"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""datasets"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""aim"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



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




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""wandb"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""comet_ml"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""boto3"""      )




def    lowerCamelCase__			(		):





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




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""sagemaker"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""tqdm"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



       return _is_package_available("""mlflow"""      )




def    lowerCamelCase__			(		):





       '''simple docstring'''



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




def    lowerCamelCase__			(		):





       '''simple docstring'''



       def get_major_and_minor_from_version(A__			:   Dict      ):
              return str(version.parse(__SCREAMING_SNAKE_CASE      ).major      ) + "." + str(version.parse(__SCREAMING_SNAKE_CASE      ).minor      )

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





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




@lru_cache
def    lowerCamelCase__			(		A__			:   Any=False      ):





       '''simple docstring'''



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


import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding







class      SCREAMING_SNAKE_CASE__					(  __UpperCamelCase    ):
       A							:	Optional[Any]          =	["image_processor", "tokenizer"]
       A							:	Dict          =	"VideoMAEImageProcessor"
       A							:	Tuple          =	("CLIPTokenizer", "CLIPTokenizerFast")

       def __init__(							self					:     str			,			_lowerCAmelCase					:     Tuple=None			,			_lowerCAmelCase					:     Any=None			,			**_lowerCAmelCase					:     Union[str, Any]			):
           __snake_case       :				int 			=    None
           if "feature_extractor" in kwargs:
               warnings.warn(
                   """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
                   """ instead."""			,			_lowerCAmelCase			,			)
               __snake_case       :				Optional[Any] 			=    kwargs.pop("""feature_extractor"""			)

           __snake_case       :				int 			=    image_processor if image_processor is not None else feature_extractor
           if image_processor is None:
               raise ValueError("""You need to specify an `image_processor`."""			)
           if tokenizer is None:
               raise ValueError("""You need to specify a `tokenizer`."""			)

           super().__init__(_lowerCAmelCase			,			_lowerCAmelCase			)
           __snake_case       :				Optional[Any] 			=    self.image_processor

       def __call__(							self					:     str			,			_lowerCAmelCase					:     int=None			,			_lowerCAmelCase					:     Dict=None			,			_lowerCAmelCase					:     Optional[int]=None			,			**_lowerCAmelCase					:     List[str]			):

           if text is None and videos is None:
               raise ValueError("""You have to specify either text or videos. Both cannot be none."""			)

           if text is not None:
               __snake_case       :				Optional[Any] 			=    self.tokenizer(_lowerCAmelCase			,			return_tensors=_lowerCAmelCase			,			**_lowerCAmelCase			)

           if videos is not None:
               __snake_case       :				Optional[int] 			=    self.image_processor(_lowerCAmelCase			,			return_tensors=_lowerCAmelCase			,			**_lowerCAmelCase			)

           if text is not None and videos is not None:
               __snake_case       :				Union[str, Any] 			=    image_features.pixel_values
               return encoding
           elif text is not None:
               return encoding
           else:
               return BatchEncoding(data=dict(**_lowerCAmelCase			)			,			tensor_type=_lowerCAmelCase			)

       def 			snake_case__    (							self					:     Tuple			,			*_lowerCAmelCase					:     str			,			**_lowerCAmelCase					:     List[Any]			):
           return self.tokenizer.batch_decode(*_lowerCAmelCase			,			**_lowerCAmelCase			)

       def 			snake_case__    (							self					:     Tuple			,			*_lowerCAmelCase					:     List[Any]			,			**_lowerCAmelCase					:     Dict			):
           return self.tokenizer.decode(*_lowerCAmelCase			,			**_lowerCAmelCase			)

       @property
       def 			snake_case__    (							self					:     str			):
           return ["input_ids", "attention_mask", "position_ids", "pixel_values"]

       @property
       def 			snake_case__    (							self					:     str			):
           warnings.warn(
               """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""			,			_lowerCAmelCase			,			)
           return self.image_processor_class





       @property
       def 			snake_case__    (							self					:     Union[str, Any]			):
           warnings.warn(
               """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""			,			_lowerCAmelCase			,			)
           return self.image_processor



