






from __future__ import annotations



def        _lowerCamelCase(      lowerCAmelCase__					:		int     ,     lowerCAmelCase__					:		int     ,     lowerCAmelCase__					:		int   ):





				'''simple docstring'''







				assert n > 1 and a > 0 and greatest_common_divisor(lowerCAmelCase__     ,     lowerCAmelCase__   ) == 1
				((SCREAMING_SNAKE_CASE_)				,							(SCREAMING_SNAKE_CASE_)				,							(SCREAMING_SNAKE_CASE_)) :						List[Any]    				= extended_gcd(lowerCAmelCase__     ,     lowerCAmelCase__   )  # Implemented below
				SCREAMING_SNAKE_CASE_ :						List[Any]    				= (b * s) % n
				return x



def        _lowerCamelCase(      lowerCAmelCase__					:		int     ,     lowerCAmelCase__					:		int   ):





				'''simple docstring'''







				((SCREAMING_SNAKE_CASE_)				,							(SCREAMING_SNAKE_CASE_)) :						str    				= extended_euclid(lowerCAmelCase__     ,     lowerCAmelCase__   )  # Implemented below
				if b < 0:
								SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= (b % n + n) % n
				return b



def        _lowerCamelCase(      lowerCAmelCase__					:		int     ,     lowerCAmelCase__					:		int     ,     lowerCAmelCase__					:		int   ):





				'''simple docstring'''







				SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= invert_modulo(lowerCAmelCase__     ,     lowerCAmelCase__   )
				SCREAMING_SNAKE_CASE_ :						int    				= (b * s) % n
				return x



def        _lowerCamelCase(      lowerCAmelCase__					:		int     ,     lowerCAmelCase__					:		int   ):





				'''simple docstring'''







				assert a >= 0 and b >= 0

				if b == 0:
								SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_ :						int    				= a, 1, 0
				else:
								((SCREAMING_SNAKE_CASE_)				,							(SCREAMING_SNAKE_CASE_)				,							(SCREAMING_SNAKE_CASE_)) :						Tuple    				= extended_gcd(lowerCAmelCase__     ,     a % b   )
								SCREAMING_SNAKE_CASE_ :						int    				= q
								SCREAMING_SNAKE_CASE_ :						Dict    				= p - q * (a // b)

				assert a % d == 0 and b % d == 0
				assert d == a * x + b * y

				return (d, x, y)



def        _lowerCamelCase(      lowerCAmelCase__					:		int     ,     lowerCAmelCase__					:		int   ):





				'''simple docstring'''







				if b == 0:
								return (1, 0)
				((SCREAMING_SNAKE_CASE_)				,							(SCREAMING_SNAKE_CASE_)) :						int    				= extended_euclid(lowerCAmelCase__     ,     a % b   )
				SCREAMING_SNAKE_CASE_ :						Dict    				= a // b
				return (y, x - k * y)



def        _lowerCamelCase(      lowerCAmelCase__					:		int     ,     lowerCAmelCase__					:		int   ):





				'''simple docstring'''







				if a < b:
								SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_ :						Optional[int]    				= b, a

				while a % b != 0:
								SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_ :						Dict    				= b, a % b

				return b


if __name__ == "__main__":
				from doctest import testmod

				testmod(name='modular_division', verbose=True)
				testmod(name='modular_division2', verbose=True)
				testmod(name='invert_modulo', verbose=True)
				testmod(name='extended_gcd', verbose=True)
				testmod(name='extended_euclid', verbose=True)
				testmod(name='greatest_common_divisor', verbose=True)







import json
import os
import unittest

from transformers import HerbertTokenizer, HerbertTokenizerFast
from transformers.models.herbert.tokenization_herbert import VOCAB_FILES_NAMES
from transformers.testing_utils import get_tests_dir, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
class 				__a				(	__A			,						unittest.TestCase    ):





		'''simple docstring'''



		UpperCAmelCase__   :					Optional[Any]					     =    HerbertTokenizer
		UpperCAmelCase__   :					List[Any]					     =    HerbertTokenizerFast
		UpperCAmelCase__   :					Optional[Any]					     =    True


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

						# Use a simpler test file without japanese/chinese characters
						with open(F'''{get_tests_dir()}/fixtures/sample_text_no_unicode.txt'''			,     encoding='utf-8'							) as f_data:
										SCREAMING_SNAKE_CASE_ :						Dict    				= f_data.read().replace('\n\n'			,     '\n'							).strip()

						SCREAMING_SNAKE_CASE_ :						str    				= [
						    '<s>',
						    '</s>',
						    'l',
						    'o',
						    'w',
						    'e',
						    'r',
						    's',
						    't',
						    'i',
						    'd',
						    'n',
						    'w</w>',
						    'r</w>',
						    't</w>',
						    'lo',
						    'low',
						    'er</w>',
						    'low</w>',
						    'lowest</w>',
						    'newer</w>',
						    'wider</w>',
						    ',</w>',
						    '<unk>',
						]
						SCREAMING_SNAKE_CASE_ :						str    				= dict(zip(UpperCamelCase__			,     range(len(UpperCamelCase__							)							)							)							)
						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= ['l o 123', 'lo w 1456', 'e r</w> 1789', '']

						SCREAMING_SNAKE_CASE_ :						int    				= os.path.join(self.tmpdirname			,     VOCAB_FILES_NAMES['vocab_file']							)
						SCREAMING_SNAKE_CASE_ :						int    				= os.path.join(self.tmpdirname			,     VOCAB_FILES_NAMES['merges_file']							)
						with open(self.vocab_file			,     'w'							) as fp:
										fp.write(json.dumps(UpperCamelCase__							)							)
						with open(self.merges_file			,     'w'							) as fp:
										fp.write('\n'.join(UpperCamelCase__							)							)


		def 	__snake_case      (    self			,     UpperCamelCase__							):
						SCREAMING_SNAKE_CASE_ :						Union[str, Any]    				= 'lower newer'
						SCREAMING_SNAKE_CASE_ :						int    				= 'lower newer'
						return input_text, output_text


		def 	__snake_case      (    self							):
						SCREAMING_SNAKE_CASE_ :						List[Any]    				= self.tokenizer_class(vocab_file=self.vocab_file			,     merges_file=self.merges_file							)

						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= 'lower'
						SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= ['low', 'er</w>']
						SCREAMING_SNAKE_CASE_ :						int    				= tokenizer.tokenize(UpperCamelCase__							)
						self.assertListEqual(UpperCamelCase__			,     UpperCamelCase__							)

						SCREAMING_SNAKE_CASE_ :						Union[str, Any]    				= tokens + ['<unk>']
						SCREAMING_SNAKE_CASE_ :						List[Any]    				= [16, 17, 23]
						self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase__							)			,     UpperCamelCase__							)


		def 	__snake_case      (    self							):
						if not self.test_rust_tokenizer:
										return

						SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= self.get_tokenizer()
						SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= self.get_rust_tokenizer()

						SCREAMING_SNAKE_CASE_ :						List[str]    				= 'lower,newer'

						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= tokenizer.tokenize(UpperCamelCase__							)
						SCREAMING_SNAKE_CASE_ :						Tuple    				= rust_tokenizer.tokenize(UpperCamelCase__							)
						self.assertListEqual(UpperCamelCase__			,     UpperCamelCase__							)

						SCREAMING_SNAKE_CASE_ :						Optional[Any]    				= tokenizer.encode(UpperCamelCase__			,     add_special_tokens=UpperCamelCase__							)
						SCREAMING_SNAKE_CASE_ :						Any    				= rust_tokenizer.encode(UpperCamelCase__			,     add_special_tokens=UpperCamelCase__							)
						self.assertListEqual(UpperCamelCase__			,     UpperCamelCase__							)

						SCREAMING_SNAKE_CASE_ :						Union[str, Any]    				= self.get_rust_tokenizer()
						SCREAMING_SNAKE_CASE_ :						Dict    				= tokenizer.encode(UpperCamelCase__							)
						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= rust_tokenizer.encode(UpperCamelCase__							)
						self.assertListEqual(UpperCamelCase__			,     UpperCamelCase__							)






		@slow
		def 	__snake_case      (    self							):
						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= self.tokenizer_class.from_pretrained('allegro/herbert-base-cased'							)

						SCREAMING_SNAKE_CASE_ :						List[str]    				= tokenizer.encode('konstruowanie sekwencji'			,     add_special_tokens=UpperCamelCase__							)
						SCREAMING_SNAKE_CASE_ :						Optional[int]    				= tokenizer.encode('konstruowanie wielu sekwencji'			,     add_special_tokens=UpperCamelCase__							)

						SCREAMING_SNAKE_CASE_ :						Any    				= tokenizer.build_inputs_with_special_tokens(UpperCamelCase__							)
						SCREAMING_SNAKE_CASE_ :						Dict    				= tokenizer.build_inputs_with_special_tokens(UpperCamelCase__			,     UpperCamelCase__							)

						assert encoded_sentence == [0] + text + [2]
						assert encoded_pair == [0] + text + [2] + text_a + [2]