






import os
import sys
import unittest


__A      =				os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, 'utils'))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
__A      =				os.path.join(git_repo_path, 'src', 'diffusers')





class 						SCREAMING_SNAKE_CASE				( unittest.TestCase					):





							"""simple docstring"""

							def       __A (  self:   List[Any]   )    ->				Union[str, Any]:
												_A								= find_backend('''    if not is_torch_available():'''   )
												self.assertEqual(__A		,     '''torch'''   )

												# backend_with_underscore = find_backend("    if not is_tensorflow_text_available():")
												# self.assertEqual(backend_with_underscore, "tensorflow_text")

												_A								= find_backend('''    if not (is_torch_available() and is_transformers_available()):'''   )
												self.assertEqual(__A		,     '''torch_and_transformers'''   )

												# double_backend_with_underscore = find_backend(
												#    "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"
												# )
												# self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text")

												_A								= find_backend(
												    '''    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):'''   )
												self.assertEqual(__A		,     '''torch_and_transformers_and_onnx'''   )

							def       __A (  self:   Dict   )    ->				Optional[int]:
												_A								= read_init()
												# We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
												self.assertIn('''torch'''		,     __A   )
												self.assertIn('''torch_and_transformers'''		,     __A   )
												self.assertIn('''flax_and_transformers'''		,     __A   )
												self.assertIn('''torch_and_transformers_and_onnx'''		,     __A   )

												# Likewise, we can't assert on the exact content of a key
												self.assertIn('''UNet2DModel'''		,     objects['''torch''']   )
												self.assertIn('''FlaxUNet2DConditionModel'''		,     objects['''flax''']   )
												self.assertIn('''StableDiffusionPipeline'''		,     objects['''torch_and_transformers''']   )
												self.assertIn('''FlaxStableDiffusionPipeline'''		,     objects['''flax_and_transformers''']   )
												self.assertIn('''LMSDiscreteScheduler'''		,     objects['''torch_and_scipy''']   )
												self.assertIn('''OnnxStableDiffusionPipeline'''		,     objects['''torch_and_transformers_and_onnx''']   )

							def       __A (  self:   int   )    ->				List[Any]:
												_A								= create_dummy_object('''CONSTANT'''		,     '''\'torch\''''   )
												self.assertEqual(__A		,     '''\nCONSTANT = None\n'''   )

												_A								= create_dummy_object('''function'''		,     '''\'torch\''''   )
												self.assertEqual(
												    __A		,     '''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n'''   )

												_A								= '''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, \'torch\')

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, \'torch\')
'''
												_A								= create_dummy_object('''FakeClass'''		,     '''\'torch\''''   )
												self.assertEqual(__A		,     __A   )



							def       __A (  self:   str   )    ->				Optional[int]:
												_A								= '''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, [\"torch\"])


class FakeClass(metaclass=DummyObject):
    _backends = [\"torch\"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, [\"torch\"])

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, [\"torch\"])

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, [\"torch\"])
'''
												_A								= create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}   )
												self.assertEqual(dummy_files['''torch''']		,     __A   )











from typing import TYPE_CHECKING

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


__A      =				{
    'configuration_mega': ['MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MegaConfig', 'MegaOnnxConfig'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A      =				[
				    'MEGA_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'MegaForCausalLM',
				    'MegaForMaskedLM',
				    'MegaForMultipleChoice',
				    'MegaForQuestionAnswering',
				    'MegaForSequenceClassification',
				    'MegaForTokenClassification',
				    'MegaModel',
				    'MegaPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_mega import (
								    MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
								    MegaForCausalLM,
								    MegaForMaskedLM,
								    MegaForMultipleChoice,
								    MegaForQuestionAnswering,
								    MegaForSequenceClassification,
								    MegaForTokenClassification,
								    MegaModel,
								    MegaPreTrainedModel,
								)

else:
				import sys

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



