
"""simple docstring"""



import os
from tempfile import TemporaryDirectory
from unittest import TestCase

import pytest
from absl.testing import parameterized

from datasets import config
from datasets.arrow_reader import HF_GCP_BASE_URL
from datasets.builder import DatasetBuilder
from datasets.dataset_dict import IterableDatasetDict
from datasets.iterable_dataset import IterableDataset
from datasets.load import dataset_module_factory, import_main_class
from datasets.utils.file_utils import cached_path


UpperCAmelCase__          = [
    {'dataset': 'wikipedia', 'config_name': '20220301.de'},
    {'dataset': 'wikipedia', 'config_name': '20220301.en'},
    {'dataset': 'wikipedia', 'config_name': '20220301.fr'},
    {'dataset': 'wikipedia', 'config_name': '20220301.frr'},
    {'dataset': 'wikipedia', 'config_name': '20220301.it'},
    {'dataset': 'wikipedia', 'config_name': '20220301.simple'},
    {'dataset': 'snli', 'config_name': 'plain_text'},
    {'dataset': 'eli5', 'config_name': 'LFQA_reddit'},
    {'dataset': 'wiki40b', 'config_name': 'en'},
    {'dataset': 'wiki_dpr', 'config_name': 'psgs_w100.nq.compressed'},
    {'dataset': 'wiki_dpr', 'config_name': 'psgs_w100.nq.no_index'},
    {'dataset': 'wiki_dpr', 'config_name': 'psgs_w100.multiset.no_index'},
    {'dataset': 'natural_questions', 'config_name': 'default'},
]
def 					_UpperCAmelCase      ( __lowerCamelCase   :       Dict=True		)     ->					List[str]:
  if with_config:
    return [
        {
            "testcase_name": d["dataset"] + "/" + d["config_name"],
            "dataset": d["dataset"],
            "config_name": d["config_name"],
        }
        for d in DATASETS_ON_HF_GCP
    ]
  else:
    return [
        {"testcase_name": dataset, "dataset": dataset} for dataset in {d["dataset"] for d in DATASETS_ON_HF_GCP}
    ]

@parameterized.named_parameters(list_datasets_on_hf_gcp_parameters(with_config=A_	)	)
class       lowerCAmelCase__				(						A_	):
     __a						=					None
     __a						=					None







     def      lowercase	(							self			:			Optional[int]    ,      _lowerCamelCase			:			Union[str, Any]    ,      _lowerCamelCase			:			List[Any]			):
       with TemporaryDirectory() as tmp_dir:
         _snake_case					     =       dataset_module_factory(_lowerCamelCase    ,      cache_dir=_lowerCamelCase			)

         _snake_case					     =       import_main_class(dataset_module.module_path    ,      dataset=_lowerCamelCase			)

         _snake_case					     =       builder_cls(
             cache_dir=_lowerCamelCase    ,      config_name=_lowerCamelCase    ,      hash=dataset_module.hash    ,      )

         _snake_case					     =       '''/'''.join(
             [
                 HF_GCP_BASE_URL,
                 builder_instance._relative_data_dir(with_hash=_lowerCamelCase			).replace(os.sep    ,      '''/'''			),
                 config.DATASET_INFO_FILENAME,
             ]			)
         _snake_case					     =       cached_path(_lowerCamelCase    ,      cache_dir=_lowerCamelCase			)
         self.assertTrue(os.path.exists(_lowerCamelCase			)			)






@pytest.mark.integration
def 					_UpperCAmelCase      ( __lowerCamelCase   :       str		)     ->					Optional[Any]:
  _snake_case					     =       tmp_path_factory.mktemp('''test_hf_gcp'''		) / '''test_wikipedia_simple'''
  _snake_case					     =       dataset_module_factory('''wikipedia''' ,					cache_dir=__lowerCamelCase		)
  _snake_case					     =       import_main_class(dataset_module.module_path		)
  _snake_case					     =       builder_cls(
      cache_dir=__lowerCamelCase ,					config_name='''20220301.frr''' ,					hash=dataset_module.hash ,					)
  # use the HF cloud storage, not the original download_and_prepare that uses apache-beam
  _snake_case					     =       None
  builder_instance.download_and_prepare()
  _snake_case					     =       builder_instance.as_dataset()
  assert ds

@pytest.mark.integration
def 					_UpperCAmelCase      ( __lowerCamelCase   :       int		)     ->					Any:
  _snake_case					     =       dataset_module_factory('''wikipedia''' ,					cache_dir=__lowerCamelCase		)
  _snake_case					     =       import_main_class(dataset_module.module_path ,					dataset=__lowerCamelCase		)
  _snake_case					     =       builder_cls(
      cache_dir=__lowerCamelCase ,					config_name='''20220301.frr''' ,					hash=dataset_module.hash ,					)
  _snake_case					     =       builder_instance.as_streaming_dataset()
  assert ds
  assert isinstance(__lowerCamelCase ,					__lowerCamelCase		)
  assert "train" in ds
  assert isinstance(ds['''train'''] ,					__lowerCamelCase		)
  assert next(iter(ds['''train''']		)		)





"""simple docstring"""



import math

import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute
def 					_UpperCAmelCase      ( __lowerCamelCase   :       int = 3		)     ->					qiskit.result.counts.Counts:
  if isinstance(__lowerCamelCase ,					__lowerCamelCase		):
    raise TypeError('''number of qubits must be a integer.'''		)
  if number_of_qubits <= 0:
    raise ValueError('''number of qubits must be > 0.'''		)
  if math.floor(__lowerCamelCase		) != number_of_qubits:
    raise ValueError('''number of qubits must be exact integer.'''		)
  if number_of_qubits > 10:
    raise ValueError('''number of qubits too large to simulate(>10).'''		)

  _snake_case					     =       QuantumRegister(__lowerCamelCase ,					'''qr'''		)
  _snake_case					     =       ClassicalRegister(__lowerCamelCase ,					'''cr'''		)

  _snake_case					     =       QuantumCircuit(__lowerCamelCase ,					__lowerCamelCase		)

  _snake_case					     =       number_of_qubits

  for i in range(__lowerCamelCase		):
    quantum_circuit.h(number_of_qubits - i - 1		)
    counter -= 1
    for j in range(__lowerCamelCase		):
      quantum_circuit.cp(np.pi / 2 ** (counter - j) ,					__lowerCamelCase ,					__lowerCamelCase		)

  for k in range(number_of_qubits // 2		):
    quantum_circuit.swap(__lowerCamelCase ,					number_of_qubits - k - 1		)

  # measure all the qubits
  quantum_circuit.measure(__lowerCamelCase ,					__lowerCamelCase		)
  # simulate with 10000 shots
  _snake_case					     =       Aer.get_backend('''qasm_simulator'''		)
  _snake_case					     =       execute(__lowerCamelCase ,					__lowerCamelCase ,					shots=1_00_00		)

  return job.result().get_counts(__lowerCamelCase		)


if __name__ == "__main__":
 print(
     F"Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}"
 )



