




from typing import Optional

from .. import Features, NamedSplit
from ..packaged_modules.text.text import Text
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader
class 						_A (  _lowerCamelCase				):






  def __init__(  self		:     List[Any]				,						_A		:     NestedDataStructureLike[PathLike]				,						_A		:     Optional[NamedSplit] = None				,						_A		:     Optional[Features] = None				,						_A		:     str = None				,						_A		:     bool = False				,						_A		:     bool = False				,						_A		:     Optional[int] = None				,						**_A		:     Dict				,						)		->   Optional[int]:






       """simple docstring"""







       super().__init__(
           _A				,						split=_A				,						features=_A				,						cache_dir=_A				,						keep_in_memory=_A				,						streaming=_A				,						num_proc=_A				,						**_A				,						)
       lowercase :       Dict       =			path_or_paths if isinstance(_A				,						_A				) else {self.split: path_or_paths}
       lowercase :       Dict       =			Text(
           cache_dir=_A				,						data_files=_A				,						features=_A				,						**_A				,						)






  def  __a      (  self		:     str				)		->   List[Any]:






       """simple docstring"""







       if self.streaming:
            lowercase :       Any       =			self.builder.as_streaming_dataset(split=self.split				)
       # Build regular (map-style) dataset
       else:
            lowercase :       List[Any]       =			None
            lowercase :       int       =			None
            lowercase :       int       =			None
            lowercase :       Optional[Any]       =			None

            self.builder.download_and_prepare(
                download_config=_A				,						download_mode=_A				,						verification_mode=_A				,						base_path=_A				,						num_proc=self.num_proc				,						)
            lowercase :       Any       =			self.builder.as_dataset(
                split=self.split				,						verification_mode=_A				,						in_memory=self.keep_in_memory				)
       return dataset





def  snake_case(    __magic_name__			,		__magic_name__   )			->							bool:





     '''simple docstring'''


     lowercase :       List[Any]       =			len(__magic_name__   )
     lowercase :       str       =			[[False] * (required_sum + 1) for _ in range(arr_len + 1   )]

     # for each arr value, a sum of zero(0) can be formed by not taking any element
     # hence True/1
     for i in range(arr_len + 1   ):
          lowercase :       List[str]       =			True

     # sum is not zero and set is empty then false
     for i in range(1			,		required_sum + 1   ):
          lowercase :       str       =			False

     for i in range(1			,		arr_len + 1   ):
          for j in range(1			,		required_sum + 1   ):
               if arr[i - 1] > j:
                    lowercase :       Optional[Any]       =			subset[i - 1][j]
               if arr[i - 1] <= j:
                    lowercase :       Dict       =			subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

     return subset[arr_len][required_sum]


if __name__ == "__main__":
 import doctest

 doctest.testmod()