def run(self, qobj: Qobj) -> QIJob:
""" Submits a quantum job to the Quantum Inspire platform.
Args:
qobj: The quantum job with the Qiskit algorithm and quantum inspire backend.
Returns:
A job that has been submitted.
"""
QuantumInspireBackend.__validate(qobj)
number_of_shots = qobj.config.shots
identifier = uuid.uuid1()
project_name = 'qi-sdk-project-{}'.format(identifier)
project = self.__api.create_project(project_name, number_of_shots,
self.__backend)
experiments = qobj.experiments
job = QIJob(self, str(project['id']), self.__api)
[
self._submit_experiment(experiment,
number_of_shots,
project=project)
for experiment in experiments
]
job.experiments = experiments
return job
def test_result(self):
api = Mock()
api.get_jobs_from_project.return_value = [{
'name': 'Test1',
'status': 'COMPLETE'
}, {
'name': 'Test2',
'status': 'COMPLETE'
}]
job_id = '42'
backend = Mock()
backend.get_experiment_results.return_value = [
self.experiment_result_1, self.experiment_result_2
]
backend.backend_name = 'some backend'
job = QIJob(backend, job_id, api)
results = job.result()
self.assertTrue(results.success)
self.assertDictEqual({'counts': {'0x0': 42}}, results.data(0))
self.assertDictEqual({'counts': {'0x1': 42}}, results.data(1))
self.assertDictEqual({'0': 42}, results.get_counts(0))
self.assertDictEqual({'1': 42}, results.get_counts(1))
self.assertEqual('42', results.job_id)
self.assertListEqual(['Test1', 'Test2'],
[r.name for r in results.results])
self.assertListEqual(['DONE', 'DONE'],
[r.status for r in results.results])
def run(self, qobj: QasmQobj) -> QIJob:
""" Submits a quantum job to the Quantum Inspire platform.
Args:
qobj: The quantum job with the Qiskit algorithm and quantum inspire backend.
Returns:
A job that has been submitted.
"""
self.__validate_number_of_shots(qobj)
number_of_shots = qobj.config.shots
identifier = uuid.uuid1()
project_name = 'qi-sdk-project-{}'.format(identifier)
project = self.__api.create_project(project_name, number_of_shots,
self.__backend)
experiments = qobj.experiments
job = QIJob(self, str(project['id']), self.__api)
for experiment in experiments:
self.__validate_number_of_clbits(experiment)
full_state_projection = self.__validate_full_state_projection(
experiment)
if not full_state_projection:
QuantumInspireBackend.__validate_unsupported_measurements(
experiment)
self._submit_experiment(
experiment,
number_of_shots,
project=project,
full_state_projection=full_state_projection)
job.experiments = experiments
return job
def test_cancel(self):
api = Mock()
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'COMPLETE'},
{'name': 'other_job', 'status': 'RUNNING'}]
job_id = '42'
backend = Mock()
job = QIJob(backend, job_id, api)
job.cancel()
api.delete_project.assert_called_with(42)
def test_result_timeout(self):
api = Mock()
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'COMPLETE'},
{'name': 'other_job', 'status': 'RUNNING'}]
job_id = '42'
backend = Mock()
job = QIJob(backend, job_id, api)
with self.assertRaises(JobTimeoutError):
job.result(timeout=1e-2, wait=0)
def test_submit_raises_error(self):
api = Mock()
api.get_jobs_from_project.return_value = []
job_id = '42'
backend = Mock()
backend.run.return_value = '25'
job = QIJob(backend, job_id, api)
with self.assertRaises(JobError):
job.submit()
def test_submit(self):
backend = Mock()
backend.run.return_value = '25'
api = Mock()
job_id = '42'
qobj = Qobj('id', {}, None, None)
job = QIJob(backend, job_id, api, qobj)
job.submit()
self.assertEqual('25', job.job_id())
def test_submit(self):
backend = Mock()
backend.run.return_value = '25'
api = Mock()
job_id = '42'
qobj = QasmQobj(qobj_id='id', config=QasmQobjConfig(), experiments=[], header=QobjHeader())
job = QIJob(backend, job_id, api, qobj)
job.submit()
self.assertEqual('25', job.job_id())
def test_result_cancelled(self):
api = Mock()
job_id = '42'
backend = Mock()
backend.get_experiment_results_from_latest_run.return_value = [self.experiment_result_3]
backend.backend_name = 'some backend'
job = QIJob(backend, job_id, api)
results = job.result(timeout=None).results[0]
self.assertFalse(results.success)
self.assertEqual(results.status, 'CANCELLED')
def test_constructor(self):
api = Mock()
api.get_jobs_from_project.return_value = []
job_id = '42'
backend = 'test_backend'
job = QIJob(backend, job_id, api)
self.assertEqual(job_id, job.job_id())
self.assertEqual(api, job._api)
self.assertIsNone(job.experiments)
self.assertEqual(JobStatus.CANCELLED, job._status)
def test_constructor_with_qobj(self):
api = Mock()
job_id = '42'
backend = 'test_backend'
qobj = QasmQobj(qobj_id='id', config=QasmQobjConfig(), experiments=[], header=QobjHeader())
job = QIJob(backend, job_id, api, qobj)
self.assertIs(qobj, job._qobj)
self.assertEqual(job.job_id(), '')
self.assertEqual(api, job._api)
self.assertIsNone(job.experiments)
self.assertEqual(JobStatus.INITIALIZING, job._status)
def test_constructor_with_qobj(self):
api = Mock()
job_id = '42'
backend = 'test_backend'
qobj = Qobj('id', {}, None, None)
job = QIJob(backend, job_id, api, qobj)
self.assertIs(qobj, job._qobj)
self.assertEqual(job.job_id(), '')
self.assertEqual(api, job._api)
self.assertIsNone(job.experiments)
self.assertEqual(JobStatus.INITIALIZING, job._status)
def test_get_experiment_results_returns_correct_value_from_latest_run(
self):
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
number_of_shots = 100
experiment = self._circuit_to_experiment(qc)
api = Mock()
api.get_result_from_job.return_value = {
'id': 1,
'histogram': {
'1': 0.6,
'3': 0.4
},
'execution_time_in_seconds': 2.1,
'number_of_qubits': 2,
'raw_data_url':
'http://saevar-qutech-nginx/api/results/24/raw-data/'
}
api.get_raw_data_from_result.return_value = [1] * 60 + [3] * 40
job = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(experiment)
user_data = {
'name': 'name',
'memory_slots': 2,
'creg_sizes': [['c1', 2]],
'measurements': measurements
}
job['user_data'] = json.dumps(user_data)
api.get_job.side_effect = [job]
quantuminspire_job = Mock()
quantuminspire_job.get_job_identifier.side_effect = [1]
qijob = QIJob('backend', '42', api)
qijob.add_job(quantuminspire_job)
simulator = QuantumInspireBackend(api, Mock())
experiment_result = simulator.get_experiment_results_from_latest_run(
qijob)[0]
self.assertEqual(experiment_result.data.counts['0x1'], 60)
self.assertEqual(experiment_result.data.counts['0x3'], 40)
self.assertEqual(experiment_result.data.probabilities['0x1'], 0.6)
self.assertEqual(experiment_result.data.probabilities['0x3'], 0.4)
self.assertEqual(len(experiment_result.data.memory), 100)
self.assertEqual(experiment_result.data.memory.count('0x1'), 60)
self.assertEqual(experiment_result.data.memory.count('0x3'), 40)
self.assertEqual(experiment_result.name, 'circuit0')
self.assertEqual(experiment_result.shots, number_of_shots)
def get_experiment_results(self, qi_job: QIJob) -> List[ExperimentResult]:
""" Get results from experiments from the Quantum-inspire platform.
Args:
qi_job: A job that has already been submitted and which execution is completed.
Raises:
QisKitBackendError: If an error occurred during execution by the backend.
Returns:
A list of experiment results; containing the data, execution time, status, etc.
"""
jobs = self.__api.get_jobs_from_project(int(qi_job.job_id()))
results = [self.__api.get_result_from_job(job['id']) for job in jobs]
experiment_results = []
for result, job in zip(results, jobs):
if not result.get('histogram', {}):
raise QisKitBackendError(
'Result from backend contains no histogram data!\n{}'.format(result.get('raw_text')))
user_data = json.loads(str(job.get('user_data')))
measurements = user_data.pop('measurements')
histogram_obj, memory_data = self.__convert_result_data(result, measurements)
full_state_histogram_obj = self.__convert_histogram(result, measurements)
experiment_result_data = ExperimentResultData(counts=histogram_obj,
probabilities=full_state_histogram_obj,
memory=memory_data)
header = Obj.from_dict(user_data)
experiment_result_dictionary = {'name': job.get('name'), 'seed': 42, 'shots': job.get('number_of_shots'),
'data': experiment_result_data, 'status': 'DONE', 'success': True,
'time_taken': result.get('execution_time_in_seconds'), 'header': header}
experiment_results.append(ExperimentResult(**experiment_result_dictionary))
return experiment_results
def test_get_experiment_results_returns_correct_value(self):
number_of_shots = 100
instructions = [{'name': 'h', 'qubits': [0]},
{'name': 'cx', 'qubits': [0, 1]},
{'name': 'measure', 'qubits': [1], 'memory': [1]},
{'name': 'measure', 'qubits': [0], 'memory': [0]}]
experiment = self._instructions_to_two_qubit_experiment(instructions)
api = Mock()
api.get_result_from_job.return_value = {'id': 1, 'histogram': {'1': 0.6, '3': 0.4},
'execution_time_in_seconds': 2.1, 'number_of_qubits': 2,
'raw_data_url': 'http://saevar-qutech-nginx/api/results/24/raw-data/'}
api.get_raw_data_from_result.return_value = [1] * 60 + [3] * 40
jobs = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(experiment)
user_data = {'name': 'name', 'memory_slots': 2,
'creg_sizes': [['c1', 2]], 'measurements': measurements}
jobs['user_data'] = json.dumps(user_data)
api.get_jobs_from_project.return_value = [jobs]
job = QIJob('backend', '42', api)
simulator = QuantumInspireBackend(api, Mock())
experiment_result = simulator.get_experiment_results(job)[0]
self.assertEqual(experiment_result.data.counts['0x1'], 60)
self.assertEqual(experiment_result.data.counts['0x3'], 40)
self.assertEqual(experiment_result.data.probabilities['0x1'], 0.6)
self.assertEqual(experiment_result.data.probabilities['0x3'], 0.4)
self.assertEqual(len(experiment_result.data.memory), 100)
self.assertEqual(experiment_result.data.memory.count('0x1'), 60)
self.assertEqual(experiment_result.data.memory.count('0x3'), 40)
self.assertEqual(experiment_result.name, 'circuit0')
self.assertEqual(experiment_result.shots, number_of_shots)
def run_histogram_test(self, single_experiment, mock_result1, mock_result2,
expected_histogram, expected_histogram_prob,
expected_memory):
self.mock_api.set(mock_result1, mock_result2)
jobs = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(
QasmQobjExperiment.from_dict(single_experiment))
user_data = {
'name': 'name',
'memory_slots': 2,
'creg_sizes': [['c1', 2]],
'measurements': measurements
}
jobs['user_data'] = json.dumps(user_data)
self.mock_api.get_jobs_from_project.return_value = [jobs]
job = QIJob('backend', '42', self.mock_api)
result = self.simulator.get_experiment_results_from_all_jobs(job)
number_of_shots = jobs['number_of_shots']
self.assertEqual(1, len(result))
first_experiment = first_item(result)
actual = first_experiment.data.counts
self.assertDictEqual(expected_histogram, actual)
probabilities = first_experiment.data.probabilities
self.assertTrue(
len(expected_histogram_prob.keys() - probabilities.keys()) == 0)
for key in set(probabilities.keys()) & set(
expected_histogram_prob.keys()):
self.assertTrue(
np.isclose(expected_histogram_prob[key], probabilities[key]))
self.assertTrue(len(first_experiment.data.memory) == number_of_shots)
self.assertListEqual(expected_memory, first_experiment.data.memory)
def test_get_experiment_results_multiple_single_shots(self):
one_shot_results = {'0x0': 0, '0x1': 0, '0x2': 0, '0x3': 0}
np.random.seed(2019)
for i in range(10000):
number_of_shots = 1
self._basic_job_dictionary['number_of_shots'] = number_of_shots
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
experiment = self._circuit_to_experiment(qc)
api = Mock()
api.get_result_from_job.return_value = {
'id':
1,
'histogram': {
'0': 0.2,
'1': 0.3,
'2': 0.4,
'3': 0.1
},
'execution_time_in_seconds':
2.1,
'number_of_qubits':
2,
'raw_data_url':
'http://saevar-qutech-nginx/api/results/24/raw-data/'
}
api.get_raw_data_from_result.return_value = []
jobs = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(
experiment)
user_data = {
'name': 'name',
'memory_slots': 2,
'creg_sizes': [['c1', 2]],
'measurements': measurements
}
jobs['user_data'] = json.dumps(user_data)
api.get_jobs_from_project.return_value = [jobs]
job = QIJob('backend', '42', api)
simulator = QuantumInspireBackend(api, Mock())
experiment_result = simulator.get_experiment_results_from_all_jobs(
job)[0]
# Exactly one value in memory
self.assertEqual(len(experiment_result.data.memory), 1)
# The only value in memory is the same as the value in the counts histogram.
self.assertEqual(
list(experiment_result.data.counts.keys())[0],
experiment_result.data.memory[0])
one_shot_results[experiment_result.data.memory[0]] += 1
self.assertEqual(one_shot_results['0x0'], 2066)
self.assertEqual(one_shot_results['0x1'], 2947)
self.assertEqual(one_shot_results['0x2'], 4003)
self.assertEqual(one_shot_results['0x3'], 984)
def test_get_experiment_results_returns_single_shot(self):
number_of_shots = 1
self._basic_job_dictionary['number_of_shots'] = number_of_shots
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
experiment = self._circuit_to_experiment(qc)
api = Mock()
api.get_result_from_job.return_value = {
'id': 1,
'histogram': {
'0': 0.5,
'3': 0.5
},
'execution_time_in_seconds': 2.1,
'number_of_qubits': 2,
'raw_data_url':
'http://saevar-qutech-nginx/api/results/24/raw-data/'
}
api.get_raw_data_from_result.return_value = []
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
jobs = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(experiment)
user_data = {
'name': 'name',
'memory_slots': 2,
'creg_sizes': [['c1', 2]],
'measurements': measurements
}
jobs['user_data'] = json.dumps(user_data)
api.get_jobs_from_project.return_value = [jobs]
job = QIJob('backend', '42', api)
simulator = QuantumInspireBackend(api, Mock())
experiment_result = simulator.get_experiment_results_from_all_jobs(
job)[0]
self.assertEqual(experiment_result.data.probabilities['0x0'], 0.5)
self.assertEqual(experiment_result.data.probabilities['0x3'], 0.5)
self.assertTrue(hasattr(experiment_result.data, 'memory'))
# Exactly one value in counts histogram
self.assertEqual(len(experiment_result.data.counts), 1)
# The single value in counts histogram has count 1
self.assertEqual(list(experiment_result.data.counts.values())[0], 1)
# Exactly one value in memory
self.assertEqual(len(experiment_result.data.memory), 1)
# The only value in memory is the same as the value in the counts histogram.
self.assertEqual(
list(experiment_result.data.counts.keys())[0],
experiment_result.data.memory[0])
self.assertEqual(experiment_result.name, 'circuit0')
self.assertEqual(experiment_result.shots, number_of_shots)
def get_experiment_results_from_all_jobs(self, qi_job: QIJob) -> List[ExperimentResult]:
"""
:param qi_job: A job that has already been submitted and which execution is completed.
:return:
A list of experiment results; containing the data, execution time, status, etc. for all the experiments in
all the job runs of the Quantum Inspire project.
"""
jobs = self.__api.get_jobs_from_project(int(qi_job.job_id()))
return self._get_experiment_results(jobs)
def get_experiment_results_from_latest_run(self, qi_job: QIJob) -> List[ExperimentResult]:
"""
:param qi_job: A job that has already been submitted and which execution is completed.
:return:
A list of experiment results; containing the data, execution time, status, etc. for the experiments in the
latest job run in the Quantum Inspire project.
"""
jobs = qi_job.get_jobs()
return self._get_experiment_results(jobs)
def retrieve_job(self, job_id: str) -> QIJob:
""" Retrieve a specified job by its job_id.
:param job_id: The job id.
:return:
The job that has been retrieved.
:raises QiskitBackendError: If job not found or error occurs during retrieval of the job.
"""
try:
self.__api.get_project(int(job_id))
except (ApiError, ValueError):
raise QiskitBackendError("Could not retrieve job with job_id '{}' ".format(job_id))
return QIJob(self, job_id, self.__api)
def test_result_timeout(self):
api = Mock()
api.get_job.return_value = {'name': 'other_job', 'status': 'RUNNING'}
job_id = '42'
backend = Mock()
quantuminspire_job = Mock()
quantuminspire_job.get_job_identifier.return_value = [1]
qijob = QIJob(backend, job_id, api)
qijob.add_job(quantuminspire_job)
with self.assertRaises(JobTimeoutError):
qijob.result(timeout=1e-2, wait=0)
def test_status(self):
api = Mock()
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'COMPLETE'},
{'name': 'other_job', 'status': 'RUNNING'}]
job_id = '42'
backend = Mock()
job = QIJob(backend, job_id, api)
status = job.status()
self.assertEqual(JobStatus.RUNNING, status)
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'COMPLETE'},
{'name': 'other_job', 'status': 'COMPLETE'}]
status = job.status()
self.assertEqual(JobStatus.DONE, status)
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'CANCELLED'},
{'name': 'other_job', 'status': 'COMPLETE'}]
status = job.status()
self.assertEqual(JobStatus.ERROR, status)
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'NEW'},
{'name': 'other_job', 'status': 'NEW'}]
status = job.status()
self.assertEqual(JobStatus.QUEUED, status)
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'CANCELLED'},
{'name': 'other_job', 'status': 'CANCELLED'}]
status = job.status()
self.assertEqual(JobStatus.CANCELLED, status)
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'NEW'},
{'name': 'other_job', 'status': 'RUNNING'}]
status = job.status()
self.assertEqual(JobStatus.RUNNING, status)
api.get_jobs_from_project.return_value = [{'name': 'test_job', 'status': 'NEW'},
{'name': 'other_job', 'status': 'COMPLETE'}]
status = job.status()
self.assertEqual(JobStatus.RUNNING, status)
def test_queue_position(self):
api = Mock()
api.get_job.side_effect = [{'name': 'test_job', 'status': 'NEW'},
{'name': 'other_job', 'status': 'NEW'}]
job_id = '42'
backend = Mock()
quantuminspire_job = Mock()
quantuminspire_job.get_job_identifier.side_effect = [1, 2]
qijob = QIJob(backend, job_id, api)
qijob.add_job(quantuminspire_job)
qijob.add_job(quantuminspire_job)
status = qijob.status()
self.assertEqual(JobStatus.QUEUED, status)
queue_position = qijob.queue_position(True)
self.assertIsNone(queue_position)
queue_position = qijob.queue_position()
self.assertIsNone(queue_position)
def run(self,
circuits: Union[QasmQobj, QuantumCircuit, List[QuantumCircuit]],
shots: Optional[int] = None,
memory: Optional[bool] = None,
**run_config: Dict[str, Any]
) -> QIJob:
""" Submits a quantum job to the Quantum Inspire platform.
The execution is asynchronous, and a handle to a job instance is returned.
:param circuits: An individual or a list of :class:`~qiskit.circuits.QuantumCircuit` objects to run
on the backend. A :class:`~qiskit.qobj.QasmQobj` object is also supported but is deprecated.
:param shots: Number of repetitions of each circuit, for sampling. Default: 1024
or ``max_shots`` from the backend configuration, whichever is smaller.
:param memory: If ``True``, per-shot measurement bitstrings are returned
:param run_config: Extra arguments used to configure the run.
:return:
A job that has been submitted.
Raises:
ApiError: If an unexpected error occurred while submitting the job to the backend.
QiskitBackendError: If the circuit is invalid for the Quantum Inspire backend.
"""
run_config_dict = self._get_run_config(
shots=shots,
memory=memory,
**run_config)
if isinstance(circuits, QasmQobj):
if not self.qobj_warning_issued:
warnings.warn("Passing a Qobj to QuantumInspireBackend.run is deprecated and will "
"be removed in a future release. Please pass in circuits "
"instead.", DeprecationWarning,
stacklevel=3)
self.qobj_warning_issued = True
qobj = circuits
else:
qobj = assemble(circuits, self, **run_config_dict)
number_of_shots = qobj.config.shots
self.__validate_number_of_shots(number_of_shots)
identifier = uuid.uuid1()
project_name = 'qi-sdk-project-{}'.format(identifier)
project: Optional[Dict[str, Any]]
project = self.__api.create_project(project_name, number_of_shots, self.__backend)
try:
experiments = qobj.experiments
job = QIJob(self, str(project['id']), self.__api)
for experiment in experiments:
self.__validate_number_of_clbits(experiment)
full_state_projection = Backend.configuration(self).simulator and \
self.__validate_full_state_projection(experiment)
if not full_state_projection:
QuantumInspireBackend.__validate_unsupported_measurements(experiment)
job_for_experiment = self._submit_experiment(experiment, number_of_shots, project=project,
full_state_projection=full_state_projection)
job.add_job(job_for_experiment)
if project is not None and job_for_experiment.get_project_identifier() != project['id']:
self.__api.delete_project(int(project['id']))
project = None
job.set_job_id(str(job_for_experiment.get_project_identifier()))
except (ApiError, QiskitBackendError) as error:
# delete the empty project
if project is not None:
self.__api.delete_project(int(project['id']))
raise error
job.experiments = experiments
return job
def test_status(self):
api = Mock()
api.get_job.side_effect = [{'name': 'test_job', 'status': 'COMPLETE'},
{'name': 'other_job', 'status': 'RUNNING'}]
job_id = '42'
backend = Mock()
quantuminspire_job = Mock()
quantuminspire_job.get_job_identifier.side_effect = [1, 2]
qijob = QIJob(backend, job_id, api)
qijob.add_job(quantuminspire_job)
qijob.add_job(quantuminspire_job)
status = qijob.status()
self.assertEqual(JobStatus.RUNNING, status)
api.get_job.side_effect = [{'name': 'test_job', 'status': 'COMPLETE'},
{'name': 'other_job', 'status': 'COMPLETE'}]
quantuminspire_job.get_job_identifier.side_effect = [1, 2]
status = qijob.status()
self.assertEqual(JobStatus.DONE, status)
api.get_job.side_effect = [{'name': 'test_job', 'status': 'CANCELLED'},
{'name': 'other_job', 'status': 'COMPLETE'}]
quantuminspire_job.get_job_identifier.side_effect = [1, 2]
status = qijob.status()
self.assertEqual(JobStatus.ERROR, status)
api.get_job.side_effect = [{'name': 'test_job', 'status': 'NEW'},
{'name': 'other_job', 'status': 'NEW'}]
quantuminspire_job.get_job_identifier.side_effect = [1, 2]
status = qijob.status()
self.assertEqual(JobStatus.QUEUED, status)
api.get_job.side_effect = [{'name': 'test_job', 'status': 'CANCELLED'},
{'name': 'other_job', 'status': 'CANCELLED'}]
quantuminspire_job.get_job_identifier.side_effect = [1, 2]
status = qijob.status()
self.assertEqual(JobStatus.CANCELLED, status)
api.get_job.side_effect = [{'name': 'test_job', 'status': 'NEW'},
{'name': 'other_job', 'status': 'RUNNING'}]
quantuminspire_job.get_job_identifier.side_effect = [1, 2]
status = qijob.status()
self.assertEqual(JobStatus.RUNNING, status)
api.get_job.side_effect = [{'name': 'test_job', 'status': 'NEW'},
{'name': 'other_job', 'status': 'COMPLETE'}]
quantuminspire_job.get_job_identifier.side_effect = [1, 2]
status = qijob.status()
self.assertEqual(JobStatus.RUNNING, status)
def test_get_experiment_results_returns_single_shot(self):
number_of_shots = 1
self._basic_job_dictionary['number_of_shots'] = number_of_shots
instructions = [{
'name': 'h',
'params': [],
'texparams': [],
'qubits': [0]
}, {
'name': 'cx',
'params': [],
'texparams': [],
'qubits': [0, 1]
}, {
'name': 'measure',
'qubits': [1],
'memory': [1]
}, {
'name': 'measure',
'qubits': [0],
'memory': [0]
}]
experiment = self._instructions_to_two_qubit_experiment(instructions)
api = Mock()
api.get_result_from_job.return_value = {
'id': 1,
'histogram': {
'0': 0.5,
'3': 0.5
},
'execution_time_in_seconds': 2.1,
'number_of_qubits': 2,
'raw_data_url':
'http://saevar-qutech-nginx/api/results/24/raw-data/'
}
api.get_raw_data_from_result.return_value = []
jobs = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(experiment)
user_data = {
'name': 'name',
'memory_slots': 2,
'creg_sizes': [['c1', 2]],
'measurements': measurements
}
jobs['user_data'] = json.dumps(user_data)
api.get_jobs_from_project.return_value = [jobs]
job = QIJob('backend', '42', api)
simulator = QuantumInspireBackend(api, Mock())
experiment_result = simulator.get_experiment_results(job)[0]
self.assertEqual(experiment_result.data.probabilities.to_dict()['0x0'],
0.5)
self.assertEqual(experiment_result.data.probabilities.to_dict()['0x3'],
0.5)
self.assertEqual('memory' in experiment_result.data.to_dict(), True)
# Exactly one value in counts histogram
self.assertEqual(len(experiment_result.data.counts.to_dict()), 1)
# The single value in counts histogram has count 1
self.assertEqual(
list(experiment_result.data.counts.to_dict().values())[0], 1)
# Exactly one value in memory
self.assertEqual(len(experiment_result.data.memory), 1)
# The only value in memory is the same as the value in the counts histogram.
self.assertEqual(
list(experiment_result.data.counts.to_dict().keys())[0],
experiment_result.data.memory[0])
self.assertEqual(experiment_result.name, 'circuit0')
self.assertEqual(experiment_result.shots, number_of_shots)