

'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


__lowerCamelCase		       =    {
    '''configuration_speech_to_text''': ['''SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Speech2TextConfig'''],
    '''processing_speech_to_text''': ['''Speech2TextProcessor'''],
}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase		       =    ['''Speech2TextTokenizer''']

try:
      if not is_speech_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase		       =    ['''Speech2TextFeatureExtractor''']

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase		       =    [
          '''TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''TFSpeech2TextForConditionalGeneration''',
          '''TFSpeech2TextModel''',
          '''TFSpeech2TextPreTrainedModel''',
      ]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase		       =    [
          '''SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''Speech2TextForConditionalGeneration''',
          '''Speech2TextModel''',
          '''Speech2TextPreTrainedModel''',
      ]


if TYPE_CHECKING:
      from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
      from .processing_speech_to_text import SpeechaTextProcessor

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_speech_to_text import SpeechaTextTokenizer

      try:
            if not is_speech_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_speech_to_text import (
                TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFSpeechaTextForConditionalGeneration,
                TFSpeechaTextModel,
                TFSpeechaTextPreTrainedModel,
            )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_speech_to_text import (
                SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
                SpeechaTextForConditionalGeneration,
                SpeechaTextModel,
                SpeechaTextPreTrainedModel,
            )

else:
      import sys

      __lowerCamelCase		       =    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



'''simple docstring'''







import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			Tuple:
       return EnvironmentCommand()
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			int:
       return EnvironmentCommand(args.accelerate_config_file				)







class 					A__      (      _snake_case			):



    @staticmethod
    def 					snake_case_			(					UpperCamelCase__       )						->      Union[str, Any]:





           '''simple docstring'''
           A_						=      parser.add_parser("""env"""       )
           download_parser.set_defaults(func=UpperCamelCase__       )
           download_parser.add_argument(
               """--accelerate-config_file"""		,				default=UpperCamelCase__		,				help="""The accelerate config file to use for the default values in the launching script."""		,				)
           download_parser.set_defaults(func=UpperCamelCase__       )



    def __init__(					self		,				UpperCamelCase__		,				*UpperCamelCase__       )						->      None:





           '''simple docstring'''
           A_						=      accelerate_config_file



    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           A_						=      """not installed"""
           if is_safetensors_available():
                  import safetensors

                  A_						=      safetensors.__version__
           elif importlib.util.find_spec("""safetensors"""       ) is not None:
                  import safetensors

                  A_						=      f'''{safetensors.__version__} but is ignored because of PyTorch version too old.'''

           A_						=      """not installed"""
           A_						=      A_						=      """not found"""
           if is_accelerate_available():
                  import accelerate
                  from accelerate.commands.config import default_config_file, load_config_from_file

                  A_						=      accelerate.__version__
                  # Get the default from the config file.
                  if self._accelerate_config_file is not None or os.path.isfile(UpperCamelCase__       ):
                         A_						=      load_config_from_file(self._accelerate_config_file       ).to_dict()

                  A_						=      (
                      """\n""".join([f'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()]       )
                      if isinstance(UpperCamelCase__		,				UpperCamelCase__       )
                      else f'''\t{accelerate_config}'''
                  )

           A_						=      """not installed"""
           A_						=      """NA"""
           if is_torch_available():
                  import torch

                  A_						=      torch.__version__
                  A_						=      torch.cuda.is_available()

           A_						=      """not installed"""
           A_						=      """NA"""
           if is_tf_available():
                  import tensorflow as tf

                  A_						=      tf.__version__
                  try:
                         # deprecated in v2.1
                         A_						=      tf.test.is_gpu_available()
                  except AttributeError:
                         # returns list of devices, convert to bool
                         A_						=      bool(tf.config.list_physical_devices("""GPU"""       )       )

           A_						=      """not installed"""
           A_						=      """not installed"""
           A_						=      """not installed"""
           A_						=      """NA"""
           if is_flax_available():
                  import flax
                  import jax
                  import jaxlib

                  A_						=      flax.__version__
                  A_						=      jax.__version__
                  A_						=      jaxlib.__version__
                  A_						=      jax.lib.xla_bridge.get_backend().platform

           A_						=      {
               """`transformers` version""": version,
               """Platform""": platform.platform(),
               """Python version""": platform.python_version(),
               """Huggingface_hub version""": huggingface_hub.__version__,
               """Safetensors version""": f'''{safetensors_version}''',
               """Accelerate version""": f'''{accelerate_version}''',
               """Accelerate config""": f'''{accelerate_config_str}''',
               """PyTorch version (GPU?)""": f'''{pt_version} ({pt_cuda_available})''',
               """Tensorflow version (GPU?)""": f'''{tf_version} ({tf_cuda_available})''',
               """Flax version (CPU?/GPU?/TPU?)""": f'''{flax_version} ({jax_backend})''',
               """Jax version""": f'''{jax_version}''',
               """JaxLib version""": f'''{jaxlib_version}''',
               """Using GPU in script?""": """<fill in>""",
               """Using distributed or parallel set-up in script?""": """<fill in>""",
           }

           print("""\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n"""       )
           print(self.format_dict(UpperCamelCase__       )       )

           return info







    @staticmethod
    def 					snake_case_			(					UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           return "\n".join([f'''- {prop}: {val}''' for prop, val in d.items()]       ) + "\n"
