def test_available_backends_exist(self):
"""Test if there are available backends.
If all correct some should exists (even if offline).
"""
QP_program = QuantumProgram(specs=QPS_SPECS)
QP_program.set_api(API_TOKEN, URL)
available_backends = QP_program.available_backends()
self.assertTrue(available_backends)
def test_available_backends_exist(self):
"""Test if there are available backends.
If all correct some should exists (even if offline).
"""
QP_program = QuantumProgram(specs=QPS_SPECS)
QP_program.set_api(API_TOKEN, URL)
available_backends = QP_program.available_backends()
self.assertTrue(available_backends)
def main():
# Quantum program setup
qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config["url"])
# enable logging
#qp.enable_logs(logging.DEBUG);
print("Backends=" + str(qp.available_backends()))
# Create qubits/registers
size = 2
q = qp.create_quantum_register('q', size)
c = qp.create_classical_register('c', size)
# Quantum circuit
grover = qp.create_circuit('grover', [q], [c])
# loops = sqrt(2^n) * PI/4
#loops = math.floor(math.sqrt(2**size) * (math.pi/4))
# 1. put all qubits in superposition
for i in range(size):
grover.h(q[i])
# Set the input
input_phase(grover, q)
# 2. Phase inversion
invert_phase(grover, q)
input_phase(grover, q)
# 3. Invert over the mean
invert_over_the_mean(grover, q)
# measure
for i in range(size):
grover.measure(q[i], c[i])
circuits = ['grover']
# Execute the quantum circuits on the simulator
backend = "local_qasm_simulator"
#backend = "ibmq_qasm_simulator"
# the number of shots in the experiment
shots = 1024
result = qp.execute(circuits,
backend=backend,
shots=shots,
max_credits=3,
timeout=240)
counts = result.get_counts("grover")
print("Counts:" + str(counts))
def get_available_backends(self):
if not self._api_set:
self.set_api()
return QuantumProgram.available_backends(self)
try:
import Qconfig
Q_program.set_api(Qconfig.APItoken,
Qconfig.config["url"],
verify=False,
hub=Qconfig.config["hub"],
group=Qconfig.config["group"],
project=Qconfig.config["project"])
except:
offline = True
print("""WARNING: There's no connection with IBMQuantumExperience servers.
cannot test I/O intesive tasks, will only test CPU intensive tasks
running the jobs in the local simulator""")
print("The backends available for use are:")
pprint(Q_program.available_backends())
print("\n")
backend = 'local_qasm_simulator'
try:
# Create a Quantum Register called "qr" with 2 qubits.
qr = Q_program.create_quantum_register("qr", 2)
# Create a Classical Register called "cr" with 2 bits.
cr = Q_program.create_classical_register("cr", 2)
# Create a Quantum Circuit called "qc". involving the Quantum Register "qr"
# and the Classical Register "cr".
qc = Q_program.create_circuit("bell", [qr], [cr])
# Add the H gate in the Qubit 0, putting this qubit in superposition.
qc.h(qr[0])
# Add the CX gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state
class QC():
'''
class QC
'''
# pylint: disable=too-many-instance-attributes
def __init__(self, backend='local_qasm_simulator', remote=False, qubits=3):
# private member
# __qp
self.__qp = None
# calc phase
self.phase = [
['0', 'initialized.']
]
# config
self.backend = backend
self.remote = remote
self.qubits = qubits
# circuits variable
self.shots = 2
# async
self.wait = False
self.last = ['init', 'None']
self.load()
def load(self, api_info=True):
'''
load
'''
self.__qp = QuantumProgram()
if self.remote:
try:
import Qconfig
self.__qp.set_api(Qconfig.APItoken, Qconfig.config["url"],
hub=Qconfig.config["hub"],
group=Qconfig.config["group"],
project=Qconfig.config["project"])
except ImportError as ex:
msg = 'Error in loading Qconfig.py!. Error = {}\n'.format(ex)
sys.stdout.write(msg)
sys.stdout.flush()
return False
if api_info is True:
api = self.__qp.get_api()
sys.stdout.write('<IBM Quantum Experience API information>\n')
sys.stdout.flush()
sys.stdout.write('Version: {0}\n'.format(api.api_version()))
sys.stdout.write('User jobs (last 5):\n')
jobs = api.get_jobs(limit=500)
def format_date(job_item):
'''
format
'''
return datetime.strptime(job_item['creationDate'],
'%Y-%m-%dT%H:%M:%S.%fZ')
sortedjobs = sorted(jobs,
key=format_date)
sys.stdout.write(' {0:<32} {1:<24} {2:<9} {3}\n'
.format('id',
'creationDate',
'status',
'backend'))
sys.stdout.write('{:-^94}\n'.format(""))
for job in sortedjobs[-5:]:
sys.stdout.write(' {0:<32} {1:<24} {2:<9} {3}\n'
.format(job['id'],
job['creationDate'],
job['status'],
job['backend']['name']))
sys.stdout.write('There are {0} jobs on the server\n'
.format(len(jobs)))
sys.stdout.write('Credits: {0}\n'
.format(api.get_my_credits()))
sys.stdout.flush()
self.backends = self.__qp.available_backends()
status = self.__qp.get_backend_status(self.backend)
if 'available' in status:
if status['available'] is False:
return False
return True
def set_config(self, config=None):
'''
set config
'''
if config is None:
config = {}
if 'backend' in config:
self.backend = str(config['backend'])
if 'local_' in self.backend:
self.remote = False
else:
self.remote = True
if 'remote' in config:
self.remote = config['remote']
if 'qubits' in config:
self.qubits = int(config['qubits'])
return True
def _progress(self, phasename, text):
self.phase.append([str(phasename), str(text)])
text = "Phase {0}: {1}".format(phasename, text)
sys.stdout.write("{}\n".format(text))
sys.stdout.flush()
def _init_circuit(self):
self._progress('1', 'Initialize quantum registers and circuit')
qubits = self.qubits
quantum_registers = [
{"name": "cin", "size": 1},
{"name": "qa", "size": qubits},
{"name": "qb", "size": qubits},
{"name": "cout", "size": 1}
]
classical_registers = [
{"name": "ans", "size": qubits + 1}
]
if 'cin' in self.__qp.get_quantum_register_names():
self.__qp.destroy_quantum_registers(quantum_registers)
self.__qp.destroy_classical_registers(classical_registers)
q_r = self.__qp.create_quantum_registers(quantum_registers)
c_r = self.__qp.create_classical_registers(classical_registers)
self.__qp.create_circuit("qcirc", q_r, c_r)
def _create_circuit_qadd(self):
# quantum ripple-carry adder from Cuccaro et al, quant-ph/0410184
def majority(circuit, q_a, q_b, q_c):
'''
majority
'''
circuit.cx(q_c, q_b)
circuit.cx(q_c, q_a)
circuit.ccx(q_a, q_b, q_c)
def unmaj(circuit, q_a, q_b, q_c):
'''
unmajority
'''
circuit.ccx(q_a, q_b, q_c)
circuit.cx(q_c, q_a)
circuit.cx(q_a, q_b)
def adder(circuit, c_in, q_a, q_b, c_out, qubits):
'''
adder
'''
# pylint: disable=too-many-arguments
majority(circuit, c_in[0], q_b[0], q_a[0])
for i in range(qubits - 1):
majority(circuit, q_a[i], q_b[i + 1], q_a[i + 1])
circuit.cx(q_a[qubits - 1], c_out[0])
for i in range(qubits - 1)[::-1]:
unmaj(circuit, q_a[i], q_b[i + 1], q_a[i + 1])
unmaj(circuit, c_in[0], q_b[0], q_a[0])
if 'add' not in self.__qp.get_circuit_names():
[c_in, q_a, q_b, c_out] = map(self.__qp.get_quantum_register,
["cin", "qa", "qb", "cout"])
ans = self.__qp.get_classical_register('ans')
qadder = self.__qp.create_circuit("qadd",
[c_in, q_a, q_b, c_out],
[ans])
adder(qadder, c_in, q_a, q_b, c_out, self.qubits)
return 'add' in self.__qp.get_circuit_names()
def _create_circuit_qsub(self):
circuit_names = self.__qp.get_circuit_names()
if 'qsub' not in circuit_names:
if 'qadd' not in circuit_names:
self._create_circuit_qadd()
# subtractor circuit
self.__qp.add_circuit('qsub', self.__qp.get_circuit('qadd'))
qsubtractor = self.__qp.get_circuit('qsub')
qsubtractor.reverse()
return 'qsub' in self.__qp.get_circuit_names()
def _qadd(self, input_a, input_b=None, subtract=False, observe=False):
# pylint: disable=too-many-locals
def measure(circuit, q_b, c_out, ans):
'''
measure
'''
circuit.barrier()
for i in range(self.qubits):
circuit.measure(q_b[i], ans[i])
circuit.measure(c_out[0], ans[self.qubits])
def char2q(circuit, cbit, qbit):
'''
char2q
'''
if cbit == '1':
circuit.x(qbit)
elif cbit == 'H':
circuit.h(qbit)
self.shots = 5 * (2**self.qubits)
def input_state(circuit, input_a, input_b=None):
'''
input state
'''
input_a = input_a[::-1]
for i in range(self.qubits):
char2q(circuit, input_a[i], q_a[i])
if input_b is not None:
input_b = input_b[::-1]
for i in range(self.qubits):
char2q(circuit, input_b[i], q_b[i])
def reset_input(circuit, c_in, q_a, c_out):
'''
reset input
'''
circuit.reset(c_in)
circuit.reset(c_out)
for i in range(self.qubits):
circuit.reset(q_a[i])
# get registers
[c_in, q_a, q_b, c_out] = map(self.__qp.get_quantum_register,
["cin", "qa", "qb", "cout"])
ans = self.__qp.get_classical_register('ans')
qcirc = self.__qp.get_circuit('qcirc')
self._progress('2',
'Define input state ({})'
.format('QADD' if subtract is False else 'QSUB'))
if input_b is not None:
if subtract is True:
# subtract
input_state(qcirc, input_b, input_a)
else:
# add
input_state(qcirc, input_a, input_b)
else:
reset_input(qcirc, c_in, q_a, c_out)
input_state(qcirc, input_a)
self._progress('3',
'Define quantum circuit ({})'
.format('QADD' if subtract is False else 'QSUB'))
if subtract is True:
self._create_circuit_qsub()
qcirc.extend(self.__qp.get_circuit('qsub'))
else:
self._create_circuit_qadd()
qcirc.extend(self.__qp.get_circuit('qadd'))
if observe is True:
measure(qcirc, q_b, c_out, ans)
def _qsub(self, input_a, input_b=None, observe=False):
self._qadd(input_a, input_b, subtract=True, observe=observe)
def _qope(self, input_a, operator, input_b=None, observe=False):
if operator == '+':
return self._qadd(input_a, input_b, observe=observe)
elif operator == '-':
return self._qsub(input_a, input_b, observe=observe)
return None
def _compile(self, name, cross_backend=None, print_qasm=False):
self._progress('4', 'Compile quantum circuit')
coupling_map = None
if cross_backend is not None:
backend_conf = self.__qp.get_backend_configuration(cross_backend)
coupling_map = backend_conf.get('coupling_map', None)
if coupling_map is None:
sys.stdout.write('backend: {} coupling_map not found'
.format(cross_backend))
qobj = self.__qp.compile([name],
backend=self.backend,
shots=self.shots,
seed=1,
coupling_map=coupling_map)
if print_qasm is True:
sys.stdout.write(self.__qp.get_compiled_qasm(qobj, 'qcirc'))
sys.stdout.flush()
return qobj
def _run(self, qobj):
self._progress('5', 'Run quantum circuit (wait for answer)')
result = self.__qp.run(qobj, wait=5, timeout=100000)
return result
def _run_async(self, qobj):
'''
_run_async
'''
self._progress('5', 'Run quantum circuit')
self.wait = True
def async_result(result):
'''
async call back
'''
self.wait = False
self.last = self.result_parse(result)
self.__qp.run_async(qobj,
wait=5, timeout=100000, callback=async_result)
def _is_regular_number(self, numstring, base):
'''
returns input binary format string or None.
'''
if base == 'bin':
binstring = numstring
elif base == 'dec':
if numstring == 'H':
binstring = 'H'*self.qubits
else:
binstring = format(int(numstring), "0{}b".format(self.qubits))
if len(binstring) != self.qubits:
return None
return binstring
def get_seq(self, text, base='dec'):
'''
convert seq and check it
if text is invalid, return the list of length 0.
'''
operators = u'(\\+|\\-)'
seq = re.split(operators, text)
# length check
if len(seq) % 2 == 0 or len(seq) == 1:
return []
# regex
if base == 'bin':
regex = re.compile(r'[01H]+')
else:
regex = re.compile(r'(^(?!.H)[0-9]+|H)')
for i in range(0, len(seq), 2):
match = regex.match(seq[i])
if match is None:
return []
num = match.group(0)
seq[i] = self._is_regular_number(num, base)
if seq[i] is None:
return []
return seq
def result_parse(self, result):
'''
result_parse
'''
data = result.get_data("qcirc")
sys.stdout.write("job id: {0}\n".format(result.get_job_id()))
sys.stdout.write("raw result: {0}\n".format(data))
sys.stdout.write("{:=^40}\n".format("answer"))
counts = data['counts']
sortedcounts = sorted(counts.items(),
key=lambda x: -x[1])
sortedans = []
for count in sortedcounts:
if count[0][0] == '1':
ans = 'OR'
else:
ans = str(int(count[0][-self.qubits:], 2))
sortedans.append(ans)
sys.stdout.write('Dec: {0:>2} Bin: {1} Count: {2} \n'
.format(ans, str(count[0]), str(count[1])))
sys.stdout.write('{0:d} answer{1}\n'
.format(len(sortedans),
'' if len(sortedans) == 1 else 's'))
sys.stdout.write("{:=^40}\n".format(""))
if 'time' in data:
sys.stdout.write("time: {0:<3} sec\n".format(data['time']))
sys.stdout.write("All process done.\n")
sys.stdout.flush()
uniqanswer = sorted(set(sortedans), key=sortedans.index)
ans = ",".join(uniqanswer)
return [str(result), ans]
def exec_calc(self, text, base='dec', wait_result=False):
'''
exec_calc
'''
seq = self.get_seq(text, base)
print('QC seq:', seq)
if seq == []:
return ["Syntax error", None]
# fail message
fail_msg = None
try:
self._init_circuit()
numbers = seq[0::2] # slice even index
i = 1
observe = False
for oper in seq[1::2]: # slice odd index
if i == len(numbers) - 1:
observe = True
if i == 1:
self._qope(numbers[0], oper, numbers[1], observe=observe)
else:
self._qope(numbers[i], oper, observe=observe)
i = i + 1
qobj = self._compile('qcirc')
if wait_result is True:
[status, ans] = self.result_parse(self._run(qobj))
else:
self._run_async(qobj)
[status, ans] = [
'Wait. Calculating on {0}'.format(self.backend),
'...'
]
except QISKitError as ex:
fail_msg = ('There was an error in the circuit!. Error = {}\n'
.format(ex))
except RegisterSizeError as ex:
fail_msg = ('Error in the number of registers!. Error = {}\n'
.format(ex))
if fail_msg is not None:
sys.stdout.write(fail_msg)
sys.stdout.flush()
return ["FAIL", None]
return [status, ans]
from qiskit.backends import local_backends
from pprint import pprint
# Import your solution function
from challenge_submission import compiler_function
# Import submission evaluation and scoring functions
from challenge_evaluation import evaluate, score
# Possibly useful other helper function
from challenge_evaluation import qasm_to_dag_circuit, load_coupling, get_layout
# Select the simulation backend to calculate the quantum states resulting from the circuits
# On Windows platform the C++ Simulator is not yet available with pip install
qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
pprint(qp.available_backends())
backend = 'local_qasm_simulator'
ex_nr = 1
test_circuit_filenames = {}
for i in range(ex_nr):
test_circuit_filenames['circuits/random8_n5_d5.qasm'] = get_layout(5)
for i in range(ex_nr):
test_circuit_filenames['circuits/random9_n16_d16.qasm'] = get_layout(16)
for i in range(ex_nr):
test_circuit_filenames['circuits/random9_n20_d20.qasm'] = get_layout(20)
test_circuits = {}
# Creating Programs create your first QuantumProgram object instance.
qp = QuantumProgram()
# Creating Registers create your first Quantum Register called 'qr' with 2 qubits
qr = qp.create_quantum_register('qr', 2)
# create your first Classical Register called 'cr' with 2 bits
cr = qp.create_classical_register('cr', 2)
# Creating Circuits create your first Quantum Circuit called 'qc' involving your Quantum Register 'qr'
# and your Classical Register 'cr'
qc = qp.create_circuit('superposition', [qr], [cr])
# add the H gate in the Qubit 0, we put this Qubit in superposition
qc.h(qr[0])
# add measure to see the state
qc.measure(qr, cr)
# Compiled and execute in the local_qasm_simulator
qp.set_api(config['qx_token'], config['qx_url'])
print('backends: {}'.format(qp.available_backends()))
result = qp.execute(['superposition'],
backend='ibmqx_qasm_simulator',
shots=1000)
# Show the results
print(result)
print(result.get_data('superposition'))
from qiskit import QuantumProgram
import Qconfig
from qiskit.backends import local_backends
from pprint import pprint
backend = 'ibmqx2'
shots = 1000
max_credits = 5
qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
pprint(qp.available_backends())
qr = qp.create_quantum_register('qr', 1)
cr = qp.create_classical_register('cr', 1)
qc = qp.create_circuit('Bell', [qr], [cr])
qc.h(qr[0])
for i in range(4):
qc.iden(qr[0])
qc.h(qr[0])
qc.measure(qr[0], cr[0])
circuits = ['Bell']
qobj = qp.compile(circuits, backend)
#result = qp.run(qobj, wait=2, timeout=240)
#print(result.get_counts('Bell'))
result = qp.execute(circuits,
backend=backend,
shots=shots,
max_credits=max_credits,
wait=20,
qc.x(x0)
qc.x(x1)
qc.h(x1)
qc.cx(x0, x1)
qc.h(x1)
qc.x(x0)
qc.x(x1)
qc.h(x0)
qc.h(x1)
qc.h(q)
testtiffoli(tiffoli)
b0 = qr[2]
b1 = qr[1]
b2 = qr[0]
qc.x(b2) #put b2 in state |1>
qc.h(b0) #put b0 in (|0>+|1>)/sqrt(2)
qc.h(b1) #put b1 in (|0>+|1>)/sqrt(2)
qc.h(b2) #put b2 in state (|0>-|1>)/sqrt(2)
for i in range(1): #apply the oracle/grover operator in a loop
grover(tiffoli, qc, b0, b1, b2)
qc.measure(qr, cr)
print(Q.get_qasm("andgate"))
print(Q.available_backends())
#result = Q.execute(["andgate"], backend="ibmqx_qasm_simulator", shots=1024)
result = Q.execute(["andgate"], backend="ibmqx4", shots=1024)
print(result)
print(result.get_data("andgate"))
def main(args):
print('')
print('working on: {}'.format(args.graph))
print('with configuration: {}'.format(args.config))
graph = common.load_graph(args.graph)
print('graph ({},{})'.format(len(graph.nodes), len(graph.edges)))
if args.remap:
print('')
print('remapping:')
graph, mapping = common.remap(graph)
for k, v in mapping.items():
print(' {} -> {}'.format(v, k))
with open(args.config, 'r') as file:
config = json.load(file)
print('')
print('config:')
print(' rounds: {}'.format(len(config['rounds'])))
num_bits = graph.max_node
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', num_bits)
cr = qp.create_classical_register('cr', num_bits)
qc = qp.create_circuit('qaoa', [qr], [cr])
for i in range(num_bits):
qc.h(qr[i])
for r in config['rounds']:
beta = r['beta']
gamma = r['gamma']
for i in range(num_bits):
qc.u3(2 * beta, -pi / 2, pi / 2, qr[i])
for e in graph.edges:
qc.x(qr[e.fr])
qc.u1(-gamma / 2.0, qr[e.fr])
qc.x(qr[e.fr])
qc.u1(-gamma / 2.0, qr[e.fr])
qc.cx(qr[e.fr], qr[e.to])
qc.x(qr[e.to])
qc.u1(gamma / 2.0, qr[e.to])
qc.x(qr[e.to])
qc.u1(-gamma / 2.0, qr[e.to])
qc.cx(qr[e.fr], qr[e.to])
qc.measure(qr, cr)
print('')
print('execute:')
backend_name = args.backend
if not 'local' in backend_name:
with open('_config') as data_file:
config = json.load(data_file)
assert ('qx_token' in config)
assert ('qx_url' in config)
qp.set_api(config['qx_token'], config['qx_url'])
backends = qp.available_backends()
print(' backends found: {}'.format(backends))
assert (backend_name in backends)
print(' backend: {}'.format(backend_name))
print(' shots: {}'.format(args.shots))
result = qp.execute(['qaoa'], backend=backend_name, shots=args.shots)
# Show the results
#print(result)
data = result.get_data('qaoa')
print('')
print('data:')
for k, v in data.items():
if k != 'counts':
print('{}: {}'.format(k, v))
print('')
print('result:')
print(' state dist.:')
for i, state in enumerate(
sorted(data['counts'].keys(),
key=lambda x: data['counts'][x],
reverse=True)):
assignment = common.str2vals(state)
cv = common.cut_value(graph, assignment)
print(' {} - {} - {}'.format(cv, state, data['counts'][state]))
if i >= 50:
print('first 50 of {} states'.format(len(data['counts'])))
break
print('')
print(' cut dist.:')
cut_dist = common.cut_dist(graph, data['counts'])
for i, cv in enumerate(sorted(cut_dist.keys(), reverse=True)):
print(' {} - {}'.format(cv, cut_dist[cv]))
if i >= 20:
print('first 20 of {} cut values'.format(len(cut_dist)))
break
ec = sum([cv * prob for (cv, prob) in cut_dist.items()])
print(' expected cut value: {}'.format(ec))
samples = 100000
print('')
print(' rand cut dist. ({}):'.format(samples))
rand_cut_dist = common.rand_cut_dist(graph, samples)
for i, cv in enumerate(sorted(rand_cut_dist.keys(), reverse=True)):
print(' {} - {}'.format(cv, rand_cut_dist[cv]))
if i >= 20:
print('first 20 of {} cut values'.format(len(rand_cut_dist)))
break
if args.show_qasm:
print('')
print(result.get_ran_qasm('qaoa'))
Qconfig.config["url"],
verify=True,
hub=Qconfig.config["hub"],
group=Qconfig.config["group"],
project=Qconfig.config["project"])
except:
offline = True
print("""WARNING: There's no connection with IBMQuantumExperience servers.
cannot test I/O intesive tasks, will only test CPU intensive tasks
running the jobs in the local simulator""")
#--------------------------------------------------------------------------------------------------------------
# Backends available/selected via env
#--------------------------------------------------------------------------------------------------------------
print("The backends available for use are:")
available_backends = Q_program.available_backends()
print(available_backends)
print("\n")
# The function to compute GCD using Euclid's method
# Input : Two number to X and Y for which a GCD is to be computed
# Output : GCD of two given numbers
#--------------------------------------------------------------------------------------------------------------
def gcd(x, y):
while y != 0:
(x, y) = (y, x % y)
return x
#--------------------------------------------------------------------------------------------------------------
def setup_experiment(args):
if args is None:
return getParams()
else:
programs = QuantumPrograms.PROGRAMS
apiToken = None
backend = None
shots = None
timeout = None
program = None
# get API token
if args.apitoken is None:
try:
apiToken = open("./.qiskit_api_token", "r").read()
except:
apiToken = input("Enter your IBM Quantum Experience API token: \n> ")
else:
apiToken = args.apitoken
engine = QuantumProgram()
engine.set_api(apiToken, 'https://quantumexperience.ng.bluemix.net/api')
# get backend
backends = get_backend_dict(engine.available_backends())
if args.backend is None:
PrintUtils.printHeader("Available backends:")
for key, value in backends.items():
PrintUtils.printInfo(f" {key}: {value}")
backend = get_backend(backends[int(input("Run on which backend?\n> "))], backends)
else:
if args.backend in backends.values():
backend = args.backend
elif int(args.backend) in backends.keys():
backend = backends[int(args.backend)]
else:
raise ValueError(f"Invalid backend: '{args.backend}'")
# set shots default value
if args.shots is None:
shots = 1024
else:
shots = int(args.shots)
# set timeout default value
if args.timeout is None:
timeout = 120
else:
timeout = int(args.timeout)
# validate program
if args.program is None:
print_available_programs(programs)
program = input("Run which program?\n> ")
while program not in programs:
PrintUtils.printErr(f"Invalid program '{program}'")
print_available_programs(programs)
program = input("Run which program?\n> ")
else:
if args.program not in programs.keys():
raise ValueError(f"Invalid program '{args.program}'")
else:
program = args.program
return QuantumPrograms(engine, QConfig(backend, shots, timeout, program))
