



"""simple docstring"""







import io
import itertools
import json
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa
import pyarrow.json as paj

import datasets
from datasets.table import table_cast
from datasets.utils.file_utils import readline


lowerCAmelCase__									=datasets.utils.logging.get_logger(__name__)




@dataclass
class        A__(  datasets.BuilderConfig			):
      lowerCAmelCase										=				None
      lowerCAmelCase										=				"utf-8"
      lowerCAmelCase										=				None
      lowerCAmelCase										=				None
      lowerCAmelCase										=				True  # deprecated
      lowerCAmelCase										=				None  # deprecated
      lowerCAmelCase										=				10 << 20  # 10MB
      lowerCAmelCase										=				None






class        A__(  datasets.ArrowBasedBuilder			):
      lowerCAmelCase										=				JsonConfig







      def  _a   (					self		:     Tuple			)							->		Optional[int]:






            """simple docstring"""

            if self.config.block_size is not None:
                  logger.warning('''The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead'''			)
                  __SCREAMING_SNAKE_CASE       		=   self.config.block_size
            if self.config.use_threads is not True:
                  logger.warning(
                      '''The JSON loader parameter `use_threads` is deprecated and doesn\'t have any effect anymore.'''			)
            if self.config.newlines_in_values is not None:
                  raise ValueError('''The JSON loader parameter `newlines_in_values` is no longer supported'''			)
            return datasets.DatasetInfo(features=self.config.features			)







      def  _a   (					self		:     Any				,				__SCREAMING_SNAKE_CASE		:     int			)							->		Union[str, Any]:






            """simple docstring"""

            if not self.config.data_files:
                  raise ValueError(f"""At least one data file must be specified, but got data_files={self.config.data_files}"""			)
            __SCREAMING_SNAKE_CASE       		=   dl_manager.download_and_extract(self.config.data_files			)
            if isinstance(snake_case__				,				(str, list, tuple)			):
                  __SCREAMING_SNAKE_CASE       		=   data_files
                  if isinstance(snake_case__				,				snake_case__			):
                        __SCREAMING_SNAKE_CASE       		=   [files]
                  __SCREAMING_SNAKE_CASE       		=   [dl_manager.iter_files(snake_case__			) for file in files]
                  return [datasets.SplitGenerator(name=datasets.Split.TRAIN				,				gen_kwargs={'''files''': files}			)]
            __SCREAMING_SNAKE_CASE       		=   []
            for split_name, files in data_files.items():
                  if isinstance(snake_case__				,				snake_case__			):
                        __SCREAMING_SNAKE_CASE       		=   [files]
                  __SCREAMING_SNAKE_CASE       		=   [dl_manager.iter_files(snake_case__			) for file in files]
                  splits.append(datasets.SplitGenerator(name=snake_case__				,				gen_kwargs={'''files''': files}			)			)
            return splits







      def  _a   (					self		:     Dict				,				__SCREAMING_SNAKE_CASE		:     pa.Table			)							->		Union[str, Any]:






            """simple docstring"""

            if self.config.features is not None:
                  # adding missing columns
                  for column_name in set(self.config.features			) - set(pa_table.column_names			):
                        __SCREAMING_SNAKE_CASE       		=   self.config.features.arrow_schema.field(snake_case__			).type
                        __SCREAMING_SNAKE_CASE       		=   pa_table.append_column(snake_case__				,				pa.array([None] * len(snake_case__			)				,				type=snake_case__			)			)
                  # more expensive cast to support nested structures with keys in a different order
                  # allows str <-> int/float or str to Audio for example
                  __SCREAMING_SNAKE_CASE       		=   table_cast(snake_case__				,				self.config.features.arrow_schema			)
            return pa_table







      def  _a   (					self		:     Optional[Any]				,				__SCREAMING_SNAKE_CASE		:     Union[str, Any]			)							->		str:






            """simple docstring"""

            for file_idx, file in enumerate(itertools.chain.from_iterable(snake_case__			)			):
                  # If the file is one json object and if we need to look at the list of items in one specific field
                  if self.config.field is not None:
                        with open(snake_case__				,				encoding=self.config.encoding				,				errors=self.config.encoding_errors			) as f:
                              __SCREAMING_SNAKE_CASE       		=   json.load(snake_case__			)

                        # We keep only the field we are interested in
                        __SCREAMING_SNAKE_CASE       		=   dataset[self.config.field]

                        # We accept two format: a list of dicts or a dict of lists
                        if isinstance(snake_case__				,				(list, tuple)			):
                              __SCREAMING_SNAKE_CASE       		=   set().union(*[row.keys() for row in dataset]			)
                              __SCREAMING_SNAKE_CASE       		=   {col: [row.get(snake_case__			) for row in dataset] for col in keys}
                        else:
                              __SCREAMING_SNAKE_CASE       		=   dataset
                        __SCREAMING_SNAKE_CASE       		=   pa.Table.from_pydict(snake_case__			)
                        yield file_idx, self._cast_table(snake_case__			)

                  # If the file has one json object per line
                  else:
                        with open(snake_case__				,				'''rb'''			) as f:
                              __SCREAMING_SNAKE_CASE       		=   0
                              # Use block_size equal to the chunk size divided by 32 to leverage multithreading
                              # Set a default minimum value of 16kB if the chunk size is really small
                              __SCREAMING_SNAKE_CASE       		=   max(self.config.chunksize // 32				,				16 << 10			)
                              __SCREAMING_SNAKE_CASE       		=   (
                                  self.config.encoding_errors if self.config.encoding_errors is not None else '''strict'''
                              )
                              while True:
                                    __SCREAMING_SNAKE_CASE       		=   f.read(self.config.chunksize			)
                                    if not batch:
                                          break
                                    # Finish current line
                                    try:
                                          batch += f.readline()
                                    except (AttributeError, io.UnsupportedOperation):
                                          batch += readline(snake_case__			)
                                    # PyArrow only accepts utf-8 encoded bytes
                                    if self.config.encoding != "utf-8":
                                          __SCREAMING_SNAKE_CASE       		=   batch.decode(self.config.encoding				,				errors=snake_case__			).encode('''utf-8'''			)
                                    try:
                                          while True:
                                                try:
                                                      __SCREAMING_SNAKE_CASE       		=   paj.read_json(
                                                          io.BytesIO(snake_case__			)				,				read_options=paj.ReadOptions(block_size=snake_case__			)			)
                                                      break
                                                except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
                                                      if (
                                                          isinstance(snake_case__				,				pa.ArrowInvalid			)
                                                          and "straddling" not in str(snake_case__			)
                                                          or block_size > len(snake_case__			)
                                                      ):
                                                            raise
                                                      else:
                                                            # Increase the block size in case it was too small.
                                                            # The block size will be reset for the next file.
                                                            logger.debug(
                                                                f"""Batch of {len(snake_case__			)} bytes couldn't be parsed with block_size={block_size}. Retrying with block_size={block_size * 2}."""			)
                                                            block_size *= 2
                                    except pa.ArrowInvalid as e:
                                          try:
                                                with open(
                                                    snake_case__				,				encoding=self.config.encoding				,				errors=self.config.encoding_errors			) as f:
                                                      __SCREAMING_SNAKE_CASE       		=   json.load(snake_case__			)
                                          except json.JSONDecodeError:
                                                logger.error(f"""Failed to read file '{file}' with error {type(snake_case__			)}: {e}"""			)
                                                raise e
                                          # If possible, parse the file as a list of json objects and exit the loop
                                          if isinstance(snake_case__				,				snake_case__			):  # list is the only sequence type supported in JSON
                                                try:
                                                      __SCREAMING_SNAKE_CASE       		=   set().union(*[row.keys() for row in dataset]			)
                                                      __SCREAMING_SNAKE_CASE       		=   {col: [row.get(snake_case__			) for row in dataset] for col in keys}
                                                      __SCREAMING_SNAKE_CASE       		=   pa.Table.from_pydict(snake_case__			)
                                                except (pa.ArrowInvalid, AttributeError) as e:
                                                      logger.error(f"""Failed to read file '{file}' with error {type(snake_case__			)}: {e}"""			)
                                                      raise ValueError(f"""Not able to read records in the JSON file at {file}."""			) from None
                                                yield file_idx, self._cast_table(snake_case__			)
                                                break
                                          else:
                                                logger.error(f"""Failed to read file '{file}' with error {type(snake_case__			)}: {e}"""			)
                                                raise ValueError(
                                                    f"""Not able to read records in the JSON file at {file}. """
                                                    f"""You should probably indicate the field of the JSON file containing your records. """
                                                    f"""This JSON file contain the following fields: {str(list(dataset.keys()			)			)}. """
                                                    f"""Select the correct one and provide it as `field='XXX'` to the dataset loading method. """			) from None
                        # Uncomment for debugging (will print the Arrow table size and elements)
                        # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                        # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                                    yield (file_idx, batch_idx), self._cast_table(snake_case__			)
                                    batch_idx += 1

"""simple docstring"""




from itertools import permutations







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		if num[3] % 2 != 0:
				return False

		if (num[2] + num[3] + num[4]) % 3 != 0:
				return False

		if num[5] % 5 != 0:
				return False

		lowerCAmelCase__   = [7, 11, 13, 17]
		for i, test in enumerate(lowerCamelCase__  ):
				if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
						return False
		return True







def 				_UpperCAmelCase		(							lowerCamelCase__ = 10  ):





		"""simple docstring"""




		return sum(
		    int("""""".join(map(lowerCamelCase__      ,	lowerCamelCase__  )  )  )
		    for num in permutations(range(lowerCamelCase__  )  )
		    if is_substring_divisible(lowerCamelCase__  )  )


if __name__ == "__main__":
			print(F"{solution() = }")




