





'''simple docstring'''




from __future__ import annotations

from collections.abc import Iterator
from typing import Any
class 			_lowerCAmelCase		:






     """simple docstring"""






     def __init__(   self							:			int   ,       __snake_case							:			Any						)->	Optional[Any]:
        snake_case 						=   data
        snake_case 						=   None




class 			_lowerCAmelCase		:






     """simple docstring"""






     def __init__(   self							:			Any						)->	Union[str, Any]:
        snake_case 						=   None
        snake_case 						=   None



     def __iter__(   self							:			int						)->	Iterator[Any]:
        snake_case 						=   self.head
        while self.head:
           yield node.data
           snake_case 						=   node.next
           if node == self.head:
              break



     def __len__(   self							:			str						)->	int:
        return sum(1 for _ in self						)



     def __repr__(   self							:			Dict						)->	Any:
        return "->".join(str(__snake_case						) for item in iter(self						)						)



     def      lowerCAmelCase			(   self							:			List[Any]   ,       __snake_case							:			Any						)->	None:
        self.insert_nth(len(self						)   ,       __snake_case						)



     def      lowerCAmelCase			(   self							:			List[Any]   ,       __snake_case							:			Any						)->	None:
        self.insert_nth(0   ,       __snake_case						)



     def      lowerCAmelCase			(   self							:			Union[str, Any]   ,       __snake_case							:			int   ,       __snake_case							:			Any						)->	None:
        if index < 0 or index > len(self						):
           raise IndexError("""list index out of range."""						)
        snake_case 						=   Node(__snake_case						)
        if self.head is None:
           snake_case 						=   new_node  # first node points itself
           snake_case 						=   snake_case 						=   new_node
        elif index == 0:  # insert at head
           snake_case 						=   self.head
           snake_case 						=   snake_case 						=   new_node
        else:
           snake_case 						=   self.head
           for _ in range(index - 1						):
              snake_case 						=   temp.next
           snake_case 						=   temp.next
           snake_case 						=   new_node
           if index == len(self						) - 1:  # insert at tail
              snake_case 						=   new_node



     def      lowerCAmelCase			(   self							:			str						)->	int:
        return self.delete_nth(0						)



     def      lowerCAmelCase			(   self							:			Any						)->	Any:
        return self.delete_nth(len(self						) - 1						)



     def      lowerCAmelCase			(   self							:			int   ,       __snake_case							:			int = 0						)->	Any:
        if not 0 <= index < len(self						):
           raise IndexError("""list index out of range."""						)
        snake_case 						=   self.head
        if self.head == self.tail:  # just one node
           snake_case 						=   snake_case 						=   None
        elif index == 0:  # delete head node
           snake_case 						=   self.tail.next.next
           snake_case 						=   self.head.next
        else:
           snake_case 						=   self.head
           for _ in range(index - 1						):
              snake_case 						=   temp.next
           snake_case 						=   temp.next
           snake_case 						=   temp.next.next
           if index == len(self						) - 1:  # delete at tail
              snake_case 						=   temp
        return delete_node.data



     def      lowerCAmelCase			(   self							:			Optional[Any]						)->	bool:
        return len(self						) == 0





def 	__lowerCamelCase			(      )		->  None:
   snake_case 						=   CircularLinkedList()
   assert len(__lowerCAmelCase		) == 0
   assert circular_linked_list.is_empty() is True
   assert str(__lowerCAmelCase		) == ""

   try:
      circular_linked_list.delete_front()
      raise AssertionError  # This should not happen
   except IndexError:
      assert True  # This should happen

   try:
      circular_linked_list.delete_tail()
      raise AssertionError  # This should not happen
   except IndexError:
      assert True  # This should happen

   try:
      circular_linked_list.delete_nth(-1		)
      raise AssertionError
   except IndexError:
      assert True

   try:
      circular_linked_list.delete_nth(0		)
      raise AssertionError
   except IndexError:
      assert True

   assert circular_linked_list.is_empty() is True
   for i in range(5		):
      assert len(__lowerCAmelCase		) == i
      circular_linked_list.insert_nth(__lowerCAmelCase      ,    i + 1		)
   assert str(__lowerCAmelCase		) == "->".join(str(__lowerCAmelCase		) for i in range(1      ,    6		)		)

   circular_linked_list.insert_tail(6		)
   assert str(__lowerCAmelCase		) == "->".join(str(__lowerCAmelCase		) for i in range(1      ,    7		)		)
   circular_linked_list.insert_head(0		)
   assert str(__lowerCAmelCase		) == "->".join(str(__lowerCAmelCase		) for i in range(0      ,    7		)		)

   assert circular_linked_list.delete_front() == 0
   assert circular_linked_list.delete_tail() == 6
   assert str(__lowerCAmelCase		) == "->".join(str(__lowerCAmelCase		) for i in range(1      ,    6		)		)
   assert circular_linked_list.delete_nth(2		) == 3

   circular_linked_list.insert_nth(2      ,    3		)
   assert str(__lowerCAmelCase		) == "->".join(str(__lowerCAmelCase		) for i in range(1      ,    6		)		)

   assert circular_linked_list.is_empty() is False


if __name__ == "__main__":
 import doctest

 doctest.testmod()








'''simple docstring'''




import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_SCREAMING_SNAKE_CASE							     =			get_tests_dir("fixtures/test_sentencepiece.model")
@require_sentencepiece
@require_tokenizers
class 			_lowerCAmelCase		(			A__							,     unittest.TestCase	):






     """simple docstring"""






     snake_case_						      =   XLNetTokenizer
     snake_case_						      =   XLNetTokenizerFast
     snake_case_						      =   True
     snake_case_						      =   True



     def      lowerCAmelCase			(   self							:			List[Any]						)->	Union[str, Any]:
        super().setUp()

        # We have a SentencePiece fixture for testing
        snake_case 						=   XLNetTokenizer(__snake_case   ,       keep_accents=__snake_case						)
        tokenizer.sanitize_special_tokens()
        tokenizer.save_pretrained(self.tmpdirname						)



     def      lowerCAmelCase			(   self							:			List[Any]						)->	str:
        snake_case 						=   """<s>"""
        snake_case 						=   1

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



     def      lowerCAmelCase			(   self							:			Tuple						)->	str:
        snake_case 						=   list(self.get_tokenizer().get_vocab().keys()						)

        self.assertEqual(vocab_keys[0]   ,       """<unk>"""						)
        self.assertEqual(vocab_keys[1]   ,       """<s>"""						)
        self.assertEqual(vocab_keys[-1]   ,       """<eod>"""						)
        self.assertEqual(len(__snake_case						)   ,       10_06						)



     def      lowerCAmelCase			(   self							:			Optional[Any]						)->	Tuple:
        self.assertEqual(self.get_tokenizer().vocab_size   ,       10_00						)



     def      lowerCAmelCase			(   self							:			List[str]						)->	int:
        snake_case 						=   XLNetTokenizer(__snake_case   ,       keep_accents=__snake_case						)

        snake_case 						=   tokenizer.tokenize("""This is a test"""						)
        self.assertListEqual(__snake_case   ,       ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]						)

        self.assertListEqual(tokenizer.convert_tokens_to_ids(__snake_case						)   ,       [2_85, 46, 10, 1_70, 3_82]						)

        snake_case 						=   tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
        self.assertListEqual(
            __snake_case   ,       [
                SPIECE_UNDERLINE + """I""",
                SPIECE_UNDERLINE + """was""",
                SPIECE_UNDERLINE + """b""",
                """or""",
                """n""",
                SPIECE_UNDERLINE + """in""",
                SPIECE_UNDERLINE + """""",
                """9""",
                """2""",
                """0""",
                """0""",
                """0""",
                """,""",
                SPIECE_UNDERLINE + """and""",
                SPIECE_UNDERLINE + """this""",
                SPIECE_UNDERLINE + """is""",
                SPIECE_UNDERLINE + """f""",
                """al""",
                """s""",
                """é""",
                """.""",
            ]   ,       )
        snake_case 						=   tokenizer.convert_tokens_to_ids(__snake_case						)
        self.assertListEqual(__snake_case   ,       [8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]						)

        snake_case 						=   tokenizer.convert_ids_to_tokens(__snake_case						)
        self.assertListEqual(
            __snake_case   ,       [
                SPIECE_UNDERLINE + """I""",
                SPIECE_UNDERLINE + """was""",
                SPIECE_UNDERLINE + """b""",
                """or""",
                """n""",
                SPIECE_UNDERLINE + """in""",
                SPIECE_UNDERLINE + """""",
                """<unk>""",
                """2""",
                """0""",
                """0""",
                """0""",
                """,""",
                SPIECE_UNDERLINE + """and""",
                SPIECE_UNDERLINE + """this""",
                SPIECE_UNDERLINE + """is""",
                SPIECE_UNDERLINE + """f""",
                """al""",
                """s""",
                """<unk>""",
                """.""",
            ]   ,       )



     def      lowerCAmelCase			(   self							:			str						)->	str:
        snake_case 						=   XLNetTokenizer(__snake_case   ,       do_lower_case=__snake_case						)
        snake_case 						=   tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
        self.assertListEqual(
            __snake_case   ,       [
                SPIECE_UNDERLINE + """""",
                """i""",
                SPIECE_UNDERLINE + """was""",
                SPIECE_UNDERLINE + """b""",
                """or""",
                """n""",
                SPIECE_UNDERLINE + """in""",
                SPIECE_UNDERLINE + """""",
                """9""",
                """2""",
                """0""",
                """0""",
                """0""",
                """,""",
                SPIECE_UNDERLINE + """and""",
                SPIECE_UNDERLINE + """this""",
                SPIECE_UNDERLINE + """is""",
                SPIECE_UNDERLINE + """f""",
                """al""",
                """se""",
                """.""",
            ]   ,       )
        self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""						)   ,       ["""▁he""", """ll""", """o"""]						)



     def      lowerCAmelCase			(   self							:			List[str]						)->	str:
        snake_case 						=   XLNetTokenizer(__snake_case   ,       do_lower_case=__snake_case						)
        snake_case 						=   tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
        self.assertListEqual(
            __snake_case   ,       [
                SPIECE_UNDERLINE + """I""",
                SPIECE_UNDERLINE + """was""",
                SPIECE_UNDERLINE + """b""",
                """or""",
                """n""",
                SPIECE_UNDERLINE + """in""",
                SPIECE_UNDERLINE + """""",
                """9""",
                """2""",
                """0""",
                """0""",
                """0""",
                """,""",
                SPIECE_UNDERLINE + """and""",
                SPIECE_UNDERLINE + """this""",
                SPIECE_UNDERLINE + """is""",
                SPIECE_UNDERLINE + """f""",
                """al""",
                """se""",
                """.""",
            ]   ,       )



     @slow
     def      lowerCAmelCase			(   self							:			Optional[Any]						)->	Dict:
        snake_case 						=   XLNetTokenizer.from_pretrained("""xlnet-base-cased"""						)

        snake_case 						=   tokenizer.encode("""sequence builders"""   ,       add_special_tokens=__snake_case						)
        snake_case 						=   tokenizer.encode("""multi-sequence build"""   ,       add_special_tokens=__snake_case						)

        snake_case 						=   tokenizer.build_inputs_with_special_tokens(__snake_case						)
        snake_case 						=   tokenizer.build_inputs_with_special_tokens(__snake_case   ,       __snake_case						)

        assert encoded_sentence == text + [4, 3]
        assert encoded_pair == text + [4] + text_a + [4, 3]



     @slow
     def      lowerCAmelCase			(   self							:			Optional[int]						)->	Union[str, Any]:
        # fmt: off
        snake_case 						=   {"""input_ids""": [[17, 2_14_42, 2_70, 17, 10, 1_46_45, 3_18, 34, 17, 45_46, 31_45, 7_87, 13, 77_52, 2_20_18, 23, 21, 17, 45_46, 31_45, 7_87, 13, 33_52, 1_44_31, 13, 55_00, 11, 11_76, 5_80, 13, 1_68_19, 47_97, 23, 17, 10, 1_71_35, 6_58, 19, 4_57, 79_32, 13, 1_84, 19, 31_54, 1_71_35, 64_68, 19, 14_04, 1_22_69, 19, 42_29, 53_56, 1_62_64, 46, 19, 17, 2_05_45, 1_03_95, 9, 9, 9, 11, 28, 64_21, 95_31, 2_07_29, 17, 10, 3_53, 1_70_22, 11, 21, 64_21, 95_31, 1_69_49, 17, 10, 1_15_09, 7_53, 11, 33, 95, 24_21, 73_85, 9_56, 1_44_31, 26_26, 25, 8_42, 73_85, 48_36, 21, 14_29, 22_72, 98_55, 31_20, 1_61, 2_47_38, 19, 1_32_03, 6_58, 2_18, 7_87, 21, 4_30, 1_84_82, 8_47, 26_37, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_22, 2_21_78, 27, 10_64, 22, 9_56, 13, 1_11_01, 14_29, 58_54, 2_43_13, 1_89_53, 40, 4_22, 2_43_66, 68, 17_58, 37, 1_04_83, 1_42_57, 31, 2_07, 2_63, 21, 2_03, 37_73, 25, 71, 97_35, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 20_49, 34_42, 17, 1_38_94, 33_80, 23, 95, 18, 1_76_34, 22_88, 9, 4, 3]], """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, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 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, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], """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, 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, 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, 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, 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, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
        # fmt: on

        self.tokenizer_integration_test_util(
            expected_encoding=__snake_case   ,       model_name="""xlnet-base-cased"""   ,       revision="""c841166438c31ec7ca9a106dee7bb312b73ae511"""   ,       )

