



'''simple docstring'''






from ..utils import DummyObject, requires_backends

class 							a__(      metaclass=lowerCamelCase__			):
    lowercase__				=					["""speech"""]







    def __init__(   self				:						int		,    *__snake_case				:						str		,    **__snake_case				:						Any			):
      requires_backends(self		,    ['speech']			)

class 							a__(      metaclass=lowerCamelCase__			):
    lowercase__				=					["""speech"""]







    def __init__(   self				:						List[str]		,    *__snake_case				:						Tuple		,    **__snake_case				:						Tuple			):
      requires_backends(self		,    ['speech']			)




'''simple docstring'''






import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import is_accelerate_available, is_torch_available, is_transformers_available, is_xformers_available
from . import BaseDiffusersCLICommand
def    lowerCamelCase__ (		_A       ):
  return EnvironmentCommand()

class 							a__(      lowerCamelCase__			):







    @staticmethod
    def     lowercase_ (   __snake_case				:						ArgumentParser			):
      a		:      Tuple       =  parser.add_parser('env'			)
      download_parser.set_defaults(func=__snake_case			)







    def     lowercase_ (   self				:						List[str]			):
      a		:      str       =  huggingface_hub.__version__

      a		:      List[str]       =  'not installed'
      a		:      List[str]       =  'NA'
      if is_torch_available():
        import torch

        a		:      Optional[Any]       =  torch.__version__
        a		:      int       =  torch.cuda.is_available()

      a		:      Optional[int]       =  'not installed'
      if is_transformers_available():
        import transformers

        a		:      Tuple       =  transformers.__version__

      a		:      Dict       =  'not installed'
      if is_accelerate_available():
        import accelerate

        a		:      int       =  accelerate.__version__

      a		:      Any       =  'not installed'
      if is_xformers_available():
        import xformers

        a		:      Optional[int]       =  xformers.__version__

      a		:      List[str]       =  {
          '`diffusers` version': version,
          'Platform': platform.platform(),
          'Python version': platform.python_version(),
          'PyTorch version (GPU?)': F"""{pt_version} ({pt_cuda_available})""",
          'Huggingface_hub version': hub_version,
          'Transformers version': transformers_version,
          'Accelerate version': accelerate_version,
          'xFormers version': xformers_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(__snake_case			)			)

      return info







    @staticmethod
    def     lowercase_ (   __snake_case				:						Union[str, Any]			):
      return "\n".join([F"""- {prop}: {val}""" for prop, val in d.items()]			) + "\n"