



'''simple docstring'''





from ..utils import DummyObject, requires_backends






class 					lowerCamelCase_    (				metaclass=SCREAMING_SNAKE_CASE_     ):
  """simple docstring"""




  a_												=["""torch""", """transformers""", """onnx"""]




  def __init__( self      :	int			,	*_a      :	int			,	**_a      :	Any   )					->					str:
    requires_backends(self			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Dict			,	*_a      :	Any			,	**_a      :	int   )					->					List[Any]:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Dict			,	*_a      :	List[Any]			,	**_a      :	Dict   )					->					Any:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )






class 					lowerCamelCase_    (				metaclass=SCREAMING_SNAKE_CASE_     ):
  """simple docstring"""




  a_												=["""torch""", """transformers""", """onnx"""]




  def __init__( self      :	List[Any]			,	*_a      :	Union[str, Any]			,	**_a      :	int   )					->					Optional[int]:
    requires_backends(self			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Any			,	*_a      :	List[Any]			,	**_a      :	List[str]   )					->					List[Any]:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Optional[Any]			,	*_a      :	str			,	**_a      :	str   )					->					Optional[int]:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )






class 					lowerCamelCase_    (				metaclass=SCREAMING_SNAKE_CASE_     ):
  """simple docstring"""




  a_												=["""torch""", """transformers""", """onnx"""]




  def __init__( self      :	Dict			,	*_a      :	Optional[Any]			,	**_a      :	int   )					->					Union[str, Any]:
    requires_backends(self			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Optional[int]			,	*_a      :	str			,	**_a      :	int   )					->					Dict:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	List[str]			,	*_a      :	int			,	**_a      :	Dict   )					->					str:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )






class 					lowerCamelCase_    (				metaclass=SCREAMING_SNAKE_CASE_     ):
  """simple docstring"""




  a_												=["""torch""", """transformers""", """onnx"""]




  def __init__( self      :	Any			,	*_a      :	Tuple			,	**_a      :	List[Any]   )					->					int:
    requires_backends(self			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	List[Any]			,	*_a      :	Optional[Any]			,	**_a      :	Optional[int]   )					->					Optional[Any]:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Optional[Any]			,	*_a      :	Tuple			,	**_a      :	Dict   )					->					str:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )






class 					lowerCamelCase_    (				metaclass=SCREAMING_SNAKE_CASE_     ):
  """simple docstring"""




  a_												=["""torch""", """transformers""", """onnx"""]




  def __init__( self      :	Optional[int]			,	*_a      :	Optional[int]			,	**_a      :	Tuple   )					->					int:
    requires_backends(self			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Union[str, Any]			,	*_a      :	Any			,	**_a      :	Optional[Any]   )					->					Dict:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	List[Any]			,	*_a      :	Optional[int]			,	**_a      :	Any   )					->					Tuple:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )






class 					lowerCamelCase_    (				metaclass=SCREAMING_SNAKE_CASE_     ):
  """simple docstring"""




  a_												=["""torch""", """transformers""", """onnx"""]




  def __init__( self      :	str			,	*_a      :	Optional[Any]			,	**_a      :	List[str]   )					->					List[Any]:
    requires_backends(self			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Any			,	*_a      :	List[str]			,	**_a      :	int   )					->					Union[str, Any]:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )




  @classmethod
  def 						_lowercase     ( cls      :	Optional[int]			,	*_a      :	Tuple			,	**_a      :	int   )					->					str:
    requires_backends(cls			,	['torch', 'transformers', 'onnx']   )











'''simple docstring'''





from typing import TYPE_CHECKING

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


_UpperCamelCase											=						{'configuration_speech_encoder_decoder': ['SpeechEncoderDecoderConfig']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase											=						['SpeechEncoderDecoderModel']

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase											=						['FlaxSpeechEncoderDecoderModel']

if TYPE_CHECKING:
   from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_speech_encoder_decoder import SpeechEncoderDecoderModel

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_speech_encoder_decoder import FlaxSpeechEncoderDecoderModel

else:
   import sys

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






