






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 				lowerCAmelCase_	(		SCREAMING_SNAKE_CASE__   ,		unittest.TestCase			):
				_UpperCamelCase					:       int							       = CLIPTokenizer
				_UpperCamelCase					:       List[str]							       = CLIPTokenizerFast
				_UpperCamelCase					:       Dict							       = True
				_UpperCamelCase					:       Optional[int]							       = {}
				_UpperCamelCase					:       str							       = False


				def 						__a					(					self      ):
											super().setUp()

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

											_lowercase							:   List[Any] 							=   os.path.join(self.tmpdirname ,						VOCAB_FILES_NAMES['vocab_file']      )
											_lowercase							:   Optional[int] 							=   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 ,						**_lowerCAmelCase      ):
											kwargs.update(self.special_tokens_map      )
											return CLIPTokenizer.from_pretrained(self.tmpdirname ,						**snake_case__      )


				def 						__a					(					self ,						**_lowerCAmelCase      ):
											kwargs.update(self.special_tokens_map      )
											return CLIPTokenizerFast.from_pretrained(self.tmpdirname ,						**snake_case__      )


				def 						__a					(					self ,						_lowerCAmelCase      ):
											_lowercase							:   List[str] 							=   'lower newer'
											_lowercase							:   List[Any] 							=   'lower newer'
											return input_text, output_text


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

											_lowercase							:   int 							=   tokens + [tokenizer.unk_token]
											_lowercase							:   Any 							=   [1_0, 2, 1_6, 9, 3, 2, 1_6, 2_0]
											self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__      ) ,						snake_case__      )


				@require_ftfy
				def 						__a					(					self      ):

											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																		with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""      ):
																									_lowercase							:   Any 							=   self.tokenizer_class.from_pretrained(snake_case__ ,						**snake_case__      )
																									_lowercase							:   List[Any] 							=   self.rust_tokenizer_class.from_pretrained(snake_case__ ,						**snake_case__      )

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

																									self.assertListEqual(snake_case__ ,						snake_case__      )

																									# Test that the tokenization is identical on unicode of space type
																									_lowercase							:   Any 							=   [
																									    '\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:
																																_lowercase							:   Any 							=   tokenizer_s.tokenize(snake_case__      )
																																_lowercase							:   Optional[Any] 							=   tokenizer_r.tokenize(snake_case__      )

																																self.assertListEqual(snake_case__ ,						snake_case__      )

																									# Test that the tokenization is identical on unicode of line break type
																									_lowercase							:   Optional[int] 							=   [
																									    '\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:
																																_lowercase							:   Dict 							=   tokenizer_s.tokenize(snake_case__      )
																																_lowercase							:   Any 							=   tokenizer_r.tokenize(snake_case__      )

																																self.assertListEqual(snake_case__ ,						snake_case__      )


				def 						__a					(					self      ):

											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																		with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""      ):
																									_lowercase							:   str 							=   'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
																									_lowercase							:   Optional[Any] 							=   F"""{text_of_1_token} {text_of_1_token}"""

																									_lowercase							:   str 							=   self.rust_tokenizer_class.from_pretrained(
																									    snake_case__ ,						use_fast=snake_case__ ,						)
																									_lowercase							:   List[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__      )) ,						)

																									_lowercase							:   List[str] 							=   F""" {text}"""

																									_lowercase							:   str 							=   self.rust_tokenizer_class.from_pretrained(
																									    snake_case__ ,						use_fast=snake_case__ ,						)
																									_lowercase							:   Any 							=   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      ):

											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      ):
											super().test_tokenization_python_rust_equals()


				def 						__a					(					self      ):
											pass










def 					_a							(					lowerCAmelCase    ,						lowerCAmelCase )->	List[str]:
		SCREAMING_SNAKE_CASE_					      =							[1]
		for i in range(2    ,						lowerCAmelCase ):
				factorials.append(factorials[-1] * i )
		assert 0 <= k < factorials[-1] * n, "k out of bounds"

		SCREAMING_SNAKE_CASE_					      =							[]
		SCREAMING_SNAKE_CASE_					      =							list(range(lowerCAmelCase ) )

		# Find permutation
		while factorials:
				SCREAMING_SNAKE_CASE_					      =							factorials.pop()
				SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							divmod(lowerCAmelCase    ,						lowerCAmelCase )
				permutation.append(elements[number] )
				elements.remove(elements[number] )
		permutation.append(elements[0] )

		return permutation


if __name__ == "__main__":
						import doctest

						doctest.testmod()