


"""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             =   256047
__snake_case             =   256145







@require_sentencepiece
@require_tokenizers
class _lowerCAmelCase    (				snake_case_   ,							unittest.TestCase     ):
   __UpperCAmelCase			:	List[str]							  =  NllbTokenizer
   __UpperCAmelCase			:	Optional[int]							  =  NllbTokenizerFast
   __UpperCAmelCase			:	str							  =  True
   __UpperCAmelCase			:	Dict							  =  True
   __UpperCAmelCase			:	int							  =  {}







   def 			lowerCamelCase		(     self						)     ->		List[Any]:

       '''simple docstring'''




       super().setUp()

       # We have a SentencePiece fixture for testing
       snake_case   :				Optional[int]				 =   NllbTokenizer(UpperCamelCase__						,     keep_accents=UpperCamelCase__						)
       tokenizer.save_pretrained(self.tmpdirname						)







   def 			lowerCamelCase		(     self						)     ->		str:

       '''simple docstring'''




       snake_case   :				Union[str, Any]				 =   NllbTokenizer(UpperCamelCase__						,     keep_accents=UpperCamelCase__						)

       snake_case   :				List[str]				 =   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]]						,     )

       snake_case   :				str				 =   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",
               "é",
               ".",
           ]						,     )
       snake_case   :				List[str]				 =   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]
           ]						,     )

       snake_case   :				int				 =   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 			lowerCamelCase		(     self						)     ->		str:

       '''simple docstring'''




       snake_case   :				str				 =   (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})'						):
               snake_case   :				Optional[Any]				 =   self.rust_tokenizer_class.from_pretrained(UpperCamelCase__						,     **UpperCamelCase__						)
               snake_case   :				Union[str, Any]				 =   self.tokenizer_class.from_pretrained(UpperCamelCase__						,     **UpperCamelCase__						)

               snake_case   :				Tuple				 =   tempfile.mkdtemp()

               snake_case   :				Any				 =   tokenizer_r.save_pretrained(UpperCamelCase__						)
               snake_case   :				Union[str, 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						)						)
               snake_case   :				List[str]				 =   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
               snake_case   :				Dict				 =   tokenizer_r.from_pretrained(UpperCamelCase__						)
               snake_case   :				Union[str, 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=True
               snake_case   :				int				 =   tempfile.mkdtemp()

               snake_case   :				List[str]				 =   tokenizer_r.save_pretrained(UpperCamelCase__						,     legacy_format=UpperCamelCase__						)
               snake_case   :				Union[str, Any]				 =   tokenizer_p.save_pretrained(UpperCamelCase__						)

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

               # Checks everything loads correctly in the same way
               snake_case   :				str				 =   tokenizer_r.from_pretrained(UpperCamelCase__						)
               snake_case   :				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=False
               snake_case   :				Optional[Any]				 =   tempfile.mkdtemp()

               snake_case   :				Optional[Any]				 =   tokenizer_r.save_pretrained(UpperCamelCase__						,     legacy_format=UpperCamelCase__						)
               snake_case   :				Tuple				 =   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
               snake_case   :				Optional[int]				 =   tokenizer_r.from_pretrained(UpperCamelCase__						)
               snake_case   :				Union[str, 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 			lowerCamelCase		(     self						)     ->		List[Any]:

       '''simple docstring'''




       if not self.test_seqaseq:
           return

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

               snake_case   :				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 			lowerCamelCase		(     self						)     ->		Dict:

       '''simple docstring'''




       pass







   def 			lowerCamelCase		(     self						)     ->		List[Any]:

       '''simple docstring'''




       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'						):
               snake_case   :				List[str]				 =   [AddedToken("<special>"						,     lstrip=UpperCamelCase__						)]

               snake_case   :				Dict				 =   self.rust_tokenizer_class.from_pretrained(
                   UpperCamelCase__						,     additional_special_tokens=UpperCamelCase__						,     **UpperCamelCase__						)
               snake_case   :				Optional[Any]				 =   tokenizer_r.encode("Hey this is a <special> token"						)

               snake_case   :				int				 =   tokenizer_r.encode("<special>"						,     add_special_tokens=UpperCamelCase__						)[0]

               self.assertTrue(special_token_id in r_output						)

               if self.test_slow_tokenizer:
                   snake_case   :				int				 =   self.rust_tokenizer_class.from_pretrained(
                       UpperCamelCase__						,     additional_special_tokens=UpperCamelCase__						,     **UpperCamelCase__						,     )
                   snake_case   :				Optional[int]				 =   self.tokenizer_class.from_pretrained(
                       UpperCamelCase__						,     additional_special_tokens=UpperCamelCase__						,     **UpperCamelCase__						)

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

                   snake_case   :				str				 =   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 _lowerCAmelCase    (				unittest.TestCase     ):
   __UpperCAmelCase			:	List[Any]							  =  '''facebook/nllb-200-distilled-600M'''
   __UpperCAmelCase			:	Dict							  =  [
       ''' 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			:	int							  =  [
       '''Ş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			:	Any							  =  [
       256047,
       16297,
       134408,
       8165,
       248066,
       14734,
       950,
       1135,
       105721,
       3573,
       83,
       27352,
       108,
       49486,
       2,
   ]







   @classmethod
   def 			lowerCamelCase		(     cls						)     ->		Any:

       '''simple docstring'''




       snake_case   :				NllbTokenizer				 =   NllbTokenizer.from_pretrained(
           cls.checkpoint_name						,     src_lang="eng_Latn"						,     tgt_lang="ron_Latn"						)
       snake_case   :				Union[str, Any]				 =   1
       return cls







   def 			lowerCamelCase		(     self						)     ->		Union[str, Any]:

       '''simple docstring'''




       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 			lowerCamelCase		(     self						)     ->		Optional[Any]:

       '''simple docstring'''




       snake_case   :				Union[str, Any]				 =   self.tokenizer.batch_encode_plus(self.src_text						).input_ids[0]
       self.assertListEqual(self.expected_src_tokens						,     UpperCamelCase__						)







   def 			lowerCamelCase		(     self						)     ->		int:

       '''simple docstring'''




       self.assertIn(UpperCamelCase__						,     self.tokenizer.all_special_ids						)
       # fmt: off
       snake_case   :				Any				 =   [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

       snake_case   :				Union[str, Any]				 =   self.tokenizer.decode(UpperCamelCase__						,     skip_special_tokens=UpperCamelCase__						)
       snake_case   :				Any				 =   self.tokenizer.decode(generated_ids[1:]						,     skip_special_tokens=UpperCamelCase__						)
       self.assertEqual(UpperCamelCase__						,     UpperCamelCase__						)
       self.assertNotIn(self.tokenizer.eos_token						,     UpperCamelCase__						)







   def 			lowerCamelCase		(     self						)     ->		Dict:

       '''simple docstring'''




       snake_case   :				Optional[Any]				 =   ["this is gunna be a long sentence " * 20]
       assert isinstance(src_text[0]						,     UpperCamelCase__						)
       snake_case   :				Any				 =   10
       snake_case   :				Optional[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 			lowerCamelCase		(     self						)     ->		Dict:

       '''simple docstring'''




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







   def 			lowerCamelCase		(     self						)     ->		Tuple:

       '''simple docstring'''




       snake_case   :				Any				 =   tempfile.mkdtemp()
       snake_case   :				Optional[Any]				 =   self.tokenizer.fairseq_tokens_to_ids
       self.tokenizer.save_pretrained(UpperCamelCase__						)
       snake_case   :				Any				 =   NllbTokenizer.from_pretrained(UpperCamelCase__						)
       self.assertDictEqual(new_tok.fairseq_tokens_to_ids						,     UpperCamelCase__						)







   @require_torch
   def 			lowerCamelCase		(     self						)     ->		Tuple:

       '''simple docstring'''




       snake_case   :				Dict				 =   self.tokenizer(
           self.src_text						,     text_target=self.tgt_text						,     padding=UpperCamelCase__						,     truncation=UpperCamelCase__						,     max_length=len(self.expected_src_tokens						)						,     return_tensors="pt"						,     )
       snake_case   :				List[str]				 =   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						)
       snake_case   :				str				 =   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 			lowerCamelCase		(     self						)     ->		Union[str, Any]:

       '''simple docstring'''




       snake_case   :				Dict				 =   self.tokenizer(self.src_text						,     padding=UpperCamelCase__						,     truncation=UpperCamelCase__						,     max_length=3						,     return_tensors="pt"						)
       snake_case   :				int				 =   self.tokenizer(
           text_target=self.tgt_text						,     padding=UpperCamelCase__						,     truncation=UpperCamelCase__						,     max_length=10						,     return_tensors="pt"						)
       snake_case   :				Optional[Any]				 =   targets["input_ids"]
       snake_case   :				Union[str, 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 			lowerCamelCase		(     self						)     ->		List[Any]:

       '''simple docstring'''




       snake_case   :				Optional[int]				 =   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 			lowerCamelCase		(     self						)     ->		Any:

       '''simple docstring'''




       snake_case   :				Dict				 =   True
       snake_case   :				List[Any]				 =   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]						)

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










"""simple docstring"""



def   __lowerCAmelCase						(						lowercase  :  int						,							lowercase  :  int						,							lowercase  :  list[list[int]]			)     ->						int:


    """simple docstring"""





    def update_area_of_max_square(lowercase  :  int						,							lowercase  :  int			) -> int:
        # BASE CASE
        if row >= rows or col >= cols:
            return 0

        snake_case   :				Dict				 =   update_area_of_max_square(lowercase						,							col + 1			)
        snake_case   :				Tuple				 =   update_area_of_max_square(row + 1						,							col + 1			)
        snake_case   :				Any				 =   update_area_of_max_square(row + 1						,							lowercase			)

        if mat[row][col]:
            snake_case   :				List[Any]				 =   1 + min([right, diagonal, down]			)
            snake_case   :				Any				 =   max(largest_square_area[0]						,							lowercase			)
            return sub_problem_sol
        else:
            return 0

    snake_case   :				int				 =   [0]
    update_area_of_max_square(0						,							0			)
    return largest_square_area[0]







def   __lowerCAmelCase						(						lowercase  :  int						,							lowercase  :  int						,							lowercase  :  list[list[int]]			)     ->						int:


    """simple docstring"""





    def update_area_of_max_square_using_dp_array(
        lowercase  :  int						,							lowercase  :  int						,							lowercase  :  list[list[int]]			) -> int:
        if row >= rows or col >= cols:
            return 0
        if dp_array[row][col] != -1:
            return dp_array[row][col]

        snake_case   :				List[str]				 =   update_area_of_max_square_using_dp_array(lowercase						,							col + 1						,							lowercase			)
        snake_case   :				Optional[int]				 =   update_area_of_max_square_using_dp_array(row + 1						,							col + 1						,							lowercase			)
        snake_case   :				Optional[int]				 =   update_area_of_max_square_using_dp_array(row + 1						,							lowercase						,							lowercase			)

        if mat[row][col]:
            snake_case   :				Dict				 =   1 + min([right, diagonal, down]			)
            snake_case   :				Union[str, Any]				 =   max(largest_square_area[0]						,							lowercase			)
            snake_case   :				str				 =   sub_problem_sol
            return sub_problem_sol
        else:
            return 0

    snake_case   :				Union[str, Any]				 =   [0]
    snake_case   :				int				 =   [[-1] * cols for _ in range(lowercase			)]
    update_area_of_max_square_using_dp_array(0						,							0						,							lowercase			)

    return largest_square_area[0]







def   __lowerCAmelCase						(						lowercase  :  int						,							lowercase  :  int						,							lowercase  :  list[list[int]]			)     ->						int:


    """simple docstring"""





    snake_case   :				int				 =   [[0] * (cols + 1) for _ in range(rows + 1			)]
    snake_case   :				List[Any]				 =   0
    for row in range(rows - 1						,							-1						,							-1			):
        for col in range(cols - 1						,							-1						,							-1			):
            snake_case   :				Tuple				 =   dp_array[row][col + 1]
            snake_case   :				Any				 =   dp_array[row + 1][col + 1]
            snake_case   :				List[str]				 =   dp_array[row + 1][col]

            if mat[row][col] == 1:
                snake_case   :				Optional[int]				 =   1 + min(lowercase						,							lowercase						,							lowercase			)
                snake_case   :				Tuple				 =   max(dp_array[row][col]						,							lowercase			)
            else:
                snake_case   :				List[Any]				 =   0

    return largest_square_area







def   __lowerCAmelCase						(						lowercase  :  int						,							lowercase  :  int						,							lowercase  :  list[list[int]]			)     ->						int:


    """simple docstring"""





    snake_case   :				Any				 =   [0] * (cols + 1)
    snake_case   :				Any				 =   [0] * (cols + 1)
    snake_case   :				Any				 =   0
    for row in range(rows - 1						,							-1						,							-1			):
        for col in range(cols - 1						,							-1						,							-1			):
            snake_case   :				Dict				 =   current_row[col + 1]
            snake_case   :				List[Any]				 =   next_row[col + 1]
            snake_case   :				Dict				 =   next_row[col]

            if mat[row][col] == 1:
                snake_case   :				Union[str, Any]				 =   1 + min(lowercase						,							lowercase						,							lowercase			)
                snake_case   :				Optional[int]				 =   max(current_row[col]						,							lowercase			)
            else:
                snake_case   :				Optional[Any]				 =   0
        snake_case   :				str				 =   current_row

    return largest_square_area


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  print(largest_square_area_in_matrix_bottom_up(2, 2, [[1, 1], [1, 1]]))





