


'''simple docstring'''







# 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


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






def 			lowercase				(_A="no"   ,						_A = default_json_config_file   ,						_A = False					):







       """simple docstring"""







       _lowerCAmelCase    :							List[Any]   			=       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
       _lowerCAmelCase    :							Any   			=       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}'					)
       _lowerCAmelCase    :							Any   			=       {
           'compute_environment': 'LOCAL_MACHINE',
           'mixed_precision': mixed_precision,
       }
       if torch.cuda.is_available():
              _lowerCAmelCase    :							Dict   			=       torch.cuda.device_count()
              _lowerCAmelCase    :							Optional[int]   			=       num_gpus
              _lowerCAmelCase    :							str   			=       False
              if num_gpus > 1:
                     _lowerCAmelCase    :							Optional[int]   			=       'MULTI_GPU'
              else:
                     _lowerCAmelCase    :							int   			=       'NO'
       elif is_xpu_available() and use_xpu:
              _lowerCAmelCase    :							Dict   			=       torch.xpu.device_count()
              _lowerCAmelCase    :							Union[str, Any]   			=       num_xpus
              _lowerCAmelCase    :							Union[str, Any]   			=       False
              if num_xpus > 1:
                     _lowerCAmelCase    :							Union[str, Any]   			=       'MULTI_XPU'
              else:
                     _lowerCAmelCase    :							Optional[Any]   			=       'NO'
       elif is_npu_available():
              _lowerCAmelCase    :							str   			=       torch.npu.device_count()
              _lowerCAmelCase    :							int   			=       num_npus
              _lowerCAmelCase    :							Optional[Any]   			=       False
              if num_npus > 1:
                     _lowerCAmelCase    :							Any   			=       'MULTI_NPU'
              else:
                     _lowerCAmelCase    :							Dict   			=       'NO'
       else:
              _lowerCAmelCase    :							Optional[Any]   			=       0
              _lowerCAmelCase    :							Optional[Any]   			=       True
              _lowerCAmelCase    :							Tuple   			=       1
              _lowerCAmelCase    :							Union[str, Any]   			=       'NO'
       _lowerCAmelCase    :							Dict   			=       ClusterConfig(**_A					)
       config.to_json_file(_A					)
       return path






def 			lowercase				(_A   ,						_A					):







       """simple docstring"""







       _lowerCAmelCase    :							List[str]   			=       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 			lowercase				(_A					):







       """simple docstring"""







       _lowerCAmelCase    :							Union[str, Any]   			=       write_basic_config(args.mixed_precision   ,						args.save_location					)
       if config_file:
              print(f'accelerate configuration saved at {config_file}'					)





'''simple docstring'''







from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase    :     Optional[int]					=						{
    """configuration_mctct""": ["""MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MCTCTConfig"""],
    """feature_extraction_mctct""": ["""MCTCTFeatureExtractor"""],
    """processing_mctct""": ["""MCTCTProcessor"""],
}


try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase    :     List[str]					=						[
           """MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """MCTCTForCTC""",
           """MCTCTModel""",
           """MCTCTPreTrainedModel""",
       ]


if TYPE_CHECKING:
       from .configuration_mctct import MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP, MCTCTConfig
       from .feature_extraction_mctct import MCTCTFeatureExtractor
       from .processing_mctct import MCTCTProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_mctct import MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST, MCTCTForCTC, MCTCTModel, MCTCTPreTrainedModel

else:
       import sys

       lowerCAmelCase    :     Tuple					=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

