
import re
import tempfile
import unittest
from pathlib import Path

from datasets.utils.metadata import DatasetMetadata


def 					__lowerCAmelCase    (    a__						) ->						str:
				__a    							=					min(re.search('''^ +'''		,					a__						).end() if t.startswith(''' '''						) else 0 for t in string.splitlines()						)
				return "\n".join([line[indent_level:] for line in string.splitlines() if indent_level < len(a__						)]						)


A  :			str     				=				'\\n---\nlanguage:\n- zh\n- en\ntask_ids:\n- sentiment-classification\n---\n# Begin of markdown\n\nSome cool dataset card\n'

A  :			List[str]     				=				'\\n---\n---\n# Begin of markdown\n\nSome cool dataset card\n'


A  :			Tuple     				=				'\\n# Begin of markdown\n\nSome cool dataset card\n'







class     __A(				unittest.TestCase    ):




				def        SCREAMING_SNAKE_CASE_	(  self       )					->   Dict:


								'''simple docstring'''




								with tempfile.TemporaryDirectory() as tmp_dir:
												__a    							=					Path(_snake_case       ) / '''README.md'''
												with open(_snake_case	,  '''w+'''       ) as readme_file:
																readme_file.write(_snake_case       )
												__a    							=					DatasetMetadata.from_readme(_snake_case       )
												self.assertDictEqual(_snake_case	,  {'''language''': ['''zh''', '''en'''], '''task_ids''': ['''sentiment-classification''']}       )

												with open(_snake_case	,  '''w+'''       ) as readme_file:
																readme_file.write(_snake_case       )
												__a    							=					DatasetMetadata.from_readme(_snake_case       )
												self.assertDictEqual(_snake_case	,  {}       )

												with open(_snake_case	,  '''w+'''       ) as readme_file:
																readme_file.write(_snake_case       )
												__a    							=					DatasetMetadata.from_readme(_snake_case       )
												self.assertEqual(_snake_case	,  {}       )




				def        SCREAMING_SNAKE_CASE_	(  self       )					->   Optional[int]:


								'''simple docstring'''




								__a    							=					_dedent(
								    '''\
            annotations_creators:
            - found
            language_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - question-answering
            task_ids:
            - open-domain-qa
            '''       )
								assert DatasetMetadata.from_yaml_string(_snake_case       )

								__a    							=					_dedent(
								    '''\
            annotations_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - question-answering
            task_ids:
            - open-domain-qa
            task_ids:
            - open-domain-qa
            '''       )
								with self.assertRaises(_snake_case       ):
												DatasetMetadata.from_yaml_string(_snake_case       )

								__a    							=					_dedent(
								    '''\
            annotations_creators:
            - found
            language_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - text-classification
            task_ids:
            - multi-class-classification
            paperswithcode_id:
            - squad
            configs:
            - en
            train-eval-index:
            - config: en
              task: text-classification
              task_id: multi_class_classification
              splits:
                train_split: train
                eval_split: test
              col_mapping:
                text: text
                label: target
              metrics:
                - type: accuracy
                  name: Accuracy
            extra_gated_prompt: |
              By clicking on “Access repository” below, you also agree to ImageNet Terms of Access:
              [RESEARCHER_FULLNAME] (the "Researcher") has requested permission to use the ImageNet database (the "Database") at Princeton University and Stanford University. In exchange for such permission, Researcher hereby agrees to the following terms and conditions:
              1. Researcher shall use the Database only for non-commercial research and educational purposes.
            extra_gated_fields:
              Company: text
              Country: text
              I agree to use this model for non-commerical use ONLY: checkbox
            '''       )
								assert DatasetMetadata.from_yaml_string(_snake_case       )

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


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


def 					__lowerCAmelCase    (    a__						) ->						List[str]:
				# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
				__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 					__lowerCAmelCase    (    ) ->						bool:
				return _torch_distributed_available


def 					__lowerCAmelCase    (    ) ->						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 					__lowerCAmelCase    (    ) ->						Union[str, Any]:
				return importlib.metadata.version('''oneccl_bind_pt'''						)


def 					__lowerCAmelCase    (    ) ->						Dict:
				return _is_package_available('''transformer_engine'''						)


@lru_cache
def 					__lowerCAmelCase    (    a__=True						) ->						Union[str, 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
												__a    							=					xm.xla_device()
												return True
								except RuntimeError:
												return False
				return _tpu_available


def 					__lowerCAmelCase    (    ) ->						Any:
				return _is_package_available('''deepspeed'''						)


def 					__lowerCAmelCase    (    a__=False						) ->						Optional[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 					__lowerCAmelCase    (    ) ->						List[str]:
				__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 					__lowerCAmelCase    (    ) ->						Any:
				__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 					__lowerCAmelCase    (    ) ->						int:
				return _is_package_available('''bitsandbytes'''						)


def 					__lowerCAmelCase    (    ) ->						str:
				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 					__lowerCAmelCase    (    ) ->						List[str]:
				return _is_package_available('''safetensors'''						)


def 					__lowerCAmelCase    (    ) ->						Optional[Any]:
				return _is_package_available('''transformers'''						)


def 					__lowerCAmelCase    (    ) ->						int:
				return _is_package_available('''datasets'''						)


def 					__lowerCAmelCase    (    ) ->						Optional[int]:
				return _is_package_available('''aim'''						)


def 					__lowerCAmelCase    (    ) ->						List[Any]:
				return _is_package_available('''tensorboard'''						) or _is_package_available('''tensorboardX'''						)


def 					__lowerCAmelCase    (    ) ->						List[Any]:
				return _is_package_available('''wandb'''						)


def 					__lowerCAmelCase    (    ) ->						Optional[int]:
				return _is_package_available('''comet_ml'''						)


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


def 					__lowerCAmelCase    (    ) ->						Optional[Any]:
				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 					__lowerCAmelCase    (    ) ->						Any:
				return _is_package_available('''sagemaker'''						)


def 					__lowerCAmelCase    (    ) ->						int:
				return _is_package_available('''tqdm'''						)


def 					__lowerCAmelCase    (    ) ->						Union[str, Any]:
				return _is_package_available('''mlflow'''						)


def 					__lowerCAmelCase    (    ) ->						Optional[Any]:
				return is_torch_version('''>='''		,					'''1.12'''						) and torch.backends.mps.is_available() and torch.backends.mps.is_built()


def 					__lowerCAmelCase    (    ) ->						str:
				def get_major_and_minor_from_version(a__						):
								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 					__lowerCAmelCase    (    a__=False						) ->						List[Any]:
				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 					__lowerCAmelCase    (    a__=False						) ->						Union[str, Any]:
				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()