


'''simple docstring'''







from __future__ import annotations

import math







def _UpperCamelCase       (     __A    )							->		bool:


      '''simple docstring'''



      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5      ,			int(math.sqrt(__A    ) + 1    )      ,			6    ):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True







def _UpperCamelCase       (     __A    )							->		list[int]:


      '''simple docstring'''



      UpperCamelCase__										=				str(__A    )
      UpperCamelCase__										=				[n]
      for i in range(1      ,			len(__A    )    ):
            list_nums.append(int(str_num[i:]    )    )
            list_nums.append(int(str_num[:-i]    )    )
      return list_nums







def _UpperCamelCase       (     __A    )							->		bool:


      '''simple docstring'''



      if len(str(__A    )    ) > 3:
            if not is_prime(int(str(__A    )[-3:]    )    ) or not is_prime(int(str(__A    )[:3]    )    ):
                  return False
      return True







def _UpperCamelCase       (     __A = 11    )							->		list[int]:


      '''simple docstring'''



      UpperCamelCase__										=				[]
      UpperCamelCase__										=				13
      while len(__A    ) != count:
            if validate(__A    ):
                  UpperCamelCase__										=				list_truncated_nums(__A    )
                  if all(is_prime(__A    ) for i in list_nums    ):
                        list_truncated_primes.append(__A    )
            num += 2
      return list_truncated_primes







def _UpperCamelCase       (     )							->		int:


      '''simple docstring'''



      return sum(compute_truncated_primes(11    )    )


if __name__ == "__main__":
  print(F"""{sum(compute_truncated_primes(1_1)) = }""")









import os
from typing import BinaryIO, Optional, Union

import numpy as np
import pyarrow.parquet as pq

from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config
from ..features.features import FeatureType, _visit
from ..formatting import query_table
from ..packaged_modules import _PACKAGED_DATASETS_MODULES
from ..packaged_modules.parquet.parquet import Parquet
from ..utils import logging
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE       ):
  A_      :				Any		     =					np.inf

  def set_batch_size(SCREAMING_SNAKE_CASE       ) -> None:
    nonlocal batch_size
    if isinstance(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ):
      A_      :				Tuple		     =					min(SCREAMING_SNAKE_CASE ,			config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS       )
    elif isinstance(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ):
      A_      :				str		     =					min(SCREAMING_SNAKE_CASE ,			config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS       )
    elif isinstance(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ) and feature.dtype == "binary":
      A_      :				Union[str, Any]		     =					min(SCREAMING_SNAKE_CASE ,			config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS       )

  _visit(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       )

  return None if batch_size is np.inf else batch_size






class   _lowerCamelCase (					UpperCamelCase			):




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE = None				,       _SCREAMING_SNAKE_CASE = None				,       _SCREAMING_SNAKE_CASE = None				,       _SCREAMING_SNAKE_CASE = False				,       _SCREAMING_SNAKE_CASE = False				,       _SCREAMING_SNAKE_CASE = None				,       **_SCREAMING_SNAKE_CASE				,       )->str:




         '''simple docstring'''





         super().__init__(
             _SCREAMING_SNAKE_CASE				,       split=_SCREAMING_SNAKE_CASE				,       features=_SCREAMING_SNAKE_CASE				,       cache_dir=_SCREAMING_SNAKE_CASE				,       keep_in_memory=_SCREAMING_SNAKE_CASE				,       streaming=_SCREAMING_SNAKE_CASE				,       num_proc=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE				,       )
         A_      :				str		     =					path_or_paths if isinstance(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		) else {self.split: path_or_paths}
         A_      :				Optional[int]		     =					_PACKAGED_DATASETS_MODULES['''parquet'''][1]
         A_      :				Union[str, Any]		     =					Parquet(
             cache_dir=_SCREAMING_SNAKE_CASE				,       data_files=_SCREAMING_SNAKE_CASE				,       features=_SCREAMING_SNAKE_CASE				,       hash=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE				,       )







       def        _snake_case       (      self		)->Optional[int]:




         '''simple docstring'''





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

           self.builder.download_and_prepare(
               download_config=_SCREAMING_SNAKE_CASE				,       download_mode=_SCREAMING_SNAKE_CASE				,       verification_mode=_SCREAMING_SNAKE_CASE				,       base_path=_SCREAMING_SNAKE_CASE				,       num_proc=self.num_proc				,       )
           A_      :				Union[str, Any]		     =					self.builder.as_dataset(
               split=self.split				,       verification_mode=_SCREAMING_SNAKE_CASE				,       in_memory=self.keep_in_memory		)
         return dataset






class   _lowerCamelCase :




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE = None				,       **_SCREAMING_SNAKE_CASE				,       )->List[Any]:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					dataset
         A_      :				Union[str, Any]		     =					path_or_buf
         A_      :				Any		     =					batch_size or get_writer_batch_size(dataset.features		)
         A_      :				Optional[int]		     =					parquet_writer_kwargs



       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE

         if isinstance(self.path_or_buf				,       (str, bytes, os.PathLike)		):
           with open(self.path_or_buf				,       '''wb+'''		) as buffer:
             A_      :				str		     =					self._write(file_obj=_SCREAMING_SNAKE_CASE				,       batch_size=_SCREAMING_SNAKE_CASE				,       **self.parquet_writer_kwargs		)
         else:
           A_      :				Tuple		     =					self._write(file_obj=self.path_or_buf				,       batch_size=_SCREAMING_SNAKE_CASE				,       **self.parquet_writer_kwargs		)
         return written







       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)->int:




         '''simple docstring'''





         A_      :				List[Any]		     =					0
         A_      :				int		     =					parquet_writer_kwargs.pop('''path_or_buf'''				,       _SCREAMING_SNAKE_CASE		)
         A_      :				List[Any]		     =					self.dataset.features.arrow_schema

         A_      :				List[str]		     =					pq.ParquetWriter(_SCREAMING_SNAKE_CASE				,       schema=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)

         for offset in logging.tqdm(
             range(0				,       len(self.dataset		)				,       _SCREAMING_SNAKE_CASE		)				,       unit='''ba'''				,       disable=not logging.is_progress_bar_enabled()				,       desc='''Creating parquet from Arrow format'''				,       ):
           A_      :				List[Any]		     =					query_table(
               table=self.dataset._data				,       key=slice(_SCREAMING_SNAKE_CASE				,       offset + batch_size		)				,       indices=self.dataset._indices if self.dataset._indices is not None else None				,       )
           writer.write_table(_SCREAMING_SNAKE_CASE		)
           written += batch.nbytes
         writer.close()
         return written




