






'''simple docstring'''





from __future__ import annotations

from typing import Any


class       snake_case__	:




					def __init__(   self   :						List[str]							,      _A   :						Any							,      _A   :						Dict							,      _A   :						Any = 0	)  ->				Optional[int]:
								UpperCAmelCase_  ,	UpperCAmelCase_	:    Optional[int]	  =    row, column
								UpperCAmelCase_	:    Optional[int]	  =    [[default_value for c in range(lowerCAmelCase__	)] for r in range(lowerCAmelCase__	)]




					def __str__(   self   :						int	)  ->				Optional[int]:
								UpperCAmelCase_	:    Optional[int]	  =    F"Matrix consist of {self.row} rows and {self.column} columns\n"

								# Make string identifier
								UpperCAmelCase_	:    Dict	  =    0
								for row_vector in self.array:
											for obj in row_vector:
														UpperCAmelCase_	:    Dict	  =    max(lowerCAmelCase__							,      len(str(lowerCAmelCase__	)	)	)
								UpperCAmelCase_	:    List[str]	  =    F"%{max_element_length}s"

								# Make string and return
								def single_line(_A   :						Tuple	) -> str:
											nonlocal string_format_identifier
											UpperCAmelCase_	:    Tuple	  =    '''['''
											line += ", ".join(string_format_identifier % (obj,) for obj in row_vector	)
											line += "]"
											return line

								s += "\n".join(single_line(lowerCAmelCase__	) for row_vector in self.array	)
								return s




					def __repr__(   self   :						str	)  ->				Dict:
								return str(self	)




					def 						A	(   self   :						str							,      _A   :						Dict	)  ->				List[Any]:
								if not (isinstance(lowerCAmelCase__							,      (list, tuple)	) and len(lowerCAmelCase__	) == 2):
											return False
								elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
											return False
								else:
											return True




					def __getitem__(   self   :						str							,      _A   :						Dict	)  ->				Any:
								assert self.validate_indicies(lowerCAmelCase__	)
								return self.array[loc[0]][loc[1]]




					def __setitem__(   self   :						List[Any]							,      _A   :						List[Any]							,      _A   :						str	)  ->				str:
								assert self.validate_indicies(lowerCAmelCase__	)
								UpperCAmelCase_	:    Any	  =    value




					def __add__(   self   :						Dict							,      _A   :						Optional[Any]	)  ->				Any:
								assert isinstance(lowerCAmelCase__							,      lowerCAmelCase__	)
								assert self.row == another.row and self.column == another.column

								# Add
								UpperCAmelCase_	:    Union[str, Any]	  =    Matrix(self.row							,      self.column	)
								for r in range(self.row	):
											for c in range(self.column	):
														UpperCAmelCase_	:    Tuple	  =    self[r, c] + another[r, c]
								return result




					def __neg__(   self   :						List[Any]	)  ->				Dict:
								UpperCAmelCase_	:    int	  =    Matrix(self.row							,      self.column	)
								for r in range(self.row	):
											for c in range(self.column	):
														UpperCAmelCase_	:    int	  =    -self[r, c]
								return result




					def __sub__(   self   :						Union[str, Any]							,      _A   :						Any	)  ->				List[str]:
								return self + (-another)




					def __mul__(   self   :						List[Any]							,      _A   :						Union[str, Any]	)  ->				Any:

								if isinstance(lowerCAmelCase__							,      (int, float)	):  # Scalar multiplication
											UpperCAmelCase_	:    Union[str, Any]	  =    Matrix(self.row							,      self.column	)
											for r in range(self.row	):
														for c in range(self.column	):
																	UpperCAmelCase_	:    Tuple	  =    self[r, c] * another
											return result
								elif isinstance(lowerCAmelCase__							,      lowerCAmelCase__	):  # Matrix multiplication
											assert self.column == another.row
											UpperCAmelCase_	:    Dict	  =    Matrix(self.row							,      another.column	)
											for r in range(self.row	):
														for c in range(another.column	):
																	for i in range(self.column	):
																				result[r, c] += self[r, i] * another[i, c]
											return result
								else:
											UpperCAmelCase_	:    str	  =    F"Unsupported type given for another ({type(lowerCAmelCase__	)})"
											raise TypeError(lowerCAmelCase__	)




					def 						A	(   self   :						int	)  ->				List[Any]:
								UpperCAmelCase_	:    List[Any]	  =    Matrix(self.column							,      self.row	)
								for r in range(self.row	):
											for c in range(self.column	):
														UpperCAmelCase_	:    Dict	  =    self[r, c]
								return result





					def 						A	(   self   :						Optional[int]							,      _A   :						Dict							,      _A   :						Optional[int]	)  ->				Any:
								assert isinstance(lowerCAmelCase__							,      lowerCAmelCase__	) and isinstance(lowerCAmelCase__							,      lowerCAmelCase__	)
								assert self.row == self.column == u.row == v.row  # u, v should be column vector
								assert u.column == v.column == 1  # u, v should be column vector

								# Calculate
								UpperCAmelCase_	:    Any	  =    v.transpose()
								UpperCAmelCase_	:    List[str]	  =    (v_t * self * u)[0, 0] + 1
								if numerator_factor == 0:
											return None  # It's not invertable
								return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":
						def __UpperCAmelCase					( )  ->					List[Any]:
									# a^(-1)
									UpperCAmelCase_	:    Optional[int]	  =    Matrix(3       ,    3       ,    0						)
									for i in range(3						):
												UpperCAmelCase_	:    Tuple	  =    1
									print(F"a^(-1) is {ainv}"						)
									# u, v
									UpperCAmelCase_	:    List[str]	  =    Matrix(3       ,    1       ,    0						)
									UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_	:    Optional[int]	  =    1, 2, -3
									UpperCAmelCase_	:    str	  =    Matrix(3       ,    1       ,    0						)
									UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_	:    List[str]	  =    4, -2, 5
									print(F"u is {u}"						)
									print(F"v is {v}"						)
									print(F"uv^T is {u * v.transpose()}"						)
									# Sherman Morrison
									print(F"(a + uv^T)^(-1) is {ainv.sherman_morrison(UpperCamelCase_       ,    UpperCamelCase_						)}"						)
						def __UpperCAmelCase					( )  ->					int:
									import doctest

									doctest.testmod()







						testa()




"""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


__magic_name__       =			get_tests_dir("fixtures/test_sentencepiece.model")
@require_sentencepiece
@require_tokenizers
class 						SCREAMING_SNAKE_CASE_ (						__a     ,				unittest.TestCase ):




		"""simple docstring"""





		__lowercase							:  Optional[Any]						   =		XLNetTokenizer
		__lowercase							:  List[str]						   =		XLNetTokenizerFast
		__lowercase							:  List[Any]						   =		True
		__lowercase							:  int						   =		True




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

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




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = """<s>"""
				__SCREAMING_SNAKE_CASE            = 1

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




		def 	snake_case_     (     self):
				__SCREAMING_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(lowerCAmelCase__)							,  1_0_0_6)




		def 	snake_case_     (     self):
				self.assertEqual(self.get_tokenizer().vocab_size							,  1_0_0_0)




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = XLNetTokenizer(lowerCAmelCase__							,  keep_accents=lowerCAmelCase__)

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

				self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__)							,  [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2])

				__SCREAMING_SNAKE_CASE            = tokenizer.tokenize("""I was born in 92000, and this is falsé.""")
				self.assertListEqual(
				    lowerCAmelCase__							,  [
				        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""",
				        """é""",
				        """.""",
				    ]							,  )
				__SCREAMING_SNAKE_CASE            = tokenizer.convert_tokens_to_ids(lowerCAmelCase__)
				self.assertListEqual(lowerCAmelCase__							,  [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 0, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 0, 4])

				__SCREAMING_SNAKE_CASE            = tokenizer.convert_ids_to_tokens(lowerCAmelCase__)
				self.assertListEqual(
				    lowerCAmelCase__							,  [
				        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 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = XLNetTokenizer(lowerCAmelCase__							,  do_lower_case=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = tokenizer.tokenize("""I was born in 92000, and this is falsé.""")
				self.assertListEqual(
				    lowerCAmelCase__							,  [
				        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 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = XLNetTokenizer(lowerCAmelCase__							,  do_lower_case=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = tokenizer.tokenize("""I was born in 92000, and this is falsé.""")
				self.assertListEqual(
				    lowerCAmelCase__							,  [
				        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 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = XLNetTokenizer.from_pretrained("""xlnet-base-cased""")

				__SCREAMING_SNAKE_CASE            = tokenizer.encode("""sequence builders"""							,  add_special_tokens=lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = tokenizer.encode("""multi-sequence build"""							,  add_special_tokens=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__							,  lowerCAmelCase__)

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




		@slow
		def 	snake_case_     (     self):
				# fmt: off
				__SCREAMING_SNAKE_CASE            = {"""input_ids""": [[1_7, 2_1_4_4_2, 2_7_0, 1_7, 1_0, 1_4_6_4_5, 3_1_8, 3_4, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 7_7_5_2, 2_2_0_1_8, 2_3, 2_1, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 3_3_5_2, 1_4_4_3_1, 1_3, 5_5_0_0, 1_1, 1_1_7_6, 5_8_0, 1_3, 1_6_8_1_9, 4_7_9_7, 2_3, 1_7, 1_0, 1_7_1_3_5, 6_5_8, 1_9, 4_5_7, 7_9_3_2, 1_3, 1_8_4, 1_9, 3_1_5_4, 1_7_1_3_5, 6_4_6_8, 1_9, 1_4_0_4, 1_2_2_6_9, 1_9, 4_2_2_9, 5_3_5_6, 1_6_2_6_4, 4_6, 1_9, 1_7, 2_0_5_4_5, 1_0_3_9_5, 9, 9, 9, 1_1, 2_8, 6_4_2_1, 9_5_3_1, 2_0_7_2_9, 1_7, 1_0, 3_5_3, 1_7_0_2_2, 1_1, 2_1, 6_4_2_1, 9_5_3_1, 1_6_9_4_9, 1_7, 1_0, 1_1_5_0_9, 7_5_3, 1_1, 3_3, 9_5, 2_4_2_1, 7_3_8_5, 9_5_6, 1_4_4_3_1, 2_6_2_6, 2_5, 8_4_2, 7_3_8_5, 4_8_3_6, 2_1, 1_4_2_9, 2_2_7_2, 9_8_5_5, 3_1_2_0, 1_6_1, 2_4_7_3_8, 1_9, 1_3_2_0_3, 6_5_8, 2_1_8, 7_8_7, 2_1, 4_3_0, 1_8_4_8_2, 8_4_7, 2_6_3_7, 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_2_2, 2_2_1_7_8, 2_7, 1_0_6_4, 2_2, 9_5_6, 1_3, 1_1_1_0_1, 1_4_2_9, 5_8_5_4, 2_4_3_1_3, 1_8_9_5_3, 4_0, 4_2_2, 2_4_3_6_6, 6_8, 1_7_5_8, 3_7, 1_0_4_8_3, 1_4_2_5_7, 3_1, 2_0_7, 2_6_3, 2_1, 2_0_3, 3_7_7_3, 2_5, 7_1, 9_7_3_5, 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, 3_2, 2_0_4_9, 3_4_4_2, 1_7, 1_3_8_9_4, 3_3_8_0, 2_3, 9_5, 1_8, 1_7_6_3_4, 2_2_8_8, 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=lowerCAmelCase__							,  model_name="""xlnet-base-cased"""							,  revision="""c841166438c31ec7ca9a106dee7bb312b73ae511"""							,  )




