





from __future__ import annotations
def 				__UpperCamelCase  (		snake_case    ,	snake_case    ,	snake_case     )  ->						tuple[float, float]:


   '''simple docstring'''







   assert (
       c % greatest_common_divisor(snake_case    ,	snake_case     ) == 0
   )  # greatest_common_divisor(a,b) function implemented below
   ((__A) ,						(__A) ,						(__A))				 =       extended_gcd(snake_case    ,	snake_case     )  # extended_gcd(a,b) function implemented below
   __A				 =       c / d
   return (r * x, r * y)
def 				__UpperCamelCase  (		snake_case    ,	snake_case    ,	snake_case    ,	snake_case = 2     )  ->						None:


   '''simple docstring'''







   ((__A) ,						(__A))				 =       diophantine(snake_case    ,	snake_case    ,	snake_case     )  # Initial value
   __A				 =       greatest_common_divisor(snake_case    ,	snake_case     )
   __A				 =       a // d
   __A				 =       b // d

   for i in range(snake_case     ):
      __A				 =       xa + i * q
      __A				 =       ya - i * p
      print(snake_case    ,	snake_case     )
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						int:


   '''simple docstring'''







   if a < b:
      __A ,						__A				 =       b, a

   while a % b != 0:
      __A ,						__A				 =       b, a % b

   return b
def 				__UpperCamelCase  (		snake_case    ,	snake_case     )  ->						tuple[int, int, int]:


   '''simple docstring'''







   assert a >= 0 and b >= 0

   if b == 0:
      __A ,						__A ,						__A				 =       a, 1, 0
   else:
      ((__A) ,						(__A) ,						(__A))				 =       extended_gcd(snake_case    ,	a % b     )
      __A				 =       q
      __A				 =       p - q * (a // b)

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

   return (d, x, y)


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

    testmod(name="""diophantine""", verbose=True)
    testmod(name="""diophantine_all_soln""", verbose=True)
    testmod(name="""extended_gcd""", verbose=True)
    testmod(name="""greatest_common_divisor""", verbose=True)






import json
import os
import unittest

from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES, FSMTTokenizer
from transformers.testing_utils import slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


# using a different tiny model than the one used for default params defined in init to ensure proper testing
_UpperCamelCase   :							str     =	"""stas/tiny-wmt19-en-ru"""







class 						_lowerCAmelCase(						_a		,   unittest.TestCase):

  """simple docstring"""







  lowerCamelCase__      					=   FSMTTokenizer
  lowerCamelCase__      					=   False

  def 		SCREAMING_SNAKE_CASE__	( self     )-> List[Any]:
     super().setUp()

     # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
     __A				 =       [
         '''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>''',
         '''<unk>''',
     ]
     __A				 =       dict(zip(UpperCAmelCase  ,    range(len(UpperCAmelCase     )     )     )     )
     __A				 =       ['''l o 123''', '''lo w 1456''', '''e r</w> 1789''', '''''']

     __A				 =       ['''en''', '''ru''']
     __A				 =       {
         '''langs''': self.langs,
         '''src_vocab_size''': 10,
         '''tgt_vocab_size''': 20,
     }

     __A				 =       os.path.join(self.tmpdirname  ,    VOCAB_FILES_NAMES['''src_vocab_file''']     )
     __A				 =       os.path.join(self.tmpdirname  ,    VOCAB_FILES_NAMES['''tgt_vocab_file''']     )
     __A				 =       os.path.join(self.tmpdirname  ,    '''tokenizer_config.json'''     )
     __A				 =       os.path.join(self.tmpdirname  ,    VOCAB_FILES_NAMES['''merges_file''']     )
     with open(self.src_vocab_file  ,    '''w'''     ) as fp:
        fp.write(json.dumps(UpperCAmelCase     )     )
     with open(self.tgt_vocab_file  ,    '''w'''     ) as fp:
        fp.write(json.dumps(UpperCAmelCase     )     )
     with open(self.merges_file  ,    '''w'''     ) as fp:
        fp.write('''\n'''.join(UpperCAmelCase     )     )
     with open(UpperCAmelCase  ,    '''w'''     ) as fp:
        fp.write(json.dumps(UpperCAmelCase     )     )

  @cached_property
  def 		SCREAMING_SNAKE_CASE__	( self     )-> Optional[int]:
     return FSMTTokenizer.from_pretrained('''facebook/wmt19-ru-en'''     )

  @cached_property
  def 		SCREAMING_SNAKE_CASE__	( self     )-> Optional[Any]:
     return FSMTTokenizer.from_pretrained('''facebook/wmt19-en-ru'''     )

  def 		SCREAMING_SNAKE_CASE__	( self     )-> Dict:
     __A				 =       FSMTTokenizer.from_pretrained(UpperCAmelCase     )
     self.assertListEqual([tokenizer.src_lang, tokenizer.tgt_lang]  ,    ['''en''', '''ru''']     )
     self.assertEqual(tokenizer.src_vocab_size  ,    21     )
     self.assertEqual(tokenizer.tgt_vocab_size  ,    21     )

  def 		SCREAMING_SNAKE_CASE__	( self     )-> Union[str, Any]:
     __A				 =       FSMTTokenizer(self.langs  ,    self.src_vocab_file  ,    self.tgt_vocab_file  ,    self.merges_file     )

     __A				 =       '''lower'''
     __A				 =       ['''low''', '''er</w>''']
     __A				 =       tokenizer.tokenize(UpperCAmelCase     )
     self.assertListEqual(UpperCAmelCase  ,    UpperCAmelCase     )

     __A				 =       tokens + ['''<unk>''']
     __A				 =       [14, 15, 20]
     self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase     )  ,    UpperCAmelCase     )

  @slow
  def 		SCREAMING_SNAKE_CASE__	( self     )-> Any:
     __A				 =       self.tokenizer_ru_en

     __A				 =       tokenizer.encode('''sequence builders'''  ,    add_special_tokens=UpperCAmelCase     )
     __A				 =       tokenizer.encode('''multi-sequence build'''  ,    add_special_tokens=UpperCAmelCase     )

     __A				 =       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase     )
     __A				 =       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase  ,    UpperCAmelCase     )

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

  @slow
  def 		SCREAMING_SNAKE_CASE__	( self     )-> Dict:
     __A				 =       self.tokenizer_en_ru
     __A				 =       self.tokenizer_ru_en

     __A				 =       [
         [
             '''Here\'s a little song I wrote. Don\'t worry, be happy.''',
             [24_70, 39, 11, 23_49, 72_22, 70, 59_79, 7, 84_50, 10_50, 1_31_60, 5, 26, 64_45, 7, 2],
         ],
         ['''This is it. No more. I\'m done!''', [1_32, 21, 37, 7, 14_34, 86, 7, 70, 64_76, 13_05, 4_27, 2]],
     ]

     # if data needs to be recreated or added, run:
     # import torch
     # model = torch.hub.load("pytorch/fairseq", "transformer.wmt19.en-ru", checkpoint_file="model4.pt", tokenizer="moses", bpe="fastbpe")
     # for src_text, _ in targets: print(f"""[\n"{src_text}",\n {model.encode(src_text).tolist()}\n],""")

     for src_text, tgt_input_ids in targets:
        __A				 =       tokenizer_enc.encode(UpperCAmelCase  ,    return_tensors=UpperCAmelCase     )
        self.assertListEqual(UpperCAmelCase  ,    UpperCAmelCase     )

        # and decode backward, using the reversed languages model
        __A				 =       tokenizer_dec.decode(UpperCAmelCase  ,    skip_special_tokens=UpperCAmelCase     )
        self.assertEqual(UpperCAmelCase  ,    UpperCAmelCase     )

  @slow
  def 		SCREAMING_SNAKE_CASE__	( self     )-> str:
     __A				 =       FSMTTokenizer.from_pretrained('''facebook/wmt19-ru-en'''  ,    do_lower_case=UpperCAmelCase     )
     __A				 =       tokenizer.tokenize('''USA is United States of America'''     )
     __A				 =       ['''us''', '''a</w>''', '''is</w>''', '''un''', '''i''', '''ted</w>''', '''st''', '''ates</w>''', '''of</w>''', '''am''', '''er''', '''ica</w>''']
     self.assertListEqual(UpperCAmelCase  ,    UpperCAmelCase     )

  @unittest.skip('''FSMTConfig.__init__  requires non-optional args'''     )
  def 		SCREAMING_SNAKE_CASE__	( self     )-> Optional[int]:
     pass





  @unittest.skip('''FSMTConfig.__init__  requires non-optional args'''     )
  def 		SCREAMING_SNAKE_CASE__	( self     )-> Optional[Any]:
     pass

