def test_run_circuit_failed_missing_processor_name(client):
client().create_program.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = quantum.QuantumJob(
name='projects/proj/programs/prog/jobs/job-id',
execution_status={
'state': 'FAILURE',
'failure': {
'error_code': 'SYSTEM_ERROR',
'error_message': 'Not good'
},
},
)
engine = cg.Engine(project_id='proj')
with pytest.raises(
RuntimeError,
match='Job projects/proj/programs/prog/jobs/job-id on processor'
' UNKNOWN failed. SYSTEM_ERROR: Not good',
):
engine.run(program=_CIRCUIT)
def test_sampler(client):
client().create_program.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = quantum.QuantumJob(
execution_status={'state': 'SUCCESS'},
update_time=_to_timestamp('2019-07-09T23:39:59Z'))
client().get_job_results.return_value = quantum.QuantumResult(
result=util.pack_any(_RESULTS_V2))
processor = cg.EngineProcessor('proj', 'mysim', EngineContext())
sampler = processor.get_sampler()
results = sampler.run_sweep(
program=_CIRCUIT,
params=[cirq.ParamResolver({'a': 1}),
cirq.ParamResolver({'a': 2})])
assert len(results) == 2
for i, v in enumerate([1, 2]):
assert results[i].repetitions == 1
assert results[i].params.param_dict == {'a': v}
assert results[i].measurements == {'q': np.array([[0]], dtype='uint8')}
assert client().create_program.call_args[0][0] == 'proj'
def test_set_job_description(client_constructor):
grpc_client = setup_mock_(client_constructor)
result = quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job0')
grpc_client.update_quantum_job.return_value = result
client = EngineClient()
assert client.set_job_description('proj', 'prog', 'job0', 'A job') == result
grpc_client.update_quantum_job.assert_called_with(
quantum.UpdateQuantumJobRequest(
name='projects/proj/programs/prog/jobs/job0',
quantum_job=quantum.QuantumJob(
name='projects/proj/programs/prog/jobs/job0', description='A job'
),
update_mask=FieldMask(paths=['description']),
)
)
assert client.set_job_description('proj', 'prog', 'job0', '') == result
grpc_client.update_quantum_job.assert_called_with(
quantum.UpdateQuantumJobRequest(
name='projects/proj/programs/prog/jobs/job0',
quantum_job=quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job0'),
update_mask=FieldMask(paths=['description']),
)
)
def test_set_job_labels(client_constructor):
grpc_client = setup_mock_(client_constructor)
grpc_client.get_quantum_job.return_value = quantum.QuantumJob(
labels={'color': 'red', 'weather': 'sun', 'run': '1'}, label_fingerprint='hash'
)
result = quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job0')
grpc_client.update_quantum_job.return_value = result
client = EngineClient()
labels = {'hello': 'world', 'color': 'blue', 'run': '1'}
assert client.set_job_labels('proj', 'prog', 'job0', labels) == result
grpc_client.update_quantum_job.assert_called_with(
quantum.UpdateQuantumJobRequest(
name='projects/proj/programs/prog/jobs/job0',
quantum_job=quantum.QuantumJob(
name='projects/proj/programs/prog/jobs/job0',
labels=labels,
label_fingerprint='hash',
),
update_mask=FieldMask(paths=['labels']),
)
)
assert client.set_job_labels('proj', 'prog', 'job0', {}) == result
grpc_client.update_quantum_job.assert_called_with(
quantum.UpdateQuantumJobRequest(
name='projects/proj/programs/prog/jobs/job0',
quantum_job=quantum.QuantumJob(
name='projects/proj/programs/prog/jobs/job0', label_fingerprint='hash'
),
update_mask=FieldMask(paths=['labels']),
)
)
def test_run_batch_delegation(create_job):
create_job.return_value = ('kittens', quantum.QuantumJob())
program = cg.EngineProgram('my-meow', 'my-meow', EngineContext(), result_type=ResultType.Batch)
resolver_list = [cirq.Points('cats', [1.0, 2.0, 3.0]), cirq.Points('cats', [4.0, 5.0, 6.0])]
job = program.run_batch(
job_id='steve', repetitions=10, params_list=resolver_list, processor_ids=['lazykitty']
)
assert job._job == quantum.QuantumJob()
def test_run_sweeps_delegation(create_job):
create_job.return_value = ('steve', quantum.QuantumJob())
program = cg.EngineProgram('my-proj', 'my-prog', EngineContext())
param_resolver = cirq.ParamResolver({})
job = program.run_sweep(
job_id='steve', repetitions=10, params=param_resolver, processor_ids=['mine']
)
assert job._job == quantum.QuantumJob()
def test_set_description(set_job_description):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
set_job_description.return_value = quantum.QuantumJob(description='world')
assert job.set_description('world').description() == 'world'
set_job_description.assert_called_with('a', 'b', 'steve', 'world')
set_job_description.return_value = quantum.QuantumJob(description='')
assert job.set_description('').description() == ''
set_job_description.assert_called_with('a', 'b', 'steve', '')
def test_description(get_job):
job = cg.EngineJob('a',
'b',
'steve',
EngineContext(),
_job=quantum.QuantumJob(description='hello'))
assert job.description() == 'hello'
get_job.return_value = quantum.QuantumJob(description='hello')
assert cg.EngineJob('a', 'b', 'steve',
EngineContext()).description() == 'hello'
get_job.assert_called_once_with('a', 'b', 'steve', False)
def setup_run_circuit_with_result_(client, result):
client().create_program.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = quantum.QuantumJob(
execution_status={'state': 'SUCCESS'}, update_time=_DT)
client().get_job_results.return_value = quantum.QuantumResult(
result=result)
def test_get_repetitions_and_sweeps_v1(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = quantum.QuantumJob(run_context=util.pack_any(
v1.program_pb2.RunContext(
parameter_sweeps=[v1.params_pb2.ParameterSweep(repetitions=10)])))
with pytest.raises(ValueError, match='v1 RunContext is not supported'):
job.get_repetitions_and_sweeps()
async def create_job_async(
self,
project_id: str,
program_id: str,
job_id: Optional[str],
processor_ids: Sequence[str],
run_context: any_pb2.Any,
priority: Optional[int] = None,
description: Optional[str] = None,
labels: Optional[Dict[str, str]] = None,
) -> Tuple[str, quantum.QuantumJob]:
"""Creates and runs a job on Quantum Engine.
Args:
project_id: A project_id of the parent Google Cloud Project.
program_id: Unique ID of the program within the parent project.
job_id: Unique ID of the job within the parent program.
run_context: Properly serialized run context.
processor_ids: List of processor id for running the program.
priority: Optional priority to run at, 0-1000.
description: Optional description to set on the job.
labels: Optional set of labels to set on the job.
Returns:
Tuple of created job id and job.
Raises:
ValueError: If the priority is not betwen 0 and 1000.
"""
# Check program to run and program parameters.
if priority and not 0 <= priority < 1000:
raise ValueError('priority must be between 0 and 1000')
# Create job.
job_name = _job_name_from_ids(project_id, program_id, job_id) if job_id else ''
job = quantum.QuantumJob(
name=job_name,
scheduling_config=quantum.SchedulingConfig(
processor_selector=quantum.SchedulingConfig.ProcessorSelector(
processor_names=[
_processor_name_from_ids(project_id, processor_id)
for processor_id in processor_ids
]
)
),
run_context=run_context,
)
if priority:
job.scheduling_config.priority = priority
if description:
job.description = description
if labels:
job.labels.update(labels)
request = quantum.CreateQuantumJobRequest(
parent=_program_name_from_ids(project_id, program_id),
quantum_job=job,
overwrite_existing_run_context=False,
)
job = await self._send_request_async(self.grpc_client.create_quantum_job, request)
return _ids_from_job_name(job.name)[2], job
def test_labels():
job = cg.EngineJob('a',
'b',
'steve',
EngineContext(),
_job=quantum.QuantumJob(labels={'t': '1'}))
assert job.labels() == {'t': '1'}
def test_run_batch_no_sweeps(create_job):
# Running with no sweeps is fine. Uses program's batch size to create
# proper empty sweeps.
create_job.return_value = ('kittens', quantum.QuantumJob())
program = cg.EngineProgram(
'my-meow',
'my-meow',
_program=quantum.QuantumProgram(code=_BATCH_PROGRAM_V2),
context=EngineContext(),
result_type=ResultType.Batch,
)
job = program.run_batch(job_id='steve', repetitions=10, processor_ids=['lazykitty'])
assert job._job == quantum.QuantumJob()
batch_run_context = v2.batch_pb2.BatchRunContext()
create_job.call_args[1]['run_context'].Unpack(batch_run_context)
assert len(batch_run_context.run_contexts) == 1
def test_batched_results(get_job_results):
qjob = quantum.QuantumJob(
execution_status=quantum.ExecutionStatus(
state=quantum.ExecutionStatus.State.SUCCESS),
update_time=UPDATE_TIME,
)
get_job_results.return_value = BATCH_RESULTS
job = cg.EngineJob('a', 'b', 'steve', EngineContext(), _job=qjob)
data = job.results()
assert len(data) == 4
assert str(data[0]) == 'q=011'
assert str(data[1]) == 'q=111'
assert str(data[2]) == 'q=1101'
assert str(data[3]) == 'q=1001'
get_job_results.assert_called_once_with('a', 'b', 'steve')
data = job.batched_results()
assert len(data) == 2
assert len(data[0]) == 2
assert len(data[1]) == 2
assert str(data[0][0]) == 'q=011'
assert str(data[0][1]) == 'q=111'
assert str(data[1][0]) == 'q=1101'
assert str(data[1][1]) == 'q=1001'
def test_get_calibration(get_calibration):
qjob = quantum.QuantumJob(execution_status=quantum.ExecutionStatus(
calibration_name='projects/a/processors/p/calibrations/123'))
calibration = quantum.QuantumCalibration(data=util.pack_any(
Merge(
"""
timestamp_ms: 123000,
metrics: [{
name: 'xeb',
targets: ['0_0', '0_1'],
values: [{
double_val: .9999
}]
}, {
name: 't1',
targets: ['0_0'],
values: [{
double_val: 321
}]
}, {
name: 'globalMetric',
values: [{
int32_val: 12300
}]
}]
""",
v2.metrics_pb2.MetricsSnapshot(),
)))
get_calibration.return_value = calibration
job = cg.EngineJob('a', 'b', 'steve', EngineContext(), _job=qjob)
assert list(job.get_calibration()) == ['xeb', 't1', 'globalMetric']
get_calibration.assert_called_once_with('a', 'p', 123)
def test_get_repetitions_and_sweeps_unsupported(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = quantum.QuantumJob(run_context=any_pb2.Any(
type_url='type.googleapis.com/unknown.proto'))
with pytest.raises(ValueError,
match='unsupported run_context type: unknown.proto'):
job.get_repetitions_and_sweeps()
def test_get_repetitions_and_sweeps(get_job):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
get_job.return_value = quantum.QuantumJob(run_context=util.pack_any(
v2.run_context_pb2.RunContext(parameter_sweeps=[
v2.run_context_pb2.ParameterSweep(repetitions=10)
])))
assert job.get_repetitions_and_sweeps() == (10, [cirq.UnitSweep])
get_job.assert_called_once_with('a', 'b', 'steve', True)
def test_run_batch(client):
client().create_program.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = quantum.QuantumJob(
execution_status={'state': 'SUCCESS'},
update_time=_to_timestamp('2019-07-09T23:39:59Z'))
client().get_job_results.return_value = quantum.QuantumResult(
result=_BATCH_RESULTS_V2)
processor = cg.EngineProcessor('a', 'p', EngineContext())
job = processor.run_batch(
programs=[_CIRCUIT, _CIRCUIT],
job_id='job-id',
params_list=[cirq.Points('a', [1, 2]),
cirq.Points('a', [3, 4])],
)
results = job.results()
assert len(results) == 4
for i, v in enumerate([1, 2, 3, 4]):
assert results[i].repetitions == 1
assert results[i].params.param_dict == {'a': v}
assert results[i].measurements == {'q': np.array([[0]], dtype='uint8')}
for result in results:
assert result.job_id == job.id()
client().create_program.assert_called_once()
client().create_job.assert_called_once()
run_context = v2.batch_pb2.BatchRunContext()
client().create_job.call_args[1]['run_context'].Unpack(run_context)
assert len(run_context.run_contexts) == 2
for idx, rc in enumerate(run_context.run_contexts):
sweeps = rc.parameter_sweeps
assert len(sweeps) == 1
assert sweeps[0].repetitions == 1
if idx == 0:
assert sweeps[0].sweep.single_sweep.points.points == [1.0, 2.0]
if idx == 1:
assert sweeps[0].sweep.single_sweep.points.points == [3.0, 4.0]
client().get_job.assert_called_once()
client().get_job_results.assert_called_once()
def test_run_circuit_timeout(client):
client().create_program_async.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job_async.return_value = (
'job-id',
quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job_async.return_value = quantum.QuantumJob(
name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'RUNNING'})
engine = cg.Engine(project_id='project-id', timeout=1)
with pytest.raises(TimeoutError):
engine.run(program=_CIRCUIT)
def test_run_circuit_timeout(patched_time_sleep, client):
client().create_program.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = quantum.QuantumJob(
name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'RUNNING'})
engine = cg.Engine(project_id='project-id', timeout=600)
with pytest.raises(RuntimeError, match='Timed out'):
engine.run(program=_CIRCUIT)
def test_run_sweep_params(client):
client().create_program.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
quantum.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = quantum.QuantumJob(
execution_status={'state': 'SUCCESS'},
update_time=_to_timestamp('2019-07-09T23:39:59Z'))
client().get_job_results.return_value = quantum.QuantumResult(
result=util.pack_any(_RESULTS_V2))
processor = cg.EngineProcessor('a', 'p', EngineContext())
job = processor.run_sweep(
program=_CIRCUIT,
params=[cirq.ParamResolver({'a': 1}),
cirq.ParamResolver({'a': 2})])
results = job.results()
assert len(results) == 2
for i, v in enumerate([1, 2]):
assert results[i].repetitions == 1
assert results[i].params.param_dict == {'a': v}
assert results[i].measurements == {'q': np.array([[0]], dtype='uint8')}
for result in results:
assert result.job_id == job.id()
assert result.job_finished_time is not None
assert results == cirq.read_json(json_text=cirq.to_json(results))
client().create_program.assert_called_once()
client().create_job.assert_called_once()
run_context = v2.run_context_pb2.RunContext()
client().create_job.call_args[1]['run_context'].Unpack(run_context)
sweeps = run_context.parameter_sweeps
assert len(sweeps) == 2
for i, v in enumerate([1.0, 2.0]):
assert sweeps[i].repetitions == 1
assert sweeps[i].sweep.sweep_function.sweeps[
0].single_sweep.points.points == [v]
client().get_job.assert_called_once()
client().get_job_results.assert_called_once()
def test_run_calibration(client):
client().create_program_async.return_value = (
'prog',
quantum.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job_async.return_value = (
'job-id',
quantum.QuantumJob(
name='projects/proj/programs/prog/jobs/job-id', execution_status={'state': 'READY'}
),
)
client().get_job_async.return_value = quantum.QuantumJob(execution_status={'state': 'SUCCESS'})
client().get_job_results_async.return_value = quantum.QuantumResult(
result=_CALIBRATION_RESULTS_V2
)
q1 = cirq.GridQubit(2, 3)
q2 = cirq.GridQubit(2, 4)
layer1 = cg.CalibrationLayer('xeb', cirq.Circuit(cirq.CZ(q1, q2)), {'num_layers': 42})
layer2 = cg.CalibrationLayer(
'readout', cirq.Circuit(cirq.measure(q1, q2)), {'num_samples': 4242}
)
processor = cg.EngineProcessor('proj', 'mysim', EngineContext())
job = processor.run_calibration(layers=[layer1, layer2], job_id='job-id')
results = job.calibration_results()
assert len(results) == 2
assert results[0].code == v2.calibration_pb2.SUCCESS
assert results[0].error_message == 'First success'
assert results[0].token == 'abc123'
assert len(results[0].metrics) == 1
assert len(results[0].metrics['fidelity']) == 1
assert results[0].metrics['fidelity'][(q1, q2)] == [0.75]
assert results[1].code == v2.calibration_pb2.SUCCESS
assert results[1].error_message == 'Second success'
# assert label is correct
client().create_job_async.assert_called_once_with(
project_id='proj',
program_id='prog',
job_id='job-id',
processor_ids=['mysim'],
run_context=util.pack_any(v2.run_context_pb2.RunContext()),
description=None,
labels={'calibration': ''},
)
def test_set_labels(set_job_labels):
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
set_job_labels.return_value = quantum.QuantumJob(labels={
'a': '1',
'b': '1'
})
assert job.set_labels({
'a': '1',
'b': '1'
}).labels() == {
'a': '1',
'b': '1'
}
set_job_labels.assert_called_with('a', 'b', 'steve', {'a': '1', 'b': '1'})
set_job_labels.return_value = quantum.QuantumJob()
assert job.set_labels({}).labels() == {}
set_job_labels.assert_called_with('a', 'b', 'steve', {})
def test_remove_labels(remove_job_labels):
job = cg.EngineJob('a',
'b',
'steve',
EngineContext(),
_job=quantum.QuantumJob(labels={
'a': '1',
'b': '1'
}))
assert job.labels() == {'a': '1', 'b': '1'}
remove_job_labels.return_value = quantum.QuantumJob(labels={'b': '1'})
assert job.remove_labels(['a']).labels() == {'b': '1'}
remove_job_labels.assert_called_with('a', 'b', 'steve', ['a'])
remove_job_labels.return_value = quantum.QuantumJob(labels={})
assert job.remove_labels(['a', 'b', 'c']).labels() == {}
remove_job_labels.assert_called_with('a', 'b', 'steve', ['a', 'b', 'c'])
def test_status(get_job):
qjob = quantum.QuantumJob(execution_status=quantum.ExecutionStatus(
state=quantum.ExecutionStatus.State.RUNNING))
get_job.return_value = qjob
job = cg.EngineJob('a', 'b', 'steve', EngineContext())
assert job.status() == 'RUNNING'
get_job.assert_called_once()
assert job.execution_status() == quantum.ExecutionStatus.State.RUNNING
def test_list_jobs(list_jobs):
job1 = quantum.QuantumJob(name='projects/proj/programs/prog1/jobs/job1')
job2 = quantum.QuantumJob(name='projects/otherproj/programs/prog1/jobs/job2')
list_jobs.return_value = [job1, job2]
ctx = EngineContext()
result = cg.EngineProgram(project_id='proj', program_id='prog1', context=ctx).list_jobs()
list_jobs.assert_called_once_with(
'proj',
'prog1',
created_after=None,
created_before=None,
has_labels=None,
execution_states=None,
)
assert [(j.program_id, j.project_id, j.job_id, j.context, j._job) for j in result] == [
('prog1', 'proj', 'job1', ctx, job1),
('prog1', 'otherproj', 'job2', ctx, job2),
]
def test_calibration_results_not_a_calibration(get_job_results):
qjob = quantum.QuantumJob(
execution_status=quantum.ExecutionStatus(
state=quantum.ExecutionStatus.State.SUCCESS),
update_time=UPDATE_TIME,
)
get_job_results.return_value = RESULTS
job = cg.EngineJob('a', 'b', 'steve', EngineContext(), _job=qjob)
with pytest.raises(ValueError, match='calibration results'):
job.calibration_results()
def test_results_len(get_job_results):
qjob = quantum.QuantumJob(
execution_status=quantum.ExecutionStatus(
state=quantum.ExecutionStatus.State.SUCCESS),
update_time=UPDATE_TIME,
)
get_job_results.return_value = RESULTS
job = cg.EngineJob('a', 'b', 'steve', EngineContext(), _job=qjob)
assert len(job) == 2
def test_timeout(get_job):
qjob = quantum.QuantumJob(
execution_status=quantum.ExecutionStatus(
state=quantum.ExecutionStatus.State.RUNNING),
update_time=UPDATE_TIME,
)
get_job.return_value = qjob
job = cg.EngineJob('a', 'b', 'steve', EngineContext(timeout=0.1))
with pytest.raises(TimeoutError):
job.results()
def test_list_jobs(client_constructor):
grpc_client = setup_mock_(client_constructor)
results = [
quantum.QuantumJob(name='projects/proj/programs/prog1/jobs/job1'),
quantum.QuantumJob(name='projects/proj/programs/prog1/jobs/job2'),
]
grpc_client.list_quantum_jobs.return_value = results
client = EngineClient()
assert client.list_jobs(project_id='proj', program_id='prog1') == results
grpc_client.list_quantum_jobs.assert_called_with(
quantum.ListQuantumJobsRequest(parent='projects/proj/programs/prog1')
)
assert client.list_jobs(project_id='proj') == results
grpc_client.list_quantum_jobs.assert_called_with(
quantum.ListQuantumJobsRequest(parent='projects/proj/programs/-')
)
