

"""simple docstring"""




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


__A     :    Union[str, Any]    =		datasets.utils.logging.get_logger(__name__)





@dataclass
class 			__UpperCamelCase (   datasets.BuilderConfig						):
		SCREAMING_SNAKE_CASE								=    None
		SCREAMING_SNAKE_CASE								=    "utf-8"
		SCREAMING_SNAKE_CASE								=    None
		SCREAMING_SNAKE_CASE								=    10 << 20  # 10MB
		SCREAMING_SNAKE_CASE								=    False
		SCREAMING_SNAKE_CASE								=    "line"





class 			__UpperCamelCase (   datasets.ArrowBasedBuilder						):
		SCREAMING_SNAKE_CASE								=    TextConfig


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


		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		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}""")
							A			=					dl_manager.download_and_extract(self.config.data_files)
							if isinstance(__SCREAMING_SNAKE_CASE     ,     (str, list, tuple)):
												A			=					data_files
												if isinstance(__SCREAMING_SNAKE_CASE     ,     __SCREAMING_SNAKE_CASE):
																	A			=					[files]
												A			=					[dl_manager.iter_files(__SCREAMING_SNAKE_CASE) for file in files]
												return [datasets.SplitGenerator(name=datasets.Split.TRAIN     ,     gen_kwargs={"files": files})]
							A			=					[]
							for split_name, files in data_files.items():
												if isinstance(__SCREAMING_SNAKE_CASE     ,     __SCREAMING_SNAKE_CASE):
																	A			=					[files]
												A			=					[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 					SCREAMING_SNAKE_CASE__   (self :		Dict     ,     __SCREAMING_SNAKE_CASE :		pa.Table):
							if self.config.features is not None:
												A			=					self.config.features.arrow_schema
												if all(not require_storage_cast(__SCREAMING_SNAKE_CASE) for feature in self.config.features.values()):
																	# cheaper cast
																	A			=					pa_table.cast(__SCREAMING_SNAKE_CASE)
												else:
																	# more expensive cast; allows str <-> int/float or str to Audio for example
																	A			=					table_cast(__SCREAMING_SNAKE_CASE     ,     __SCREAMING_SNAKE_CASE)
												return pa_table
							else:
												return pa_table.cast(pa.schema({"text": pa.string()}))


		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]):
							A			=					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":
																						A			=					0
																						while True:
																											A			=					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)
																											A			=					StringIO(__SCREAMING_SNAKE_CASE).readlines()
																											if not self.config.keep_linebreaks:
																																A			=					[line.rstrip("\n") for line in batch]
																											A			=					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":
																						A			=					0
																						A			=					""
																						while True:
																											A			=					f.read(self.config.chunksize)
																											if not new_batch:
																																break
																											batch += new_batch
																											batch += f.readline()  # finish current line
																											A			=					batch.split("\n\n")
																											A			=					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
																											A			=					batch[-1]
																						if batch:
																											A			=					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":
																						A			=					f.read()
																						A			=					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)





