




'''simple docstring'''



from typing import TYPE_CHECKING

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


UpperCAmelCase_				:     Tuple     			=						{
    '''configuration_gpt2''': ['''GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPT2Config''', '''GPT2OnnxConfig'''],
    '''tokenization_gpt2''': ['''GPT2Tokenizer'''],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase_				:     Optional[int]     			=						['''GPT2TokenizerFast''']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase_				:     int     			=						[
         '''GPT2_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''GPT2DoubleHeadsModel''',
         '''GPT2ForQuestionAnswering''',
         '''GPT2ForSequenceClassification''',
         '''GPT2ForTokenClassification''',
         '''GPT2LMHeadModel''',
         '''GPT2Model''',
         '''GPT2PreTrainedModel''',
         '''load_tf_weights_in_gpt2''',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase_				:     int     			=						[
         '''TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''TFGPT2DoubleHeadsModel''',
         '''TFGPT2ForSequenceClassification''',
         '''TFGPT2LMHeadModel''',
         '''TFGPT2MainLayer''',
         '''TFGPT2Model''',
         '''TFGPT2PreTrainedModel''',
     ]

try:
     if not is_keras_nlp_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase_				:     Tuple     			=						['''TFGPT2Tokenizer''']

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase_				:     int     			=						['''FlaxGPT2LMHeadModel''', '''FlaxGPT2Model''', '''FlaxGPT2PreTrainedModel''']

if TYPE_CHECKING:
     from .configuration_gpta import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTaConfig, GPTaOnnxConfig
     from .tokenization_gpta import GPTaTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_gpta_fast import GPTaTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_gpta import (
              GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
              GPTaDoubleHeadsModel,
              GPTaForQuestionAnswering,
              GPTaForSequenceClassification,
              GPTaForTokenClassification,
              GPTaLMHeadModel,
              GPTaModel,
              GPTaPreTrainedModel,
              load_tf_weights_in_gpta,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_gpta import (
              TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFGPTaDoubleHeadsModel,
              TFGPTaForSequenceClassification,
              TFGPTaLMHeadModel,
              TFGPTaMainLayer,
              TFGPTaModel,
              TFGPTaPreTrainedModel,
          )

     try:
          if not is_keras_nlp_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_gpta_tf import TFGPTaTokenizer

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel, FlaxGPTaPreTrainedModel

else:
     import sys

     UpperCAmelCase_				:     List[Any]     			=						_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)












'''simple docstring'''



import os

from packaging import version

from .. import __version__
from .accelerate_utils import apply_forward_hook
from .constants import (
    CONFIG_NAME,
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    DIFFUSERS_DYNAMIC_MODULE_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    ONNX_EXTERNAL_WEIGHTS_NAME,
    ONNX_WEIGHTS_NAME,
    SAFETENSORS_WEIGHTS_NAME,
    TEXT_ENCODER_ATTN_MODULE,
    WEIGHTS_NAME,
)
from .deprecation_utils import deprecate
from .doc_utils import replace_example_docstring
from .dynamic_modules_utils import get_class_from_dynamic_module
from .hub_utils import (
    HF_HUB_OFFLINE,
    _add_variant,
    _get_model_file,
    extract_commit_hash,
    http_user_agent,
)
from .import_utils import (
    BACKENDS_MAPPING,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    is_accelerate_available,
    is_accelerate_version,
    is_bsa_available,
    is_flax_available,
    is_ftfy_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_omegaconf_available,
    is_onnx_available,
    is_safetensors_available,
    is_scipy_available,
    is_tensorboard_available,
    is_tf_available,
    is_torch_available,
    is_torch_version,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    is_wandb_available,
    is_xformers_available,
    requires_backends,
)
from .logging import get_logger
from .outputs import BaseOutput
from .pil_utils import PIL_INTERPOLATION, numpy_to_pil, pt_to_pil
from .torch_utils import is_compiled_module, randn_tensor


if is_torch_available():
     from .testing_utils import (
         floats_tensor,
         load_hf_numpy,
         load_image,
         load_numpy,
         load_pt,
         nightly,
         parse_flag_from_env,
         print_tensor_test,
         require_torch_a,
         require_torch_gpu,
         skip_mps,
         slow,
         torch_all_close,
         torch_device,
     )
     from .torch_utils import maybe_allow_in_graph

from .testing_utils import export_to_gif, export_to_video


UpperCAmelCase_				:     int     			=						get_logger(__name__)







def 	_UpperCamelCase       (_lowerCamelCase							:   Union[str, Any]		)->      Tuple:




     '''simple docstring'''





     if version.parse(_lowerCamelCase		) < version.parse(_lowerCamelCase		):
          if "dev" in min_version:
               __snake_case			    =     (
                   '''This example requires a source install from HuggingFace diffusers (see '''
                   '''`https://huggingface.co/docs/diffusers/installation#install-from-source`),'''
               )
          else:
               __snake_case			    =     f'''This example requires a minimum version of {min_version},'''
          error_message += f''' but the version found is {__version__}.\n'''
          raise ImportError(_lowerCamelCase		)






