






import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


UpperCamelCase        =				get_tests_dir("fixtures/test_sentencepiece_with_bytefallback.model")

@require_sentencepiece
@require_tokenizers
class        lowerCAmelCase_				(      lowercase						,      unittest.TestCase	):







				"""simple docstring"""




				_snake_case				:   List[str]        =			GPTSwaTokenizer
				_snake_case				:   Dict        =			False
				_snake_case				:   str        =			True
				_snake_case				:   int        =			False







				def 				__a   ( self     :Union[str, Any]     ):
					super().setUp()

					# We have a SentencePiece fixture for testing
					UpperCamelCase__ :int						=      GPTSwaTokenizer(lowerCamelCase__  ,     eos_token="""<unk>"""  ,     bos_token="""<unk>"""  ,     pad_token="""<unk>"""     )

					tokenizer.save_pretrained(self.tmpdirname     )







				def 				__a   ( self     :Dict  ,     lowerCamelCase__     :Tuple     ):
					UpperCamelCase__ :List[Any]						=      """This is a test"""
					UpperCamelCase__ :Optional[Any]						=      """This is a test"""
					return input_text, output_text







				def 				__a   ( self     :Optional[Any]     ):
					UpperCamelCase__ :int						=      """<s>"""
					UpperCamelCase__ :Optional[int]						=      1

					self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__     )  ,     lowerCamelCase__     )
					self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__     )  ,     lowerCamelCase__     )







				def 				__a   ( self     :Union[str, Any]     ):
					UpperCamelCase__ :Tuple						=      list(self.get_tokenizer().get_vocab().keys()     )

					self.assertEqual(vocab_keys[0]  ,     """<unk>"""     )
					self.assertEqual(vocab_keys[1]  ,     """<s>"""     )
					self.assertEqual(vocab_keys[-1]  ,     """j"""     )
					self.assertEqual(len(lowerCamelCase__     )  ,     20_00     )







				def 				__a   ( self     :List[Any]     ):
					self.assertEqual(self.get_tokenizer().vocab_size  ,     20_00     )







				def 				__a   ( self     :Any     ):
					UpperCamelCase__ :Union[str, Any]						=      GPTSwaTokenizer(lowerCamelCase__     )

					UpperCamelCase__ :Optional[int]						=      tokenizer.tokenize("""This is a test"""     )
					self.assertListEqual(lowerCamelCase__  ,     ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]     )

					self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__     )  ,     [4_65, 2_87, 2_65, 6_31, 8_42]     )

					UpperCamelCase__ :Dict						=      tokenizer.tokenize("""I was born in 92000, and this is falsé."""     )
					# fmt: off
					self.assertListEqual(
					    lowerCamelCase__  ,     ["""▁I""", """▁was""", """▁bor""", """n""", """▁in""", """▁""", """<0x39>""", """2""", """0""", """0""", """0""", """,""", """▁and""", """▁this""", """▁is""", """▁f""", """al""", """s""", """<0xC3>""", """<0xA9>""", """."""]  ,     )
					# fmt: on

					UpperCamelCase__ :Tuple						=      tokenizer.convert_tokens_to_ids(lowerCamelCase__     )
					self.assertListEqual(
					    lowerCamelCase__  ,     [2_62, 2_72, 15_25, 2_86, 2_71, 2_68, 60, 9_16, 6_33, 6_33, 6_33, 2_59, 2_66, 3_01, 2_87, 3_84, 3_67, 2_63, 1_98, 1_72, 2_60]  ,     )

					UpperCamelCase__ :Optional[Any]						=      tokenizer.convert_ids_to_tokens(lowerCamelCase__     )
					# fmt: off
					self.assertListEqual(
					    lowerCamelCase__  ,     ["""▁I""", """▁was""", """▁bor""", """n""", """▁in""", """▁""", """<0x39>""", """2""", """0""", """0""", """0""", """,""", """▁and""", """▁this""", """▁is""", """▁f""", """al""", """s""", """<0xC3>""", """<0xA9>""", """."""]     )
					# fmt: on







				def 				__a   ( self     :Optional[Any]     ):
					UpperCamelCase__ :Dict						=      GPTSwaTokenizer(lowerCamelCase__     )
					UpperCamelCase__ :List[str]						=      ["""This is a test""", """I was born in 92000, and this is falsé."""]
					UpperCamelCase__ :Union[str, Any]						=      [
					    [4_65, 2_87, 2_65, 6_31, 8_42],
					    [2_62, 2_72, 15_25, 2_86, 2_71, 2_68, 60, 9_16, 6_33, 6_33, 6_33, 2_59, 2_66, 3_01, 2_87, 3_84, 3_67, 2_63, 1_98, 1_72, 2_60],
					]

					# Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
					for text, expected_ids in zip(lowerCamelCase__  ,     lowerCamelCase__     ):
						self.assertListEqual(tokenizer.encode_fast(lowerCamelCase__     )  ,     lowerCamelCase__     )

					# Test that decode_fast returns the input text
					for text, token_ids in zip(lowerCamelCase__  ,     lowerCamelCase__     ):
						self.assertEqual(tokenizer.decode_fast(lowerCamelCase__     )  ,     lowerCamelCase__     )







				@slow
				def 				__a   ( self     :Optional[int]     ):
					UpperCamelCase__ :Tuple						=      [
					    """<|python|>def fibonacci(n)\n    if n < 0:\n        print('Incorrect input')""",
					    """Hey there, how are you doing this fine day?""",
					    """This is a text with a trailing spaces followed by a dot     .""",
					    """Häj sväjs lillebrör! =)""",
					    """Det är inget fel på Mr. Cool""",
					]

					# fmt: off
					UpperCamelCase__ :str						=      {"""input_ids""": [[6_34_23, 5, 68_11, 1_49_54, 2_82, 8_16, 38_21, 6_34_66, 6_34_25, 6_34_62, 18, 6_39_78, 6_78, 3_01, 13_20, 6_34_23, 6_34_55, 6_34_58, 18, 6_39_82, 42_46, 39_40, 19_01, 4_77_89, 55_47, 1_89_94], [1_96_30, 11_00, 6_34_46, 13_42, 6_33, 5_44, 44_88, 5_93, 51_02, 24_16, 6_34_95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [16_52, 4_28, 2_68, 19_36, 5_15, 2_68, 5_85_93, 2_24_13, 91_06, 5_46, 2_68, 3_32_13, 6_39_79, 6_98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_51_30, 6_34_50, 9_24, 6_34_49, 22_49, 40_62, 15_58, 3_18, 6_35_04, 2_14_98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_09, 3_77, 28_27, 25_59, 3_32, 65_75, 6_34_43, 2_68_01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """token_type_ids""": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
					# fmt: on
					self.tokenizer_integration_test_util(
					    expected_encoding=lowerCamelCase__  ,     model_name="""AI-Sweden/gpt-sw3-126m"""  ,     sequences=lowerCamelCase__  ,     )





'''simple docstring'''


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

						__snake_case						 =   sorted(string.lower()							)
						return len(a							) == len(set(a							)							)


if __name__ == "__main__":
	_lowercase  =			input("""Enter a string """).strip()

	_lowercase  =			is_isogram(input_str)
	print(f'''{input_str} is {'an' if isogram else 'not an'} isogram.''')

