




from typing import TYPE_CHECKING

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


if is_sentencepiece_available():
      from ..ta.tokenization_ta import TaTokenizer
else:
      from ...utils.dummy_sentencepiece_objects import TaTokenizer

__magic_name__  :  List[Any]					=       TaTokenizer

if is_tokenizers_available():
      from ..ta.tokenization_ta_fast import TaTokenizerFast
else:
      from ...utils.dummy_tokenizers_objects import TaTokenizerFast

__magic_name__  :  Union[str, Any]					=       TaTokenizerFast

__magic_name__  :  Optional[int]					=       {"""configuration_mt5""": ["""MT5Config""", """MT5OnnxConfig"""]}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __magic_name__  :  str					=       [
          """MT5EncoderModel""",
          """MT5ForConditionalGeneration""",
          """MT5ForQuestionAnswering""",
          """MT5Model""",
          """MT5PreTrainedModel""",
          """MT5Stack""",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __magic_name__  :  Dict					=       ["""TFMT5EncoderModel""", """TFMT5ForConditionalGeneration""", """TFMT5Model"""]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __magic_name__  :  int					=       ["""FlaxMT5EncoderModel""", """FlaxMT5ForConditionalGeneration""", """FlaxMT5Model"""]


if TYPE_CHECKING:
      from .configuration_mta import MTaConfig, MTaOnnxConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_mta import (
                MTaEncoderModel,
                MTaForConditionalGeneration,
                MTaForQuestionAnswering,
                MTaModel,
                MTaPreTrainedModel,
                MTaStack,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel

else:
      import sys

      __magic_name__  :  Union[str, Any]					=       _LazyModule(
          __name__,
          globals()["""__file__"""],
          _import_structure,
          extra_objects={"""MT5Tokenizer""": MTaTokenizer, """MT5TokenizerFast""": MTaTokenizerFast},
          module_spec=__spec__,
      )







from typing import TYPE_CHECKING

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


__magic_name__  :  Optional[int]					=       {
    """configuration_biogpt""": ["""BIOGPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """BioGptConfig"""],
    """tokenization_biogpt""": ["""BioGptTokenizer"""],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __magic_name__  :  int					=       [
          """BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """BioGptForCausalLM""",
          """BioGptForTokenClassification""",
          """BioGptForSequenceClassification""",
          """BioGptModel""",
          """BioGptPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_biogpt import BIOGPT_PRETRAINED_CONFIG_ARCHIVE_MAP, BioGptConfig
      from .tokenization_biogpt import BioGptTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_biogpt import (
                BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST,
                BioGptForCausalLM,
                BioGptForSequenceClassification,
                BioGptForTokenClassification,
                BioGptModel,
                BioGptPreTrainedModel,
            )


else:
      import sys

      __magic_name__  :  int					=       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

