'''simple docstring'''

import os
import sys
import unittest


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

__a:			List[Any]	       =       """
{0} = None
"""

__a:			Optional[Any]	       =       """
class {0}(metaclass=DummyObject):
    _backends = {1}

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


__a:			int	       =       """
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
"""



class       UpperCAmelCase  (						unittest.TestCase ):





       '''simple docstring'''



       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   int						= find_backend('''    _import_structure["models.albert"].append("AlbertTokenizerFast")'''			)
        self.assertIsNone(__lowerCAmelCase			)

        lowercase__    :   List[str]						= find_backend('''    if not is_tokenizers_available():'''			)
        self.assertEqual(__lowerCAmelCase     ,       '''tokenizers'''			)

        lowercase__    :   Optional[Any]						= find_backend('''    if not is_tensorflow_text_available():'''			)
        self.assertEqual(__lowerCAmelCase     ,       '''tensorflow_text'''			)

        lowercase__    :   Tuple						= find_backend('''    if not (is_sentencepiece_available() and is_tokenizers_available()):'''			)
        self.assertEqual(__lowerCAmelCase     ,       '''sentencepiece_and_tokenizers'''			)

        lowercase__    :   Optional[Any]						= find_backend(
            '''    if not (is_sentencepiece_available() and is_tensorflow_text_available()):'''			)
        self.assertEqual(__lowerCAmelCase     ,       '''sentencepiece_and_tensorflow_text'''			)

        lowercase__    :   Optional[int]						= find_backend(
            '''    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):'''			)
        self.assertEqual(__lowerCAmelCase     ,       '''sentencepiece_and_tokenizers_and_vision'''			)

       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   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 _lowerCAmelCase(						self			)  ->  int:
        lowercase__    :   Dict						= create_dummy_object('''CONSTANT'''     ,       '''\'torch\''''			)
        self.assertEqual(__lowerCAmelCase     ,       '''\nCONSTANT = None\n'''			)

        lowercase__    :   Any						= create_dummy_object('''function'''     ,       '''\'torch\''''			)
        self.assertEqual(
            __lowerCAmelCase     ,       '''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n'''			)

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

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')
'''
        lowercase__    :   List[str]						= create_dummy_object('''FakeClass'''     ,       '''\'torch\''''			)
        self.assertEqual(__lowerCAmelCase     ,       __lowerCAmelCase			)


       def _lowerCAmelCase(						self			)  ->  Union[str, Any]:
        lowercase__    :   Tuple						= '''# 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"])
'''
        lowercase__    :   Tuple						= create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}			)
        self.assertEqual(dummy_files['''torch''']     ,       __lowerCAmelCase			)





'''simple docstring'''

def       __UpperCamelCase	(       UpperCAmelCase					):
 if not all(x.isalpha() for x in string					):
  raise ValueError('''String must only contain alphabetic characters.'''					)

 lowercase__    :   Tuple						= sorted(string.lower()					)
 return len(UpperCAmelCase					) == len(set(UpperCAmelCase					)					)


if __name__ == "__main__":
  __a:			Union[str, Any]	       =       input("""Enter a string """).strip()

  __a:			Tuple	       =       is_isogram(input_str)
  print(F'{input_str} is {"an" if isogram else "not an"} isogram.')

