'''simple docstring'''




import os
from tempfile import TemporaryDirectory
from unittest import TestCase

import pytest
from absl.testing import parameterized

from datasets import config
from datasets.arrow_reader import HF_GCP_BASE_URL
from datasets.builder import DatasetBuilder
from datasets.dataset_dict import IterableDatasetDict
from datasets.iterable_dataset import IterableDataset
from datasets.load import dataset_module_factory, import_main_class
from datasets.utils.file_utils import cached_path


_A								=   [
    {'dataset': 'wikipedia', 'config_name': '20220301.de'},
    {'dataset': 'wikipedia', 'config_name': '20220301.en'},
    {'dataset': 'wikipedia', 'config_name': '20220301.fr'},
    {'dataset': 'wikipedia', 'config_name': '20220301.frr'},
    {'dataset': 'wikipedia', 'config_name': '20220301.it'},
    {'dataset': 'wikipedia', 'config_name': '20220301.simple'},
    {'dataset': 'snli', 'config_name': 'plain_text'},
    {'dataset': 'eli5', 'config_name': 'LFQA_reddit'},
    {'dataset': 'wiki40b', 'config_name': 'en'},
    {'dataset': 'wiki_dpr', 'config_name': 'psgs_w100.nq.compressed'},
    {'dataset': 'wiki_dpr', 'config_name': 'psgs_w100.nq.no_index'},
    {'dataset': 'wiki_dpr', 'config_name': 'psgs_w100.multiset.no_index'},
    {'dataset': 'natural_questions', 'config_name': 'default'},
]

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_=True							):
     if with_config:
          return [
              {
                  "testcase_name": d["dataset"] + "/" + d["config_name"],
                  "dataset": d["dataset"],
                  "config_name": d["config_name"],
              }
              for d in DATASETS_ON_HF_GCP
          ]
     else:
          return [
              {"testcase_name": dataset, "dataset": dataset} for dataset in {d["dataset"] for d in DATASETS_ON_HF_GCP}
          ]


@parameterized.named_parameters(list_datasets_on_hf_gcp_parameters(with_config=_snake_case			)			)
class       UpperCAmelCase__  (       _snake_case			):






   """simple docstring"""
   A							:       Dict     =    None
   A							:       Tuple     =    None
   def 		_lowerCamelCase (self       ,				_a       ,				_a				)    ->     Any:
        with TemporaryDirectory() as tmp_dir:
             lowercase_					:       Tuple     				=					dataset_module_factory(_a       ,				cache_dir=_a				)

             lowercase_					:       Tuple     				=					import_main_class(dataset_module.module_path       ,				dataset=_a				)

             lowercase_					:       DatasetBuilder     				=					builder_cls(
                 cache_dir=_a       ,				config_name=_a       ,				hash=dataset_module.hash       ,				)

             lowercase_					:       Optional[Any]     				=					'/'.join(
                 [
                     HF_GCP_BASE_URL,
                     builder_instance._relative_data_dir(with_hash=_a				).replace(os.sep       ,				'/'				),
                     config.DATASET_INFO_FILENAME,
                 ]				)
             lowercase_					:       int     				=					cached_path(_a       ,				cache_dir=_a				)
             self.assertTrue(os.path.exists(_a				)				)



@pytest.mark.integration
def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       str     				=					tmp_path_factory.mktemp('test_hf_gcp'							) / 'test_wikipedia_simple'
     lowercase_					:       str     				=					dataset_module_factory('wikipedia'  ,       cache_dir=SCREAMING_SNAKE_CASE_							)
     lowercase_					:       str     				=					import_main_class(dataset_module.module_path							)
     lowercase_					:       DatasetBuilder     				=					builder_cls(
         cache_dir=SCREAMING_SNAKE_CASE_  ,       config_name='20220301.frr'  ,       hash=dataset_module.hash  ,       )
     # use the HF cloud storage, not the original download_and_prepare that uses apache-beam
     lowercase_					:       Dict     				=					None
     builder_instance.download_and_prepare()
     lowercase_					:       str     				=					builder_instance.as_dataset()
     assert ds






@pytest.mark.integration
def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       Dict     				=					dataset_module_factory('wikipedia'  ,       cache_dir=SCREAMING_SNAKE_CASE_							)
     lowercase_					:       int     				=					import_main_class(dataset_module.module_path  ,       dataset=SCREAMING_SNAKE_CASE_							)
     lowercase_					:       DatasetBuilder     				=					builder_cls(
         cache_dir=SCREAMING_SNAKE_CASE_  ,       config_name='20220301.frr'  ,       hash=dataset_module.hash  ,       )
     lowercase_					:       Union[str, Any]     				=					builder_instance.as_streaming_dataset()
     assert ds
     assert isinstance(SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							)
     assert "train" in ds
     assert isinstance(ds['train']  ,       SCREAMING_SNAKE_CASE_							)
     assert next(iter(ds['train']							)							)





'''simple docstring'''




import os

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       List[Any]     				=					len(grid[0]							)
     lowercase_					:       Union[str, Any]     				=					len(SCREAMING_SNAKE_CASE_							)

     lowercase_					:       Union[str, Any]     				=					0
     lowercase_					:       int     				=					0
     lowercase_					:       Union[str, Any]     				=					0

     # Check vertically, horizontally, diagonally at the same time (only works
     # for nxn grid)
     for i in range(SCREAMING_SNAKE_CASE_							):
          for j in range(n_rows - 3							):
               lowercase_					:       Dict     				=					grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
               lowercase_					:       Optional[Any]     				=					grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]

               # Left-to-right diagonal (\) product
               if i < n_columns - 3:
                    lowercase_					:       Tuple     				=					(
                        grid[i][j]
                        * grid[i + 1][j + 1]
                        * grid[i + 2][j + 2]
                        * grid[i + 3][j + 3]
                    )

               # Right-to-left diagonal(/) product
               if i > 2:
                    lowercase_					:       int     				=					(
                        grid[i][j]
                        * grid[i - 1][j + 1]
                        * grid[i - 2][j + 2]
                        * grid[i - 3][j + 3]
                    )

               lowercase_					:       Optional[int]     				=					max(
                   SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							)
               if max_product > largest:
                    lowercase_					:       List[Any]     				=					max_product

     return largest

def _UpperCamelCase   (       ):
     lowercase_					:       int     				=					[]
     with open(os.path.dirname(SCREAMING_SNAKE_CASE_							) + '/grid.txt'							) as file:
          for line in file:
               grid.append(line.strip('\n'							).split(' '							)							)

     lowercase_					:       Dict     				=					[[int(SCREAMING_SNAKE_CASE_							) for i in grid[j]] for j in range(len(SCREAMING_SNAKE_CASE_							)							)]

     return largest_product(SCREAMING_SNAKE_CASE_							)


if __name__ == "__main__":
 print(solution())




