def test_client_init(self):
"""Before/After client init events are dispatched with correct signatures."""
# setup event handlers
memo = {}
def handler(event, **data):
memo[event] = data
add_handler('before_client_init', handler)
add_handler('after_client_init', handler)
# client init
client = Client(endpoint='endpoint', token='token', unknown='unknown')
# test entry values
before = memo['before_client_init']
self.assertEqual(before['obj'], client)
self.assertIn('endpoint', before['args'])
self.assertIn('token', before['args'])
self.assertIn('kwargs', before['args'])
self.assertEqual(before['args']['token'], 'token')
self.assertEqual(before['args']['kwargs']['unknown'], 'unknown')
# test exit values
after = memo['after_client_init']
self.assertEqual(after['obj'], client)
self.assertEqual(after['args']['token'], 'token')
self.assertEqual(after['args']['kwargs']['unknown'], 'unknown')
self.assertEqual(after['args']['endpoint'], 'endpoint')
self.assertEqual(after['return_value'], None)
def enable_data_capture():
"""Enable logging of submitted problems/answers, embedding parameters,
embedding/sampling warnings, etc. across the Ocean stack.
"""
def capture_qmi_response(event, obj, args, return_value):
logger.debug("{!s}(obj={!r}, args={!r}, return_value={!r})".format(
event, obj, args, return_value))
topology = _get_solver_topology(obj)
if topology['type'] not in SUPPORTED_SOLVER_TOPOLOGY_TYPES:
logger.error(
'Solver topology {!r} not supported.'.format(topology))
return
try:
storage.add_problem(problem=args,
solver=obj,
response=return_value)
except Exception as e:
logger.error('Failed to store problem: %r', e)
# subscribe to problems sampled and results returned in the cloud client
add_handler('after_sample', capture_qmi_response)
# save all warnings during embedding by default (equivalent to setting
# `warnings=WarningAction.SAVE` during sampling)
EmbeddingComposite.warnings_default = WarningAction.SAVE
# return embedding map/parameters (equivalent to setting
# `return_embedding=True` during sampling)
EmbeddingComposite.return_embedding_default = True
logger.debug("Data capture enabled for embeddings, warnings and QMIs")
def test_validation(self):
"""Event name and handler are validated."""
with self.assertRaises(ValueError):
add_handler('invalid_event_name', lambda: None)
with self.assertRaises(TypeError):
add_handler('before_client_init', None)
def test_decorator(self):
"""Decorator adds on-entry and on-exit event calls, with correct args."""
class MockSampler:
@dispatches_events('sample')
def mock_sample(self, h, J, offset=0, fail=False, **kwargs):
if fail:
raise ValueError
return offset + 1
mock_object = MockSampler()
h = [1, 1]
J = {(0, 1): 1}
def before(name, obj, args):
self.assertEqual(obj, mock_object)
args.pop('fail')
self.assertEqual(args, dict(h=h, J=J, offset=0, kwargs={}))
def after(name, obj, args, return_value=None, exception=None):
self.assertEqual(obj, mock_object)
fail = args.pop('fail')
self.assertEqual(args, dict(h=h, J=J, offset=0, kwargs={}))
if fail:
self.assertIsInstance(exception, ValueError)
else:
self.assertEqual(return_value, 1)
add_handler('before_sample', before)
add_handler('before_sample', after)
mock_object.mock_sample(h, J)
with self.assertRaises(ValueError):
mock_object.mock_sample(h, J, fail=True)
def test_get_solvers(self):
"""Before/After get_solvers events are dispatched with correct signatures."""
# setup event handlers
memo = {}
def handler(event, **data):
memo[event] = data
add_handler('before_get_solvers', handler)
add_handler('after_get_solvers', handler)
# get solver(s)
self.client.get_solver()
# test entry values
before = memo['before_get_solvers']
self.assertEqual(before['obj'], self.client)
self.assertIn('refresh', before['args'])
self.assertIn('filters', before['args'])
self.assertIn('name__contains', before['args']['filters'])
# test exit values
after = memo['after_get_solvers']
self.assertEqual(after['obj'], self.client)
self.assertIn('name__contains', after['args']['filters'])
self.assertEqual(after['return_value'], self.solvers)
def test_sample(self):
"""Before/After solver sample events are dispatched with correct signatures."""
# setup event handlers
memo = {}
def handler(event, **data):
memo[event] = data
add_handler('before_sample', handler)
add_handler('after_sample', handler)
# sample
lin = {0: 1}
quad = {(0, 1): 1}
offset = 2
params = dict(num_reads=100)
future = self.solver.sample_ising(lin, quad, offset, **params)
# test entry values
before = memo['before_sample']
args = dict(type_='ising',
linear=lin,
quadratic=quad,
offset=offset,
params=params,
undirected_biases=False)
self.assertEqual(before['obj'], self.solver)
self.assertDictEqual(before['args'], args)
# test exit values
after = memo['after_sample']
self.assertEqual(after['obj'], self.solver)
self.assertDictEqual(after['args'], args)
self.assertEqual(after['return_value'], future)
def subtest_sample(self, solver):
# setup event handlers
memo = {}
def handler(event, **data):
memo[event] = data
add_handler('before_sample', handler)
add_handler('after_sample', handler)
# sample
lin = {0: 1}
quad = {(0, 1): 1}
offset = 2
params = dict(num_reads=100)
future = solver.sample_ising(lin, quad, offset, **params)
# test entry values
before = memo['before_sample']
if solver.qpu:
args = dict(type_='ising',
linear=lin,
quadratic=quad,
offset=offset,
params=params,
undirected_biases=False,
label=None)
elif solver.hybrid:
if not dimod:
self.skipTest("dimod not installed")
bqm = dimod.BQM.from_ising(lin, quad, offset)
args = dict(problem=bqm,
problem_type=None,
label=None,
params=params)
self.assertEqual(before['obj'], solver)
self.assertDictEqual(before['args'], args)
# test exit values
after = memo['after_sample']
self.assertEqual(after['obj'], solver)
self.assertDictEqual(after['args'], args)
self.assertEqual(after['return_value'], future)
