
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

			_lowerCamelCase     					=    True
except ImportError:
			_lowerCamelCase     					=    False


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






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






def  a_	( )				->						bool:
			return _torch_distributed_available






def  a_	( )				->						Tuple:
			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_	( )				->						Tuple:
			return importlib.metadata.version('oneccl_bind_pt'				)






def  a_	( )				->						Any:
			return _is_package_available('transformer_engine'				)






@lru_cache
def  a_	( __lowercase     :			Any=True				)				->						Any:
			# 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
									_snake_case						=    xm.xla_device()
									return True
						except RuntimeError:
									return False
			return _tpu_available






def  a_	( )				->						List[Any]:
			return _is_package_available('deepspeed'				)






def  a_	( __lowercase     :			str=False				)				->						List[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_	( )				->						str:
			_snake_case						=    _is_package_available('bitsandbytes'				)
			if package_exists:
						_snake_case						=    version.parse(importlib.metadata.version('bitsandbytes'				)				)
						return compare_versions(__lowercase ,      '>=' ,      '0.39.0'				)
			return False






def  a_	( )				->						Optional[Any]:
			_snake_case						=    _is_package_available('bitsandbytes'				)
			if package_exists:
						_snake_case						=    version.parse(importlib.metadata.version('bitsandbytes'				)				)
						return compare_versions(__lowercase ,      '>=' ,      '0.37.2'				)
			return False






def  a_	( )				->						str:
			return _is_package_available('bitsandbytes'				)






def  a_	( )				->						List[str]:
			if strtobool(os.environ.get('ACCELERATE_USE_MEGATRON_LM' ,      'False'				)				) == 1:
						_snake_case						=    importlib.util.find_spec('megatron'				) is not None
						if package_exists:
									try:
												_snake_case						=    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[str]:
			return _is_package_available('transformers'				)






def  a_	( )				->						Optional[Any]:
			return _is_package_available('datasets'				)






def  a_	( )				->						Optional[Any]:
			return _is_package_available('aim'				)






def  a_	( )				->						Dict:
			return _is_package_available('tensorboard'				) or _is_package_available('tensorboardX'				)






def  a_	( )				->						int:
			return _is_package_available('wandb'				)






def  a_	( )				->						Dict:
			return _is_package_available('comet_ml'				)






def  a_	( )				->						str:
			return _is_package_available('boto3'				)






def  a_	( )				->						List[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_	( )				->						Any:
			return _is_package_available('tqdm'				)






def  a_	( )				->						List[Any]:
			return _is_package_available('mlflow'				)






def  a_	( )				->						Dict:
			return is_torch_version('>=' ,      '1.12'				) and torch.backends.mps.is_available() and torch.backends.mps.is_built()






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

			_snake_case						=    importlib.metadata.version('torch'				)
			if importlib.util.find_spec('intel_extension_for_pytorch'				) is None:
						return False
			_snake_case						=    """N/A"""
			try:
						_snake_case						=    importlib.metadata.version('intel_extension_for_pytorch'				)
			except importlib.metadata.PackageNotFoundError:
						return False
			_snake_case						=    get_major_and_minor_from_version(_torch_version				)
			_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_	( __lowercase     :			int=False				)				->						str:
			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						=    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_	( __lowercase     :			Union[str, Any]=False				)				->						Optional[int]:
			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
									_snake_case						=    torch.xpu.device_count()
									return torch.xpu.is_available()
						except RuntimeError:
									return False
			return hasattr(__lowercase ,      'xpu'				) and torch.xpu.is_available()

# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


_lowerCamelCase :       int     					=    {
    '''configuration_tvlt''': ['''TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TvltConfig'''],
    '''feature_extraction_tvlt''': ['''TvltFeatureExtractor'''],
    '''processing_tvlt''': ['''TvltProcessor'''],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_lowerCamelCase :       str     					=    [
			    '''TVLT_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TvltModel''',
			    '''TvltForPreTraining''',
			    '''TvltForAudioVisualClassification''',
			    '''TvltPreTrainedModel''',
			]

try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_lowerCamelCase :       str     					=    ['''TvltImageProcessor''']


if TYPE_CHECKING:
			from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
			from .processing_tvlt import TvltProcessor
			from .feature_extraction_tvlt import TvltFeatureExtractor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tvlt import (
						    TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TvltForAudioVisualClassification,
						    TvltForPreTraining,
						    TvltModel,
						    TvltPreTrainedModel,
						)

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .image_processing_tvlt import TvltImageProcessor


else:
			import sys

			_lowerCamelCase :       Dict     					=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)