fixed the issue on the api_call method

Author: zardaloop

openml/apiconnector.py

@@ -818,191 +818,8 @@ def _create_task_cache_dir(self, task_id):
         return task_cache_dir
 
     def _perform_api_call(self, call, data=None, file_dictionary=None, add_authentication=True):
-    ############################################################################
-    # Runs
-    def get_runs_list(self, task_id=None, flow_id=None, setup_id=None):
-        """Return a list of all runs for either a task, flow or setup.
-
-        Exactly one of the optional parameters must be given.
-
-        Parameters
-        ----------
-        task_id : int, optional
-        flow_id : int, optional
-        setup_id : int, optional
-
-        Returns
-        -------
-        list
-            A list of all runs for a given ID.
-        """
-        test = [task_id is None, flow_id is None, setup_id is None]
-        if np.nansum(test) != 2:
-            raise ValueError
-
-        call = "run/list"
-
-        if task_id is not None:
-            call += "?task_id=%d" % task_id
-        elif flow_id is not None:
-            call += "?flow_id=%d" % flow_id
-        elif setup_id is not None:
-            call += "?setup_id=%d" % setup_id
-
-        return_code, xml_string = self._perform_api_call(call)
-        datasets_dict = xmltodict.parse(xml_string)
-
-
-        if isinstance(datasets_dict['oml:runs']['oml:run'], dict):
-            runs = [datasets_dict['oml:runs']['oml:run']]
-        else:
-            # Minimalistic check if the XML is useful
-            assert type(datasets_dict['oml:runs']['oml:run']) == list, \
-                type(datasets_dict['oml:runs']['oml:run'])
-            assert datasets_dict['oml:runs']['@xmlns:oml'] == \
-                   'http://openml.org/openml'
-
-            runs = []
-            for runs_ in datasets_dict['oml:runs']['oml:run']:
-                run = {'run_id': int(runs_['oml:run_id']),
-                       'task_id': int(runs_['oml:task_id']),
-                       'setup_id': int(runs_['oml:setup_id']),
-                       'flow_id': int(runs_['oml:flow_id']),
-                       'uploader': int(runs_['oml:uploader']),
-                       'error_message': runs_['oml:error_message']}
-
-                runs.append(run)
-            runs.sort(key=lambda t: t['run_id'])
-
-        return runs
-
-    def download_run(self, run_id):
-        """Download the OpenML run for a given run ID.
-
-        Parameters
-        ----------
-        run_id : int
-            The OpenML run id.
-        """
-        try:
-            run_id = int(run_id)
-        except:
-            raise ValueError("Task ID is neither an Integer nor can be "
-                             "cast to an Integer.")
-
-        xml_file = os.path.join(self._create_run_cache_dir(run_id),
-                                "run.xml")
-
-        try:
-            with open(xml_file) as fh:
-                run = self._create_run_from_xml(fh.read())
-        except (OSError, IOError):
-
-            try:
-                return_code, run_xml = self._perform_api_call(
-                    "run/%d" % run_id)
-            except (URLError, UnicodeEncodeError) as e:
-                print(e)
-                raise e
-
-            # Cache the xml task file
-            if os.path.exists(xml_file):
-                with open(xml_file) as fh:
-                    local_xml = fh.read()
-
-                if run_xml != local_xml:
-                    raise ValueError("Run description of run %d cached at %s "
-                                     "has changed." % (run_id, xml_file))
-
-            else:
-                with open(xml_file, "w") as fh:
-                    fh.write(run_xml)
-
-            run = self._create_run_from_xml(run_xml)
-
-        return run
-
-    def _create_run_cache_dir(self, run_id):
-        run_cache_dir = os.path.join(self.task_cache_dir, str(run_id))
-
-        try:
-            os.makedirs(run_cache_dir)
-        except (IOError, OSError):
-            # TODO add debug information!
-            pass
-        return run_cache_dir
-
-    def _create_run_from_xml(self, xml):
-        dic = xmltodict.parse(xml)[u"oml:run"]
-        datasets = []
-        for key in dic[u'oml:input_data']:
-            dataset = dic[u'oml:input_data'][key]
-            did = dataset[u'oml:did']
-            datasets.append(did)
-
-        tags = []
-        for tag in dic[u"oml:tag"]:
-            tags.append(tag)
-
-        files = dict()
-        for file_ in dic[u"oml:output_data"][u"oml:file"]:
-            name = file_[u"oml:name"]
-            url = file_[u"oml:url"]
-            files[name] = url
-
-        evaluations = dict()
-        for evaluation in dic[u"oml:output_data"][u"oml:evaluation"]:
-            name = evaluation[u"oml:name"]
-            value = evaluation.get(u"oml:value")
-            value_array = evaluation.get(u"oml:array_data")
-            evaluations[name] = (value, value_array)
-
-        return OpenMLRun(
-            dic[u"oml:run_id"], dic[u"oml:uploader"],
-            dic[u"oml:task_id"], dic[u"oml:flow_id"],
-            dic[u"oml:setup_string"], dic[u'oml:setup_id'],
-            tags, datasets, files, evaluations)
-
-    ############################################################################
-    # Flows
-    def get_flow_list(self):
-        """Return a list of all flows on OpenML.
-
-        Returns
-        -------
-        list
-            A list of all flows.
         """
-        return_code, xml_string = self._perform_api_call("/flow/list")
-        datasets_dict = xmltodict.parse(xml_string)
-
-        if isinstance(datasets_dict['oml:flows']['oml:flow'], dict):
-            flows = [datasets_dict['oml:implementations']['oml:implementation']]
-        else:
-            # Minimalistic check if the XML is useful
-            assert type(datasets_dict['oml:flows']['oml:flow']) == list, \
-                type(datasets_dict['oml:flows']['oml:flow'])
-            assert datasets_dict['oml:flows']['@xmlns:oml'] == \
-                   'http://openml.org/openml'
-
-            flows = []
-            for flow_ in datasets_dict['oml:flows']['oml:flow']:
-                flow = {'id': int(flow_['oml:id']),
-                        'full_name': flow_['oml:full_name'],
-                        'name': flow_['oml:name'],
-                        'version': flow_['oml:version'],
-                        'external_version': flow_['oml:external_version'],
-                        'uploader': int(flow_['oml:uploader'])}
-
-                flows.append(flow)
-            flows.sort(key=lambda t: t['id'])
-
-        return flows
-
-    ############################################################################
-    # Internal stuff
-    def _perform_api_call(self, call, data=None, file_path=None):
-        """Perform an API call at the OpenML server.
+        Perform an API call at the OpenML server.
         return self._read_url(url, data=data, filePath=filePath,
         def _read_url(self, url, add_authentication=False, data=None, filePath=None):
 
@@ -1047,12 +864,10 @@ def _read_url(self, url, data=None, file_dictionary=None):
                         raise ValueError("The file you have provided is not a valid arff file")
 
                     file_elements[key] = open(path, 'rb')
-                except URLError as error:
-                    print(error)
 
                 else:
                     raise ValueError("File doesn't exist")
-
+            try:
                 response = requests.post(url, data=data, files=file_elements)
                 return response.status_code, response
 
@@ -1104,6 +919,8 @@ def upload_dataset(self, description, file_path=None):
             data = {'description': description}
             if file_path is not None:
                 return_code, dataset_xml = self._perform_api_call("/data/",data=data, file_dictionary={'dataset': file_path})
+            else:
+                return_code, dataset_xml = self._perform_api_call("/data/",data=data)
 
         except URLError as e:
             # TODO logger.debug
@@ -1137,6 +954,4 @@ def upload_run(self, files):
                 raise e
             return return_code, dataset_xml
         else:
-            raise ValueError("prediction files doesn't exist")
-
-
+            raise ValueError("prediction files doesn't exist")