def _wait_for_job(self, timeout=60, wait=5):
"""Wait until all online ran circuits of a qobj are 'COMPLETED'.
Args:
timeout (float or None): seconds to wait for job. If None, wait
indefinitely.
wait (float): seconds between queries
Returns:
Result: A result object.
Raises:
JobTimeoutError: if the job does not return results before a specified timeout.
JobError: if something wrong happened in some of the server API calls
"""
start_time = time.time()
while self.status() not in JOB_FINAL_STATES:
elapsed_time = time.time() - start_time
if timeout is not None and elapsed_time >= timeout:
raise JobTimeoutError(
'Timeout while waiting for the job: {}'.format(self._id))
logger.info('status = %s (%d seconds)', self._status, elapsed_time)
time.sleep(wait)
if self._cancelled:
return Result({
'id': self._id,
'status': 'CANCELLED',
'result': 'job cancelled'
})
job_data = self._api.get_job(self._id)
job_result_list = []
for circuit_result in job_data['qasms']:
this_result = {
'data': circuit_result['data'],
'name': circuit_result.get('name'),
'compiled_circuit_qasm': circuit_result.get('qasm'),
'status': circuit_result['status']
}
if 'metadata' in circuit_result:
this_result['metadata'] = circuit_result['metadata']
job_result_list.append(this_result)
return Result({
'id': self._id,
'status': job_data['status'],
'used_credits': job_data.get('usedCredits'),
'result': job_result_list,
'backend_name': self.backend_name
})
def run(self, q_job):
"""Run q_job
Args:
q_job (QuantumJob): job to run
Returns:
Result: Result is a class including the information to be returned to users.
Specifically, result_list in the return looks is important and it like this:
[
{'data': {'unitary':
array([[sqrt(2)/2, sqrt(2)/2, 0, 0],
[0, 0, sqrt(2)/2, -sqrt(2)/2],
[0, 0, sqrt(2)/2, sqrt(2)/2],
[sqrt(2)/2, -sqrt(2)/2, 0, 0]], dtype=object)},
'status': 'DONE'}
]
"""
# Generating a string id for the job
job_id = str(uuid.uuid4())
qobj = q_job.qobj
result_list = []
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
return Result(
{
'job_id': job_id,
'result': result_list,
'status': 'COMPLETED'
}, qobj)
def _run_job(self, qobj):
"""Run circuits in qobj and return the result
Args:
qobj (dict): all the information necessary
(e.g., circuit, backend and resources) for running a circuit
Returns:
Result: Result is a class including the information to be returned to users.
Specifically, result_list in the return contains the essential information,
which looks like this::
[{'data':
{
'statevector': array([sqrt(2)/2, 0, 0, sqrt(2)/2], dtype=object),
},
'status': 'DONE'
}]
"""
self._validate(qobj)
result_list = []
start = time.time()
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
end = time.time()
job_id = str(uuid.uuid4())
result = {'backend': self._configuration['name'],
'id': qobj['id'],
'job_id': job_id,
'result': result_list,
'status': 'COMPLETED',
'success': True,
'time_taken': (end - start)}
return Result(result)
def run(self, q_job):
"""Run circuits in q_job and return the result
Args:
q_job (QuantumJob): all the information necessary
(e.g., circuit, backend and resources) for running a circuit
Returns:
Result: Result is a class including the information to be returned to users.
Specifically, result_list in the return contains the essential information,
which looks like this::
[{'data':
{
'counts': {'00': 1},
'quantum_state': array([sqrt(2)/2, 0, 0, sqrt(2)/2], dtype=object),
'classical_state': 0
},
'status': 'DONE'
}]
"""
job_id = str(uuid.uuid4())
qobj = q_job.qobj
result_list = []
self._shots = qobj['config']['shots']
if self._shots > 1:
logger.info("No need for multiple shots. A single execution will be performed.")
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
return Result({'job_id': job_id, 'result': result_list, 'status': 'COMPLETED'}, qobj)
def _run_job(self, qobj):
"""Run qobj. This is a blocking call.
Args:
qobj (Qobj): job description
Returns:
Result: Result object
"""
result_list = []
start = time.time()
for circuit in qobj.experiments:
result_list.append(self.run_circuit(circuit))
end = time.time()
job_id = str(uuid.uuid4())
result = {
'backend': self._configuration['name'],
'id': qobj.qobj_id,
'job_id': job_id,
'result': result_list,
'status': 'COMPLETED',
'sucsess': True,
'time_taken': (end - start)
}
copy_qasm_from_qobj_into_result(qobj, result)
return Result(result)
def _run_job(self, q_job):
qobj = q_job.qobj
self._validate(qobj)
simulator = SimulatorWrapper()
result = simulator.run(json.dumps(qobj, cls=QASMSimulatorEncoder))
result = json.loads(result, cls=QASMSimulatorDecoder)
return Result(result, qobj)
def run(self):
"""
Run simulation on C++ simulator.
"""
# result_list = []
# for circuit in self.qobj['circuits']:
# result_list.append( self.run_circuit(circuit) )
# return Result({'result': result_list, 'status': 'COMPLETED'},
# self.qobj)
cmd = self._exe + ' - '
with subprocess.Popen(cmd.split(),
stdin=PIPE,
stdout=PIPE,
stderr=PIPE) as proc:
cin = json.dumps(self.qobj).encode()
cout, cerr = proc.communicate(cin)
if len(cerr) == 0:
# no error messages, load std::cout
cresult = json.loads(cout.decode())
# convert possible complex valued result fields
for result in cresult['result']:
for k in ['state', 'saved_states', 'inner_products']:
parse_complex(result['data'], k)
return Result(cresult, self.qobj)
else:
# custom "backend" or "result" exception handler here?
raise SimulatorError(
'local_qasm_cpp_simulator returned: {0}\n{1}'.format(
cout.decode(), cerr.decode()))
def run(self, q_job):
"""Run a QuantumJob on the backend."""
qobj = q_job.qobj
self._validate(qobj)
final_state_key = 32767 # Internal key for final state snapshot
# Add final snapshots to circuits
for circuit in qobj['circuits']:
circuit['compiled_circuit']['operations'].append({
'name':
'snapshot',
'params': [final_state_key]
})
result = super().run(q_job)._result
# Extract final state snapshot and move to 'statevector' data field
for res in result['result']:
snapshots = res['data']['snapshots']
if str(final_state_key) in snapshots:
final_state_key = str(final_state_key)
# Pop off final snapshot added above
final_state = snapshots.pop(final_state_key, None)
final_state = final_state['statevector'][0]
# Add final state to results data
res['data']['statevector'] = final_state
# Remove snapshot dict if empty
if snapshots == {}:
res['data'].pop('snapshots', None)
return Result(result, qobj)
def _run_job(self, qobj):
"""Run a Qobj on the backend."""
self._validate(qobj)
final_state_key = 32767 # Internal key for final state snapshot
# Add final snapshots to circuits
for circuit in qobj['circuits']:
circuit['compiled_circuit']['operations'].append({
'name':
'snapshot',
'params': [final_state_key]
})
result = super()._run_job(qobj)._result
# Replace backend name with current backend
result['backend'] = self._configuration['name']
# Extract final state snapshot and move to 'statevector' data field
for res in result['result']:
snapshots = res['data']['snapshots']
if str(final_state_key) in snapshots:
final_state_key = str(final_state_key)
# Pop off final snapshot added above
final_state = snapshots.pop(final_state_key, None)
final_state = final_state['statevector'][0]
# Add final state to results data
res['data']['statevector'] = final_state
# Remove snapshot dict if empty
if snapshots == {}:
res['data'].pop('snapshots', None)
return Result(result)
def run(self, q_job):
"""Run circuits in q_job"""
# Generating a string id for the job
result_list = []
qobj = q_job.qobj
self._validate(qobj)
self._sim = Simulator(gate_fusion=True)
if 'seed' in qobj['config']:
self._seed = qobj['config']['seed']
self._sim._simulator = CppSim(self._seed)
else:
self._seed = random.getrandbits(32)
self._shots = qobj['config']['shots']
start = time.time()
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
end = time.time()
result = {
'backend': self._configuration['name'],
'id': qobj['id'],
'result': result_list,
'status': 'COMPLETED',
'success': True,
'time_taken': (end - start)
}
return Result(result, qobj)
def run(self):
"""Run circuits in qobj"""
result_list = []
for circuit in self.qobj['circuits']:
result_list.append(self.run_circuit(circuit))
return Result({
'result': result_list,
'status': 'COMPLETED'
}, self.qobj)
def _run_job(self, qobj):
self._validate()
# set backend to Clifford simulator
if 'config' in qobj:
qobj['config']['simulator'] = 'clifford'
else:
qobj['config'] = {'simulator': 'clifford'}
result = run(qobj, self._configuration['exe'])
return Result(result)
def run(self, q_job):
qobj = q_job.qobj
# set backend to Clifford simulator
if 'config' in qobj:
qobj['config']['simulator'] = 'clifford'
else:
qobj['config'] = {'simulator': 'clifford'}
result = run(qobj, self._configuration['exe'])
return Result(result, qobj)
def run(self, q_job):
"""Run a QuantumJob on the the backend."""
qobj = q_job.qobj
self._validate()
# set backend to Clifford simulator
if 'config' in qobj:
qobj['config']['simulator'] = 'clifford'
else:
qobj['config'] = {'simulator': 'clifford'}
result = run(qobj, self._configuration['exe'])
return Result(result, qobj)
def run(self, silent=True):
"""Run circuits in qobj
Args:
silent (bool, optional): Silence print statements. Default is True.
"""
result_list = []
self._shots = self.qobj['config']['shots']
for circuit in self.qobj['circuits']:
result_list.append( self.run_circuit(circuit) )
return Result({'result': result_list, 'status': 'COMPLETED'},
self.qobj)
def _run_job(self, q_job):
qobj = q_job.qobj
self._validate()
# set backend to Clifford simulator
if 'config' in qobj:
qobj['config']['simulator'] = 'clifford'
else:
qobj['config'] = {'simulator': 'clifford'}
simulator = SimulatorWrapper()
result = simulator.run(json.dumps(qobj, cls=QASMSimulatorEncoder))
result = json.loads(result, cls=QASMSimulatorDecoder)
return Result(result, qobj)
def _job_done_callback(self, future):
try:
result = future.result()
except Exception as ex:
result = Result({'status': 'ERROR', 'result': ex}, future.qobj)
with self.lock:
self.futures[future]['result'] = result
self.jobs_results.append(result)
if self.num_jobs != 0:
self.num_jobs -= 1
# Call the callback when all jobs have finished
if self.num_jobs == 0:
logger.info(pprint.pformat(result))
self.callback(self.jobs_results)
def _run_job(self, qobj):
"""Run qobj. This is a blocking call.
Args:
qobj (dict): job description
Returns:
Result: Result object
"""
result_list = []
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
job_id = str(uuid.uuid4())
return Result(
{'job_id': job_id, 'result': result_list, 'status': 'COMPLETED'})
def _run_job(self, qobj):
"""Run qobj. This is a blocking call.
Args:
qobj (Qobj): job description
Returns:
Result: Result object
"""
result_list = []
qobj_converted = qobj_to_dict(qobj, version='0.0.1')
for circuit in qobj_converted['circuits']:
result_list.append(self.run_circuit(circuit))
job_id = str(uuid.uuid4())
return Result(
{'job_id': job_id, 'result': result_list, 'status': 'COMPLETED'})
def run(self, q_job):
"""Run circuits in q_job"""
# Generating a string id for the job
job_id = str(uuid.uuid4())
qobj = q_job.qobj
result_list = []
self._shots = qobj['config']['shots']
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
return Result(
{
'job_id': job_id,
'result': result_list,
'status': 'COMPLETED'
}, qobj)
def run(self, q_job):
"""Run jobs
Args:
q_job (QuantumJob): job to run
Returns:
Result object.
Raises:
ResultError: if the api put 'error' in its output
"""
qobj = q_job.qobj
wait = q_job.wait
timeout = q_job.timeout
api_jobs = []
for circuit in qobj['circuits']:
if (('compiled_circuit_qasm' not in circuit)
or (circuit['compiled_circuit_qasm'] is None)):
compiled_circuit = openquantumcompiler.compile(
circuit['circuit'].qasm())
circuit['compiled_circuit_qasm'] = compiled_circuit.qasm(
qeflag=True)
if isinstance(circuit['compiled_circuit_qasm'], bytes):
api_jobs.append(
{'qasm': circuit['compiled_circuit_qasm'].decode()})
else:
api_jobs.append({'qasm': circuit['compiled_circuit_qasm']})
seed0 = qobj['circuits'][0]['config']['seed']
output = self._api.run_job(api_jobs,
qobj['config']['backend'],
shots=qobj['config']['shots'],
max_credits=qobj['config']['max_credits'],
seed=seed0)
if 'error' in output:
raise ResultError(output['error'])
logger.debug('Running on remote backend %s with job id: %s',
qobj['config']['backend'], output['id'])
job_result = _wait_for_job(output['id'],
self._api,
wait=wait,
timeout=timeout)
job_result['name'] = qobj['id']
job_result['backend'] = qobj['config']['backend']
this_result = Result(job_result, qobj)
return this_result
def _run_job(self, q_job):
"""Run q_job. This is a blocking call.
Args:
q_job (QuantumJob): job to run
Returns:
Result: Result object
"""
qobj = q_job.qobj
result_list = []
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
job_id = str(uuid.uuid4())
return Result(
{'job_id': job_id, 'result': result_list, 'status': 'COMPLETED'},
qobj)
def _job_done_callback(self, future):
try:
result = future.result()
except Exception as ex:
result = Result({'status': 'ERROR', 'result': ex}, future.qobj)
with self.lock:
self.futures[future]['result'] = result
self.jobs_results.append(result)
if self.num_jobs != 0:
self.num_jobs -= 1
# Call the callback when all jobs have finished
if self.num_jobs == 0:
if not future.silent:
import pprint
pprint.pprint(result)
sys.stdout.flush()
self.callback(self.jobs_results)
def run(self, q_job):
"""Run q_job
Args:
q_job (QuantumJob): job to run
Returns:
Result: Result object
"""
# Generating a string id for the job
job_id = str(uuid.uuid4())
qobj = q_job.qobj
result_list = []
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
return Result(
{'job_id': job_id, 'result': result_list, 'status': 'COMPLETED'},
qobj)
def _run_job(self, qobj):
"""Run circuits in qobj"""
self._validate(qobj)
result_list = []
self._shots = qobj.config.shots
start = time.time()
for circuit in qobj.circuits:
result_list.append(self.run_circuit(circuit.as_dict()))
end = time.time()
job_id = str(uuid.uuid4())
result = {'backend': self._configuration['name'],
'id': qobj.id,
'job_id': job_id,
'result': result_list,
'status': 'COMPLETED',
'success': True,
'time_taken': (end - start)}
return Result(result)
def run(self, q_job):
"""Run circuits in q_job"""
# Generating a string id for the job
job_id = str(uuid.uuid4())
result_list = []
qobj = q_job.qobj
self._sim = Simulator(gate_fusion=True)
if 'seed' in qobj['config']:
self._seed = qobj['config']['seed']
self._sim._simulator = CppSim(self._seed)
else:
self._seed = random.getrandbits(32)
self._shots = qobj['config']['shots']
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
return Result({'job_id': job_id, 'result': result_list,
'status': 'COMPLETED'},
qobj)
def run(self, q_job):
"""Run circuits in q_job"""
qobj = q_job.qobj
self._validate(qobj)
result_list = []
self._shots = qobj['config']['shots']
start = time.time()
for circuit in qobj['circuits']:
result_list.append(self.run_circuit(circuit))
end = time.time()
result = {
'backend': self._configuration['name'],
'id': qobj['id'],
'result': result_list,
'status': 'COMPLETED',
'success': True,
'time_taken': (end - start)
}
return Result(result, qobj)
def _job_done_callback(self, future):
try:
result = future.result()
except Exception as ex: # pylint: disable=broad-except
result = Result({
'job_id': '0',
'status': 'ERROR',
'result': ex
}, future.qobj)
with self.lock:
logger.debug("Have a Result: %s", pprint.pformat(result))
self.futures[future]['result'] = result
self.jobs_results.append(result)
if self.num_jobs != 0:
self.num_jobs -= 1
logger.debug("Jobs left count decreased: %d", self.num_jobs)
# Call the callback when all jobs have finished
if self.num_jobs == 0:
logger.debug("No more jobs in queue, returning results")
self.callback(self.jobs_results)
def run_remote_backend(qobj, api, wait=5, timeout=60, silent=True):
"""
Args:
qobj (dict): quantum object dictionary
api (IBMQuantumExperience): IBMQuantumExperience API connection
Raises:
QISKitError: if "ERROR" string in server response.
"""
api_jobs = []
for circuit in qobj['circuits']:
if (('compiled_circuit_qasm' not in circuit)
or (circuit['compiled_circuit_qasm'] is None)):
compiled_circuit = openquantumcompiler.compile(
circuit['circuit'].qasm())
circuit['compiled_circuit_qasm'] = compiled_circuit.qasm(
qeflag=True)
if isinstance(circuit['compiled_circuit_qasm'], bytes):
api_jobs.append(
{'qasm': circuit['compiled_circuit_qasm'].decode()})
else:
api_jobs.append({'qasm': circuit['compiled_circuit_qasm']})
seed0 = qobj['circuits'][0]['config']['seed']
output = api.run_job(api_jobs,
qobj['config']['backend'],
shots=qobj['config']['shots'],
max_credits=qobj['config']['max_credits'],
seed=seed0)
if 'error' in output:
raise ResultError(output['error'])
job_result = _wait_for_job(output['id'],
api,
wait=wait,
timeout=timeout,
silent=silent)
job_result['name'] = qobj['id']
job_result['backend'] = qobj['config']['backend']
this_result = Result(job_result, qobj)
return this_result
def result(self, timeout=None, wait=5):
"""Return the result from the job.
Args:
timeout (int): number of seconds to wait for job
wait (int): time between queries to IBM Q server
Returns:
Result: Result object
Raises:
IBMQJobError: exception raised during job initialization
"""
# pylint: disable=arguments-differ
while self._status == JobStatus.INITIALIZING:
if self._future_submit.exception():
raise IBMQJobError('error submitting job: {}'.format(
repr(self._future_submit.exception())))
time.sleep(0.1)
try:
this_result = self._wait_for_job(timeout=timeout, wait=wait)
except TimeoutError as err:
# A timeout error retrieving the results does not imply the job
# is failing. The job can be still running.
return Result({
'id': self._id,
'status': 'ERROR',
'result': str(err)
})
if self._is_device and self.done:
_reorder_bits(this_result)
if self._status not in JOB_FINAL_STATES:
if this_result.get_status() == 'ERROR':
self._status = JobStatus.ERROR
else:
self._status = JobStatus.DONE
return this_result
