'''simple docstring'''

from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching







def      UpperCamelCase_						(					)					->     Tuple:






 '''simple docstring'''

 import os as original_os
 from os import path as original_path
 from os import rename as original_rename
 from os.path import dirname as original_dirname
 from os.path import join as original_join

 assert _test_patching.os is original_os
 assert _test_patching.path is original_path
 assert _test_patching.join is original_join

 assert _test_patching.renamed_os is original_os
 assert _test_patching.renamed_path is original_path
 assert _test_patching.renamed_join is original_join

 __lowerCAmelCase											=						"""__test_patch_submodule_mock__"""
 with patch_submodule(_test_patching						,		"""os.path.join"""						,		snake_case_      ):
  # Every way to access os.path.join must be patched, and the rest must stay untouched

  # check os.path.join
  assert isinstance(_test_patching.os						,		_PatchedModuleObj      )
  assert isinstance(_test_patching.os.path						,		_PatchedModuleObj      )
  assert _test_patching.os.path.join is mock

  # check path.join
  assert isinstance(_test_patching.path						,		_PatchedModuleObj      )
  assert _test_patching.path.join is mock

  # check join
  assert _test_patching.join is mock

  # check that the other attributes are untouched
  assert _test_patching.os.rename is original_rename
  assert _test_patching.path.dirname is original_dirname
  assert _test_patching.os.path.dirname is original_dirname

  # Even renamed modules or objects must be patched

  # check renamed_os.path.join
  assert isinstance(_test_patching.renamed_os						,		_PatchedModuleObj      )
  assert isinstance(_test_patching.renamed_os.path						,		_PatchedModuleObj      )
  assert _test_patching.renamed_os.path.join is mock

  # check renamed_path.join
  assert isinstance(_test_patching.renamed_path						,		_PatchedModuleObj      )
  assert _test_patching.renamed_path.join is mock

  # check renamed_join
  assert _test_patching.renamed_join is mock

  # check that the other attributes are untouched
  assert _test_patching.renamed_os.rename is original_rename
  assert _test_patching.renamed_path.dirname is original_dirname
  assert _test_patching.renamed_os.path.dirname is original_dirname

 # check that everthing is back to normal when the patch is over

 assert _test_patching.os is original_os
 assert _test_patching.path is original_path
 assert _test_patching.join is original_join

 assert _test_patching.renamed_os is original_os
 assert _test_patching.renamed_path is original_path
 assert _test_patching.renamed_join is original_join







def      UpperCamelCase_						(					)					->     Tuple:






 '''simple docstring'''

 assert _test_patching.open is open

 __lowerCAmelCase											=						"""__test_patch_submodule_builtin_mock__"""
 # _test_patching has "open" in its globals
 assert _test_patching.open is open
 with patch_submodule(_test_patching						,		"""open"""						,		snake_case_      ):
  assert _test_patching.open is mock

 # check that everthing is back to normal when the patch is over

 assert _test_patching.open is open







def      UpperCamelCase_						(					)					->     List[str]:






 '''simple docstring'''

 __lowerCAmelCase											=						"""__test_patch_submodule_missing_mock__"""
 with patch_submodule(_test_patching						,		"""pandas.read_csv"""						,		snake_case_      ):
  pass







def      UpperCamelCase_						(					)					->     List[str]:






 '''simple docstring'''

 __lowerCAmelCase											=						"""__test_patch_submodule_missing_builtin_mock__"""
 # _test_patching doesn't have "len" in its globals
 assert getattr(_test_patching						,		"""len"""						,		snake_case_      ) is None
 with patch_submodule(_test_patching						,		"""len"""						,		snake_case_      ):
  assert _test_patching.len is mock
 assert _test_patching.len is len







def      UpperCamelCase_						(					)					->     Tuple:






 '''simple docstring'''

 __lowerCAmelCase											=						"""__test_patch_submodule_start_and_stop_mock__"""
 __lowerCAmelCase											=						patch_submodule(_test_patching						,		"""open"""						,		snake_case_      )
 assert _test_patching.open is open
 patch.start()
 assert _test_patching.open is mock
 patch.stop()
 assert _test_patching.open is open







def      UpperCamelCase_						(					)					->     Any:






 '''simple docstring'''

 from os import rename as original_rename
 from os.path import dirname as original_dirname
 from os.path import join as original_join

 __lowerCAmelCase											=						"""__test_patch_submodule_successive_join__"""
 __lowerCAmelCase											=						"""__test_patch_submodule_successive_dirname__"""
 __lowerCAmelCase											=						"""__test_patch_submodule_successive_rename__"""
 assert _test_patching.os.path.join is original_join
 assert _test_patching.os.path.dirname is original_dirname
 assert _test_patching.os.rename is original_rename

 with patch_submodule(_test_patching						,		"""os.path.join"""						,		snake_case_      ):
  with patch_submodule(_test_patching						,		"""os.rename"""						,		snake_case_      ):
   with patch_submodule(_test_patching						,		"""os.path.dirname"""						,		snake_case_      ):
    assert _test_patching.os.path.join is mock_join
    assert _test_patching.os.path.dirname is mock_dirname
    assert _test_patching.os.rename is mock_rename

    # try another order
 with patch_submodule(_test_patching						,		"""os.rename"""						,		snake_case_      ):
  with patch_submodule(_test_patching						,		"""os.path.join"""						,		snake_case_      ):
   with patch_submodule(_test_patching						,		"""os.path.dirname"""						,		snake_case_      ):
    assert _test_patching.os.path.join is mock_join
    assert _test_patching.os.path.dirname is mock_dirname
    assert _test_patching.os.rename is mock_rename

 assert _test_patching.os.path.join is original_join
 assert _test_patching.os.path.dirname is original_dirname
 assert _test_patching.os.rename is original_rename







def      UpperCamelCase_						(					)					->     Optional[Any]:






 '''simple docstring'''

 __lowerCAmelCase											=						"""__test_patch_submodule_doesnt_exist_mock__"""
 with patch_submodule(_test_patching						,		"""__module_that_doesn_exist__.__attribute_that_doesn_exist__"""						,		snake_case_      ):
  pass
 with patch_submodule(_test_patching						,		"""os.__attribute_that_doesn_exist__"""						,		snake_case_      ):
  pass







'''simple docstring'''

import numpy as np
import qiskit







def      UpperCamelCase_						(					snake_case_       :       int = 8						,		snake_case_       :       int | None = None      )					->     str:






 '''simple docstring'''

 __lowerCAmelCase											=						np.random.default_rng(seed=snake_case_      )

 # Roughly 25% of the qubits will contribute to the key.
 # So we take more than we need.
 __lowerCAmelCase											=						6 * key_len
 # Measurement basis for Alice's qubits.
 __lowerCAmelCase											=						rng.integers(2						,		size=snake_case_      )
 # The set of states Alice will prepare.
 __lowerCAmelCase											=						rng.integers(2						,		size=snake_case_      )
 # Measurement basis for Bob's qubits.
 __lowerCAmelCase											=						rng.integers(2						,		size=snake_case_      )

 # Quantum Circuit to simulate BB84
 __lowerCAmelCase											=						qiskit.QuantumCircuit(snake_case_						,		name="""BB84"""      )

 # Alice prepares her qubits according to rules above.
 for index, _ in enumerate(snake_case_      ):
  if alice_state[index] == 1:
   bbaa_circ.x(snake_case_      )
  if alice_basis[index] == 1:
   bbaa_circ.h(snake_case_      )
 bbaa_circ.barrier()

 # Bob measures the received qubits according to rules above.
 for index, _ in enumerate(snake_case_      ):
  if bob_basis[index] == 1:
   bbaa_circ.h(snake_case_      )

 bbaa_circ.barrier()
 bbaa_circ.measure_all()

 # Simulate the quantum circuit.
 __lowerCAmelCase											=						qiskit.Aer.get_backend("""aer_simulator"""      )
 # We only need to run one shot because the key is unique.
 # Multiple shots will produce the same key.
 __lowerCAmelCase											=						qiskit.execute(snake_case_						,		snake_case_						,		shots=1						,		seed_simulator=snake_case_      )
 # Returns the result of measurement.
 __lowerCAmelCase											=						job.result().get_counts(snake_case_      ).most_frequent()

 # Extracting the generated key from the simulation results.
 # Only keep measurement results where Alice and Bob chose the same basis.
 __lowerCAmelCase											=						"""""".join(
     [
         result_bit
         for alice_basis_bit, bob_basis_bit, result_bit in zip(
             snake_case_						,		snake_case_						,		snake_case_      )
         if alice_basis_bit == bob_basis_bit
     ]      )

 # Get final key. Pad with 0 if too short, otherwise truncate.
 __lowerCAmelCase											=						gen_key[:key_len] if len(snake_case_      ) >= key_len else gen_key.ljust(snake_case_						,		"""0"""      )
 return key


if __name__ == "__main__":
 print(f'The generated key is : {bbaa(8, seed=0)}')
 from doctest import testmod

 testmod()






