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 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)