
# Copyright 2021 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 pathlib import Path

import torch

from ...utils import is_npu_available, is_xpu_available
from .config_args import ClusterConfig, default_json_config_file
from .config_utils import SubcommandHelpFormatter


SCREAMING_SNAKE_CASE							:Union[str, Any]							 =				'Create a default config file for Accelerate with only a few flags set.'


def 						UpperCAmelCase			(	a_="no"		,   a_ = default_json_config_file		,   a_ = False						)		->	Optional[int]:







				"""simple docstring"""



				__A   			= Path(a_						)
				path.parent.mkdir(parents=a_		,   exist_ok=a_						)
				if path.exists():
								print(
								    F'''Configuration already exists at {save_location}, will not override. Run `accelerate config` manually or pass a different `save_location`.'''						)
								return False
				__A   			= mixed_precision.lower()
				if mixed_precision not in ["no", "fp16", "bf16", "fp8"]:
								raise ValueError(
								    F'''`mixed_precision` should be one of \'no\', \'fp16\', \'bf16\', or \'fp8\'. Received {mixed_precision}'''						)
				__A   			= {
				    "compute_environment": "LOCAL_MACHINE",
				    "mixed_precision": mixed_precision,
				}
				if torch.cuda.is_available():
								__A   			= torch.cuda.device_count()
								__A   			= num_gpus
								__A   			= False
								if num_gpus > 1:
												__A   			= "MULTI_GPU"
								else:
												__A   			= "NO"
				elif is_xpu_available() and use_xpu:
								__A   			= torch.xpu.device_count()
								__A   			= num_xpus
								__A   			= False
								if num_xpus > 1:
												__A   			= "MULTI_XPU"
								else:
												__A   			= "NO"
				elif is_npu_available():
								__A   			= torch.npu.device_count()
								__A   			= num_npus
								__A   			= False
								if num_npus > 1:
												__A   			= "MULTI_NPU"
								else:
												__A   			= "NO"
				else:
								__A   			= 0
								__A   			= True
								__A   			= 1
								__A   			= "NO"
				__A   			= ClusterConfig(**a_						)
				config.to_json_file(a_						)
				return path


def 						UpperCAmelCase			(	a_		,   a_						)		->	List[Any]:







				"""simple docstring"""



				__A   			= parser.add_parser("default"		,   parents=a_		,   help=a_		,   formatter_class=a_						)
				parser.add_argument(
				    "--config_file"		,   default=a_		,   help=(
				        "The path to use to store the config file. Will default to a file named default_config.yaml in the cache "
				        "location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have "
				        "such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed "
				        "with 'huggingface'."
				    )		,   dest="save_location"		,   )

				parser.add_argument(
				    "--mixed_precision"		,   choices=["no", "fp16", "bf16"]		,   type=a_		,   help="Whether or not to use mixed precision training. "
				    "Choose between FP16 and BF16 (bfloat16) training. "
				    "BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later."		,   default="no"		,   )
				parser.set_defaults(func=a_						)
				return parser


def 						UpperCAmelCase			(	a_						)		->	Dict:







				"""simple docstring"""



				__A   			= write_basic_config(args.mixed_precision		,   args.save_location						)
				if config_file:
								print(F'''accelerate configuration saved at {config_file}'''						)


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


SCREAMING_SNAKE_CASE							:List[Any]							 =				{}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE							:List[str]							 =				['BartphoTokenizer']

if TYPE_CHECKING:
					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_bartpho import BartphoTokenizer

else:
					import sys

					SCREAMING_SNAKE_CASE							:Union[str, Any]							 =				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
