class TestIBMQFactoryProvider(IBMQTestCase):
"""Tests for IBMQFactory provider related methods."""
@requires_qe_access
def _get_provider(self, qe_token=None, qe_url=None):
"""Return default provider."""
return self.factory.enable_account(qe_token, qe_url)
def setUp(self):
"""Initial test setup."""
super().setUp()
self.factory = IBMQFactory()
self.provider = self._get_provider()
self.credentials = self.provider.credentials
def test_get_provider(self):
"""Test get single provider."""
provider = self.factory.get_provider(hub=self.credentials.hub,
group=self.credentials.group,
project=self.credentials.project)
self.assertEqual(self.provider, provider)
def test_providers_with_filter(self):
"""Test providers() with a filter."""
provider = self.factory.providers(hub=self.credentials.hub,
group=self.credentials.group,
project=self.credentials.project)[0]
self.assertEqual(self.provider, provider)
def test_providers_no_filter(self):
"""Test providers() without a filter."""
providers = self.factory.providers()
self.assertIn(self.provider, providers)
def get_provider(ibmq_factory: IBMQFactory,
qe_token: str,
qe_url: str,
default: bool = True) -> AccountProvider:
"""Return a provider for the account.
Args:
ibmq_factory: An `IBMQFactory` instance.
qe_token: IBM Quantum Experience token.
qe_url: IBM Quantum Experience auth URL.
default: If `True`, the default open access project provider is returned.
Otherwise, a non open access project provider is returned.
Returns:
A provider, as specified by `default`.
"""
provider_to_return = ibmq_factory.enable_account(
qe_token, url=qe_url) # Default provider.
if not default:
# Get a non default provider (i.e.not the default open access project).
providers = ibmq_factory.providers()
for provider in providers:
if provider != provider_to_return:
provider_to_return = provider
break
ibmq_factory.disable_account()
return provider_to_return
def test_pulse_job(self, qe_token, qe_url):
"""Test running a pulse job."""
factory = IBMQFactory()
factory.enable_account(qe_token, qe_url)
backend = None
for provider in factory.providers():
backends = provider.backends(open_pulse=True)
if backends:
backend = least_busy(backends)
break
self.assertIsNotNone(backend)
config = backend.configuration()
defaults = backend.defaults()
cmd_def = defaults.build_cmd_def()
# Run 2 experiments - 1 with x pulse and 1 without
x = cmd_def.get('x', 0)
measure = cmd_def.get('measure', range(config.n_qubits)) << x.duration
ground_sched = measure
excited_sched = x | measure
schedules = [ground_sched, excited_sched]
qobj = assemble(schedules, backend, meas_level=1, shots=256)
job = backend.run(qobj)
_ = job.result()
def _wrapper(obj, *args, **kwargs):
if get_test_options()['skip_online']:
raise SkipTest('Skipping online tests')
if os.getenv('USE_STAGING_CREDENTIALS', ''):
credentials = Credentials(os.getenv('QE_STAGING_TOKEN'), os.getenv('QE_STAGING_URL'))
backend_name = os.getenv('QE_STAGING_DEVICE', None)
else:
if not get_test_options()['run_slow']:
raise SkipTest('Skipping slow tests')
credentials = _get_credentials()
backend_name = os.getenv('QE_DEVICE', None)
obj.using_ibmq_credentials = credentials.is_ibmq()
ibmq_factory = IBMQFactory()
provider = ibmq_factory.enable_account(credentials.token, credentials.url)
_backend = None
if backend_name:
for provider in ibmq_factory.providers():
backends = provider.backends(name=backend_name)
if backends:
_backend = backends[0]
break
else:
_backend = least_busy(provider.backends(simulator=False))
if not _backend:
raise Exception("Unable to find suitable backend.")
kwargs.update({'provider': provider})
kwargs.update({'backend': _backend})
return func(obj, *args, **kwargs)
def _wrapper(obj, *args, **kwargs):
ibmq_factory = IBMQFactory()
qe_token = kwargs.pop('qe_token')
qe_url = kwargs.pop('qe_url')
provider = ibmq_factory.enable_account(qe_token, qe_url)
backend_name = os.getenv('QE_STAGING_DEVICE', None) if \
os.getenv('USE_STAGING_CREDENTIALS', '') else os.getenv('QE_DEVICE', None)
_backend = None
provider = _get_custom_provider(ibmq_factory) or provider
if backend_name:
# Put desired provider as the first in the list.
providers = [provider] + ibmq_factory.providers()
for provider in providers:
backends = provider.backends(name=backend_name)
if backends:
_backend = backends[0]
break
else:
_backend = least_busy(provider.backends(
simulator=False, filters=lambda b: b.configuration().n_qubits >= 5))
if not _backend:
raise Exception("Unable to find suitable backend.")
kwargs.update({'backend': _backend})
return func(obj, *args, **kwargs)
