def test_generate_randomized_benchmarking_sequence__returns_benchmarking_sequence( mocker: MockerFixture, ): client_configuration = QCSClientConfiguration.load() compiler_client = CompilerClient(client_configuration=client_configuration) rpcq_client = patch_rpcq_client( mocker=mocker, return_value=rpcq.messages.RandomizedBenchmarkingResponse( sequence=[[3, 1, 4], [1, 6, 1]])) request = GenerateRandomizedBenchmarkingSequenceRequest( depth=42, num_qubits=3, gateset=["some", "gate", "set"], seed=314, interleaver="some-interleaver", ) assert compiler_client.generate_randomized_benchmarking_sequence( request) == GenerateRandomizedBenchmarkingSequenceResponse( sequence=[[3, 1, 4], [1, 6, 1]]) rpcq_client.call.assert_called_once_with( "generate_rb_sequence", rpcq.messages.RandomizedBenchmarkingRequest( depth=42, qubits=3, gateset=["some", "gate", "set"], seed=314, interleaver="some-interleaver", ))
def test_conjugate_pauli_by_clifford__returns_conjugation_result( mocker: MockerFixture): client_configuration = QCSClientConfiguration.load() compiler_client = CompilerClient(client_configuration=client_configuration) rpcq_client = patch_rpcq_client( mocker=mocker, return_value=rpcq.messages.ConjugateByCliffordResponse(phase=42, pauli="pauli")) request = ConjugatePauliByCliffordRequest( pauli_indices=[0, 1, 2], pauli_symbols=["x", "y", "z"], clifford="cliff", ) assert compiler_client.conjugate_pauli_by_clifford( request) == ConjugatePauliByCliffordResponse( phase_factor=42, pauli="pauli", ) rpcq_client.call.assert_called_once_with( "conjugate_pauli_by_clifford", rpcq.messages.ConjugateByCliffordRequest( pauli=rpcq.messages.PauliTerm(indices=[0, 1, 2], symbols=["x", "y", "z"]), clifford="cliff", ))
def test_get_version__returns_version(mocker: MockerFixture): client_configuration = QCSClientConfiguration.load() compiler_client = CompilerClient(client_configuration=client_configuration) rpcq_client = patch_rpcq_client(mocker=mocker, return_value={"quilc": "1.2.3"}) assert compiler_client.get_version() == "1.2.3" rpcq_client.call.assert_called_once_with("get_version_info")
def test_sets_timeout_on_requests(mocker: MockerFixture): client_configuration = QCSClientConfiguration.load() compiler_client = CompilerClient(client_configuration=client_configuration, request_timeout=0.1) patch_rpcq_client(mocker=mocker, return_value={}) with compiler_client._rpcq_client() as client: assert client.timeout == compiler_client.timeout
def __init__( self, noise_model: Optional[NoiseModel] = None, gate_noise: Optional[Tuple[float, float, float]] = None, measurement_noise: Optional[Tuple[float, float, float]] = None, random_seed: Optional[int] = None, timeout: float = 10.0, client_configuration: Optional[QCSClientConfiguration] = None, ) -> None: """ A virtual machine that classically emulates the execution of Quil programs. :param noise_model: A noise model that describes noise to apply when emulating a program's execution. :param gate_noise: A tuple of three numbers [Px, Py, Pz] indicating the probability of an X, Y, or Z gate getting applied to each qubit after a gate application or reset. The default value of None indicates no noise. :param measurement_noise: A tuple of three numbers [Px, Py, Pz] indicating the probability of an X, Y, or Z gate getting applied before a measurement. The default value of None indicates no noise. :param random_seed: A seed for the QVM's random number generators. Either None (for an automatically generated seed) or a non-negative integer. :param timeout: Time limit for requests, in seconds. :param client_configuration: Optional client configuration. If none is provided, a default one will be loaded. """ super().__init__() if (noise_model is not None) and (gate_noise is not None or measurement_noise is not None): raise ValueError(""" You have attempted to supply the QVM with both a Kraus noise model (by supplying a `noise_model` argument), as well as either `gate_noise` or `measurement_noise`. At this time, only one may be supplied. To read more about supplying noise to the QVM, see http://pyquil.readthedocs.io/en/latest/noise_models.html#support-for-noisy-gates-on-the-rigetti-qvm. """) self.noise_model = noise_model validate_noise_probabilities(gate_noise) validate_noise_probabilities(measurement_noise) self.gate_noise = gate_noise self.measurement_noise = measurement_noise if random_seed is None: self.random_seed = None elif isinstance(random_seed, int) and random_seed >= 0: self.random_seed = random_seed else: raise TypeError("random_seed should be None or a non-negative int") client_configuration = client_configuration or QCSClientConfiguration.load( ) self._qvm_client = QVMClient(client_configuration=client_configuration, request_timeout=timeout) self.connect()
def test_init__sets_base_url_and_timeout(monkeypatch: MonkeyPatch): host = "tcp://localhost:1234" monkeypatch.setenv("QCS_SETTINGS_APPLICATIONS_PYQUIL_QUILC_URL", host) client_configuration = QCSClientConfiguration.load() compiler_client = CompilerClient(client_configuration=client_configuration, request_timeout=3.14) assert compiler_client.base_url == host assert compiler_client.timeout == 3.14
def test_init__validates_compiler_url(monkeypatch: MonkeyPatch): monkeypatch.setenv("QCS_SETTINGS_APPLICATIONS_PYQUIL_QUILC_URL", "not-http-or-tcp://example.com") client_configuration = QCSClientConfiguration.load() with raises( ValueError, match= "Expected compiler URL 'not-http-or-tcp://example.com' to start with 'tcp://'", ): CompilerClient(client_configuration=client_configuration)
def __init__(self, *, timeout: float = 10.0, client_configuration: Optional[QCSClientConfiguration] = None): """ Client to communicate with the benchmarking data endpoint. :param timeout: Time limit for requests, in seconds. :param client_configuration: Optional client configuration. If none is provided, a default one will be loaded. """ self._compiler_client = CompilerClient( client_configuration=client_configuration or QCSClientConfiguration.load(), request_timeout=timeout, )
def test_compile_to_native_quil__returns_native_quil( aspen8_compiler_isa: CompilerISA, mocker: MockerFixture, ): client_configuration = QCSClientConfiguration.load() compiler_client = CompilerClient(client_configuration=client_configuration) rpcq_client = patch_rpcq_client( mocker=mocker, return_value=rpcq.messages.NativeQuilResponse( quil="native-program", metadata=rpcq.messages.NativeQuilMetadata( final_rewiring=[0, 1, 2], gate_depth=10, gate_volume=42, multiqubit_gate_depth=5, program_duration=3.14, program_fidelity=0.99, topological_swaps=3, qpu_runtime_estimation=0.1618, ), )) request = CompileToNativeQuilRequest( program="some-program", target_quantum_processor=compiler_isa_to_target_quantum_processor( aspen8_compiler_isa), protoquil=True, ) assert compiler_client.compile_to_native_quil( request) == CompileToNativeQuilResponse( native_program="native-program", metadata=NativeQuilMetadataResponse( final_rewiring=[0, 1, 2], gate_depth=10, gate_volume=42, multiqubit_gate_depth=5, program_duration=3.14, program_fidelity=0.99, topological_swaps=3, qpu_runtime_estimation=0.1618, ), ) rpcq_client.call.assert_called_once_with( "quil_to_native_quil", rpcq.messages.NativeQuilRequest( quil="some-program", target_device=compiler_isa_to_target_quantum_processor( aspen8_compiler_isa), ), protoquil=True, )
def __init__( self, *, quantum_processor: AbstractQuantumProcessor, timeout: float, client_configuration: Optional[QCSClientConfiguration], ) -> None: self.quantum_processor = quantum_processor self._timeout = timeout self._client_configuration = client_configuration or QCSClientConfiguration.load( ) self._compiler_client = CompilerClient( client_configuration=self._client_configuration, request_timeout=timeout)
def __init__( self, *, gate_noise: Optional[Tuple[float, float, float]] = None, measurement_noise: Optional[Tuple[float, float, float]] = None, random_seed: Optional[int] = None, timeout: float = 10.0, client_configuration: Optional[QCSClientConfiguration] = None, ) -> None: """ A simulator that propagates a wavefunction representation of a quantum state. :param gate_noise: A tuple of three numbers [Px, Py, Pz] indicating the probability of an X, Y, or Z gate getting applied to each qubit after a gate application or reset. :param measurement_noise: A tuple of three numbers [Px, Py, Pz] indicating the probability of an X, Y, or Z gate getting applied before a measurement. :param random_seed: A seed for the simulator's random number generators. Either None (for an automatically generated seed) or a non-negative integer. :param timeout: Time limit for requests, in seconds. :param client_configuration: Optional client configuration. If none is provided, a default one will be loaded. """ validate_noise_probabilities(gate_noise) validate_noise_probabilities(measurement_noise) self.gate_noise = gate_noise self.measurement_noise = measurement_noise if random_seed is None: self.random_seed = None elif isinstance(random_seed, int) and random_seed >= 0: self.random_seed = random_seed else: raise TypeError("random_seed should be None or a non-negative int") client_configuration = client_configuration or QCSClientConfiguration.load( ) self._qvm_client = QVMClient(client_configuration=client_configuration, request_timeout=timeout)
def __init__( self, *, quantum_processor_id: str, priority: int = 1, timeout: float = 10.0, client_configuration: Optional[QCSClientConfiguration] = None, engagement_manager: Optional[EngagementManager] = None, endpoint_id: Optional[str] = None, ) -> None: """ A connection to the QPU. :param quantum_processor_id: Processor to run against. :param priority: The priority with which to insert jobs into the QPU queue. Lower integers correspond to higher priority. :param timeout: Time limit for requests, in seconds. :param client_configuration: Optional client configuration. If none is provided, a default one will be loaded. :param endpoint_id: Optional endpoint ID to be used for engagement. :param engagement_manager: Optional engagement manager. If none is provided, a default one will be created. """ super().__init__() self.priority = priority client_configuration = client_configuration or QCSClientConfiguration.load( ) engagement_manager = engagement_manager or EngagementManager( client_configuration=client_configuration) self._qpu_client = QPUClient( quantum_processor_id=quantum_processor_id, endpoint_id=endpoint_id, engagement_manager=engagement_manager, request_timeout=timeout, ) self._last_results: Dict[str, np.ndarray] = {} self._memory_results: Dict[str, Optional[np.ndarray]] = defaultdict( lambda: None)
def client_configuration() -> QCSClientConfiguration: return QCSClientConfiguration.load()