def startIBMQ():
global Q, backend
# Written to work with versions of IBMQ-Provider both before and after 0.3
IBMQP_Vers=float(IBMQVersion['qiskit-ibmq-provider'][:3])
print('IBMQ Provider v',IBMQP_Vers)
print ('Pinging IBM Quantum Experience before start')
p=ping('https://api.quantum-computing.ibm.com',1,0.5,True)
try:
print("requested backend: ",backendparm)
except:
sleep(0)
# specify the simulator as the backend
backend='ibmq_qasm_simulator'
if p==200:
if (IBMQP_Vers > 0.2): # The new authentication technique with provider as the object
provider0=IBMQ.load_account()
try:
Q=provider0.get_backend(backendparm)
except:
Q=provider0.get_backend(backend)
else:
interval = 300
else: # The older IBMQ authentication technique
IBMQ.load_accounts()
try:
Q=IBMQ.get_backend(backendparm)
except:
Q=IBMQ.get_backend(backend)
else:
interval = 300
else:
exit()
def set_backend(b='qasm_simulator'):
global _backend
if b == 'ibmqx4' or b == 'ibmqx5':
_backend = IBMQ.get_backend(b)
setqbits(5)
elif b == 'ibmq_16_melbourne':
_backend = IBMQ.get_backend(b)
setqbits(16)
elif b == 'ibmq_qasm_simulator':
_backend = IBMQ.get_backend(b)
setqbits(32)
else:
_backend = qiskit.BasicAer.get_backend('qasm_simulator')
setqbits(8)
def startIBMQ():
global Q, backend
# Written to work with versions of IBMQ-Provider both before and after 0.3
sQPV = IBMQVersion['qiskit-ibmq-provider']
pd = '.'
dot1 = [pos for pos, char in enumerate(sQPV) if char == pd][0]
dot2 = [pos for pos, char in enumerate(sQPV) if char == pd][1]
IBMQP_Vers = float(sQPV[dot1 + 1:dot2])
print('IBMQ Provider v', IBMQP_Vers)
if not UseLocal:
print('Pinging IBM Quantum Experience before start')
p = ping('https://api.quantum-computing.ibm.com', 1, 0.5, True)
#p=ping('https://quantum-computing.ibm.com/',1,0.5,True)
try:
print("requested backend: ", backendparm)
except:
sleep(0)
# specify the simulator as the backend
backend = 'ibmq_qasm_simulator'
if p == 200:
if (
IBMQP_Vers > 2
): # The new authentication technique with provider as the object
provider0 = IBMQ.load_account()
try:
Q = provider0.get_backend(backendparm)
except:
Q = provider0.get_backend(backend)
else:
interval = 300
else: # The older IBMQ authentication technique
IBMQ.load_accounts()
try:
Q = IBMQ.get_backend(backendparm)
except:
Q = IBMQ.get_backend(backend)
else:
interval = 300
else:
exit()
else: # THIS IS THE CASE FOR USING LOCAL SIMULATOR
backend = 'local aer qasm_simulator'
print("Building ", backend, "with requested attributes...")
if not AddNoise:
Q = Aer.get_backend('qasm_simulator')
else:
fake_backend = fake_qc()
Q = QasmSimulator.from_backend(fake_backend)
def load_devise(self, devise_name):
IBMQ.save_account(
'53d53f699d4b706ce125b3fea389764d22ca4a5e031581e0db1e13abaa8a565b1ec61e5b9f3ddeaf507b912aff0e1229b38ad38783ecc072df17686610e7b00d',
overwrite=True)
IBMQ.update_account()
IBMQ.load_account()
return IBMQ.get_backend(devise_name)
def test_get_jobs_filter_counts(self, qe_token, qe_url):
# TODO: consider generalizing backend name
# TODO: this tests depends on the previous executions of the user
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
my_filter = {
'backend.name': 'ibmq_qasm_simulator',
'shots': 1024,
'qasms.result.data.counts.00': {
'lt': 500
}
}
self.log.info('searching for at most 5 jobs with 1024 shots, a count '
'for "00" of < 500, on the ibmq_qasm_simulator backend')
job_list = backend.jobs(limit=5, skip=0, db_filter=my_filter)
self.log.info('found %s matching jobs', len(job_list))
for i, job in enumerate(job_list):
self.log.info('match #%d', i)
result = job.result()
self.assertTrue(
any(cresult.data['counts']['00'] < 500
for cresult in result.results.values()))
for circuit_name in result.get_names():
self.log.info('\tcircuit_name: %s', circuit_name)
if circuit_name:
counts = result.get_counts(circuit_name)
self.log.info('\t%s', str(counts))
def get_appropriate_backend(n, real, online, backend_name):
# Online, real or simuator?
if (not online):
global Aer
from qiskit import Aer
max_credits = 10
shots = 4098
print("Local simulator backend")
backend = Aer.get_backend('qasm_simulator')
# list of online devices: ibmq_qasm_simulator, ibmqx2, ibmqx4, ibmqx5, ibmq_16_melbourne
else:
global IBMQ
from qiskit import IBMQ
print("Online {0} backend".format("real" if real else "simulator"))
max_credits = 3
shots = 4098
import Qconfig
IBMQ.load_accounts()
if (backend_name is not None):
backend = IBMQ.get_backend(backend_name)
else:
large_enough_devices = IBMQ.backends(
filters=lambda x: x.configuration()['n_qubits'] >= n and x.configuration()[
'simulator'] == (not real)
)
backend = least_busy(large_enough_devices)
print("Backend name is {0}; max_credits = {1}, shots = {2}".format(
backend, max_credits, shots))
return backend, max_credits, shots
def _circuit_validator(self, circuit, qregs, init_state,
remote=False, test_shots=100000, threshold=1e-4):
# TODO check with unitary simulator(currently, ansilla is bothering...)
nc = ClassicalRegister(self.n_qubit)
circuit.add_register(nc)
for q, c in zip(qregs, nc):
circuit.measure(q, c)
if remote:
backend = IBMQ.get_backend('ibmq_qasm_simulator')
else:
backend = Aer.get_backend('qasm_simulator')
theoretical_prob = self._theoretical_prob(init_state)
print(theoretical_prob)
vjob = execute(circuit, backend=backend, shots=test_shots)
result = vjob.result().get_counts(circuit)
rb = self.n_qubit
bins = [format(i, '0%sb' % rb) for i in range(2**rb)]
probs = np.array([result.get(bi, 0)/test_shots for bi in bins])
print(probs)
# TODO check L2 norm is good enough to validate in larger case
# and check threshold
l2dist = self._L2_dist(theoretical_prob, probs)
if l2dist < threshold:
flag = True
else:
flag = False
circuit.remove_final_measurements()
return circuit, flag
def test_get_backend_name(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
job = backend.run(qobj)
self.assertTrue(job.backend().name() == backend.name())
def get_job_status(backend, job_id):
backend = IBMQ.get_backend(backend)
try:
print("Backend {0} is operational? {1}".format(
backend.name(),
backend.status()['operational']))
print("Backend was last updated in {0}".format(
backend.properties()['last_update_date']))
print("Backend has {0} pending jobs".format(
backend.status()['pending_jobs']))
except:
print("Maybe some errors in the properties of backend")
ibmq_job = backend.retrieve_job(job_id)
status = ibmq_job.status()
print(status.name)
print(ibmq_job.creation_date())
if (status.name == 'DONE'):
print("EUREKA")
result = ibmq_job.result()
counts = result.get_counts()
print("Result is: {0}".format(counts))
plot_histogram(counts)
else:
print("... Work in progress ...")
print("Queue position = {0}".format(ibmq_job.queue_position()))
print("Error message = {0}".format(ibmq_job.error_message()))
def set_backend(back):
global backend
if back == "ibmq":
backend = IBMQ.get_backend('ibmqx4')
else:
backend = Aer.get_backend('qasm_simulator')
print(backend.name)
def test_execute_several_circuits_simulator_online(self, qe_token, qe_url):
"""Test execute_several_circuits_simulator_online.
If all correct should return correct counts.
"""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qcr1 = QuantumCircuit(qr, cr)
qcr2 = QuantumCircuit(qr, cr)
qcr1.h(qr)
qcr2.h(qr[0])
qcr2.cx(qr[0], qr[1])
qcr1.measure(qr[0], cr[0])
qcr1.measure(qr[1], cr[1])
qcr2.measure(qr[0], cr[0])
qcr2.measure(qr[1], cr[1])
shots = 1024
qobj = compile([qcr1, qcr2], backend=backend, seed=73846087, shots=shots)
job = backend.run(qobj)
result = job.result()
counts1 = result.get_counts(qcr1)
counts2 = result.get_counts(qcr2)
target1 = {'00': shots / 4, '01': shots / 4,
'10': shots / 4, '11': shots / 4}
target2 = {'00': shots / 2, '11': shots / 2}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts1, target1, threshold)
self.assertDictAlmostEqual(counts2, target2, threshold)
def test_online_qasm_simulator_two_registers(self, qe_token, qe_url):
"""Test online_qasm_simulator_two_registers.
If all correct should return correct counts.
"""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qr1 = QuantumRegister(2)
cr1 = ClassicalRegister(2)
qr2 = QuantumRegister(2)
cr2 = ClassicalRegister(2)
qcr1 = QuantumCircuit(qr1, qr2, cr1, cr2)
qcr2 = QuantumCircuit(qr1, qr2, cr1, cr2)
qcr1.x(qr1[0])
qcr2.x(qr2[1])
qcr1.measure(qr1[0], cr1[0])
qcr1.measure(qr1[1], cr1[1])
qcr1.measure(qr2[0], cr2[0])
qcr1.measure(qr2[1], cr2[1])
qcr2.measure(qr1[0], cr1[0])
qcr2.measure(qr1[1], cr1[1])
qcr2.measure(qr2[0], cr2[0])
qcr2.measure(qr2[1], cr2[1])
shots = 1024
qobj = transpiler.compile([qcr1, qcr2],
backend,
seed=8458,
shots=shots)
job = backend.run(qobj)
result = job.result()
result1 = result.get_counts(qcr1)
result2 = result.get_counts(qcr2)
self.assertEqual(result1, {'00 01': 1024})
self.assertEqual(result2, {'10 00': 1024})
def test_run_simulator(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qr = QuantumRegister(2, 'q')
cr = ClassicalRegister(2, 'c')
qc = QuantumCircuit(qr, cr, name='hadamard')
qc.h(qr)
qc.measure(qr, cr)
qobj = compile([self._qc, qc], backend)
shots = qobj.config.shots
job = backend.run(qobj)
result = job.result()
counts_qx1 = result.get_counts(0)
counts_qx2 = result.get_counts(1)
counts_ex1 = {'00': shots/2, '11': shots/2}
counts_ex2 = {'00': shots/4, '11': shots/4, '10': shots/4, '01': shots/4}
states1 = counts_qx1.keys() | counts_ex1.keys()
states2 = counts_qx2.keys() | counts_ex2.keys()
# contingency table
ctable1 = numpy.array([[counts_qx1.get(key, 0) for key in states1],
[counts_ex1.get(key, 0) for key in states1]])
ctable2 = numpy.array([[counts_qx2.get(key, 0) for key in states2],
[counts_ex2.get(key, 0) for key in states2]])
self.log.info('states1: %s', str(states1))
self.log.info('states2: %s', str(states2))
self.log.info('ctable1: %s', str(ctable1))
self.log.info('ctable2: %s', str(ctable2))
contingency1 = chi2_contingency(ctable1)
contingency2 = chi2_contingency(ctable2)
self.log.info('chi2_contingency1: %s', str(contingency1))
self.log.info('chi2_contingency2: %s', str(contingency2))
self.assertGreater(contingency1[1], 0.01)
self.assertGreater(contingency2[1], 0.01)
def test_job_id(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
job = backend.run(qobj)
self.log.info('job_id: %s', job.job_id())
self.assertTrue(job.job_id() is not None)
def get_backend(device):
"""Returns backend object for device specified by input string."""
try:
backend = Aer.get_backend(device)
except:
print("You are using an IBMQ backend. The results for this are provided in accordance with the IBM Q Experience EULA.\nhttps://quantumexperience.ng.bluemix.net/qx/terms") # Legal stuff! Yay!
backend = IBMQ.get_backend(device)
return backend
def compile(circuits,
backend,
config=None,
basis_gates=None,
coupling_map=None,
initial_layout=None,
shots=1024,
max_credits=10,
seed=None,
qobj_id=None,
hpc=None,
skip_transpiler=False):
"""Compile a list of circuits into a qobj.
Args:
circuits (QuantumCircuit or list[QuantumCircuit]): circuits to compile
backend (BaseBackend or str): a backend to compile for
config (dict): dictionary of parameters (e.g. noise) used by runner
basis_gates (str): comma-separated basis gate set to compile to
coupling_map (list): coupling map (perhaps custom) to target in mapping
initial_layout (list): initial layout of qubits in mapping
shots (int): number of repetitions of each circuit, for sampling
max_credits (int): maximum credits to use
seed (int): random seed for simulators
qobj_id (int): identifier for the generated qobj
hpc (dict): HPC simulator parameters
skip_transpiler (bool): skip most of the compile steps and produce qobj directly
Returns:
Qobj: the qobj to be run on the backends
Raises:
TranspilerError: in case of bad compile options, e.g. the hpc options.
.. deprecated:: 0.6+
After 0.6, compile will only take a backend object.
"""
# pylint: disable=redefined-builtin
if isinstance(backend, str):
warnings.warn(
'compile() no longer takes backend string names.'
'Please pass backend objects, obtained via'
'IBMQ.get_backend() or Aer.get_backend().', DeprecationWarning)
try:
backend = Aer.get_backend(backend)
except KeyError:
backend = IBMQ.get_backend(backend)
pass_manager = None # default pass manager which executes predetermined passes
# TODO (jay) why do we need to pass skip and not pass manager directly
if skip_transpiler: # empty pass manager which does nothing
pass_manager = PassManager()
qobj_standard = transpiler.compile(circuits, backend, config, basis_gates,
coupling_map, initial_layout, shots,
max_credits, seed, qobj_id, hpc,
pass_manager)
return qobj_standard
def solve_ibmqx_ising_qubo_nisq_ibmqx4(G, matrix_func, optimizer, p):
backend = IBMQ.get_backend('ibmqx4')
w = matrix_func(G)
ops = get_qubitops(w)
qaoa = QAOA(ops, optimizer, p, operator_mode='paulis')
quantum_instance = QuantumInstance(backend)
result = qaoa.run(quantum_instance)
x = sample_most_likely(result['eigvecs'][0])
return x
def monitor():
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.x(q[0])
qc.measure(q, c)
backend_sim = IBMQ.get_backend('ibmqx_hpc_qasm_simulator')
result = execute(qc, backend_sim, shots=100).result()
def test_retrieve_job(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
job = backend.run(qobj)
rjob = backend.retrieve_job(job.job_id())
self.assertTrue(job.job_id() == rjob.job_id())
self.assertTrue(job.result().get_counts() == rjob.result().get_counts())
def ask_for_device ():
d = input("Do you want to play on the real device? (y/n)\n").upper()
if (d=="Y"):
device = IBMQ.get_backend('ibmq_5_tenerife') # if real, we use ibmqx4
else:
device = Aer.get_backend('qasm_simulator') # otherwise, we use a simulator
return device
def ask_for_device ():
d = input("Do you want to play on the real device? (y/n)\n").upper()
if (d=="Y"):
device = IBMQ.get_backend('ibmq_5_tenerife') # if real, we use ibmqx4
else:
device = Aer.get_backend('qasm_simulator') # otherwise, we use a simulator
return device
def test_aliases(self, qe_token, qe_url):
"""Test that display names of devices map the same backends as the
regular names."""
IBMQ.enable_account(qe_token, qe_url)
aliased_names = IBMQ.aliased_backend_names()
for display_name, backend_name in aliased_names.items():
with self.subTest(display_name=display_name,
backend_name=backend_name):
try:
backend_by_name = IBMQ.get_backend(backend_name)
except KeyError:
# The real name of the backend might not exist
pass
else:
backend_by_display_name = IBMQ.get_backend(display_name)
self.assertEqual(backend_by_name, backend_by_display_name)
self.assertEqual(backend_by_display_name.name(), backend_name)
def test_ibmq_result_fields(self, qe_token, qe_url):
"""Test components of a result from a remote simulator."""
IBMQ.enable_account(qe_token, qe_url)
remote_backend = IBMQ.get_backend(local=False, simulator=True)
remote_result = execute(self._qc1, remote_backend).result()
self.assertEqual(remote_result.backend_name, remote_backend.name())
self.assertIsInstance(remote_result.job_id, str)
self.assertEqual(remote_result.status, 'COMPLETED')
self.assertEqual(remote_result.results[0].status, 'DONE')
def get_single_job(self):
backend = IBMQ.get_backend(self.backend_name)
number_of_jobs_to_download = 1
downloaded_job = backend.jobs(limit=number_of_jobs_to_download,
skip=self.jobs_to_skip,
status='DONE')
return downloaded_job[0]
def test_double_submit_fails(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
# backend.run() will automatically call job.submit()
job = backend.run(qobj)
with self.assertRaises(JobError):
job.submit()
def __init__(self, problem_description, backend_params=None, depth=3, var_form='RYRZ', APItoken=None, target_backend_name=None):
self.check_and_load_accounts()
if backend_params is None:
self.depth = depth
self.var_form_name = var_form
else:
self.depth=backend_params['depth']
self.var_form_name=backend_params['var_form']
try:
self.num_qubits = problem_description['num_qubits']
except KeyError:
self.num_qubits = problem_description['n_nodes']
self.coupling_map = None
self.noise_model = None
self.basis_gates = None
if self.var_form_name == 'RYRZ':
self.target_backend_name = target_backend_name
if self.target_backend_name is not None:
# load noise models
target_backend = IBMQ.get_backend(self.target_backend_name)
properties = target_backend.properties()
self.coupling_map = target_backend.configuration().coupling_map
# Generate an Aer noise model for target_backend
# self.noise_model = noise.device.basic_device_noise_model(properties) # unreliable
# self.basis_gates = self.noise_model.basis_gates
self.var_form = RYRZ(self.num_qubits, self.depth, entanglement='linear')
self.shift = 0
elif self.var_form_name == 'QAOA':
if backend_params is not None and 'mixer_operator' in backend_params:
mixerOp = backend_params['mixer_operator']
else:
mixerOp = None
if problem_description['name'] == 'modularity':
B = problem_description['B']
if B is None:
raise ValueError("If using var_form == QAOA, have to specify B")
qubitOp = get_modularity_qubitops(B)
self.shift = 0
elif problem_description['name'] == 'maxcut':
A = problem_description['A']
qubitOp, shift = get_maxcut_qubitops(A)
self.shift = shift
elif problem_description['name'] == 'ising':
B_matrix = problem_description['B_matrix']
B_bias = problem_description['B_bias']
qubitOp, shift = get_general_ising_qubitops(B_matrix, B_bias)
self.shift = shift
else:
raise ValueError("Unsupported problem: {}".format(problem_description['name']))
self.var_form = QAOAVarForm(qubitOp, self.depth, mixer_operator=mixerOp)
else:
raise ValueError("Incorrect var_form {}".format(self.var_form_name))
self.num_parameters = self.var_form.num_parameters
logging.info("Initialized IBMQXVarForm {} with num_qubits={}, depth={}".format(self.var_form_name, self.num_qubits, self.depth))
def test_run_async_simulator(self, qe_token, qe_url):
IBMQJob._executor = futures.ThreadPoolExecutor(max_workers=2)
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
self.log.info('submitting to backend %s', backend.name())
num_qubits = 16
qr = QuantumRegister(num_qubits, 'qr')
cr = ClassicalRegister(num_qubits, 'cr')
qc = QuantumCircuit(qr, cr)
for i in range(num_qubits - 1):
qc.cx(qr[i], qr[i + 1])
qc.measure(qr, cr)
qobj = transpiler.compile([qc] * 10, backend)
num_jobs = 5
job_array = [backend.run(qobj) for _ in range(num_jobs)]
found_async_jobs = False
timeout = 30
start_time = time.time()
while not found_async_jobs:
check = sum(
[job.status() is JobStatus.RUNNING for job in job_array])
if check >= 2:
self.log.info('found %d simultaneous jobs', check)
break
if all([job.status() is JobStatus.DONE for job in job_array]):
# done too soon? don't generate error
self.log.warning('all jobs completed before simultaneous jobs '
'could be detected')
break
for job in job_array:
self.log.info('%s %s %s %s', job.status(),
job.status() is JobStatus.RUNNING, check,
job.job_id())
self.log.info('-' * 20 + ' ' + str(time.time() - start_time))
if time.time() - start_time > timeout:
raise TimeoutError('failed to see multiple running jobs after '
'{0} s'.format(timeout))
time.sleep(0.2)
result_array = [job.result() for job in job_array]
self.log.info('got back all job results')
# Ensure all jobs have finished.
self.assertTrue(
all([job.status() is JobStatus.DONE for job in job_array]))
self.assertTrue(
all([
result.get_status() == 'COMPLETED' for result in result_array
]))
# Ensure job ids are unique.
job_ids = [job.job_id() for job in job_array]
self.assertEqual(sorted(job_ids), sorted(list(set(job_ids))))
def generateQK(num_bits, theta1=0, theta2=0, securityThresh=1000, simulation=True, withHist=False):
# Create the circuit
cx_circ = parityCircuit(theta1, theta2)
if simulation:
# Execute the circuit
print("Running on simulation...")
job = execute(cx_circ, backend = Aer.get_backend('qasm_simulator'), shots=256*num_bits, memory=True)
result = job.result()
else:
# Execute the circuit
print("Running on real quantum computer...")
job = execute(cx_circ, backend = IBMQ.get_backend('ibmqx2'), shots=256*num_bits, memory=True)
result = job.result()
# Print circuit.
# print(cx_circ)
# Print the result
if withHist:
counts = result.get_counts(cx_circ)
plot.bar(counts.keys(), counts.values(), 1.0, color='g')
plot.show()
memory = result.get_memory()
num_bits = int(num_bits)
# memory = memory[len(memory)-num_bits: len(memory)]
res = {'A': '', 'B': '', 'errorCounter':0, 'valid': True}
counter = 0
i = len(memory)-1
while len(res["A"]) != num_bits:
# print('Memory', memory[i], i)
# Check if error in parity bit and discard if there is
if memory[i][4] == '0':
counter+=1
else:
res["A"] = res["A"] + memory[i][1]
res["B"] = res["B"] + memory[i][2]
# SecurityThreshold from which we discard the key
if counter >= securityThresh:
res['valid'] = False
res["errorCounter"] = counter
return res
i-=1
res["errorCounter"] = counter
return res
def test_cancel(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backend_name = ('ibmq_20_tokyo'
if self.using_ibmq_credentials else 'ibmqx4')
backend = IBMQ.get_backend(backend_name)
qobj = compile(self._qc, backend)
job = backend.run(qobj)
self.wait_for_initialization(job, timeout=5)
can_cancel = job.cancel()
self.assertTrue(can_cancel)
self.assertTrue(job.status() is JobStatus.CANCELLED)
def setUp(self):
super().setUp()
self._testing_device = os.getenv('IBMQ_QOBJ_DEVICE', None)
self._qe_token = os.getenv('IBMQ_TOKEN', None)
self._qe_url = os.getenv('IBMQ_QOBJ_URL')
if not self._testing_device or not self._qe_token or not self._qe_url:
self.skipTest('No credentials or testing device available for '
'testing Qobj capabilities.')
IBMQ.enable_account(self._qe_token, self._qe_url)
self._backend = IBMQ.get_backend(self._testing_device)
self._qc = _bell_circuit()
def test_retrieve_job(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
job = backend.run(qobj)
rjob = backend.retrieve_job(job.job_id())
self.assertEqual(job.job_id(), rjob.job_id())
self.assertEqual(job.result().get_counts(), rjob.result().get_counts())
if getattr(backend.configuration(), 'allow_q_object'):
self.assertEqual(job.qobj().as_dict(), qobj.as_dict())
else:
self.assertEqual(job.qobj(), None)
