def test_retrieve_jobs_between_datetimes_not_overriden( self, qe_token, qe_url): """Test retrieving jobs created between two specified datetimes and ensure `db_filter` does not override datetime arguments.""" ibmq_factory = IBMQFactory() provider = ibmq_factory.enable_account(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') date_today = datetime.now() past_two_month = date_today - timedelta(30) past_two_month_str = past_two_month.strftime('%Y-%m-%dT%H:%M:%S.%fZ') past_three_month = date_today - timedelta(60) past_three_month_str = past_three_month.strftime( '%Y-%m-%dT%H:%M:%S.%fZ') # Used for `db_filter`, should not override `start_datetime` and `end_datetime` arguments. past_ten_days = date_today - timedelta(10) job_list = provider.backends.jobs( backend_name=backend.name(), limit=5, skip=0, start_datetime=past_three_month, end_datetime=past_two_month, db_filter={'creationDate': { 'gt': past_ten_days }}) self.assertTrue(job_list) for i, job in enumerate(job_list): self.assertTrue( (past_three_month_str <= job.creation_date() <= past_two_month_str), '{}) job creation date {} is not ' 'between past three month {} and past two month {}'.format( i, past_three_month_str, job.creation_date(), past_two_month_str))
def test_api1_url(self, qe_token, qe_url): """Test login into an API 1 auth account.""" with self.assertRaises(IBMQApiUrlError) as context_manager: ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) self.assertIn('authentication URL', str(context_manager.exception))
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) kwargs.update({'provider': provider}) _backend = provider.get_backend(backend_name) if backend_name else \ least_busy(provider.backends(simulator=False)) kwargs.update({'backend': _backend}) return func(obj, *args, **kwargs)
def setUp(self): """Initial test setup.""" super().setUp() self.factory = IBMQFactory() self.provider = self._get_provider() self.credentials = self.provider.credentials
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()
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 test_circuit_random_uniform(self, qe_token, qe_url): """Test random_uniform circuit.""" ibmq_factory = IBMQFactory() provider = ibmq_factory.enable_account(qe_token, qe_url) results = provider.circuits.random_uniform(number_of_qubits=4) self.assertIsInstance(results, Result)
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 _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)
def test_retrieve_jobs_between_datetimes(self, qe_token, qe_url): """Test retrieving jobs created between two specified datetimes.""" ibmq_factory = IBMQFactory() provider = ibmq_factory.enable_account(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') date_today = datetime.now() past_month = date_today - timedelta(30) past_month_str = past_month.strftime('%Y-%m-%dT%H:%M:%S.%fZ') past_two_month = date_today - timedelta(60) past_two_month_str = past_two_month.strftime('%Y-%m-%dT%H:%M:%S.%fZ') job_list = provider.backends.jobs(backend_name=backend.name(), limit=5, skip=0, start_datetime=past_two_month, end_datetime=past_month) self.assertTrue(job_list) for i, job in enumerate(job_list): self.assertTrue( (past_two_month_str <= job.creation_date() <= past_month_str), '{}) job creation date {} is not ' 'between past two month {} and past month {}'.format( i, past_two_month_str, job.creation_date(), past_month_str))
def _wrapper(*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) kwargs.update({'provider': provider}) return func(*args, **kwargs)
def test_non_auth_url(self): """Test login into a non-auth account.""" qe_token = 'invalid' qe_url = API_URL with self.assertRaises(IBMQAccountCredentialsInvalidUrl) as context_manager: ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) self.assertIn('authentication URL', str(context_manager.exception))
def test_non_auth_url_with_hub(self): """Test login into a non-auth account with h/g/p.""" qe_token = 'invalid' qe_url = API_URL + '/Hubs/X/Groups/Y/Projects/Z' with self.assertRaises(IBMQAccountCredentialsInvalidUrl) as context_manager: ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) self.assertIn('authentication URL', str(context_manager.exception))
def _wrapper(*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) if os.getenv('QE_HGP', None): hgp = os.getenv('QE_HGP').split('/') provider = ibmq_factory.get_provider(hub=hgp[0], group=hgp[1], project=hgp[2]) kwargs.update({'provider': provider}) return func(*args, **kwargs)
def test_pass_unreachable_proxy(self, qe_token, qe_url): """Test using an unreachable proxy while enabling an account.""" proxies = { 'urls': { 'http': 'http://*****:*****@127.0.0.1:5678', 'https': 'https://*****:*****@127.0.0.1:5678' } } ibmq = IBMQFactory() with self.assertRaises(RequestsApiError) as context_manager: ibmq.enable_account(qe_token, qe_url, proxies=proxies) self.assertIn('ProxyError', str(context_manager.exception))
def test_api1_get_backend(self, qe_token, qe_url): """Test backward compatibility for API 1 get_backend().""" ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) ibmq_provider = IBMQProvider() ibmq_provider.enable_account(qe_token, qe_url) backend = ibmq_provider.backends()[0] with self.assertWarns(DeprecationWarning): ibmq_backend = ibmq.get_backend(backend.name()) self.assertEqual(backend.name(), ibmq_backend.name())
def test_api1_delete_accounts(self): """Test backward compatibility for API 1 delete_accounts().""" ibmq_provider = IBMQProvider() ibmq_factory = IBMQFactory() with custom_qiskitrc(): ibmq_provider.save_account('QISKITRC_TOKEN', url=API1_URL) with self.assertWarns(DeprecationWarning): ibmq_factory.delete_accounts() with self.assertWarns(DeprecationWarning): stored_accounts = ibmq_factory.stored_accounts() self.assertEqual(len(stored_accounts), 0)
def test_enable_specified_provider(self, qe_token, qe_url): """Test enabling an account with a specified provider.""" ibmq = IBMQFactory() non_default_provider = get_provider(ibmq, qe_token, qe_url, default=False) enabled_provider = ibmq.enable_account( token=qe_token, url=qe_url, hub=non_default_provider.credentials.hub, group=non_default_provider.credentials.group, project=non_default_provider.credentials.project) self.assertEqual(non_default_provider, enabled_provider)
def test_custom_job_name(self, qe_token, qe_url): """Test assigning a custom job name.""" factory = IBMQFactory() provider = factory.enable_account(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') qobj = assemble(transpile(self._qc, backend=backend), backend=backend) # Use a unique job name job_name = str(time.time()).replace('.', '') job_id = backend.run(qobj, job_name=job_name).job_id() job_list = backend.jobs(limit=1, job_name=job_name) self.assertEqual(len(job_list), 1) self.assertEqual(job_id, job_list[0].job_id())
def test_api1_backends(self, qe_token, qe_url): """Test backward compatibility for API 1 backends().""" ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) ibmq_provider = IBMQProvider() ibmq_provider.enable_account(qe_token, qe_url) ibmq_provider_backend_names = [ b.name() for b in ibmq_provider.backends() ] with self.assertWarns(DeprecationWarning): ibmq_backend_names = [b.name() for b in ibmq.backends()] self.assertEqual(set(ibmq_backend_names), set(ibmq_provider_backend_names))
def test_retrieve_jobs_end_datetime(self, qe_token, qe_url): """Test retrieving jobs created before a specified datetime.""" ibmq_factory = IBMQFactory() provider = ibmq_factory.enable_account(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') past_month = datetime.now() - timedelta(days=30) past_month_str = past_month.strftime('%Y-%m-%dT%H:%M:%S.%fZ') job_list = provider.backends.jobs(backend_name=backend.name(), limit=5, skip=0, end_datetime=past_month) self.assertTrue(job_list) for i, job in enumerate(job_list): self.assertTrue(job.creation_date() <= past_month_str, '{}) job creation_date {} is not ' 'less than or equal to past month: {}' .format(i, job.creation_date(), past_month_str))
def test_duplicate_job_name(self, qe_token, qe_url): """Test multiple jobs with the same custom job name.""" factory = IBMQFactory() provider = factory.enable_account(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') qobj = assemble(transpile(self._qc, backend=backend), backend=backend) # Use a unique job name job_name = str(time.time()).replace('.', '') job_ids = set() for _ in range(2): job_ids.add(backend.run(qobj, job_name=job_name).job_id()) retrieved_jobs = backend.jobs(job_name=job_name) self.assertEqual(len(retrieved_jobs), 2) retrieved_job_ids = {job.job_id() for job in retrieved_jobs} self.assertEqual(job_ids, retrieved_job_ids)
def _wrapper(*args, **kwargs): ibmq_factory = IBMQFactory() qe_token = kwargs.pop('qe_token') qe_url = kwargs.pop('qe_url') # Get the open access project public provider. public_provider = ibmq_factory.enable_account(qe_token, qe_url) # Get a premium provider. premium_provider = _get_custom_provider(ibmq_factory) if premium_provider is None: raise SkipTest('Requires both the public provider and a premium provider.') kwargs.update({ 'providers': {'public_provider': public_provider, 'premium_provider': premium_provider} }) return func(*args, **kwargs)
def _wrapper(*args, **kwargs): ibmq_factory = IBMQFactory() qe_token = kwargs.pop("qe_token") qe_url = kwargs.pop("qe_url") # Get the open access project public provider. public_provider = ibmq_factory.enable_account(qe_token, qe_url) # Get a premium provider. premium_provider = _get_custom_provider(ibmq_factory) if premium_provider is None: raise SkipTest( "Requires both the public provider and a premium provider.") kwargs.update({ "providers": { "public_provider": public_provider, "premium_provider": premium_provider, } }) return func(*args, **kwargs)
def test_api1_disable_accounts(self, qe_token, qe_url): """Test backward compatibility for API 1 disable_accounts().""" ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) with warnings.catch_warnings(record=True) as warnings_list: accounts = ibmq.active_accounts()[0] self.assertEqual(accounts['token'], qe_token) self.assertEqual(accounts['url'], qe_url) ibmq.disable_accounts() number_of_accounts = len(ibmq.active_accounts()) self.assertEqual(number_of_accounts, 0) self.assertEqual(len(warnings_list), 3) for warn in warnings_list: self.assertTrue(issubclass(warn.category, DeprecationWarning))
def test_enable_twice(self, qe_token, qe_url): """Test login into an already logged-in account.""" ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) with self.assertRaises(IBMQAccountError) as context_manager: ibmq.enable_account(qe_token, qe_url) self.assertIn('already', str(context_manager.exception))
def _get_custom_provider(ibmq_factory: IBMQFactory) -> Optional[AccountProvider]: """Find the provider for the specific hub/group/project, if any. Args: ibmq_factory: IBMQFactory instance with account already loaded. Returns: Custom provider or ``None`` if default is to be used. """ hgp = os.getenv('QE_STAGING_HGP', None) if os.getenv('USE_STAGING_CREDENTIALS', '') else \ os.getenv('QE_HGP', None) if hgp: hgp = hgp.split('/') return ibmq_factory.get_provider(hub=hgp[0], group=hgp[1], project=hgp[2]) return None # No custom provider.
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, filters=lambda b: b.configuration().n_qubits >= 5)) if not _backend: raise Exception("Unable to find suitable backend.") kwargs.update({'provider': provider}) kwargs.update({'backend': _backend}) return func(obj, *args, **kwargs)
def test_api2_after_api1(self, qe_token, qe_url): """Test login into API 2 during an already logged-in API 1 account.""" ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) with self.assertRaises(IBMQAccountError) as context_manager: qe_token_api2 = 'invalid' qe_url_api2 = AUTH_URL ibmq.enable_account(qe_token_api2, qe_url_api2) self.assertIn('already', str(context_manager.exception))
def test_enable_twice_invalid(self, qe_token, qe_url): """Test login into an invalid account during an already logged-in account.""" ibmq = IBMQFactory() ibmq.enable_account(qe_token, qe_url) with self.assertRaises(IBMQAccountError) as context_manager: qe_token_api1 = 'invalid' qe_url_api1 = API1_URL ibmq.enable_account(qe_token_api1, qe_url_api1) self.assertIn('already', str(context_manager.exception))