





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


__lowerCamelCase						: Dict		=   get_tests_dir('fixtures/test_sentencepiece.model')


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

__lowerCamelCase						: Optional[int]		=   25_6047
__lowerCamelCase						: int		=   25_6145







@require_sentencepiece
@require_tokenizers
class 		UpperCAmelCase   (				lowercase_   ,     unittest.TestCase):


  """simple docstring"""







  lowerCAmelCase_					=				NllbTokenizer
  lowerCAmelCase_					=				NllbTokenizerFast
  lowerCAmelCase_					=				True
  lowerCAmelCase_					=				True
  lowerCAmelCase_					=				{}


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

    # We have a SentencePiece fixture for testing
    _UpperCamelCase       			=NllbTokenizer(UpperCamelCase__							,	keep_accents=UpperCamelCase__  )
    tokenizer.save_pretrained(self.tmpdirname  )


  def   UpperCamelCase__      (				self    :					str  )     ->						Any:
    _UpperCamelCase       			=NllbTokenizer(UpperCamelCase__							,	keep_accents=UpperCamelCase__  )

    _UpperCamelCase       			=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]]							,	)

    _UpperCamelCase       			=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''',
            '''é''',
            '''.''',
        ]							,	)
    _UpperCamelCase       			=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]
        ]							,	)

    _UpperCamelCase       			=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   UpperCamelCase__      (				self    :					List[str]  )     ->						Tuple:
    _UpperCamelCase       			=(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})'''  ):
        _UpperCamelCase       			=self.rust_tokenizer_class.from_pretrained(UpperCamelCase__							,	**UpperCamelCase__  )
        _UpperCamelCase       			=self.tokenizer_class.from_pretrained(UpperCamelCase__							,	**UpperCamelCase__  )

        _UpperCamelCase       			=tempfile.mkdtemp()

        _UpperCamelCase       			=tokenizer_r.save_pretrained(UpperCamelCase__  )
        _UpperCamelCase       			=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  )  )
        _UpperCamelCase       			=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
        _UpperCamelCase       			=tokenizer_r.from_pretrained(UpperCamelCase__  )
        _UpperCamelCase       			=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
        _UpperCamelCase       			=tempfile.mkdtemp()

        _UpperCamelCase       			=tokenizer_r.save_pretrained(UpperCamelCase__							,	legacy_format=UpperCamelCase__  )
        _UpperCamelCase       			=tokenizer_p.save_pretrained(UpperCamelCase__  )

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

        # Checks everything loads correctly in the same way
        _UpperCamelCase       			=tokenizer_r.from_pretrained(UpperCamelCase__  )
        _UpperCamelCase       			=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
        _UpperCamelCase       			=tempfile.mkdtemp()

        _UpperCamelCase       			=tokenizer_r.save_pretrained(UpperCamelCase__							,	legacy_format=UpperCamelCase__  )
        _UpperCamelCase       			=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
        _UpperCamelCase       			=tokenizer_r.from_pretrained(UpperCamelCase__  )
        _UpperCamelCase       			=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   UpperCamelCase__      (				self    :					int  )     ->						List[Any]:
    if not self.test_seqaseq:
      return

    _UpperCamelCase       			=self.get_tokenizers()
    for tokenizer in tokenizers:
      with self.subTest(F'''{tokenizer.__class__.__name__}'''  ):
        # Longer text that will definitely require truncation.
        _UpperCamelCase       			=[
            ''' 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       			=[
            '''Ş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:
          _UpperCamelCase       			=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
        _UpperCamelCase       			=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  )

        _UpperCamelCase       			=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   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						List[Any]:
    pass




  def   UpperCamelCase__      (				self    :					Tuple  )     ->						Optional[Any]:
    for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
      with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''  ):
        _UpperCamelCase       			=[AddedToken('''<special>'''							,	lstrip=UpperCamelCase__  )]

        _UpperCamelCase       			=self.rust_tokenizer_class.from_pretrained(
            UpperCamelCase__							,	additional_special_tokens=UpperCamelCase__							,	**UpperCamelCase__  )
        _UpperCamelCase       			=tokenizer_r.encode('''Hey this is a <special> token'''  )

        _UpperCamelCase       			=tokenizer_r.encode('''<special>'''							,	add_special_tokens=UpperCamelCase__  )[0]

        self.assertTrue(special_token_id in r_output  )

        if self.test_slow_tokenizer:
          _UpperCamelCase       			=self.rust_tokenizer_class.from_pretrained(
              UpperCamelCase__							,	additional_special_tokens=UpperCamelCase__							,	**UpperCamelCase__							,	)
          _UpperCamelCase       			=self.tokenizer_class.from_pretrained(
              UpperCamelCase__							,	additional_special_tokens=UpperCamelCase__							,	**UpperCamelCase__  )

          _UpperCamelCase       			=tokenizer_p.encode('''Hey this is a <special> token'''  )

          _UpperCamelCase       			=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):


  """simple docstring"""







  lowerCAmelCase_					=				"""facebook/nllb-200-distilled-600M"""
  lowerCAmelCase_					=				[
      """ 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.""",
  ]
  lowerCAmelCase_					=				[
      """Ş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.""",
  ]
  lowerCAmelCase_					=				[
      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   UpperCamelCase__      (				cls    :					Optional[Any]  )     ->						Union[str, Any]:
    _UpperCamelCase       			=NllbTokenizer.from_pretrained(
        cls.checkpoint_name							,	src_lang='''eng_Latn'''							,	tgt_lang='''ron_Latn'''  )
    _UpperCamelCase       			=1
    return cls


  def   UpperCamelCase__      (				self    :					Union[str, Any]  )     ->						List[str]:
    self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ace_Arab''']							,	25_6001  )
    self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ace_Latn''']							,	25_6002  )
    self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''fra_Latn''']							,	25_6057  )


  def   UpperCamelCase__      (				self    :					Tuple  )     ->						List[Any]:
    _UpperCamelCase       			=self.tokenizer.batch_encode_plus(self.src_text  ).input_ids[0]
    self.assertListEqual(self.expected_src_tokens							,	UpperCamelCase__  )


  def   UpperCamelCase__      (				self    :					str  )     ->						List[str]:
    self.assertIn(UpperCamelCase__							,	self.tokenizer.all_special_ids  )
    # fmt: off
    _UpperCamelCase       			=[RO_CODE, 4254, 9_8068, 11_2923, 3_9072, 3909, 713, 10_2767, 26, 1_7314, 3_5642, 1_4683, 3_3118, 2022, 6_6987, 2, 25_6047]
    # fmt: on

    _UpperCamelCase       			=self.tokenizer.decode(UpperCamelCase__							,	skip_special_tokens=UpperCamelCase__  )
    _UpperCamelCase       			=self.tokenizer.decode(generated_ids[1:]							,	skip_special_tokens=UpperCamelCase__  )
    self.assertEqual(UpperCamelCase__							,	UpperCamelCase__  )
    self.assertNotIn(self.tokenizer.eos_token							,	UpperCamelCase__  )


  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						int:
    _UpperCamelCase       			=['''this is gunna be a long sentence ''' * 20]
    assert isinstance(src_text[0]							,	UpperCamelCase__  )
    _UpperCamelCase       			=10
    _UpperCamelCase       			=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   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						Any:
    self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR''']  )							,	[25_6203, 3]  )


  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						str:
    _UpperCamelCase       			=tempfile.mkdtemp()
    _UpperCamelCase       			=self.tokenizer.fairseq_tokens_to_ids
    self.tokenizer.save_pretrained(UpperCamelCase__  )
    _UpperCamelCase       			=NllbTokenizer.from_pretrained(UpperCamelCase__  )
    self.assertDictEqual(new_tok.fairseq_tokens_to_ids							,	UpperCamelCase__  )


  @require_torch
  def   UpperCamelCase__      (				self    :					List[Any]  )     ->						List[Any]:
    _UpperCamelCase       			=self.tokenizer(
        self.src_text							,	text_target=self.tgt_text							,	padding=UpperCamelCase__							,	truncation=UpperCamelCase__							,	max_length=len(self.expected_src_tokens  )							,	return_tensors='''pt'''							,	)
    _UpperCamelCase       			=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  )
    _UpperCamelCase       			=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   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						Optional[Any]:
    _UpperCamelCase       			=self.tokenizer(self.src_text							,	padding=UpperCamelCase__							,	truncation=UpperCamelCase__							,	max_length=3							,	return_tensors='''pt'''  )
    _UpperCamelCase       			=self.tokenizer(
        text_target=self.tgt_text							,	padding=UpperCamelCase__							,	truncation=UpperCamelCase__							,	max_length=10							,	return_tensors='''pt'''  )
    _UpperCamelCase       			=targets['''input_ids''']
    _UpperCamelCase       			=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   UpperCamelCase__      (				self    :					Dict  )     ->						int:
    _UpperCamelCase       			=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''': [[25_6047, 70, 7356, 2]],
            '''attention_mask''': [[1, 1, 1, 1]],
            # ar_AR
            '''forced_bos_token_id''': 25_6057,
        }							,	)




  @require_torch
  def   UpperCamelCase__      (				self    :					List[Any]  )     ->						Dict:
    _UpperCamelCase       			=True
    _UpperCamelCase       			=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							,	[1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2, 25_6047]  )

    _UpperCamelCase       			=False
    _UpperCamelCase       			=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							,	[25_6047, 1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2]  )













'''simple docstring'''






def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  return 1 if digit in (0, 1) else (digit * factorial(digit - 1   ))


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  _UpperCamelCase       			=0
  _UpperCamelCase       			=number
  while duplicate > 0:
    _UpperCamelCase			,     _UpperCamelCase       			=divmod(__SCREAMING_SNAKE_CASE  ,      10   )
    fact_sum += factorial(__SCREAMING_SNAKE_CASE   )
  return fact_sum == number


if __name__ == "__main__":
      print('Program to check whether a number is a Krisnamurthy Number or not.')
      __lowerCamelCase						: Optional[Any]		=   int(input('Enter number: ').strip())
      print(
          F"""{number} is {'' if krishnamurthy(number) else 'not '}a Krishnamurthy Number."""
      )






