



def    _lowerCAmelCase    (_lowerCAmelCase):
					UpperCamelCase_		  =   generate_pascal_triangle(_lowerCAmelCase)
					for row_idx in range(_lowerCAmelCase):
										# Print left spaces
										for _ in range(num_rows - row_idx - 1):
															print(end=" ")
										# Print row values
										for col_idx in range(row_idx + 1):
															if col_idx != row_idx:
																				print(triangle[row_idx][col_idx]   ,	end=" ")
															else:
																				print(triangle[row_idx][col_idx]   ,	end="")
										print()



def    _lowerCAmelCase    (_lowerCAmelCase):

					if not isinstance(_lowerCAmelCase   ,	_lowerCAmelCase):
										raise TypeError("The input value of 'num_rows' should be 'int'")

					if num_rows == 0:
										return []
					elif num_rows < 0:
										raise ValueError(
										    "The input value of 'num_rows' should be greater than or equal to 0")

					UpperCamelCase_		  =   []
					for current_row_idx in range(_lowerCAmelCase):
										UpperCamelCase_		  =   populate_current_row(_lowerCAmelCase   ,	_lowerCAmelCase)
										triangle.append(_lowerCAmelCase)
					return triangle



def    _lowerCAmelCase    (_lowerCAmelCase   ,	_lowerCAmelCase):
					UpperCamelCase_		  =   [-1] * (current_row_idx + 1)
					# first and last elements of current row are equal to 1
					UpperCamelCase_  ,    UpperCamelCase_		  =   1, 1
					for current_col_idx in range(1   ,	_lowerCAmelCase):
										calculate_current_element(
										    _lowerCAmelCase   ,	_lowerCAmelCase   ,	_lowerCAmelCase   ,	_lowerCAmelCase)
					return current_row



def    _lowerCAmelCase    (_lowerCAmelCase   ,	_lowerCAmelCase   ,	_lowerCAmelCase   ,	_lowerCAmelCase   ,	):
					UpperCamelCase_		  =   triangle[current_row_idx - 1][current_col_idx - 1]
					UpperCamelCase_		  =   triangle[current_row_idx - 1][current_col_idx]
					UpperCamelCase_		  =   above_to_left_elt + above_to_right_elt



def    _lowerCAmelCase    (_lowerCAmelCase):

					if not isinstance(_lowerCAmelCase   ,	_lowerCAmelCase):
										raise TypeError("The input value of 'num_rows' should be 'int'")

					if num_rows == 0:
										return []
					elif num_rows < 0:
										raise ValueError(
										    "The input value of 'num_rows' should be greater than or equal to 0")

					UpperCamelCase_		  =   [[1]]

					for row_index in range(1   ,	_lowerCAmelCase):
										UpperCamelCase_		  =   [0] + result[-1] + [0]
										UpperCamelCase_		  =   row_index + 1
										# Calculate the number of distinct elements in a row
										UpperCamelCase_		  =   sum(divmod(_lowerCAmelCase   ,	2))
										UpperCamelCase_		  =   [
										    temp_row[i - 1] + temp_row[i] for i in range(1   ,	distinct_elements + 1)
										]
										UpperCamelCase_		  =   row_first_half[: (row_index + 1) // 2]
										row_second_half.reverse()
										UpperCamelCase_		  =   row_first_half + row_second_half
										result.append(_lowerCAmelCase)

					return result



def    _lowerCAmelCase    ():
					from collections.abc import Callable
					from timeit import timeit

					def benchmark_a_function(_lowerCAmelCase   ,	_lowerCAmelCase) -> None:
										UpperCamelCase_		  =   f"""{func.__name__}({value})"""
										UpperCamelCase_		  =   timeit(f"""__main__.{call}"""   ,	setup="import __main__")
										# print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
										print(f"""{call:38} -- {timing:.4f} seconds""")

					for value in range(15):  # (1, 7, 14):
										for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
															benchmark_a_function(_lowerCAmelCase   ,	_lowerCAmelCase)
										print()


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	benchmark()





import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartTokenizer, MBartTokenizerFast, 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


UpperCAmelCase   :							List[str]							 =get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
	from transformers.models.mbart.modeling_mbart import shift_tokens_right

UpperCAmelCase   :							int							 =25_0004
UpperCAmelCase   :							Dict							 =25_0020


@require_sentencepiece
@require_tokenizers
class       _lowercase   (a_      ,   unittest.TestCase      ):
				'''simple docstring'''







				lowercase__   						=						MBartTokenizer
				lowercase__   						=						MBartTokenizerFast
				lowercase__   						=						True
				lowercase__   						=						True

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									super().setUp()

									# We have a SentencePiece fixture for testing
									UpperCamelCase_		  =   MBartTokenizer(snake_case__     , keep_accents=snake_case__    )
									tokenizer.save_pretrained(self.tmpdirname    )

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									UpperCamelCase_		  =   MBartTokenizer(snake_case__     , keep_accents=snake_case__    )

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

									self.assertListEqual(
									    tokenizer.convert_tokens_to_ids(snake_case__    )     , [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(
									    snake_case__     , [
									        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(snake_case__    )
									self.assertListEqual(
									    snake_case__     , [
									        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]
									        #                                       ^ unk: 2 + 1 = 3                  unk: 2 + 1 = 3 ^
									    ]     , )

									UpperCamelCase_		  =   tokenizer.convert_ids_to_tokens(snake_case__    )
									self.assertListEqual(
									    snake_case__     , [
									        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       _lowerCamelCase					( self    ):

									'''simple docstring'''


									if not self.test_slow_tokenizer:
														# as we don't have a slow version, we can't compare the outputs between slow and fast versions
														return

									UpperCamelCase_		  =   (self.rust_tokenizer_class, "hf-internal-testing/tiny-random-mbart", {})
									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(snake_case__     , **snake_case__    )
																			UpperCamelCase_		  =   self.tokenizer_class.from_pretrained(snake_case__     , **snake_case__    )

																			UpperCamelCase_		  =   tempfile.mkdtemp()

																			UpperCamelCase_		  =   tokenizer_r.save_pretrained(snake_case__    )
																			UpperCamelCase_		  =   tokenizer_p.save_pretrained(snake_case__    )

																			# 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(snake_case__     , snake_case__    )

																			# Checks everything loads correctly in the same way
																			UpperCamelCase_		  =   tokenizer_r.from_pretrained(snake_case__    )
																			UpperCamelCase_		  =   tokenizer_p.from_pretrained(snake_case__    )

																			# Check special tokens are set accordingly on Rust and Python
																			for key in tokenizer_pp.special_tokens_map:
																								self.assertTrue(hasattr(snake_case__     , snake_case__    )    )
																								# self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
																								# self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

																			shutil.rmtree(snake_case__    )

																			# Save tokenizer rust, legacy_format=True
																			UpperCamelCase_		  =   tempfile.mkdtemp()

																			UpperCamelCase_		  =   tokenizer_r.save_pretrained(snake_case__     , legacy_format=snake_case__    )
																			UpperCamelCase_		  =   tokenizer_p.save_pretrained(snake_case__    )

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

																			# Checks everything loads correctly in the same way
																			UpperCamelCase_		  =   tokenizer_r.from_pretrained(snake_case__    )
																			UpperCamelCase_		  =   tokenizer_p.from_pretrained(snake_case__    )

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

																			shutil.rmtree(snake_case__    )

																			# Save tokenizer rust, legacy_format=False
																			UpperCamelCase_		  =   tempfile.mkdtemp()

																			UpperCamelCase_		  =   tokenizer_r.save_pretrained(snake_case__     , legacy_format=snake_case__    )
																			UpperCamelCase_		  =   tokenizer_p.save_pretrained(snake_case__    )

																			# 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(snake_case__    )
																			UpperCamelCase_		  =   tokenizer_p.from_pretrained(snake_case__    )

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

																			shutil.rmtree(snake_case__    )




@require_torch
@require_sentencepiece
@require_tokenizers
class       _lowercase   (unittest.TestCase      ):
				'''simple docstring'''







				lowercase__   						=						"""facebook/mbart-large-en-ro"""
				lowercase__   						=						[
				    """ 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.""",
				]
				lowercase__   						=						[
				    """Ş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.""",
				]
				lowercase__   						=						[82_74, 12_78_73, 2_59_16, 7, 86_22, 20_71, 4_38, 6_74_85, 53, 18_78_95, 23, 5_17_12, 2, EN_CODE]

				@classmethod
				def       _lowerCamelCase					( cls    ):

									'''simple docstring'''


									UpperCamelCase_		  =   MBartTokenizer.from_pretrained(
									    cls.checkpoint_name     , src_lang="en_XX"     , tgt_lang="ro_RO"    )
									UpperCamelCase_		  =   1
									return cls

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ar_AR"]     , 25_0001    )
									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["en_EN"]     , 25_0004    )
									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ro_RO"]     , 25_0020    )

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									UpperCamelCase_		  =   self.tokenizer.batch_encode_plus(self.src_text    ).input_ids[0]
									self.assertListEqual(self.expected_src_tokens     , snake_case__    )

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									self.assertIn(snake_case__     , self.tokenizer.all_special_ids    )
									UpperCamelCase_		  =   [RO_CODE, 884, 9019, 96, 9, 916, 8_6792, 36, 1_8743, 1_5596, 5, 2]
									UpperCamelCase_		  =   self.tokenizer.decode(snake_case__     , skip_special_tokens=snake_case__    )
									UpperCamelCase_		  =   self.tokenizer.decode(generated_ids[1:]     , skip_special_tokens=snake_case__    )
									self.assertEqual(snake_case__     , snake_case__    )
									self.assertNotIn(self.tokenizer.eos_token     , snake_case__    )

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									UpperCamelCase_		  =   ["this is gunna be a long sentence " * 20]
									assert isinstance(src_text[0]     , snake_case__    )
									UpperCamelCase_		  =   10
									UpperCamelCase_		  =   self.tokenizer(snake_case__     , max_length=snake_case__     , truncation=snake_case__    ).input_ids[0]
									self.assertEqual(ids[-2]     , 2    )
									self.assertEqual(ids[-1]     , snake_case__    )
									self.assertEqual(len(snake_case__    )     , snake_case__    )

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"]    )     , [25_0026, 25_0001]    )

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									UpperCamelCase_		  =   tempfile.mkdtemp()
									UpperCamelCase_		  =   self.tokenizer.fairseq_tokens_to_ids
									self.tokenizer.save_pretrained(snake_case__    )
									UpperCamelCase_		  =   MBartTokenizer.from_pretrained(snake_case__    )
									self.assertDictEqual(new_tok.fairseq_tokens_to_ids     , snake_case__    )

				@require_torch
				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									UpperCamelCase_		  =   self.tokenizer(self.src_text     , text_target=self.tgt_text     , padding=snake_case__     , return_tensors="pt"    )
									UpperCamelCase_		  =   shift_tokens_right(batch["labels"]     , self.tokenizer.pad_token_id    )

									# fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
									assert batch.input_ids[1][-2:].tolist() == [2, EN_CODE]
									assert batch.decoder_input_ids[1][0].tolist() == RO_CODE
									assert batch.decoder_input_ids[1][-1] == 2
									assert batch.labels[1][-2:].tolist() == [2, RO_CODE]

				@require_torch
				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									UpperCamelCase_		  =   self.tokenizer(
									    self.src_text     , text_target=self.tgt_text     , padding=snake_case__     , truncation=snake_case__     , max_length=len(self.expected_src_tokens    )     , return_tensors="pt"     , )

									UpperCamelCase_		  =   shift_tokens_right(batch["labels"]     , self.tokenizer.pad_token_id    )

									self.assertIsInstance(snake_case__     , snake_case__    )

									self.assertEqual((2, 14)     , batch.input_ids.shape    )
									self.assertEqual((2, 14)     , batch.attention_mask.shape    )
									UpperCamelCase_		  =   batch.input_ids.tolist()[0]
									self.assertListEqual(self.expected_src_tokens     , snake_case__    )
									self.assertEqual(2     , batch.decoder_input_ids[0, -1]    )  # EOS
									# Test that special tokens are reset
									self.assertEqual(self.tokenizer.prefix_tokens     , []    )
									self.assertEqual(self.tokenizer.suffix_tokens     , [self.tokenizer.eos_token_id, EN_CODE]    )

				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									UpperCamelCase_		  =   self.tokenizer(self.src_text     , padding=snake_case__     , truncation=snake_case__     , max_length=3     , return_tensors="pt"    )
									UpperCamelCase_		  =   self.tokenizer(
									    text_target=self.tgt_text     , padding=snake_case__     , truncation=snake_case__     , max_length=10     , return_tensors="pt"    )
									UpperCamelCase_		  =   targets["input_ids"]
									UpperCamelCase_		  =   shift_tokens_right(snake_case__     , self.tokenizer.pad_token_id    )

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

				@require_torch
				def       _lowerCamelCase					( self    ):

									'''simple docstring'''


									UpperCamelCase_		  =   self.tokenizer._build_translation_inputs(
									    "A test"     , return_tensors="pt"     , src_lang="en_XX"     , tgt_lang="ar_AR"    )

									self.assertEqual(
									    nested_simplify(snake_case__    )     , {
									        # A, test, EOS, en_XX
									        "input_ids": [[62, 3034, 2, 25_0004]],
									        "attention_mask": [[1, 1, 1, 1]],
									        # ar_AR
									        "forced_bos_token_id": 25_0001,
									    }     , )
