






'''simple docstring'''
# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position

UpperCamelCase__ =			"""2.13.1"""

import platform

import pyarrow
from packaging import version


if version.parse(platform.python_version()) < version.parse('3.7'):
 raise ImportWarning(
     'To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.'
 )

if version.parse(pyarrow.__version__).major < 8:
 raise ImportWarning(
     'To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n'
     'If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.'
 )

del platform
del pyarrow
del version

from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
    list_datasets,
    list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
    NamedSplit,
    NamedSplitAll,
    Split,
    SplitBase,
    SplitDict,
    SplitGenerator,
    SplitInfo,
    SubSplitInfo,
    percent,
)
from .tasks import *
from .utils import *
from .utils import logging


# deprecated modules
from datasets import arrow_dataset as _arrow_dataset  # isort:skip
from datasets import utils as _utils  # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip

UpperCamelCase__ =			concatenate_datasets
UpperCamelCase__ =			DownloadConfig
UpperCamelCase__ =			DownloadManager
UpperCamelCase__ =			DownloadMode
UpperCamelCase__ =			DownloadConfig
UpperCamelCase__ =			DownloadMode
UpperCamelCase__ =			DownloadManager

del _arrow_dataset, _utils, _deprecated_download_manager







'''simple docstring'''
def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




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

      lowercase_	:    List[str]           =     update_area_of_max_square(_UpperCamelCase						,		col + 1							)
      lowercase_	:    List[Any]           =     update_area_of_max_square(row + 1						,		col + 1							)
      lowercase_	:    Tuple           =     update_area_of_max_square(row + 1						,		_UpperCamelCase							)

      if mat[row][col]:
         lowercase_	:    Optional[int]           =     1 + min([right, diagonal, down]							)
         lowercase_	:    Any           =     max(largest_square_area[0]						,		_UpperCamelCase							)
         return sub_problem_sol
      else:
         return 0

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




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




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

      lowercase_	:    Dict           =     update_area_of_max_square_using_dp_array(_UpperCamelCase						,		col + 1						,		_UpperCamelCase							)
      lowercase_	:    str           =     update_area_of_max_square_using_dp_array(row + 1						,		col + 1						,		_UpperCamelCase							)
      lowercase_	:    Optional[Any]           =     update_area_of_max_square_using_dp_array(row + 1						,		_UpperCamelCase						,		_UpperCamelCase							)

      if mat[row][col]:
         lowercase_	:    Tuple           =     1 + min([right, diagonal, down]							)
         lowercase_	:    int           =     max(largest_square_area[0]						,		_UpperCamelCase							)
         lowercase_	:    Dict           =     sub_problem_sol
         return sub_problem_sol
      else:
         return 0

   lowercase_	:    Any           =     [0]
   lowercase_	:    Optional[int]           =     [[-1] * cols for _ in range(_UpperCamelCase							)]
   update_area_of_max_square_using_dp_array(0						,		0						,		_UpperCamelCase							)

   return largest_square_area[0]




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




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

         if mat[row][col] == 1:
            lowercase_	:    Any           =     1 + min(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
            lowercase_	:    Any           =     max(dp_array[row][col]						,		_UpperCamelCase							)
         else:
            lowercase_	:    int           =     0

   return largest_square_area




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    Optional[int]           =     [0] * (cols + 1)
   lowercase_	:    Union[str, Any]           =     [0] * (cols + 1)
   lowercase_	:    int           =     0
   for row in range(rows - 1						,		-1						,		-1							):
      for col in range(cols - 1						,		-1						,		-1							):
         lowercase_	:    Dict           =     current_row[col + 1]
         lowercase_	:    List[Any]           =     next_row[col + 1]
         lowercase_	:    Tuple           =     next_row[col]

         if mat[row][col] == 1:
            lowercase_	:    Dict           =     1 + min(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
            lowercase_	:    int           =     max(current_row[col]						,		_UpperCamelCase							)
         else:
            lowercase_	:    Tuple           =     0
      lowercase_	:    Optional[Any]           =     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]]))




