


"""simple docstring"""
import os
import sys

UpperCAmelCase				=						os.path.join(os.path.dirname(__file__), """src""")
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


UpperCAmelCase				=						[
    """torch""",
    """numpy""",
    """tokenizers""",
    """filelock""",
    """requests""",
    """tqdm""",
    """regex""",
    """sentencepiece""",
    """sacremoses""",
    """importlib_metadata""",
    """huggingface_hub""",
]

@add_start_docstrings(AutoConfig.__doc__   )
def 				_snake_case      (   *__snake_case							:      Dict						, **__snake_case							:      Union[str, Any]   ):




   """simple docstring"""







   return AutoConfig.from_pretrained(*__snake_case						, **__snake_case   )

@add_start_docstrings(AutoTokenizer.__doc__   )
def 				_snake_case      (   *__snake_case							:      str						, **__snake_case							:      Any   ):




   """simple docstring"""







   return AutoTokenizer.from_pretrained(*__snake_case						, **__snake_case   )

@add_start_docstrings(AutoModel.__doc__   )
def 				_snake_case      (   *__snake_case							:      Optional[Any]						, **__snake_case							:      Dict   ):




   """simple docstring"""







   return AutoModel.from_pretrained(*__snake_case						, **__snake_case   )

@add_start_docstrings(AutoModelForCausalLM.__doc__   )
def 				_snake_case      (   *__snake_case							:      int						, **__snake_case							:      Dict   ):




   """simple docstring"""







   return AutoModelForCausalLM.from_pretrained(*__snake_case						, **__snake_case   )

@add_start_docstrings(AutoModelForMaskedLM.__doc__   )
def 				_snake_case      (   *__snake_case							:      int						, **__snake_case							:      List[str]   ):




   """simple docstring"""







   return AutoModelForMaskedLM.from_pretrained(*__snake_case						, **__snake_case   )

@add_start_docstrings(AutoModelForSequenceClassification.__doc__   )
def 				_snake_case      (   *__snake_case							:      int						, **__snake_case							:      int   ):




   """simple docstring"""







   return AutoModelForSequenceClassification.from_pretrained(*__snake_case						, **__snake_case   )





@add_start_docstrings(AutoModelForQuestionAnswering.__doc__   )
def 				_snake_case      (   *__snake_case							:      Dict						, **__snake_case							:      List[Any]   ):




   """simple docstring"""







   return AutoModelForQuestionAnswering.from_pretrained(*__snake_case						, **__snake_case   )





"""simple docstring"""
from typing import TYPE_CHECKING

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


UpperCAmelCase				=						{
    """configuration_vision_encoder_decoder""": ["""VisionEncoderDecoderConfig""", """VisionEncoderDecoderOnnxConfig"""]
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase				=						["""VisionEncoderDecoderModel"""]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase				=						["""TFVisionEncoderDecoderModel"""]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase				=						["""FlaxVisionEncoderDecoderModel"""]

if TYPE_CHECKING:
 from .configuration_vision_encoder_decoder import VisionEncoderDecoderConfig, VisionEncoderDecoderOnnxConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_vision_encoder_decoder import VisionEncoderDecoderModel

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_vision_encoder_decoder import TFVisionEncoderDecoderModel

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_vision_encoder_decoder import FlaxVisionEncoderDecoderModel

else:
 import sys

 UpperCAmelCase				=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

