def disable_ibmq_account(url, token, proxies):
"""Disable IBMQ account."""
if not has_ibmq():
return
try:
url = url or ''
token = token or ''
proxies = proxies or {}
if url != '' and token != '':
# pylint: disable=no-name-in-module, import-error
from qiskit import IBMQ
if IBMQ._v1_provider._accounts:
from qiskit.providers.ibmq.credentials import Credentials
credentials = Credentials(token, url, proxies=proxies)
unique_id = credentials.unique_id()
if unique_id in IBMQ._v1_provider._accounts:
del IBMQ._v1_provider._accounts[unique_id]
logger.info("Disabled IBMQ v1 account. Url:'{}' "
"Token:'{}' Proxies:'{}'".format(url, token, proxies))
else:
logger.info("IBMQ v1 account is not active. Not disabled. "
"Url:'{}' Token:'{}' Proxies:'{}'".format(url, token, proxies))
elif IBMQ._credentials:
enabled_credentials = IBMQ._credentials
if enabled_credentials.url == url and enabled_credentials.token == token and enabled_credentials.proxies == proxies:
IBMQ.disable_account()
else:
logger.info("IBMQ v2 account is not active. Not disabled. "
"Url:'{}' Token:'{}' Proxies:'{}'".format(url, token, proxies))
except Exception as e:
logger.warning("Failed to disable IBMQ account. Url:'{}' "
"Token:'{}' Proxies:'{}' :{}".format(url, token, proxies, str(e)))
def token():
t = os.getenv("IBMQX_TOKEN", None)
if t is None:
pytest.skip("Skipping test, no IBMQ token available")
yield t
IBMQ.disable_account()
def backend(account, backend_id):
token = utils.accounts()[account]["token"]
try:
IBMQ.disable_account()
except:
pass
provider = IBMQ.enable_account(token)
return provider.get_backend(backend_id)
def token():
"""Get the IBMQX test token."""
t = os.getenv("IBMQX_TOKEN_TEST", None)
if t is None:
pytest.skip("Skipping test, no IBMQ token available")
yield t
IBMQ.disable_account()
def _refresh_ibmq_account():
"""
Refresh IBMQ account by enabling or disabling it depending on preferences stored values
"""
preferences = Preferences().ibmq_credentials_preferences
token = preferences.token or ''
proxies = preferences.proxies or {}
hub = preferences.hub
group = preferences.group
project = preferences.project
provider = None
try:
# pylint: disable=no-name-in-module, import-error
from qiskit import IBMQ
providers = IBMQ.providers()
if token != '':
# check if there was a previous account that needs to be disabled first
disable_account = False
enable_account = True
for provider in providers:
if provider.credentials.token == token and provider.credentials.proxies == proxies:
enable_account = False
else:
disable_account = True
if disable_account:
IBMQ.disable_account()
logger.info('Disabled IBMQ account.')
if enable_account:
IBMQ.enable_account(token, proxies=proxies)
logger.info('Enabled IBMQ account.')
providers = IBMQ.providers(hub=hub, group=group, project=project)
provider = providers[0] if providers else None
if provider is None:
logger.info(
"No Provider found for IBMQ account. "
"Hub/Group/Project: '%s/%s/%s' Proxies:'%s'", hub, group,
project, proxies)
else:
if providers:
IBMQ.disable_account()
logger.info('Disabled IBMQ account.')
except Exception as ex: # pylint: disable=broad-except
logger.warning(
"IBMQ account Account Failure. "
"Hub/Group/Project: '%s/%s/%s' "
"Proxies:'%s' :%s", hub, group, project, proxies, str(ex))
return provider
def connect(kwargs):
"""Function that allows connection to IBMQ.
Args:
kwargs(dict): dictionary that contains the token and the url"""
token = kwargs.get("ibmqx_token", None) or os.getenv("IBMQX_TOKEN")
url = kwargs.get("ibmqx_url", None) or os.getenv("IBMQX_URL")
# TODO: remove "no cover" when #173 is resolved
if token is not None: # pragma: no cover
# token was provided by the user, so attempt to enable an
# IBM Q account manually
def login():
ibmq_kwargs = {"url": url} if url is not None else {}
IBMQ.enable_account(token, **ibmq_kwargs)
active_account = IBMQ.active_account()
if active_account is None:
login()
else:
# There is already an active account:
# If the token is the same, do nothing.
# If the token is different, authenticate with the new account.
if active_account["token"] != token:
IBMQ.disable_account()
login()
else:
# check if an IBM Q account is already active.
#
# * IBMQ v2 credentials stored in active_account().
# If no accounts are active, it returns None.
if IBMQ.active_account() is None:
# no active account
try:
# attempt to load a v2 account stored on disk
IBMQ.load_account()
except IBMQAccountError:
# attempt to enable an account manually using
# a provided token
raise IBMQAccountError(
"No active IBM Q account, and no IBM Q token provided."
) from None
def enable_ibmq_account(url, token, proxies):
"""
Enable IBMQ account, if not alreay enabled.
"""
provider = None
if not has_ibmq():
return provider
try:
url = url or ''
token = token or ''
proxies = proxies or {}
if url != '' and token != '':
# pylint: disable=no-name-in-module, import-error
from qiskit import IBMQ
from qiskit.providers.ibmq.credentials import Credentials
credentials = Credentials(token, url, proxies=proxies)
unique_id = credentials.unique_id()
if IBMQ._v1_provider._accounts:
if unique_id in IBMQ._v1_provider._accounts:
# disable first any existent previous account with same unique_id and different properties
enabled_credentials = IBMQ._v1_provider._accounts[unique_id].credentials
if enabled_credentials.url != url or enabled_credentials.token != token or enabled_credentials.proxies != proxies:
del IBMQ._v1_provider._accounts[unique_id]
else:
return IBMQ._v1_provider
elif IBMQ._credentials:
enabled_credentials = IBMQ._credentials
# disable first any existent previous account with same unique_id and different properties
if enabled_credentials.url != url or enabled_credentials.token != token or enabled_credentials.proxies != proxies:
IBMQ.disable_account()
else:
providers = IBMQ.providers(hub=unique_id.hub, group=unique_id.group, project=unique_id.project)
return providers[0] if providers else None
provider = IBMQ.enable_account(token, url=url, proxies=proxies)
logger.info("Enabled IBMQ account. Url:'{}' Token:'{}' "
"Proxies:'{}'".format(url, token, proxies))
except Exception as e:
logger.warning("Failed to enable IBMQ account. Url:'{}' Token:'{}' "
"Proxies:'{}' :{}".format(url, token, proxies, str(e)))
return provider
def get_qc_actual_results(circuit, sim_count=1024):
token = open(r"<path to token file>\ibm_token.txt",
mode='r').read() # or just copy the token here
# In case you do not want to save credential on disk, just enable & disable them as required
provider = IBMQ.enable_account(token)
provider = IBMQ.get_provider()
# for keeping the credentioal on disk, just save once& then use laod
# IBMQ.save_account(token)
# provider = IBMQ.load_account()
# Load IBM Q account and get the least busy backend device
device = least_busy(provider.backends(simulator=False))
print("Running on current least busy device: ", device)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
job = execute(circuit, backend=device, shots=sim_count, max_credits=10)
job_monitor(job, interval=2)
# Get the results from the computation, job.result() will wait untill your program is finished
results = job.result()
IBMQ.disable_account()
return results
