def test_serialize_round_trip(self):
"""
Test the serialization of a dictionary with Nodes in various data structure
Also make sure that the serialized data is json-serializable
"""
node_a = Node().store()
node_b = Node().store()
data = {
'test': 1,
'list': [1, 2, 3, node_a],
'dict': {
('Si', ): node_b,
'foo': 'bar'
},
'baz': 'aar'
}
serialized_data = serialize_data(data)
json_dumped = json.dumps(serialized_data)
deserialized_data = deserialize_data(serialized_data)
# For now manual element-for-element comparison until we come up with general
# purpose function that can equate two node instances properly
self.assertEqual(data['test'], deserialized_data['test'])
self.assertEqual(data['baz'], deserialized_data['baz'])
self.assertEqual(data['list'][:3], deserialized_data['list'][:3])
self.assertEqual(data['list'][3].uuid,
deserialized_data['list'][3].uuid)
self.assertEqual(data['dict'][('Si', )].uuid,
deserialized_data['dict'][('Si', )].uuid)
def save_instance_state(self, out_state, save_context):
super(WorkChain, self).save_instance_state(out_state, save_context)
# Save the context
out_state[self._CONTEXT] = serialize_data(self.ctx)
# Ask the stepper to save itself
if self._stepper is not None:
out_state[self._STEPPER_STATE] = self._stepper.save()
def encode_input_args(self, inputs):
"""
Encode input arguments such that they may be saved in a Bundle
:param inputs: A mapping of the inputs as passed to the process
:return: The encoded inputs
"""
return serialize_data(inputs)
def store_and_serialize_inputs(inputs):
"""
Iterate over the values of the input dictionary, try to store them as if they were unstored
nodes and then return the serialized dictionary
:param inputs: dictionary where keys are potentially unstored node instances
:returns: a dictionary where nodes are serialized
"""
_store_inputs(inputs)
return serialize_data(inputs)
def encode_response(response):
"""
Used by kiwipy to encode a message for sending. Because we can have nodes, we have
to convert these to PIDs before sending (we can't just send the live instance)
:param response: The message to encode
:return: The encoded message
:rtype: str
"""
serialized = serialize_data(response)
return yaml.dump(serialized)
def test_serialize_group(self):
"""
Test that serialization and deserialization of Groups works.
Also make sure that the serialized data is json-serializable
"""
group_name = 'groupie'
group_a = Group(name=group_name).store()
data = {'group': group_a}
serialized_data = serialize_data(data)
json_dumped = json.dumps(serialized_data)
deserialized_data = deserialize_data(serialized_data)
self.assertEqual(data['group'].uuid, deserialized_data['group'].uuid)
self.assertEqual(data['group'].name, deserialized_data['group'].name)
def save_instance_state(self, out_state):
for k, v in self._content.iteritems():
if isinstance(v, Node) and not v.is_stored:
v.store()
out_state[k] = serialize_data(v)