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)