


'''simple docstring'''



from ..utils import DummyObject, requires_backends



class      a    (		metaclass=_a	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Any							       =       ["torch", "transformers", "onnx"]

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

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






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



class      a    (		metaclass=_a	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       ["torch", "transformers", "onnx"]

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

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






     @classmethod
     def 			lowerCamelCase__			(    cls					:		List[Any]							,			*snake_case					:		List[str]							,			**snake_case					:		int      )						->							Tuple:
          requires_backends(cls							,			['''torch''', '''transformers''', '''onnx''']      )



class      a    (		metaclass=_a	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			List[Any]							       =       ["torch", "transformers", "onnx"]

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

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






     @classmethod
     def 			lowerCamelCase__			(    cls					:		Optional[Any]							,			*snake_case					:		str							,			**snake_case					:		Dict      )						->							List[str]:
          requires_backends(cls							,			['''torch''', '''transformers''', '''onnx''']      )



class      a    (		metaclass=_a	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			List[Any]							       =       ["torch", "transformers", "onnx"]

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

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






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



class      a    (		metaclass=_a	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Tuple							       =       ["torch", "transformers", "onnx"]

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

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






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



class      a    (		metaclass=_a	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			int							       =       ["torch", "transformers", "onnx"]

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

     @classmethod
     def 			lowerCamelCase__			(    cls					:		Any							,			*snake_case					:		int							,			**snake_case					:		Dict      )						->							Optional[int]:
          requires_backends(cls							,			['''torch''', '''transformers''', '''onnx''']      )






     @classmethod
     def 			lowerCamelCase__			(    cls					:		Dict							,			*snake_case					:		Dict							,			**snake_case					:		Dict      )						->							Tuple:
          requires_backends(cls							,			['''torch''', '''transformers''', '''onnx''']      )



'''simple docstring'''



from typing import TYPE_CHECKING

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


__UpperCAmelCase      :Union[str, Any]			    =       {
    "configuration_rag": ["RagConfig"],
    "retrieval_rag": ["RagRetriever"],
    "tokenization_rag": ["RagTokenizer"],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase      :Dict			    =       [
          "RagModel",
          "RagPreTrainedModel",
          "RagSequenceForGeneration",
          "RagTokenForGeneration",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase      :Dict			    =       [
          "TFRagModel",
          "TFRagPreTrainedModel",
          "TFRagSequenceForGeneration",
          "TFRagTokenForGeneration",
      ]


if TYPE_CHECKING:
      from .configuration_rag import RagConfig
      from .retrieval_rag import RagRetriever
      from .tokenization_rag import RagTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_rag import RagModel, RagPreTrainedModel, RagSequenceForGeneration, RagTokenForGeneration

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_rag import (
                TFRagModel,
                TFRagPreTrainedModel,
                TFRagSequenceForGeneration,
                TFRagTokenForGeneration,
            )

else:
      import sys

      __UpperCAmelCase      :Any			    =       _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)