


"""simple docstring"""



import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


__snake_case             =   logging.getLogger()







@unittest.skip('''Temporarily disable the doc tests.'''     )
@require_torch
@require_tf
@slow
class _lowerCAmelCase    (				unittest.TestCase     ):







   def 			lowerCamelCase		(     self						,     UpperCamelCase__						,     UpperCamelCase__ = None						,     UpperCamelCase__ = None						,     UpperCamelCase__ = None						,     UpperCamelCase__ = True						,     )     ->		Tuple:

       '''simple docstring'''




       snake_case   :				List[Any]				 =   [file for file in os.listdir(UpperCamelCase__						) if os.path.isfile(os.path.join(UpperCamelCase__						,     UpperCamelCase__						)						)]

       if identifier is not None:
           snake_case   :				Optional[Any]				 =   [file for file in files if identifier in file]

       if n_identifier is not None:
           if isinstance(UpperCamelCase__						,     UpperCamelCase__						):
               for n_ in n_identifier:
                   snake_case   :				str				 =   [file for file in files if n_ not in file]
           else:
               snake_case   :				str				 =   [file for file in files if n_identifier not in file]

       snake_case   :				Tuple				 =   ignore_files or []
       ignore_files.append("__init__.py"						)
       snake_case   :				Optional[Any]				 =   [file for file in files if file not in ignore_files]

       for file in files:
           # Open all files
           print("Testing"						,     UpperCamelCase__						)

           if only_modules:
               snake_case   :				str				 =   file.split("."						)[0]
               try:
                   snake_case   :				Optional[int]				 =   getattr(UpperCamelCase__						,     UpperCamelCase__						)
                   snake_case   :				str				 =   doctest.DocTestSuite(UpperCamelCase__						)
                   snake_case   :				Optional[Any]				 =   unittest.TextTestRunner().run(UpperCamelCase__						)
                   self.assertIs(len(result.failures						)						,     0						)
               except AttributeError:
                   logger.info(F'{module_identifier} is not a module.'						)
           else:
               snake_case   :				Tuple				 =   doctest.testfile(str(".." / directory / file						)						,     optionflags=doctest.ELLIPSIS						)
               self.assertIs(result.failed						,     0						)







   def 			lowerCamelCase		(     self						)     ->		str:

       '''simple docstring'''




       snake_case   :				Tuple				 =   Path("src/transformers"						)
       snake_case   :				List[Any]				 =   "modeling"
       snake_case   :				Dict				 =   [
           "modeling_ctrl.py",
           "modeling_tf_ctrl.py",
       ]
       self.analyze_directory(UpperCamelCase__						,     identifier=UpperCamelCase__						,     ignore_files=UpperCamelCase__						)







   def 			lowerCamelCase		(     self						)     ->		Dict:

       '''simple docstring'''




       snake_case   :				Optional[Any]				 =   Path("src/transformers"						)
       snake_case   :				Optional[Any]				 =   "tokenization"
       self.analyze_directory(UpperCamelCase__						,     identifier=UpperCamelCase__						)







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

       '''simple docstring'''




       snake_case   :				Union[str, Any]				 =   Path("src/transformers"						)
       snake_case   :				Optional[Any]				 =   "configuration"
       self.analyze_directory(UpperCamelCase__						,     identifier=UpperCamelCase__						)







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

       '''simple docstring'''




       snake_case   :				List[str]				 =   Path("src/transformers"						)
       snake_case   :				List[str]				 =   ["configuration", "modeling", "tokenization"]
       self.analyze_directory(UpperCamelCase__						,     n_identifier=UpperCamelCase__						)







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

       '''simple docstring'''




       snake_case   :				Any				 =   Path("docs/source"						)
       snake_case   :				Tuple				 =   ["favicon.ico"]
       self.analyze_directory(UpperCamelCase__						,     ignore_files=UpperCamelCase__						,     only_modules=UpperCamelCase__						)









"""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]]))





