def test_from_repr(self):
msg = Message('test', 'str_content')
r = simple_repr(msg)
msg2 = from_repr(r)
self.assertEqual(msg, msg2)
def test_from_repr(self):
domain = VariableDomain('d', 'd', [1, 2, 3, 4])
v = ExternalVariable('v', domain, value=1)
r = simple_repr(v)
v1 = from_repr(r)
self.assertEqual(v, v1)
def test_from_repr(self):
msg = Message("test", "str_content")
r = simple_repr(msg)
msg2 = from_repr(r)
self.assertEqual(msg, msg2)
def do_POST(self):
sender, dest = None, None
type = MSG_ALGO
if 'sender-agent' in self.headers:
sender = self.headers['sender-agent']
if 'dest-agent' in self.headers:
dest = self.headers['dest-agent']
src_comp, dest_comp = None, None
if 'sender-comp' in self.headers:
src_comp = self.headers['sender-comp']
if 'dest-comp' in self.headers:
dest_comp = self.headers['dest-comp']
if 'type' in self.headers:
type = self.headers['type']
content_length = int(self.headers['Content-Length'])
post_data = self.rfile.read(content_length)
content = json.loads(str(post_data, "utf-8"))
comp_msg = ComputationMessage(src_comp, dest_comp, from_repr(content),
int(type))
try:
self.server.comm.on_post_message(self.path, sender, dest, comp_msg)
# Always answer 200, as the actual message is not processed yet by
# the target computation.
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
except UnknownComputation as e:
# if the requested computation is not hosted here
self.send_response(404, str(e))
self.send_header("Content-type", "text/plain")
self.end_headers()
def test_message_factory_serialization():
MyMessage = message_type('my_msg', ['foo', 'bar'])
msg = MyMessage(42, 21)
r = simple_repr(msg)
print(r)
obtained = from_repr(r)
assert msg == obtained
def test_from_repr_dist_attr(self):
a = A('foo', {'a': 1, 'b': 2})
r = a._simple_repr()
b = from_repr(r)
self.assertEqual(b._attr1, a._attr1)
self.assertEqual(b._attr2, a._attr2)
def test_from_repr_list_attr(self):
a = A('foo', [1, 2, 3])
r = a._simple_repr()
b = from_repr(r)
self.assertEqual(b._attr1, a._attr1)
self.assertEqual(b._attr2, a._attr2)
def test_message_factory_serialization():
MyMessage = message_type("my_msg", ["foo", "bar"])
msg = MyMessage(42, 21)
r = simple_repr(msg)
print(r)
obtained = from_repr(r)
assert msg == obtained
def test_from_repr_simple_attr_only(self):
a = A('foo', 'bar')
r = a._simple_repr()
b = from_repr(r)
self.assertTrue(isinstance(b, A))
self.assertEqual(b._attr1, 'foo')
self.assertEqual(b._attr2, 'bar')
def _from_repr(cls, r):
params = r['params']
del r['params']
args = {
k: from_repr(v)
for k, v in r.items() if k not in ['__qualname__', '__module__']
}
algo = cls(**args, params=params)
return algo
def test_from_repr(self):
a = AlgoDef('maxsum', 'min', stability_coef=0.01)
r = simple_repr(a)
a2 = from_repr(r)
self.assertEqual(a, a2)
self.assertEqual(a2.param_value('stability_coef'), 0.01)
def test_from_repr():
a = AlgorithmDef("maxsum", {"stability": 0.01}, "min")
r = simple_repr(a)
a2 = from_repr(r)
assert a == a2
assert a2.param_value("stability") == 0.01
def _from_repr(cls, r):
fixed_vars = r['fixed_vars']
del r['fixed_vars']
args = {
k: from_repr(v)
for k, v in r.items() if k not in ['__qualname__', '__module__']
}
exp_fct = cls(**args, **fixed_vars)
return exp_fct
def test_from_repr_with_expression_function(self):
domain = VariableDomain('d', 'd', [1, 2, 3, 4])
cost_func = ExpressionFunction('v / 2')
v = VariableWithCostFunc('v', domain, cost_func=cost_func)
r = simple_repr(v)
v2 = from_repr(r)
self.assertEqual(v2.cost_for_val(2), v.cost_for_val(2))
self.assertEqual(v2, v)
def test_pathtable_unserialize():
p1 = ("a2", "a3")
p2 = ("a2", "a4")
table = [(2, p1), (3, p2)]
r = simple_repr(table)
assert r
obtained = from_repr(r)
assert obtained == table
def test_from_simple_repr(self):
f = ExpressionFunction('a + b ')
self.assertEqual(f.expression, 'a + b ')
r = simple_repr(f)
f2 = from_repr(r)
self.assertEqual(f(a=2, b=3), f2(a=2, b=3))
self.assertEqual(f2(a=2, b=3), 5)
self.assertEqual(f, f2)
def test_from_repr_on_partial(self):
f = ExpressionFunction('a + b')
fp = f.partial(a=2)
r = simple_repr(fp)
f1 = from_repr(r)
print(r)
self.assertEqual(f1(b=3), 5)
self.assertEqual(f1(b=5), f(a=2, b=5))
def test_from_repr_object_attr(self):
a2 = A('foo2', 'bar2')
a = A('foo', a2)
r = a._simple_repr()
b = from_repr(r)
self.assertIsInstance(b, A)
self.assertEqual(b._attr1, 'foo')
self.assertEqual(b._attr2._attr1, 'foo2')
self.assertEqual(b._attr2._attr2, 'bar2')
def test_var_node_simple_repr():
d = Domain('d', 'test', [1, 2, 3])
v1 = Variable('v1', d)
c1 = constraint_from_str('c1', 'v1 * 0.5', [v1])
cv1 = VariableComputationNode(v1, [c1])
r = simple_repr(cv1)
cv1_obtained = from_repr(r)
assert cv1 == cv1_obtained
def test_namedtuple(self):
# Named = namedtuple('Named', ['foo', 'bar'])
n = Named(1, 2)
r = simple_repr(n)
self.assertEqual(r['foo'], 1)
self.assertEqual(r['bar'], 2)
obtained = from_repr(r)
self.assertEqual(obtained, n)
def test_namedtuple_complex(self):
# Named = namedtuple('Named', ['foo', 'bar'])
n = Named({'a': 1, 'b': 2}, [1, 2, 3, 5])
r = simple_repr(n)
self.assertEqual(r['foo'], {'a': 1, 'b': 2})
self.assertEqual(r['bar'], [1, 2, 3, 5])
obtained = from_repr(r)
self.assertEqual(obtained, n)
def test_node_simplerepr():
n1 = ComputationNode('n1', neighbors=['n2', 'n3', 'n4'])
r1 = simple_repr(n1)
obtained = from_repr(r1)
assert n1 == obtained
assert 'n2' in n1.neighbors
assert 'n3' in n1.neighbors
assert 'n4' in n1.neighbors
assert len(n1.links) == 3
def test_from_repr_list_of_objects(self):
a2 = A('foo2', 'bar2')
a3 = A('foo3', 'bar3')
a = A('foo', [a2, a3])
r = a._simple_repr()
b = from_repr(r)
self.assertIsInstance(b, A)
self.assertEqual(b._attr1, 'foo')
self.assertTrue(isinstance(b._attr2, list))
self.assertEqual(b._attr2[0]._attr1, 'foo2')
self.assertEqual(b._attr2[1]._attr2, 'bar3')
def test_variablenode_simple_repr():
d1 = Domain('d1', '', [1, 2, 3, 5])
v1 = Variable('v1', d1)
f1 = constraint_from_str('f1', 'v1 * 0.5', [v1])
cv1 = VariableComputationNode(v1, ['f1'])
cf1 = FactorComputationNode(f1, )
r = simple_repr(cv1)
obtained = from_repr(r)
assert obtained == cv1
assert cv1.variable == obtained.variable
def test_from_repr_with_expression_function(self):
domain = VariableDomain('d', 'd', [1, 2, 3, 4])
cost_func = ExpressionFunction('v / 2')
v = VariableNoisyCostFunc('v', domain, cost_func=cost_func)
r = simple_repr(v)
v2 = from_repr(r)
# Due to the noise, the cost will de different
c1 = v2.cost_for_val(2)
c2 = v.cost_for_val(2)
self.assertLessEqual(abs(c1 - c2), v.noise_level * 2)
self.assertEquals(v2, v)
def test_serialize_repr(self):
# Make sure that even after serialization / deserialization,
# from_repr and simple_repr still produce equal messages.
# This has been causing problems with maxsum costs dict where key
# were integers
msg = MaxSumMessage({1: 10, 2: 20})
r = simple_repr(msg)
msg_json = json.dumps(r)
r2 = json.loads(msg_json)
msg2 = from_repr(r2)
self.assertEqual(msg, msg2)
def test_link_simple_repr():
d = Domain('d', 'test', [1, 2, 3])
v1 = Variable('v1', d)
v2 = Variable('v2', d)
v3 = Variable('v3', d)
c1 = constraint_from_str('c1', 'v1 * 0.5 + v2 - v3', [v1, v2, v3])
cv1 = VariableComputationNode(v1, [c1])
cv2 = VariableComputationNode(v2, [c1])
cv3 = VariableComputationNode(v3, [c1])
link = ConstraintLink(c1.name, ['c1', 'c2', 'c3'])
r = simple_repr(link)
link_obtained = from_repr(r)
assert link == link_obtained
def test_unserialization_msg():
p1 = ("1", "2", "2")
table = [(3, p1)]
msg = UCSReplicateMessage("msg_type", 0, 0, p1, table, ["1", "2"], None, 5,
2, [])
r = simple_repr(msg)
assert r
# simply taking a simple_repr does not ensure that the json serialization is valid
json_msg = json.dumps(r)
loaded = json.loads(json_msg)
obtained = from_repr(loaded)
assert obtained
assert obtained == msg
def do_POST(self):
sender, dest = None, None
type = MSG_ALGO
if "sender-agent" in self.headers:
sender = self.headers["sender-agent"]
if "dest-agent" in self.headers:
dest = self.headers["dest-agent"]
src_comp, dest_comp = None, None
if "sender-comp" in self.headers:
src_comp = self.headers["sender-comp"]
if "dest-comp" in self.headers:
dest_comp = self.headers["dest-comp"]
if "type" in self.headers:
type = self.headers["type"]
content_length = int(self.headers["Content-Length"])
post_data = self.rfile.read(content_length)
try:
content = json.loads(str(post_data, "utf-8"))
except JSONDecodeError as jde:
print(jde)
print(post_data)
raise jde
comp_msg = ComputationMessage(src_comp, dest_comp, from_repr(content),
int(type))
try:
self.server.comm.on_post_message(self.path, sender, dest, comp_msg)
# Always answer 200, as the actual message is not processed yet by
# the target computation.
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
except UnknownComputation as e:
# if the requested computation is not hosted here
self.send_response(404, str(e))
self.send_header("Content-type", "text/plain")
self.end_headers()
def test_path_unserialize():
given = ("a2", "a3", "__hosting__")
r = simple_repr(given)
obtained = from_repr(r)
assert given == obtained
