


"""simple docstring"""







import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class 				SCREAMING_SNAKE_CASE__    (		lowercase       ,   unittest.TestCase    ):
       """simple docstring"""


       a  :    Union[str, Any]       =CLIPTokenizer
       a  :    List[Any]       =CLIPTokenizerFast
       a  :    Any       =True
       a  :    Any       ={}
       a  :    List[str]       =False

       def 	lowercase__							(						self						):






         """simple docstring"""





         super().setUp()

         # fmt: off
         lowerCAmelCase					:					str								=							["l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
         # fmt: on
         lowerCAmelCase					:					List[Any]								=							dict(zip(snake_case__		,					range(len(snake_case__						)						)						)						)
         lowerCAmelCase					:					Dict								=							["#version: 0.2", "l o", "lo w</w>", "e r</w>"]
         lowerCAmelCase					:					List[Any]								=							{"unk_token": "<unk>"}

         lowerCAmelCase					:					int								=							os.path.join(self.tmpdirname		,					VOCAB_FILES_NAMES["vocab_file"]						)
         lowerCAmelCase					:					Any								=							os.path.join(self.tmpdirname		,					VOCAB_FILES_NAMES["merges_file"]						)
         with open(self.vocab_file		,					"w"		,					encoding="utf-8"						) as fp:
           fp.write(json.dumps(snake_case__						) + "\n"						)
         with open(self.merges_file		,					"w"		,					encoding="utf-8"						) as fp:
           fp.write("\n".join(snake_case__						)						)

       def 	lowercase__							(						self		,					**snake_case__						):






         """simple docstring"""





         kwargs.update(self.special_tokens_map						)
         return CLIPTokenizer.from_pretrained(self.tmpdirname		,					**snake_case__						)

       def 	lowercase__							(						self		,					**snake_case__						):






         """simple docstring"""





         kwargs.update(self.special_tokens_map						)
         return CLIPTokenizerFast.from_pretrained(self.tmpdirname		,					**snake_case__						)

       def 	lowercase__							(						self		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							"lower newer"
         lowerCAmelCase					:					str								=							"lower newer"
         return input_text, output_text

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							CLIPTokenizer(self.vocab_file		,					self.merges_file		,					**self.special_tokens_map						)
         lowerCAmelCase					:					int								=							"lower newer"
         lowerCAmelCase					:					Optional[Any]								=							["lo", "w", "er</w>", "n", "e", "w", "er</w>"]
         lowerCAmelCase					:					str								=							tokenizer.tokenize(snake_case__						)
         self.assertListEqual(snake_case__		,					snake_case__						)

         lowerCAmelCase					:					Optional[int]								=							tokens + [tokenizer.unk_token]
         lowerCAmelCase					:					int								=							[10, 2, 16, 9, 3, 2, 16, 20]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__						)		,					snake_case__						)

       @require_ftfy
       def 	lowercase__							(						self						):






         """simple docstring"""





         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""						):
             lowerCAmelCase					:					str								=							self.tokenizer_class.from_pretrained(snake_case__		,					**snake_case__						)
             lowerCAmelCase					:					int								=							self.rust_tokenizer_class.from_pretrained(snake_case__		,					**snake_case__						)

             lowerCAmelCase					:					Tuple								=							"A\n'll 11p223RF☆ho!!to?'d'd''d of a cat to-$''d."
             lowerCAmelCase					:					Dict								=							tokenizer_s.tokenize(snake_case__						)
             lowerCAmelCase					:					Union[str, Any]								=							tokenizer_r.tokenize(snake_case__						)

             self.assertListEqual(snake_case__		,					snake_case__						)

             # Test that the tokenization is identical on an example containing a character (Latin Small Letter A
             # with Tilde) encoded in 2 different ways
             lowerCAmelCase					:					int								=							"xa\u0303y" + " " + "x\xe3y"
             lowerCAmelCase					:					Optional[Any]								=							tokenizer_s.tokenize(snake_case__						)
             lowerCAmelCase					:					int								=							tokenizer_r.tokenize(snake_case__						)

             self.assertListEqual(snake_case__		,					snake_case__						)

             # Test that the tokenization is identical on unicode of space type
             lowerCAmelCase					:					int								=							[
                 "\u0009",  # (horizontal tab, '\t')
                 "\u000B",  # (vertical tab)
                 "\u000C",  # (form feed)
                 "\u0020",  # (space, ' ')
                 "\u200E",  # (left-to-right mark):w
                 "\u200F",  # (right-to-left mark)
             ]
             for unicode_seq in spaces_unicodes:
               lowerCAmelCase					:					int								=							tokenizer_s.tokenize(snake_case__						)
               lowerCAmelCase					:					List[Any]								=							tokenizer_r.tokenize(snake_case__						)

               self.assertListEqual(snake_case__		,					snake_case__						)

             # Test that the tokenization is identical on unicode of line break type
             lowerCAmelCase					:					Union[str, Any]								=							[
                 "\u000A",  # (line feed, '\n')
                 "\r\n",  # (carriage return and line feed, '\r\n')
                 "\u000D",  # (carriage return, '\r')
                 "\r",  # (carriage return, '\r')
                 "\u000D",  # (carriage return, '\r')
                 "\u2028",  # (line separator)
                 "\u2029",  # (paragraph separator)
                 # "\u0085", # (next line)
             ]

             # The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
             # it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
             # space (and thus into an empty list).

             for unicode_seq in line_break_unicodes:
               lowerCAmelCase					:					int								=							tokenizer_s.tokenize(snake_case__						)
               lowerCAmelCase					:					Optional[int]								=							tokenizer_r.tokenize(snake_case__						)

               self.assertListEqual(snake_case__		,					snake_case__						)

       def 	lowercase__							(						self						):






         """simple docstring"""





         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""						):
             lowerCAmelCase					:					Tuple								=							"hello"  # `hello` is a token in the vocabulary of `pretrained_name`
             lowerCAmelCase					:					str								=							f"""{text_of_1_token} {text_of_1_token}"""

             lowerCAmelCase					:					str								=							self.rust_tokenizer_class.from_pretrained(
                 snake_case__		,					use_fast=snake_case__		,					)
             lowerCAmelCase					:					Dict								=							tokenizer_r(snake_case__		,					return_offsets_mapping=snake_case__		,					add_special_tokens=snake_case__						)
             self.assertEqual(encoding.offset_mapping[0]		,					(0, len(snake_case__						))						)
             self.assertEqual(
                 encoding.offset_mapping[1]		,					(len(snake_case__						) + 1, len(snake_case__						) + 1 + len(snake_case__						))		,					)

             lowerCAmelCase					:					Dict								=							f""" {text}"""

             lowerCAmelCase					:					Any								=							self.rust_tokenizer_class.from_pretrained(
                 snake_case__		,					use_fast=snake_case__		,					)
             lowerCAmelCase					:					List[str]								=							tokenizer_r(snake_case__		,					return_offsets_mapping=snake_case__		,					add_special_tokens=snake_case__						)
             self.assertEqual(encoding.offset_mapping[0]		,					(1, 1 + len(snake_case__						))						)
             self.assertEqual(
                 encoding.offset_mapping[1]		,					(1 + len(snake_case__						) + 1, 1 + len(snake_case__						) + 1 + len(snake_case__						))		,					)

       def 	lowercase__							(						self						):






         """simple docstring"""





         with self.assertRaises(snake_case__						) as context:
           self.rust_tokenizer_class.from_pretrained("robot-test/old-clip-tokenizer"						)

         self.assertTrue(
             context.exception.args[0].startswith(
                 "The `backend_tokenizer` provided does not match the expected format."						)						)

       @require_ftfy
       def 	lowercase__							(						self						):






         """simple docstring"""





         super().test_tokenization_python_rust_equals()







       def 	lowercase__							(						self						):






         """simple docstring"""





         pass









"""simple docstring"""







from typing import Any


class 				SCREAMING_SNAKE_CASE__    :
       """simple docstring"""


       def __init__(						self		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							data
         lowerCAmelCase					:					Tuple								=							None


class 				SCREAMING_SNAKE_CASE__    :
       """simple docstring"""


       def __init__(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[int]								=							None

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							self.head
         while temp is not None:
           print(temp.data		,					end=" "						)
           lowerCAmelCase					:					List[str]								=							temp.next
         print()

       def 	lowercase__							(						self		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							Node(snake_case__						)
         lowerCAmelCase					:					Union[str, Any]								=							self.head
         lowerCAmelCase					:					Optional[Any]								=							new_node







       def 	lowercase__							(						self		,					snake_case__		,					snake_case__						):






         """simple docstring"""





         if node_data_a == node_data_a:
           return
         else:
           lowerCAmelCase					:					str								=							self.head
           while node_a is not None and node_a.data != node_data_a:
             lowerCAmelCase					:					Union[str, Any]								=							node_a.next

           lowerCAmelCase					:					Any								=							self.head
           while node_a is not None and node_a.data != node_data_a:
             lowerCAmelCase					:					List[Any]								=							node_a.next

           if node_a is None or node_a is None:
             return

           lowerCAmelCase						,  lowerCAmelCase					:					str								=							node_a.data, node_a.data


if __name__ == "__main__":
     lowerCAmelCase__				    =       LinkedList()
     for i in range(5, 0, -1):
          ll.push(i)

     ll.print_list()

     ll.swap_nodes(1, 4)
     print('''After swapping''')
     ll.print_list()





