FIX issue #77

Author: mfeurer

openml/flows/__init__.py

@@ -1,6 +1,6 @@
 from .flow import OpenMLFlow
 from .sklearn_converter import sklearn_to_flow, flow_to_sklearn
-from .functions import get_flow
+from .functions import get_flow, list_flows
 
-__all__ = ['OpenMLFlow', 'create_flow_from_model', 'get_flow',
+__all__ = ['OpenMLFlow', 'create_flow_from_model', 'get_flow', 'list_flows',
            'sklearn_to_flow', 'flow_to_sklearn']

openml/flows/functions.py

@@ -12,6 +12,7 @@ def get_flow(flow_id):
     flow_id : int
         The OpenML flow id.
     """
+    # TODO add caching here!
     try:
         flow_id = int(flow_id)
     except:
@@ -25,4 +26,69 @@ def get_flow(flow_id):
     if 'sklearn' in flow.external_version:
         flow.model = flow_to_sklearn(flow)
 
-    return flow
+    return flow
+
+
+def list_flows(offset=None, size=None, tag=None):
+    """Return a list of all flows which are on OpenML.
+
+    Parameters
+    ----------
+    offset : int, optional
+        the number of flows to skip, starting from the first
+    size : int, optional
+        the maximum number of flows to return
+    tag : str, optional
+        the tag to include
+
+    Returns
+    -------
+    flows : dict
+        A mapping from flow_id to a dict giving a brief overview of the
+        respective flow.
+
+        Every flow is represented by a dictionary containing
+        the following information:
+        - flow id
+        - full name
+        - name
+        - version
+        - external version
+        - uploader
+    """
+    api_call = "flow/list"
+    if offset is not None:
+        api_call += "/offset/%d" % int(offset)
+
+    if size is not None:
+        api_call += "/limit/%d" % int(size)
+
+    if tag is not None:
+        api_call += "/tag/%s" % tag
+
+    return _list_datasets(api_call)
+
+
+def _list_datasets(api_call):
+    # TODO add proper error handling here!
+    return_code, xml_string = _perform_api_call(api_call)
+    flows_dict = xmltodict.parse(xml_string)
+
+    # Minimalistic check if the XML is useful
+    assert type(flows_dict['oml:flows']['oml:flow']) == list, \
+        type(flows_dict['oml:flows'])
+    assert flows_dict['oml:flows']['@xmlns:oml'] == \
+           'http://openml.org/openml', flows_dict['oml:flows']['@xmlns:oml']
+
+    flows = dict()
+    for flow_ in flows_dict['oml:flows']['oml:flow']:
+        fid = int(flow_['oml:id'])
+        flow = {'id': fid,
+                'full_name': flow_['oml:full_name'],
+                'name': flow_['oml:name'],
+                'version': flow_['oml:version'],
+                'external_version': flow_['oml:external_version'],
+                'uploader': flow_['oml:uploader']}
+        flows[fid] = flow
+
+    return flows

openml/flows/sklearn_converter.py

@@ -1,10 +1,12 @@
 """Convert scikit-learn estimators into an OpenMLFlows and vice versa."""
 
 from collections import OrderedDict
+from distutils.version import LooseVersion
 import importlib
 import inspect
 import json
 import json.decoder
+import re
 import six
 import warnings
 import sys
@@ -25,6 +27,10 @@
     JSONDecodeError = ValueError
 
 
+DEPENDENCIES_PATTERN = re.compile(
+    '^(?P<name>[\w\-]+)((?P<operation>==|>=|>)(?P<version>(\d+\.)?(\d+\.)?(\d+)))?$')
+
+
 def sklearn_to_flow(o):
 
     if _is_estimator(o):
@@ -174,6 +180,10 @@ def _serialize_model(model):
     # Get the external versions of all sub-components
     external_version = _get_external_version_string(model, sub_components)
 
+    dependencies = [_format_external_version('sklearn', sklearn.__version__),
+                    'numpy>=1.6.1', 'scipy>=0.9']
+    dependencies = '\n'.join(dependencies)
+
     flow = OpenMLFlow(name=name,
                       class_name=class_name,
                       description='Automatically created sub-component.',
@@ -185,7 +195,7 @@ def _serialize_model(model):
                       tags=[],
                       language='English',
                       # TODO fill in dependencies!
-                      dependencies=None)
+                      dependencies=dependencies)
 
     return flow
 
@@ -317,6 +327,7 @@ def _extract_information_from_model(model):
 def _deserialize_model(flow, **kwargs):
 
     model_name = flow.class_name
+    _check_dependencies(flow.dependencies)
 
     parameters = flow.parameters
     components = flow.components
@@ -352,6 +363,33 @@ def _deserialize_model(flow, **kwargs):
     return model_class(**parameter_dict)
 
 
+def _check_dependencies(dependencies):
+    dependencies = dependencies.split('\n')
+    for dependency_string in dependencies:
+        match = DEPENDENCIES_PATTERN.match(dependency_string)
+        dependency_name = match.group('name')
+        operation = match.group('operation')
+        version = match.group('version')
+
+        module = importlib.import_module(dependency_name)
+        required_version = LooseVersion(version)
+        installed_version = LooseVersion(module.__version__)
+
+        if operation == '==':
+            check = required_version == installed_version
+        elif operation == '>':
+            check = installed_version > required_version
+        elif operation == '>=':
+            check = installed_version > required_version or \
+                    installed_version == required_version
+        else:
+            raise NotImplementedError(
+                'operation \'%s\' is not supported' % operation)
+        if not check:
+            raise ValueError('Trying to deserialize a model with dependency '
+                             '%s not satisfied.' % dependency_string)
+
+
 def serialize_type(o):
     mapping = {float: 'float',
                np.float: 'np.float',

tests/test_flows/test_flow.py

@@ -69,17 +69,6 @@ def get_sentinel():
 
 class TestFlow(TestBase):
 
-    @unittest.skip('The method which is tested by this function doesnt exist')
-    def test_download_flow_list(self):
-        def check_flow(flow):
-            self.assertIsInstance(flow, dict)
-            self.assertEqual(len(flow), 6)
-
-        flows = openml.flows.get_flow_list()
-        self.assertGreaterEqual(len(flows), 1448)
-        for flow in flows:
-            check_flow(flow)
-
     def test_get_flow(self):
         # We need to use the production server here because 4024 is not the test
         # server

tests/test_flows/test_flow_functions.py

@@ -0,0 +1,42 @@
+import unittest
+
+import openml
+from openml.util import is_string
+
+
+class TestFlowFunctions(unittest.TestCase):
+    def _check_flow(self, flow):
+        self.assertEqual(type(flow), dict)
+        self.assertEqual(len(flow), 6)
+        self.assertIsInstance(flow['id'], int)
+        self.assertTrue(is_string(flow['name']))
+        self.assertTrue(is_string(flow['full_name']))
+        self.assertTrue(is_string(flow['version']))
+        # There are some runs on openml.org that can have an empty external
+        # version
+        self.assertTrue(is_string(flow['external_version']) or
+                        flow['external_version'] is None)
+
+    def test_list_datasets(self):
+        # We can only perform a smoke test here because we test on dynamic
+        # data from the internet...
+        flows = openml.flows.list_flows()
+        # 3000 as the number of datasets on openml.org
+        self.assertGreaterEqual(len(flows), 3000)
+        for fid in flows:
+            self._check_flow(flows[fid])
+
+    def test_list_datasets_by_tag(self):
+        flows = openml.flows.list_flows(tag='weka')
+        self.assertGreaterEqual(len(flows), 5)
+        for did in flows:
+            self._check_flow(flows[did])
+
+    def test_list_datasets_paginate(self):
+        size = 10
+        max = 100
+        for i in range(0, max, size):
+            flows = openml.flows.list_flows(offset=i, size=size)
+            self.assertGreaterEqual(size, len(flows))
+            for did in flows:
+                self._check_flow(flows[did])

tests/test_flows/test_sklearn.py

@@ -3,6 +3,7 @@
 import os
 import sys
 import unittest
+import unittest.mock
 
 import numpy as np
 import scipy.optimize
@@ -19,8 +20,9 @@
 import sklearn.preprocessing
 import sklearn.tree
 
+import openml
 from openml.flows import OpenMLFlow, sklearn_to_flow, flow_to_sklearn
-from openml.flows.sklearn_converter import _format_external_version
+from openml.flows.sklearn_converter import _format_external_version, _check_dependencies
 
 this_directory = os.path.dirname(os.path.abspath(__file__))
 sys.path.append(this_directory)
@@ -47,13 +49,15 @@ def setUp(self):
         self.X = iris.data
         self.y = iris.target
 
-    def test_serialize_model(self):
+    @unittest.mock.patch('openml.flows.sklearn_converter._check_dependencies')
+    def test_serialize_model(self, check_dependencies_mock):
         model = sklearn.tree.DecisionTreeClassifier(criterion='entropy',
                                                     max_features='auto',
                                                     max_leaf_nodes=2000)
 
         fixture_name = 'sklearn.tree.tree.DecisionTreeClassifier'
         fixture_description = 'Automatically created sub-component.'
+        version_fixture = 'sklearn==%s\nnumpy>=1.6.1\nscipy>=0.9' % sklearn.__version__
         fixture_parameters = \
             OrderedDict((('class_weight', 'null'),
                          ('criterion', '"entropy"'),
@@ -74,6 +78,7 @@ def test_serialize_model(self):
         self.assertEqual(serialization.class_name, fixture_name)
         self.assertEqual(serialization.description, fixture_description)
         self.assertEqual(serialization.parameters, fixture_parameters)
+        self.assertEqual(serialization.dependencies, version_fixture)
 
         new_model = flow_to_sklearn(serialization)
 
@@ -83,6 +88,8 @@ def test_serialize_model(self):
         self.assertEqual(new_model.get_params(), model.get_params())
         new_model.fit(self.X, self.y)
 
+        self.assertEqual(check_dependencies_mock.call_count, 1)
+
     def test_serialize_model_with_subcomponent(self):
         model = sklearn.ensemble.AdaBoostClassifier(
             n_estimators=100, base_estimator=sklearn.tree.DecisionTreeClassifier())
@@ -508,3 +515,8 @@ def test_subflow_version_propagated(self):
         self.assertEqual(flow.external_version, '%s,%s' % (
             _format_external_version('sklearn', sklearn.__version__),
             _format_external_version('tests', '0.1')))
+
+    def test_check_dependencies(self):
+        dependencies = ['sklearn==0.1', 'sklearn>=99.99.99', 'sklearn>99.99.99']
+        for dependency in dependencies:
+            self.assertRaises(ValueError, _check_dependencies, dependency)