openml integration in shogun

src/shogun/io/OpenmlFlow.cpp

@@ -0,0 +1,100 @@
+/*
+ * This software is distributed under BSD 3-clause license (see LICENSE file).
+ *
+ * Authors: Gil Hoben
+ */
+
+#ifdef HAVE_CURL
+
+#include <shogun/io/OpenmlFlow.h>
+#include "OpenmlFlow.h"
+
+
+using namespace shogun;
+
+size_t writer(char *data, size_t size, size_t nmemb, std::string* buffer_in)
+{
+	// adapted from https://stackoverflow.com/a/5780603
+	// Is there anything in the buffer?
+	if (buffer_in->empty())
+	{
+		// Append the data to the buffer
+		buffer_in->append(data, size * nmemb);
+
+		return size * nmemb;
+	}
+
+	return 0;
+}
+
+const char* OpenMLReader::xml_server = "https://www.openml.org/api/v1/xml";
+const char* OpenMLReader::json_server = "https://www.openml.org/api/v1/json";
+const char* OpenMLReader::dataset_description = "/data/{}";
+const char* OpenMLReader::list_data_qualities = "/data/qualities/list";
+const char* OpenMLReader::data_features = "/data/features/{}";
+const char* OpenMLReader::list_dataset_qualities = "/data/qualities/{}";
+const char* OpenMLReader::list_dataset_filter = "/data/list/{}";
+const char* OpenMLReader::flow_file = "/flow/{}";
+
+const std::unordered_map<std::string, std::string>
+    OpenMLReader::m_format_options = {{"xml", xml_server},
+                                      {"json", json_server}};
+const std::unordered_map<std::string, std::string>
+    OpenMLReader::m_request_options = {
+
+        {"dataset_description", dataset_description},
+        {"list_data_qualities", list_data_qualities},
+        {"data_features", data_features},
+        {"list_dataset_qualities", list_dataset_qualities},
+        {"list_dataset_filter", list_dataset_filter},
+		{"flow_file", flow_file}};
+
+OpenMLReader::OpenMLReader(const std::string& api_key) : m_api_key(api_key)
+{
+}
+
+void OpenMLReader::post(const std::string& request, const std::string& data)
+{
+}
+
+void OpenMLReader::openml_curl_request_helper(const std::string& url)
+{
+	CURL* curl_handle = nullptr;
+
+	curl_handle = curl_easy_init();
+
+	if (!curl_handle)
+	{
+		SG_SERROR("Failed to initialise curl handle.")
+		return;
+	}
+
+	curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str());
+	curl_easy_setopt(curl_handle, CURLOPT_HTTPGET,1);
+	curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, writer);
+	curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, &m_curl_response_buffer);
+
+	CURLcode res = curl_easy_perform(curl_handle);
+
+	openml_curl_error_helper(res);
+
+	curl_easy_cleanup(curl_handle);
+}
+
+void OpenMLReader::openml_curl_error_helper(CURLcode code) {
+
+}
+
+
+void OpenMLFlow::download_flow()
+{
+
+	auto reader = OpenMLReader(m_api_key);
+	auto return_string = reader.get("flow_file", "json", m_flow_id);
+}
+
+void OpenMLFlow::upload_flow(const OpenMLFlow& flow)
+{
+}
+
+#endif // HAVE_CURL

src/shogun/io/OpenmlFlow.h

@@ -0,0 +1,154 @@
+/*
+ * This software is distributed under BSD 3-clause license (see LICENSE file).
+ *
+ * Authors: Gil Hoben
+ */
+
+#ifndef SHOGUN_OPENMLFLOW_H
+#define SHOGUN_OPENMLFLOW_H
+
+#ifdef HAVE_CURL
+
+#include <shogun/io/SGIO.h>
+
+#include <curl/curl.h>
+#include <numeric>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <iostream>
+
+namespace shogun
+{
+	class OpenMLReader
+	{
+
+	public:
+		explicit OpenMLReader(const std::string& api_key);
+
+		/**
+		 * Returns a string returned by the server given a request.
+		 * Raises an error if the returned code is not 200.
+		 * Additional arguments can be passed to the request,
+		 * which are then concatenated with a "/" character.
+		 *
+		 * @tparam Args argument type pack, should all be std::string
+		 * @param request the request name, see m_request_options
+		 * @param format the format to return the data in, see m_format_options
+		 * @param args the additional arguments to be passed to request
+		 * @return the returned stream from the server if the return code is 200
+		 */
+		template <typename... Args>
+		std::string
+		get(const std::string& request, const std::string& format, Args... args)
+		{
+			auto find_format = m_format_options.find(format);
+			if (find_format == m_format_options.end())
+			{
+				SG_SERROR(
+				    "The provided format \"%s\" is not available\n",
+				    format.c_str())
+			}
+			auto find_request = m_request_options.find(request);
+			if (find_request == m_request_options.end())
+			{
+				SG_SERROR(
+				    "Could not find a way to solve the request \"%s\"\n",
+				    request.c_str())
+			}
+			std::string request_format = find_format->second;
+			std::string request_path = find_request->second;
+
+			// get additional args and concatenate them with "/"
+			if (sizeof...(Args) > 0)
+			{
+				if (request_path.substr(request_path.size() - 2) == "{}")
+				{
+					request_path =
+					    request_path.substr(0, request_path.size() - 2);
+				}
+				else
+				{
+					SG_SERROR(
+					    "The provided request \"%s\" cannot handle additional "
+					    "args.\n",
+					    request.c_str())
+				}
+				std::vector<std::string> args_vec = {args...};
+				std::string args_string = std::accumulate(
+				    args_vec.begin() + 1, args_vec.end(), args_vec.front(),
+				    [](std::string s0, std::string& s1) {
+					    return s0 += "/" + s1;
+				    });
+				request_path += args_string;
+			}
+
+			std::string url = request_format + request_path + "?" + m_api_key;
+
+			openml_curl_request_helper(url);
+
+			return m_curl_response_buffer;
+		}
+
+		void post(const std::string& request, const std::string& data);
+
+	private:
+
+		std::string m_curl_response_buffer;
+
+		/**
+		 * Initialises CURL session and gets the data.
+		 * This function also handles the response code from the server.
+		 *
+		 * @param url the url to query
+		 */
+		void openml_curl_request_helper(const std::string& url);
+
+		/**
+		 * Handles all possible codes
+		 *
+		 * @param code the code returned by the query
+		 */
+		void openml_curl_error_helper(CURLcode code);
+
+		std::string m_api_key;
+
+		static const char* xml_server;
+		static const char* json_server;
+
+		static const std::unordered_map<std::string, std::string>
+		    m_format_options;
+		static const std::unordered_map<std::string, std::string>
+		    m_request_options;
+
+		/* DATA API */
+		static const char* dataset_description;
+		static const char* list_data_qualities;
+		static const char* data_features;
+		static const char* list_dataset_qualities;
+		static const char* list_dataset_filter;
+
+		/* FLOW API */
+		static const char* flow_file;
+	};
+
+	class OpenMLFlow
+	{
+
+	public:
+		explicit OpenMLFlow(
+		    const std::string& api_key, const std::string& flow_id)
+		    : m_api_key(api_key), m_flow_id(flow_id){};
+
+		void download_flow();
+
+		static void upload_flow(const OpenMLFlow& flow);
+
+	private:
+		std::string m_api_key;
+		std::string m_flow_id;
+	};
+} // namespace shogun
+#endif // HAVE_CURL
+
+#endif // SHOGUN_OPENMLFLOW_H