'''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: Optional[int]          =   [
    {'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       (   UpperCAmelCase=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=lowercase__					)					)
class 			UpperCAmelCase  (						lowercase__					):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE							=    None
       SCREAMING_SNAKE_CASE							=    None

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  List[str]:
        with TemporaryDirectory() as tmp_dir:
         lowercase__				:    Optional[Any]  =					dataset_module_factory(SCREAMING_SNAKE_CASE__	,   cache_dir=SCREAMING_SNAKE_CASE__ )

         lowercase__				:    Optional[int]  =					import_main_class(dataset_module.module_path	,   dataset=SCREAMING_SNAKE_CASE__ )

         lowercase__				:    DatasetBuilder  =					builder_cls(
             cache_dir=SCREAMING_SNAKE_CASE__	,   config_name=SCREAMING_SNAKE_CASE__	,   hash=dataset_module.hash	,   )

         lowercase__				:    Any  =					'/'.join(
             [
                 HF_GCP_BASE_URL,
                 builder_instance._relative_data_dir(with_hash=SCREAMING_SNAKE_CASE__ ).replace(os.sep	,   '''/''' ),
                 config.DATASET_INFO_FILENAME,
             ] )
         lowercase__				:    Dict  =					cached_path(SCREAMING_SNAKE_CASE__	,   cache_dir=SCREAMING_SNAKE_CASE__ )
         self.assertTrue(os.path.exists(SCREAMING_SNAKE_CASE__ ) )


@pytest.mark.integration
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    List[str]  =					tmp_path_factory.mktemp('''test_hf_gcp'''     ) / 'test_wikipedia_simple'
 lowercase__				:    Union[str, Any]  =					dataset_module_factory('''wikipedia'''		,     cache_dir=__A     )
 lowercase__				:    Dict  =					import_main_class(dataset_module.module_path     )
 lowercase__				:    DatasetBuilder  =					builder_cls(
     cache_dir=__A		,     config_name='''20220301.frr'''		,     hash=dataset_module.hash		,     )
 # use the HF cloud storage, not the original download_and_prepare that uses apache-beam
 lowercase__				:    Optional[Any]  =					None
 builder_instance.download_and_prepare()
 lowercase__				:    List[Any]  =					builder_instance.as_dataset()
 assert ds





@pytest.mark.integration
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					dataset_module_factory('''wikipedia'''		,     cache_dir=__A     )
 lowercase__				:    Any  =					import_main_class(dataset_module.module_path		,     dataset=__A     )
 lowercase__				:    DatasetBuilder  =					builder_cls(
     cache_dir=__A		,     config_name='''20220301.frr'''		,     hash=dataset_module.hash		,     )
 lowercase__				:    Tuple  =					builder_instance.as_streaming_dataset()
 assert ds
 assert isinstance(__A		,     __A     )
 assert "train" in ds
 assert isinstance(ds['''train''']		,     __A     )
 assert next(iter(ds['''train''']     )     )





UpperCAmelCase_      : Optional[int]  					=       [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
UpperCAmelCase_      : str  					=       [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
UpperCAmelCase_      : str  					=       {
    0: 'Sunday',
    1: 'Monday',
    2: 'Tuesday',
    3: 'Wednesday',
    4: 'Thursday',
    5: 'Friday',
    6: 'Saturday',
}







def        SCREAMING_SNAKE_CASE_						(			__A :			int  ,    __A :			int  ,    __A :			int				)	->		str:

       """simple docstring"""

       assert len(str(__A				)				) > 2, "year should be in YYYY format"
       assert 1 <= month <= 12, "month should be between 1 to 12"
       assert 1 <= day <= 31, "day should be between 1 to 31"

       # Doomsday algorithm:
       a_					:		List[str]							=  year // 1_00
       a_					:		Optional[int]							=  (5 * (century % 4) + 2) % 7
       a_					:		List[str]							=  year % 1_00
       a_					:		str							=  centurian % 12
       a_					:		List[str]							=  (
           (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
       ) % 7
       a_					:		Any							=  (
           DOOMSDAY_NOT_LEAP[month - 1]
           if (year % 4 != 0) or (centurian == 0 and (year % 4_00) == 0)
           else DOOMSDAY_LEAP[month - 1]
       )
       a_					:		Any							=  (dooms_day + day - day_anchor) % 7
       return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
   import doctest

   doctest.testmod()


