




'''simple docstring'''







# Copyright 2023 The HuggingFace Inc. 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,
)


_lowerCamelCase							:		Dict										=						{
    'agents': ['Agent', 'AzureOpenAiAgent', 'HfAgent', 'LocalAgent', 'OpenAiAgent'],
    'base': ['PipelineTool', 'RemoteTool', 'Tool', 'launch_gradio_demo', 'load_tool'],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCamelCase							:		Any										=						['DocumentQuestionAnsweringTool']
						_lowerCamelCase							:		Tuple										=						['ImageCaptioningTool']
						_lowerCamelCase							:		Any										=						['ImageQuestionAnsweringTool']
						_lowerCamelCase							:		Tuple										=						['ImageSegmentationTool']
						_lowerCamelCase							:		Optional[int]										=						['SpeechToTextTool']
						_lowerCamelCase							:		Optional[Any]										=						['TextClassificationTool']
						_lowerCamelCase							:		str										=						['TextQuestionAnsweringTool']
						_lowerCamelCase							:		int										=						['TextSummarizationTool']
						_lowerCamelCase							:		Optional[Any]										=						['TextToSpeechTool']
						_lowerCamelCase							:		Union[str, Any]										=						['TranslationTool']

if TYPE_CHECKING:
						from .agents import Agent, AzureOpenAiAgent, HfAgent, LocalAgent, OpenAiAgent
						from .base import PipelineTool, RemoteTool, Tool, launch_gradio_demo, load_tool

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .document_question_answering import DocumentQuestionAnsweringTool
												from .image_captioning import ImageCaptioningTool
												from .image_question_answering import ImageQuestionAnsweringTool
												from .image_segmentation import ImageSegmentationTool
												from .speech_to_text import SpeechToTextTool
												from .text_classification import TextClassificationTool
												from .text_question_answering import TextQuestionAnsweringTool
												from .text_summarization import TextSummarizationTool
												from .text_to_speech import TextToSpeechTool
												from .translation import TranslationTool
else:
						import sys

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











'''simple docstring'''







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							:		int										=						True
except ImportError:
						_lowerCamelCase							:		List[str]										=						False


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






def 	_lowercase	(			lowercase_						):



		'''simple docstring'''







		_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 	_lowercase	(			):



		'''simple docstring'''







		return _torch_distributed_available






def 	_lowercase	(			):



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



		'''simple docstring'''







		return importlib.metadata.version("oneccl_bind_pt"						)






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("transformer_engine"						)






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






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("deepspeed"						)






def 	_lowercase	(			lowercase_=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 	_lowercase	(			):



		'''simple docstring'''







		_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 	_lowercase	(			):



		'''simple docstring'''







		_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 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("bitsandbytes"						)






def 	_lowercase	(			):



		'''simple docstring'''







		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 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("safetensors"						)






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("transformers"						)






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("datasets"						)






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("aim"						)






def 	_lowercase	(			):



		'''simple docstring'''







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






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("wandb"						)






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("comet_ml"						)






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("boto3"						)






def 	_lowercase	(			):



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






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("sagemaker"						)






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("tqdm"						)






def 	_lowercase	(			):



		'''simple docstring'''







		return _is_package_available("mlflow"						)






def 	_lowercase	(			):



		'''simple docstring'''







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






def 	_lowercase	(			):



		'''simple docstring'''







		def get_major_and_minor_from_version(lowercase_						):
				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 	_lowercase	(			lowercase_=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
						_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 	_lowercase	(			lowercase_=False						):



		'''simple docstring'''







		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()





