


import os
import sys
import unittest


_snake_case	:						Any         =							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
_snake_case	:						Optional[Any]         =							os.path.join(git_repo_path, "src", "transformers")

_snake_case	:						int         =							"\n{0} = None\n"

_snake_case	:						Dict         =							"\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n"


_snake_case	:						Tuple         =							"\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n"

class 							a						(unittest.TestCase ):




							"""simple docstring"""


							def        __snake_case   (				self			:    Dict							)      ->       Optional[int]:
														__snake_case						:     str									=  find_backend("    _import_structure[\"models.albert\"].append(\"AlbertTokenizerFast\")"							)
														self.assertIsNone(lowerCamelCase							)

														__snake_case						:     str									=  find_backend("    if not is_tokenizers_available():"							)
														self.assertEqual(lowerCamelCase       ,      "tokenizers"							)

														__snake_case						:     List[str]									=  find_backend("    if not is_tensorflow_text_available():"							)
														self.assertEqual(lowerCamelCase       ,      "tensorflow_text"							)

														__snake_case						:     Any									=  find_backend("    if not (is_sentencepiece_available() and is_tokenizers_available()):"							)
														self.assertEqual(lowerCamelCase       ,      "sentencepiece_and_tokenizers"							)

														__snake_case						:     List[Any]									=  find_backend(
														    "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"							)
														self.assertEqual(lowerCamelCase       ,      "sentencepiece_and_tensorflow_text"							)

														__snake_case						:     Union[str, Any]									=  find_backend(
														    "    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):"							)
														self.assertEqual(lowerCamelCase       ,      "sentencepiece_and_tokenizers_and_vision"							)

							def        __snake_case   (				self			:    List[Any]							)      ->       Optional[int]:
														__snake_case						:     List[Any]									=  read_init()
														# We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
														self.assertIn("torch"       ,      lowerCamelCase							)
														self.assertIn("tensorflow_text"       ,      lowerCamelCase							)
														self.assertIn("sentencepiece_and_tokenizers"       ,      lowerCamelCase							)

														# Likewise, we can't assert on the exact content of a key
														self.assertIn("BertModel"       ,      objects["torch"]							)
														self.assertIn("TFBertModel"       ,      objects["tf"]							)
														self.assertIn("FlaxBertModel"       ,      objects["flax"]							)
														self.assertIn("BertModel"       ,      objects["torch"]							)
														self.assertIn("TFBertTokenizer"       ,      objects["tensorflow_text"]							)
														self.assertIn("convert_slow_tokenizer"       ,      objects["sentencepiece_and_tokenizers"]							)

							def        __snake_case   (				self			:    Dict							)      ->       Union[str, Any]:
														__snake_case						:     int									=  create_dummy_object("CONSTANT"       ,      "'torch'"							)
														self.assertEqual(lowerCamelCase       ,      "\nCONSTANT = None\n"							)

														__snake_case						:     Tuple									=  create_dummy_object("function"       ,      "'torch'"							)
														self.assertEqual(
														    lowerCamelCase       ,      "\ndef function(*args, **kwargs):\n    requires_backends(function, 'torch')\n"							)

														__snake_case						:     Optional[Any]									=  "\nclass FakeClass(metaclass=DummyObject):\n    _backends = 'torch'\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, 'torch')\n"
														__snake_case						:     List[Any]									=  create_dummy_object("FakeClass"       ,      "'torch'"							)
														self.assertEqual(lowerCamelCase       ,      lowerCamelCase							)






							def        __snake_case   (				self			:    Optional[Any]							)      ->       Optional[Any]:
														__snake_case						:     Optional[int]									=  "# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n    requires_backends(function, [\"torch\"])\n\n\nclass FakeClass(metaclass=DummyObject):\n    _backends = [\"torch\"]\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, [\"torch\"])\n"
														__snake_case						:     Any									=  create_dummy_files({"torch": ["CONSTANT", "function", "FakeClass"]}							)
														self.assertEqual(dummy_files["torch"]       ,      lowerCamelCase							)






"""simple docstring"""







from typing import TYPE_CHECKING

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


a_							=    {"""configuration_opt""": ["""OPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OPTConfig"""]}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a_							=    [
	    """OPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """OPTForCausalLM""",
	    """OPTModel""",
	    """OPTPreTrainedModel""",
	    """OPTForSequenceClassification""",
	    """OPTForQuestionAnswering""",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a_							=    ["""TFOPTForCausalLM""", """TFOPTModel""", """TFOPTPreTrainedModel"""]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a_							=    [
	    """FlaxOPTForCausalLM""",
	    """FlaxOPTModel""",
	    """FlaxOPTPreTrainedModel""",
	]


if TYPE_CHECKING:
	from .configuration_opt import OPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPTConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_opt import (
		    OPT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    OPTForCausalLM,
		    OPTForQuestionAnswering,
		    OPTForSequenceClassification,
		    OPTModel,
		    OPTPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_opt import TFOPTForCausalLM, TFOPTModel, TFOPTPreTrainedModel

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_opt import FlaxOPTForCausalLM, FlaxOPTModel, FlaxOPTPreTrainedModel

else:
	import sys

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





