"""simple docstring"""



import os
import sys
import unittest


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

__lowercase		:		str														=							"\n{0} = None\n"

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


__lowercase		:		Optional[Any]														=							"\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n"



class      _A	(						unittest.TestCase					):




    """simple docstring"""




    def  lowercase					(		self							:     List[str]    )    ->       Union[str, Any]:
         __snake_case				=							find_backend('''    _import_structure["models.albert"].append("AlbertTokenizerFast")'''    )
         self.assertIsNone(A_    )

         __snake_case				=							find_backend('''    if not is_tokenizers_available():'''    )
         self.assertEqual(A_	,      '''tokenizers'''    )

         __snake_case				=							find_backend('''    if not is_tensorflow_text_available():'''    )
         self.assertEqual(A_	,      '''tensorflow_text'''    )

         __snake_case				=							find_backend('''    if not (is_sentencepiece_available() and is_tokenizers_available()):'''    )
         self.assertEqual(A_	,      '''sentencepiece_and_tokenizers'''    )

         __snake_case				=							find_backend(
             '''    if not (is_sentencepiece_available() and is_tensorflow_text_available()):'''    )
         self.assertEqual(A_	,      '''sentencepiece_and_tensorflow_text'''    )

         __snake_case				=							find_backend(
             '''    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):'''    )
         self.assertEqual(A_	,      '''sentencepiece_and_tokenizers_and_vision'''    )
    def  lowercase					(		self							:     Tuple    )    ->       Tuple:
         __snake_case				=							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('''tensorflow_text'''	,      A_    )
         self.assertIn('''sentencepiece_and_tokenizers'''	,      A_    )

         # 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  lowercase					(		self							:     Union[str, Any]    )    ->       str:
         __snake_case				=							create_dummy_object('''CONSTANT'''	,      '''\'torch\''''    )
         self.assertEqual(A_	,      '''\nCONSTANT = None\n'''    )

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

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

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')
'''
         __snake_case				=							create_dummy_object('''FakeClass'''	,      '''\'torch\''''    )
         self.assertEqual(A_	,      A_    )







    def  lowercase					(		self							:     Any    )    ->       Union[str, Any]:
         __snake_case				=							'''# 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"])
'''
         __snake_case				=							create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}    )
         self.assertEqual(dummy_files['''torch''']	,      A_    )
"""simple docstring"""



from typing import TYPE_CHECKING

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


__lowercase		:		Optional[Any]														=							{
    "configuration_falcon": ["FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP", "FalconConfig"],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowercase		:		str														=							[
           "FALCON_PRETRAINED_MODEL_ARCHIVE_LIST",
           "FalconForCausalLM",
           "FalconModel",
           "FalconPreTrainedModel",
           "FalconForSequenceClassification",
           "FalconForTokenClassification",
           "FalconForQuestionAnswering",
       ]


if TYPE_CHECKING:
       from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_falcon import (
                  FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
                  FalconForCausalLM,
                  FalconForQuestionAnswering,
                  FalconForSequenceClassification,
                  FalconForTokenClassification,
                  FalconModel,
                  FalconPreTrainedModel,
              )


else:
       import sys

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