'''simple docstring'''




import os
import sys
import unittest


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

__SCREAMING_SNAKE_CASE       :     Optional[int]     =  """
{0} = None
"""

__SCREAMING_SNAKE_CASE       :     Dict     =  """
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})
"""


__SCREAMING_SNAKE_CASE       :     Union[str, Any]     =  """
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
"""

class 	lowerCamelCase_	(unittest.TestCase    ):
      '''simple docstring'''

      def      _A	(       self						:				Any       ):
             _UpperCAmelCase     :  Optional[Any]							      =    find_backend("    _import_structure[\"models.albert\"].append(\"AlbertTokenizerFast\")"       )
             self.assertIsNone(A       )

             _UpperCAmelCase     :  int							      =    find_backend("    if not is_tokenizers_available():"       )
             self.assertEqual(A						,					"tokenizers"       )

             _UpperCAmelCase     :  Optional[int]							      =    find_backend("    if not is_tensorflow_text_available():"       )
             self.assertEqual(A						,					"tensorflow_text"       )

             _UpperCAmelCase     :  List[str]							      =    find_backend("    if not (is_sentencepiece_available() and is_tokenizers_available()):"       )
             self.assertEqual(A						,					"sentencepiece_and_tokenizers"       )

             _UpperCAmelCase     :  Any							      =    find_backend(
                 "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"       )
             self.assertEqual(A						,					"sentencepiece_and_tensorflow_text"       )

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




      def      _A	(       self						:				Any       ):
             _UpperCAmelCase     :  str							      =    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      _A	(       self						:				Dict       ):
             _UpperCAmelCase     :  List[str]							      =    create_dummy_object("CONSTANT"						,					"'torch'"       )
             self.assertEqual(A						,					"\nCONSTANT = None\n"       )

             _UpperCAmelCase     :  Union[str, Any]							      =    create_dummy_object("function"						,					"'torch'"       )
             self.assertEqual(
                 A						,					"\ndef function(*args, **kwargs):\n    requires_backends(function, 'torch')\n"       )

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





      def      _A	(       self						:				Optional[Any]       ):
             _UpperCAmelCase     :  Dict							      =    "# 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"
             _UpperCAmelCase     :  Tuple							      =    create_dummy_files({"torch": ["CONSTANT", "function", "FakeClass"]}       )
             self.assertEqual(dummy_files["torch"]						,					A       )








def 		lowerCAmelCase_    (  __UpperCAmelCase:			int      )      ->	bool:
    return str(__UpperCAmelCase      ) == str(__UpperCAmelCase      )[::-1]




def 		lowerCAmelCase_    (  __UpperCAmelCase:			int      )      ->	int:
    return int(__UpperCAmelCase      ) + int(str(__UpperCAmelCase      )[::-1]      )




def 		lowerCAmelCase_    (  __UpperCAmelCase:			int = 1_0000      )      ->	int:
    UpperCamelCase__							:				Optional[Any]          =      []
    for num in range(1		,   __UpperCAmelCase      ):
        UpperCamelCase__							:				str          =      0
        UpperCamelCase__							:				Any          =      num
        while iterations < 50:
            UpperCamelCase__							:				List[Any]          =      sum_reverse(__UpperCAmelCase      )
            iterations += 1
            if is_palindrome(__UpperCAmelCase      ):
                break
        else:
            lychrel_nums.append(__UpperCAmelCase      )
    return len(__UpperCAmelCase      )


if __name__ == "__main__":
  print(F'''{solution() = }''')

