Tweaking a function from flow which will be used to create a task dict as a pre step for publish

ArlindKadra · ArlindKadra · commit 22b1e620459f · 2018-09-19T16:47:21.000+01:00
diff --git a/openml/tasks/task.py b/openml/tasks/task.py
@@ -1,5 +1,6 @@
 import io
 import os
+from collections import OrderedDict
 
 from .. import config
 from .. import datasets
@@ -22,7 +23,6 @@ def __init__(self, task_id, task_type_id, task_type, data_set_id,
         self.estimation_procedure["type"] = estimation_procedure_type
         self.estimation_procedure["data_splits_url"] = data_splits_url
         self.estimation_procedure["parameters"] = estimation_parameters
-        #
         self.estimation_parameters = estimation_parameters
         self.evaluation_measure = evaluation_measure
         self.cost_matrix = cost_matrix
@@ -116,6 +116,92 @@ def remove_tag(self, tag):
         openml._api_calls._perform_api_call("/task/untag", data=data)
 
 
+    def _to_dict(self):
+        """ Helper function used by _to_xml and itself.
+
+        Creates a dictionary representation of self which can be serialized
+        to xml by the function _to_xml. Since a flow can contain subflows
+        (components) this helper function calls itself recursively to also
+        serialize these flows to dictionaries.
+
+        Uses OrderedDict to ensure consistent ordering when converting to xml.
+        The return value (OrderedDict) will be used to create the upload xml
+        file. The xml file must have the tags in exactly the order given in the
+        xsd schema of a flow (see class docstring).
+
+        Returns
+        -------
+        OrderedDict
+            Flow represented as OrderedDict.
+
+        """
+        task_container = OrderedDict()
+        task_dict = OrderedDict([('@xmlns:oml', 'http://openml.org/openml')])
+        task_container['oml:task'] = task_dict
+        _add_if_nonempty(task_dict, 'oml:task_id', self.task_id)
+
+        if getattr(self, "task_type_id") is None:
+                raise ValueError("task_type_id is required but None")
+        else:
+            task_dict["task_type_id"] = self.task_type_id
+
+        for attribute in ["source_data", "target_name"]:
+
+            _add_if_nonempty(task_dict, 'oml:{}'.format(attribute),
+                             getattr(self, attribute))
+
+        flow_parameters = []
+        for key in self.parameters:
+            param_dict = OrderedDict()
+            param_dict['oml:name'] = key
+            meta_info = self.parameters_meta_info[key]
+
+            _add_if_nonempty(param_dict, 'oml:data_type',
+                             meta_info['data_type'])
+            param_dict['oml:default_value'] = self.parameters[key]
+            _add_if_nonempty(param_dict, 'oml:description',
+                             meta_info['description'])
+
+            for key_, value in param_dict.items():
+                if key_ is not None and not isinstance(key_, six.string_types):
+                    raise ValueError('Parameter name %s cannot be serialized '
+                                     'because it is of type %s. Only strings '
+                                     'can be serialized.' % (key_, type(key_)))
+                if value is not None and not isinstance(value, six.string_types):
+                    raise ValueError('Parameter value %s cannot be serialized '
+                                     'because it is of type %s. Only strings '
+                                     'can be serialized.' % (value, type(value)))
+
+            flow_parameters.append(param_dict)
+
+        flow_dict['oml:parameter'] = flow_parameters
+
+        components = []
+        for key in self.components:
+            component_dict = OrderedDict()
+            component_dict['oml:identifier'] = key
+            component_dict['oml:flow'] = \
+                self.components[key]._to_dict()['oml:flow']
+
+            for key_ in component_dict:
+                # We only need to check if the key is a string, because the
+                # value is a flow. The flow itself is valid by recursion
+                if key_ is not None and not isinstance(key_, six.string_types):
+                    raise ValueError('Parameter name %s cannot be serialized '
+                                     'because it is of type %s. Only strings '
+                                     'can be serialized.' % (key_, type(key_)))
+
+            components.append(component_dict)
+
+        flow_dict['oml:component'] = components
+        flow_dict['oml:tag'] = self.tags
+        for attribute in ["binary_url", "binary_format", "binary_md5"]:
+            _add_if_nonempty(flow_dict, 'oml:{}'.format(attribute),
+                             getattr(self, attribute))
+
+        return flow_container
+
+
 def _create_task_cache_dir(task_id):
     task_cache_dir = os.path.join(config.get_cache_directory(), "tasks", str(task_id))
 
@@ -125,3 +211,8 @@ def _create_task_cache_dir(task_id):
         # TODO add debug information!
         pass
     return task_cache_dir
+
+
+def _add_if_nonempty(dic, key, value):
+    if value is not None:
+        dic[key] = value
