






"""simple docstring"""




import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


_snake_case          =   get_tests_dir('fixtures/test_sentencepiece.model')


if is_torch_available():
 from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

_snake_case          =   25_6047
_snake_case          =   25_6145






@require_sentencepiece
@require_tokenizers
class        UpperCamelCase			(	snake_case_		,     unittest.TestCase      ):
 UpperCamelCase					:       List[str]			=					NllbTokenizer
 UpperCamelCase					:       List[str]			=					NllbTokenizerFast
 UpperCamelCase					:       Optional[Any]			=					True
 UpperCamelCase					:       Union[str, Any]			=					True
 UpperCamelCase					:       Any			=					{}


 def _lowercase	(     self		:						Any							)					->       Union[str, Any]:
   super().setUp()

   # We have a SentencePiece fixture for testing
   _a  :       Tuple             =	NllbTokenizer(UpperCAmelCase__							,						keep_accents=UpperCAmelCase__							)
   tokenizer.save_pretrained(self.tmpdirname							)


 def _lowercase	(     self		:						List[str]							)					->       Optional[int]:
   _a  :       List[Any]             =	NllbTokenizer(UpperCAmelCase__							,						keep_accents=UpperCAmelCase__							)

   _a  :       Optional[int]             =	tokenizer.tokenize("""This is a test"""							)
   self.assertListEqual(UpperCAmelCase__							,						["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]							)

   self.assertListEqual(
       tokenizer.convert_tokens_to_ids(UpperCAmelCase__							)							,						[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]							,						)

   _a  :       Optional[int]             =	tokenizer.tokenize("""I was born in 92000, and this is falsé."""							)
   self.assertListEqual(
       UpperCAmelCase__							,						[
           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""",
           """é""",
           """.""",
       ]							,						)
   _a  :       int             =	tokenizer.convert_tokens_to_ids(UpperCAmelCase__							)
   self.assertListEqual(
       UpperCAmelCase__							,						[
           value + tokenizer.fairseq_offset
           for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
       ]							,						)

   _a  :       Any             =	tokenizer.convert_ids_to_tokens(UpperCAmelCase__							)
   self.assertListEqual(
       UpperCAmelCase__							,						[
           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 _lowercase	(     self		:						Any							)					->       List[Any]:
   _a  :       Optional[Any]             =	(self.rust_tokenizer_class, """hf-internal-testing/tiny-random-nllb""", {})
   for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
       _a  :       Optional[int]             =	self.rust_tokenizer_class.from_pretrained(UpperCAmelCase__							,						**UpperCAmelCase__							)
       _a  :       Optional[Any]             =	self.tokenizer_class.from_pretrained(UpperCAmelCase__							,						**UpperCAmelCase__							)

       _a  :       Union[str, Any]             =	tempfile.mkdtemp()

       _a  :       List[Any]             =	tokenizer_r.save_pretrained(UpperCAmelCase__							)
       _a  :       List[Any]             =	tokenizer_p.save_pretrained(UpperCAmelCase__							)

       # Checks it save with the same files + the tokenizer.json file for the fast one
       self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files							)							)
       _a  :       Union[str, Any]             =	tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f							)
       self.assertSequenceEqual(UpperCAmelCase__							,						UpperCAmelCase__							)

       # Checks everything loads correctly in the same way
       _a  :       Tuple             =	tokenizer_r.from_pretrained(UpperCAmelCase__							)
       _a  :       Tuple             =	tokenizer_p.from_pretrained(UpperCAmelCase__							)

       # Check special tokens are set accordingly on Rust and Python
       for key in tokenizer_pp.special_tokens_map:
         self.assertTrue(hasattr(UpperCAmelCase__							,						UpperCAmelCase__							)							)

       shutil.rmtree(UpperCAmelCase__							)

       # Save tokenizer rust, legacy_format=True
       _a  :       Optional[Any]             =	tempfile.mkdtemp()

       _a  :       Optional[Any]             =	tokenizer_r.save_pretrained(UpperCAmelCase__							,						legacy_format=UpperCAmelCase__							)
       _a  :       Dict             =	tokenizer_p.save_pretrained(UpperCAmelCase__							)

       # Checks it save with the same files
       self.assertSequenceEqual(UpperCAmelCase__							,						UpperCAmelCase__							)

       # Checks everything loads correctly in the same way
       _a  :       int             =	tokenizer_r.from_pretrained(UpperCAmelCase__							)
       _a  :       Any             =	tokenizer_p.from_pretrained(UpperCAmelCase__							)

       # Check special tokens are set accordingly on Rust and Python
       for key in tokenizer_pp.special_tokens_map:
         self.assertTrue(hasattr(UpperCAmelCase__							,						UpperCAmelCase__							)							)

       shutil.rmtree(UpperCAmelCase__							)

       # Save tokenizer rust, legacy_format=False
       _a  :       Optional[Any]             =	tempfile.mkdtemp()

       _a  :       List[str]             =	tokenizer_r.save_pretrained(UpperCAmelCase__							,						legacy_format=UpperCAmelCase__							)
       _a  :       List[str]             =	tokenizer_p.save_pretrained(UpperCAmelCase__							)

       # Checks it saved the tokenizer.json file
       self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files							)							)

       # Checks everything loads correctly in the same way
       _a  :       Tuple             =	tokenizer_r.from_pretrained(UpperCAmelCase__							)
       _a  :       Any             =	tokenizer_p.from_pretrained(UpperCAmelCase__							)

       # Check special tokens are set accordingly on Rust and Python
       for key in tokenizer_pp.special_tokens_map:
         self.assertTrue(hasattr(UpperCAmelCase__							,						UpperCAmelCase__							)							)

       shutil.rmtree(UpperCAmelCase__							)


 @require_torch
 def _lowercase	(     self		:						str							)					->       List[str]:
   if not self.test_seqaseq:
     return

   _a  :       Tuple             =	self.get_tokenizers()
   for tokenizer in tokenizers:
     with self.subTest(f"""{tokenizer.__class__.__name__}"""							):
       # Longer text that will definitely require truncation.
       _a  :       Union[str, Any]             =	[
           """ UN Chief Says There Is No Military Solution in Syria""",
           """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for"""
           """ Syria is that 'there is no military solution' to the nearly five-year conflict and more weapons"""
           """ will only worsen the violence and misery for millions of people.""",
       ]
       _a  :       Dict             =	[
           """Şeful ONU declară că nu există o soluţie militară în Siria""",
           """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al"""
           """ Rusiei pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi"""
           """ că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
       ]
       try:
         _a  :       Optional[int]             =	tokenizer.prepare_seqaseq_batch(
             src_texts=UpperCAmelCase__							,						tgt_texts=UpperCAmelCase__							,						max_length=3							,						max_target_length=10							,						return_tensors="""pt"""							,						src_lang="""eng_Latn"""							,						tgt_lang="""ron_Latn"""							,						)
       except NotImplementedError:
         return
       self.assertEqual(batch.input_ids.shape[1]							,						3							)
       self.assertEqual(batch.labels.shape[1]							,						10							)
       # max_target_length will default to max_length if not specified
       _a  :       List[str]             =	tokenizer.prepare_seqaseq_batch(
           UpperCAmelCase__							,						tgt_texts=UpperCAmelCase__							,						max_length=3							,						return_tensors="""pt"""							)
       self.assertEqual(batch.input_ids.shape[1]							,						3							)
       self.assertEqual(batch.labels.shape[1]							,						3							)

       _a  :       List[Any]             =	tokenizer.prepare_seqaseq_batch(
           src_texts=UpperCAmelCase__							,						max_length=3							,						max_target_length=10							,						return_tensors="""pt"""							)
       self.assertEqual(batch_encoder_only.input_ids.shape[1]							,						3							)
       self.assertEqual(batch_encoder_only.attention_mask.shape[1]							,						3							)
       self.assertNotIn("""decoder_input_ids"""							,						UpperCAmelCase__							)


 @unittest.skip("""Unfortunately way too slow to build a BPE with SentencePiece."""							)
 def _lowercase	(     self		:						List[Any]							)					->       Dict:
   pass







 def _lowercase	(     self		:						Any							)					->       Optional[Any]:
   for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
       _a  :       Tuple             =	[AddedToken("""<special>"""							,						lstrip=UpperCAmelCase__							)]

       _a  :       Union[str, Any]             =	self.rust_tokenizer_class.from_pretrained(
           UpperCAmelCase__							,						additional_special_tokens=UpperCAmelCase__							,						**UpperCAmelCase__							)
       _a  :       Optional[int]             =	tokenizer_r.encode("""Hey this is a <special> token"""							)

       _a  :       Optional[Any]             =	tokenizer_r.encode("""<special>"""							,						add_special_tokens=UpperCAmelCase__							)[0]

       self.assertTrue(special_token_id in r_output							)

       if self.test_slow_tokenizer:
         _a  :       str             =	self.rust_tokenizer_class.from_pretrained(
             UpperCAmelCase__							,						additional_special_tokens=UpperCAmelCase__							,						**UpperCAmelCase__							,						)
         _a  :       Tuple             =	self.tokenizer_class.from_pretrained(
             UpperCAmelCase__							,						additional_special_tokens=UpperCAmelCase__							,						**UpperCAmelCase__							)

         _a  :       Any             =	tokenizer_p.encode("""Hey this is a <special> token"""							)

         _a  :       Optional[int]             =	tokenizer_cr.encode("""Hey this is a <special> token"""							)

         self.assertEqual(UpperCAmelCase__							,						UpperCAmelCase__							)
         self.assertEqual(UpperCAmelCase__							,						UpperCAmelCase__							)
         self.assertTrue(special_token_id in p_output							)
         self.assertTrue(special_token_id in cr_output							)







@require_torch
@require_sentencepiece
@require_tokenizers
class        UpperCamelCase			(	unittest.TestCase      ):
 UpperCamelCase					:       Optional[int]			=					'''facebook/nllb-200-distilled-600M'''
 UpperCamelCase					:       Any			=					[
     ''' UN Chief Says There Is No Military Solution in Syria''',
     ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.''',
 ]
 UpperCamelCase					:       str			=					[
     '''Şeful ONU declară că nu există o soluţie militară în Siria''',
     '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'''
     ''' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'''
     ''' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''',
 ]
 UpperCamelCase					:       int			=					[
     256_047,
     16_297,
     134_408,
     8_165,
     248_066,
     14_734,
     950,
     1_135,
     105_721,
     3_573,
     83,
     27_352,
     108,
     49_486,
     2,
 ]


 @classmethod
 def _lowercase	(     cls		:						List[Any]							)					->       List[Any]:
   _a  :       NllbTokenizer             =	NllbTokenizer.from_pretrained(
       cls.checkpoint_name							,						src_lang="""eng_Latn"""							,						tgt_lang="""ron_Latn"""							)
   _a  :       Union[str, Any]             =	1
   return cls


 def _lowercase	(     self		:						Dict							)					->       Any:
   self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Arab"""]							,						256001							)
   self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Latn"""]							,						256002							)
   self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""fra_Latn"""]							,						256057							)


 def _lowercase	(     self		:						str							)					->       str:
   _a  :       str             =	self.tokenizer.batch_encode_plus(self.src_text							).input_ids[0]
   self.assertListEqual(self.expected_src_tokens							,						UpperCAmelCase__							)


 def _lowercase	(     self		:						List[str]							)					->       List[Any]:
   self.assertIn(UpperCAmelCase__							,						self.tokenizer.all_special_ids							)
   # fmt: off
   _a  :       int             =	[RO_CODE, 4254, 98068, 112923, 39072, 3909, 713, 102767, 26, 17314, 35642, 14683, 33118, 2022, 66987, 2, 256047]
   # fmt: on

   _a  :       int             =	self.tokenizer.decode(UpperCAmelCase__							,						skip_special_tokens=UpperCAmelCase__							)
   _a  :       Optional[int]             =	self.tokenizer.decode(generated_ids[1:]							,						skip_special_tokens=UpperCAmelCase__							)
   self.assertEqual(UpperCAmelCase__							,						UpperCAmelCase__							)
   self.assertNotIn(self.tokenizer.eos_token							,						UpperCAmelCase__							)


 def _lowercase	(     self		:						Any							)					->       List[str]:
   _a  :       Tuple             =	["""this is gunna be a long sentence """ * 20]
   assert isinstance(src_text[0]							,						UpperCAmelCase__							)
   _a  :       Tuple             =	10
   _a  :       int             =	self.tokenizer(UpperCAmelCase__							,						max_length=UpperCAmelCase__							,						truncation=UpperCAmelCase__							).input_ids[0]
   self.assertEqual(ids[-1]							,						2							)
   self.assertEqual(ids[0]							,						UpperCAmelCase__							)
   self.assertEqual(len(UpperCAmelCase__							)							,						UpperCAmelCase__							)


 def _lowercase	(     self		:						Tuple							)					->       Optional[Any]:
   self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]							)							,						[256203, 3]							)


 def _lowercase	(     self		:						int							)					->       int:
   _a  :       int             =	tempfile.mkdtemp()
   _a  :       Union[str, Any]             =	self.tokenizer.fairseq_tokens_to_ids
   self.tokenizer.save_pretrained(UpperCAmelCase__							)
   _a  :       Tuple             =	NllbTokenizer.from_pretrained(UpperCAmelCase__							)
   self.assertDictEqual(new_tok.fairseq_tokens_to_ids							,						UpperCAmelCase__							)


 @require_torch
 def _lowercase	(     self		:						List[Any]							)					->       Tuple:
   _a  :       Optional[int]             =	self.tokenizer(
       self.src_text							,						text_target=self.tgt_text							,						padding=UpperCAmelCase__							,						truncation=UpperCAmelCase__							,						max_length=len(self.expected_src_tokens							)							,						return_tensors="""pt"""							,						)
   _a  :       Tuple             =	shift_tokens_right(
       batch["""labels"""]							,						self.tokenizer.pad_token_id							,						self.tokenizer.lang_code_to_id["""ron_Latn"""]							)

   self.assertIsInstance(UpperCAmelCase__							,						UpperCAmelCase__							)

   self.assertEqual((2, 15)							,						batch.input_ids.shape							)
   self.assertEqual((2, 15)							,						batch.attention_mask.shape							)
   _a  :       Optional[Any]             =	batch.input_ids.tolist()[0]
   self.assertListEqual(self.expected_src_tokens							,						UpperCAmelCase__							)
   self.assertEqual(UpperCAmelCase__							,						batch.decoder_input_ids[0, 0]							)  # EOS
   # Test that special tokens are reset
   self.assertEqual(self.tokenizer.prefix_tokens							,						[EN_CODE]							)
   self.assertEqual(self.tokenizer.suffix_tokens							,						[self.tokenizer.eos_token_id]							)


 def _lowercase	(     self		:						Optional[Any]							)					->       Optional[Any]:
   _a  :       Dict             =	self.tokenizer(self.src_text							,						padding=UpperCAmelCase__							,						truncation=UpperCAmelCase__							,						max_length=3							,						return_tensors="""pt"""							)
   _a  :       List[str]             =	self.tokenizer(
       text_target=self.tgt_text							,						padding=UpperCAmelCase__							,						truncation=UpperCAmelCase__							,						max_length=10							,						return_tensors="""pt"""							)
   _a  :       Optional[int]             =	targets["""input_ids"""]
   _a  :       List[Any]             =	shift_tokens_right(
       UpperCAmelCase__							,						self.tokenizer.pad_token_id							,						decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]							,						)

   self.assertEqual(batch.input_ids.shape[1]							,						3							)
   self.assertEqual(batch.decoder_input_ids.shape[1]							,						10							)


 @require_torch
 def _lowercase	(     self		:						List[str]							)					->       Any:
   _a  :       List[str]             =	self.tokenizer._build_translation_inputs(
       """A test"""							,						return_tensors="""pt"""							,						src_lang="""eng_Latn"""							,						tgt_lang="""fra_Latn"""							)

   self.assertEqual(
       nested_simplify(UpperCAmelCase__							)							,						{
           # A, test, EOS, en_XX
           """input_ids""": [[256047, 70, 7356, 2]],
           """attention_mask""": [[1, 1, 1, 1]],
           # ar_AR
           """forced_bos_token_id""": 256057,
       }							,						)







 @require_torch
 def _lowercase	(     self		:						Optional[Any]							)					->       Dict:
   _a  :       str             =	True
   _a  :       List[str]             =	self.tokenizer(
       """UN Chief says there is no military solution in Syria"""							,						src_lang="""eng_Latn"""							,						tgt_lang="""fra_Latn"""							)
   self.assertEqual(
       inputs.input_ids							,						[16297, 134408, 25653, 6370, 248, 254, 103929, 94995, 108, 49486, 2, 256047]							)

   _a  :       Any             =	False
   _a  :       int             =	self.tokenizer(
       """UN Chief says there is no military solution in Syria"""							,						src_lang="""eng_Latn"""							,						tgt_lang="""fra_Latn"""							)
   self.assertEqual(
       inputs.input_ids							,						[256047, 16297, 134408, 25653, 6370, 248, 254, 103929, 94995, 108, 49486, 2]							)









"""simple docstring"""




def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''

  # Check if the input is valid
  if not len(UpperCamelCase__				) == len(UpperCamelCase__				) == 3:
    raise ValueError("""Please enter a valid equation."""				)
  if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
    raise ValueError("""Both a & b of two equations can't be zero."""				)

  # Extract the coefficients
  _a      ,  _a      ,  _a  :       Any             =	equationa
  _a      ,  _a      ,  _a  :       Tuple             =	equationa

  # Calculate the determinants of the matrices
  _a  :       int             =	aa * ba - aa * ba
  _a  :       str             =	ca * ba - ca * ba
  _a  :       str             =	aa * ca - aa * ca

  # Check if the system of linear equations has a solution (using Cramer's rule)
  if determinant == 0:
    if determinant_x == determinant_y == 0:
      raise ValueError("""Infinite solutions. (Consistent system)"""				)
    else:
      raise ValueError("""No solution. (Inconsistent system)"""				)
  else:
    if determinant_x == determinant_y == 0:
      # Trivial solution (Inconsistent system)
      return (0.0, 0.0)
    else:
      _a  :       Dict             =	determinant_x / determinant
      _a  :       str             =	determinant_y / determinant
      # Non-Trivial Solution (Consistent system)
      return (x, y)

