


'''simple docstring'''
import itertools
from dataclasses import dataclass
from typing import List, Optional

import pyarrow as pa
import pyarrow.parquet as pq

import datasets
from datasets.table import table_cast


__snake_case											=					datasets.utils.logging.get_logger(__name__)
@dataclass
class        lowercase     (							datasets.BuilderConfig ):

		"""simple docstring"""

		_a   			=    1_00_00
		_a   			=    None
		_a   			=    None



class        lowercase     (							datasets.ArrowBasedBuilder ):

		"""simple docstring"""

		_a   			=    ParquetConfig




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							return datasets.DatasetInfo(features=self.config.features							)




		def    lowerCAmelCase__    (		self   ,       UpperCamelCase_							):

							'''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}'''							)
							UpperCamelCase__       :Any							 =			dl_manager.download_and_extract(self.config.data_files							)
							if isinstance(__lowerCamelCase   ,       (str, list, tuple)							):
												UpperCamelCase__       :Optional[Any]							 =			data_files
												if isinstance(__lowerCamelCase   ,       __lowerCamelCase							):
																	UpperCamelCase__       :List[Any]							 =			[files]
												# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
												UpperCamelCase__       :Dict							 =			[dl_manager.iter_files(__lowerCamelCase							) for file in files]
												return [datasets.SplitGenerator(name=datasets.Split.TRAIN   ,       gen_kwargs={'''files''': files}							)]
							UpperCamelCase__       :int							 =			[]
							for split_name, files in data_files.items():
												if isinstance(__lowerCamelCase   ,       __lowerCamelCase							):
																	UpperCamelCase__       :int							 =			[files]
												# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
												UpperCamelCase__       :Union[str, Any]							 =			[dl_manager.iter_files(__lowerCamelCase							) for file in files]
												# Infer features is they are stoed in the arrow schema
												if self.info.features is None:
																	for file in itertools.chain.from_iterable(__lowerCamelCase							):
																						with open(__lowerCamelCase   ,       '''rb'''							) as f:
																											UpperCamelCase__       :str							 =			datasets.Features.from_arrow_schema(pq.read_schema(__lowerCamelCase							)							)
																						break
												splits.append(datasets.SplitGenerator(name=__lowerCamelCase   ,       gen_kwargs={'''files''': files}							)							)
							return splits




		def    lowerCAmelCase__    (		self   ,       UpperCamelCase_							):

							'''simple docstring'''


							if self.info.features is not None:
												# more expensive cast to support nested features with keys in a different order
												# allows str <-> int/float or str to Audio for example
												UpperCamelCase__       :Dict							 =			table_cast(__lowerCamelCase   ,       self.info.features.arrow_schema							)
							return pa_table




		def    lowerCAmelCase__    (		self   ,       UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__       :int							 =			self.info.features.arrow_schema if self.info.features is not None else None
							if self.info.features is not None and self.config.columns is not None:
												if sorted(field.name for field in schema							) != sorted(self.config.columns							):
																	raise ValueError(
																	    F'''Tried to load parquet data with columns \'{self.config.columns}\' with mismatching features \'{self.info.features}\''''							)
							for file_idx, file in enumerate(itertools.chain.from_iterable(__lowerCamelCase							)							):
												with open(__lowerCamelCase   ,       '''rb'''							) as f:
																	UpperCamelCase__       :str							 =			pq.ParquetFile(__lowerCamelCase							)
																	try:
																						for batch_idx, record_batch in enumerate(
																						    parquet_file.iter_batches(batch_size=self.config.batch_size   ,       columns=self.config.columns							)							):
																											UpperCamelCase__       :List[str]							 =			pa.Table.from_batches([record_batch]							)
																											# 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 F'''{file_idx}_{batch_idx}''', self._cast_table(__lowerCamelCase							)
																	except ValueError as e:
																						logger.error(F'''Failed to read file \'{file}\' with error {type(__lowerCamelCase							)}: {e}'''							)
																						raise










'''simple docstring'''
from __future__ import annotations

from typing import Any


def       a				(      __a       )  ->     None:



					'''simple docstring'''






					create_state_space_tree(__a			, []			, 0       )


def       a				(      __a			, __a			, __a       )  ->     None:



					'''simple docstring'''






					if index == len(__a       ):
										print(__a       )
										return

					create_state_space_tree(__a			, __a			, index + 1       )
					current_subsequence.append(sequence[index]       )
					create_state_space_tree(__a			, __a			, index + 1       )
					current_subsequence.pop()


if __name__ == "__main__":
		__snake_case											=					[3, 1, 2, 4]
		generate_all_subsequences(seq)

		seq.clear()
		seq.extend(['''A''', '''B''', '''C'''])
		generate_all_subsequences(seq)