



'''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(							A__							,		unittest.TestCase			):







	"""simple docstring"""






	lowerCamelCase__			 =       CLIPTokenizer
	lowerCamelCase__			 =       CLIPTokenizerFast
	lowerCamelCase__			 =       True
	lowerCamelCase__			 =       {}
	lowerCamelCase__			 =       False







	def      A	(						self			:     Any		)			->		Optional[int]:
								super().setUp()

								# fmt: off
								UpperCAmelCase :       int 							=		['''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
								UpperCAmelCase :       Dict 							=		dict(zip(__snake_case		,			range(len(__snake_case		)		)		)		)
								UpperCAmelCase :       Any 							=		['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''']
								UpperCAmelCase :       Dict 							=		{'''unk_token''': '''<unk>'''}

								UpperCAmelCase :       Dict 							=		os.path.join(self.tmpdirname		,			VOCAB_FILES_NAMES['''vocab_file''']		)
								UpperCAmelCase :       str 							=		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      A	(						self			:     Optional[int]		,			**__snake_case			:     Optional[int]		)			->		Optional[int]:
								kwargs.update(self.special_tokens_map		)
								return CLIPTokenizer.from_pretrained(self.tmpdirname		,			**__snake_case		)







	def      A	(						self			:     List[Any]		,			**__snake_case			:     Any		)			->		List[Any]:
								kwargs.update(self.special_tokens_map		)
								return CLIPTokenizerFast.from_pretrained(self.tmpdirname		,			**__snake_case		)







	def      A	(						self			:     List[str]		,			__snake_case			:     Tuple		)			->		int:
								UpperCAmelCase :       Optional[Any] 							=		'''lower newer'''
								UpperCAmelCase :       List[Any] 							=		'''lower newer'''
								return input_text, output_text







	def      A	(						self			:     Dict		)			->		List[Any]:
								UpperCAmelCase :       str 							=		CLIPTokenizer(self.vocab_file		,			self.merges_file		,			**self.special_tokens_map		)
								UpperCAmelCase :       Dict 							=		'''lower newer'''
								UpperCAmelCase :       List[str] 							=		['''lo''', '''w''', '''er</w>''', '''n''', '''e''', '''w''', '''er</w>''']
								UpperCAmelCase :       List[Any] 							=		tokenizer.tokenize(__snake_case		)
								self.assertListEqual(__snake_case		,			__snake_case		)

								UpperCAmelCase :       Union[str, Any] 							=		tokens + [tokenizer.unk_token]
								UpperCAmelCase :       Dict 							=		[10, 2, 16, 9, 3, 2, 16, 20]
								self.assertListEqual(tokenizer.convert_tokens_to_ids(__snake_case		)		,			__snake_case		)







	@require_ftfy
	def      A	(						self			:     str		)			->		str:
								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
															with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""		):
																						UpperCAmelCase :       Any 							=		self.tokenizer_class.from_pretrained(__snake_case		,			**__snake_case		)
																						UpperCAmelCase :       List[str] 							=		self.rust_tokenizer_class.from_pretrained(__snake_case		,			**__snake_case		)

																						UpperCAmelCase :       Optional[int] 							=		'''A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'''
																						UpperCAmelCase :       List[str] 							=		tokenizer_s.tokenize(__snake_case		)
																						UpperCAmelCase :       int 							=		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
																						UpperCAmelCase :       str 							=		'''xa\u0303y''' + ''' ''' + '''x\xe3y'''
																						UpperCAmelCase :       int 							=		tokenizer_s.tokenize(__snake_case		)
																						UpperCAmelCase :       List[str] 							=		tokenizer_r.tokenize(__snake_case		)

																						self.assertListEqual(__snake_case		,			__snake_case		)

																						# Test that the tokenization is identical on unicode of space type
																						UpperCAmelCase :       Tuple 							=		[
																						    '''\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:
																													UpperCAmelCase :       Union[str, Any] 							=		tokenizer_s.tokenize(__snake_case		)
																													UpperCAmelCase :       Union[str, Any] 							=		tokenizer_r.tokenize(__snake_case		)

																													self.assertListEqual(__snake_case		,			__snake_case		)

																						# Test that the tokenization is identical on unicode of line break type
																						UpperCAmelCase :       Optional[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:
																													UpperCAmelCase :       str 							=		tokenizer_s.tokenize(__snake_case		)
																													UpperCAmelCase :       Tuple 							=		tokenizer_r.tokenize(__snake_case		)

																													self.assertListEqual(__snake_case		,			__snake_case		)







	def      A	(						self			:     Tuple		)			->		Optional[int]:
								# Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
															with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""		):
																						UpperCAmelCase :       int 							=		'''hello'''  # `hello` is a token in the vocabulary of `pretrained_name`
																						UpperCAmelCase :       Dict 							=		F"""{text_of_1_token} {text_of_1_token}"""

																						UpperCAmelCase :       List[str] 							=		self.rust_tokenizer_class.from_pretrained(
																						    __snake_case		,			use_fast=__snake_case		,			)
																						UpperCAmelCase :       Optional[Any] 							=		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		))		,			)

																						UpperCAmelCase :       Optional[int] 							=		F""" {text}"""

																						UpperCAmelCase :       str 							=		self.rust_tokenizer_class.from_pretrained(
																						    __snake_case		,			use_fast=__snake_case		,			)
																						UpperCAmelCase :       Tuple 							=		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      A	(						self			:     str		)			->		str:
								# Test related to the breaking change introduced in transformers v4.17.0
								# We need to check that an error in raised when the user try to load a previous version of the tokenizer.
								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      A	(						self			:     str		)			->		Dict:
								super().test_tokenization_python_rust_equals()







	def      A	(						self			:     Optional[Any]		)			->		Optional[Any]:
								# CLIP always lower cases letters
								pass










'''simple docstring'''






from __future__ import annotations

import matplotlib.pyplot as plt  # type: ignore
import numpy

# initial triangle of Koch snowflake
UpperCamelCase__:   Tuple								=			numpy.array([0, 0])
UpperCamelCase__:   Union[str, Any]								=			numpy.array([0.5, 0.8660254])
UpperCamelCase__:   Dict								=			numpy.array([1, 0])
UpperCamelCase__:   int								=			[VECTOR_1, VECTOR_2, VECTOR_3, VECTOR_1]


def  snake_case_     (					_lowerCAmelCase  :						list[numpy.ndarray]   ,      _lowerCAmelCase  :						int  )      ->   list[numpy.ndarray]:
							UpperCAmelCase :       Union[str, Any] 							=		initial_vectors
							for _ in range(_lowerCAmelCase  ):
														UpperCAmelCase :       Union[str, Any] 							=		iteration_step(_lowerCAmelCase  )
							return vectors


def  snake_case_     (					_lowerCAmelCase  :						list[numpy.ndarray]  )      ->   list[numpy.ndarray]:
							UpperCAmelCase :       Tuple 							=		[]
							for i, start_vector in enumerate(vectors[:-1]  ):
														UpperCAmelCase :       List[str] 							=		vectors[i + 1]
														new_vectors.append(_lowerCAmelCase  )
														UpperCAmelCase :       Optional[Any] 							=		end_vector - start_vector
														new_vectors.append(start_vector + difference_vector / 3  )
														new_vectors.append(
														    start_vector + difference_vector / 3 + rotate(difference_vector / 3   ,      60  )  )
														new_vectors.append(start_vector + difference_vector * 2 / 3  )
							new_vectors.append(vectors[-1]  )
							return new_vectors


def  snake_case_     (					_lowerCAmelCase  :						numpy.ndarray   ,      _lowerCAmelCase  :						float  )      ->   numpy.ndarray:
							UpperCAmelCase :       List[str] 							=		numpy.radians(_lowerCAmelCase  )
							UpperCAmelCase							,		UpperCAmelCase :       Tuple 							=		numpy.cos(_lowerCAmelCase  ), numpy.sin(_lowerCAmelCase  )
							UpperCAmelCase :       Union[str, Any] 							=		numpy.array(((c, -s), (s, c))  )
							return numpy.dot(_lowerCAmelCase   ,      _lowerCAmelCase  )


def  snake_case_     (					_lowerCAmelCase  :						list[numpy.ndarray]  )      ->   None:
							UpperCAmelCase :       List[Any] 							=		plt.gca()
							axes.set_aspect('''equal'''  )

							# matplotlib.pyplot.plot takes a list of all x-coordinates and a list of all
							# y-coordinates as inputs, which are constructed from the vector-list using
							# zip()
							UpperCAmelCase							,		UpperCAmelCase :       str 							=		zip(*_lowerCAmelCase  )
							plt.plot(_lowerCAmelCase   ,      _lowerCAmelCase  )
							plt.show()


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						UpperCamelCase__:   List[Any]								=			iterate(INITIAL_VECTORS, 5)
						plot(processed_vectors)





