





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

import pyarrow as pa

import datasets
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


lowerCamelCase__						=  datasets.utils.logging.get_logger(__name__)
@dataclass
class      __magic_name__       (datasets.BuilderConfig      ):
					lowerCamelCase__					=			None
					lowerCamelCase__					=			'''utf-8'''
					lowerCamelCase__					=			None
					lowerCamelCase__					=			10 << 20  # 10MB
					lowerCamelCase__					=			False
					lowerCamelCase__					=			'''line'''





class      __magic_name__       (datasets.ArrowBasedBuilder      ):
					lowerCamelCase__					=			TextConfig




					def  __a			(    self		)       -> Optional[int]:
							return datasets.DatasetInfo(features=self.config.features		)




					def  __a			(    self     ,					_a		)       -> List[str]:
							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}"		)
							lowerCAmelCase_				=							dl_manager.download_and_extract(self.config.data_files		)
							if isinstance(__SCREAMING_SNAKE_CASE     ,					(str, list, tuple)		):
									lowerCAmelCase_				=							data_files
									if isinstance(__SCREAMING_SNAKE_CASE     ,					__SCREAMING_SNAKE_CASE		):
											lowerCAmelCase_				=							[files]
									lowerCAmelCase_				=							[dl_manager.iter_files(__SCREAMING_SNAKE_CASE		) for file in files]
									return [datasets.SplitGenerator(name=datasets.Split.TRAIN     ,					gen_kwargs={"files": files}		)]
							lowerCAmelCase_				=							[]
							for split_name, files in data_files.items():
									if isinstance(__SCREAMING_SNAKE_CASE     ,					__SCREAMING_SNAKE_CASE		):
											lowerCAmelCase_				=							[files]
									lowerCAmelCase_				=							[dl_manager.iter_files(__SCREAMING_SNAKE_CASE		) for file in files]
									splits.append(datasets.SplitGenerator(name=__SCREAMING_SNAKE_CASE     ,					gen_kwargs={"files": files}		)		)
							return splits




					def  __a			(    self     ,					_a		)       -> Union[str, Any]:
							if self.config.features is not None:
									lowerCAmelCase_				=							self.config.features.arrow_schema
									if all(not require_storage_cast(__SCREAMING_SNAKE_CASE		) for feature in self.config.features.values()		):
											# cheaper cast
											lowerCAmelCase_				=							pa_table.cast(__SCREAMING_SNAKE_CASE		)
									else:
											# more expensive cast; allows str <-> int/float or str to Audio for example
											lowerCAmelCase_				=							table_cast(__SCREAMING_SNAKE_CASE     ,					__SCREAMING_SNAKE_CASE		)
									return pa_table
							else:
									return pa_table.cast(pa.schema({"text": pa.string()}		)		)




					def  __a			(    self     ,					_a		)       -> Any:
							lowerCAmelCase_				=							list(self.config.features		) if self.config.features is not None else ["text"]
							for file_idx, file in enumerate(itertools.chain.from_iterable(__SCREAMING_SNAKE_CASE		)		):
									# open in text mode, by default translates universal newlines ("\n", "\r\n" and "\r") into "\n"
									with open(__SCREAMING_SNAKE_CASE     ,					encoding=self.config.encoding     ,					errors=self.config.errors		) as f:
											if self.config.sample_by == "line":
													lowerCAmelCase_				=							0
													while True:
															lowerCAmelCase_				=							f.read(self.config.chunksize		)
															if not batch:
																	break
															batch += f.readline()  # finish current line
															# StringIO.readlines, by default splits only on "\n" (and keeps line breaks)
															lowerCAmelCase_				=							StringIO(__SCREAMING_SNAKE_CASE		).readlines()
															if not self.config.keep_linebreaks:
																	lowerCAmelCase_				=							[line.rstrip("\n"		) for line in batch]
															lowerCAmelCase_				=							pa.Table.from_arrays([pa.array(__SCREAMING_SNAKE_CASE		)]     ,					names=__SCREAMING_SNAKE_CASE		)
															# 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(__SCREAMING_SNAKE_CASE		)
															batch_idx += 1
											elif self.config.sample_by == "paragraph":
													lowerCAmelCase_				=							0
													lowerCAmelCase_				=							""
													while True:
															lowerCAmelCase_				=							f.read(self.config.chunksize		)
															if not new_batch:
																	break
															batch += new_batch
															batch += f.readline()  # finish current line
															lowerCAmelCase_				=							batch.split("\n\n"		)
															lowerCAmelCase_				=							pa.Table.from_arrays(
															    [pa.array([example for example in batch[:-1] if example]		)]     ,					names=__SCREAMING_SNAKE_CASE		)
															# 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(__SCREAMING_SNAKE_CASE		)
															batch_idx += 1
															lowerCAmelCase_				=							batch[-1]
													if batch:
															lowerCAmelCase_				=							pa.Table.from_arrays([pa.array([batch]		)]     ,					names=__SCREAMING_SNAKE_CASE		)
															yield (file_idx, batch_idx), self._cast_table(__SCREAMING_SNAKE_CASE		)
											elif self.config.sample_by == "document":
													lowerCAmelCase_				=							f.read()
													lowerCAmelCase_				=							pa.Table.from_arrays([pa.array([text]		)]     ,					names=__SCREAMING_SNAKE_CASE		)
													yield file_idx, self._cast_table(__SCREAMING_SNAKE_CASE		)




"""simple docstring"""




import doctest

import projectq
from projectq.ops import H, Measure
def    __SCREAMING_SNAKE_CASE						(						lowercase__      ):
					"""simple docstring"""
					A			=					quantum_engine.allocate_qubit()
					H | qubit
					Measure | qubit
					return int(lowercase__      )


if __name__ == "__main__":
	doctest.testmod()

	# initialises a new quantum backend
	__A     :    Dict    =		projectq.MainEngine()

	# Generate a list of 10 random numbers
	__A     :    Any    =		[get_random_number(quantum_engine) for _ in range(10)]

	# Flushes the quantum engine from memory
	quantum_engine.flush()

	print('Random numbers', random_numbers_list)





