Merge 10a409b into f139c62

niquery/app.py

@@ -62,7 +62,7 @@ def add(x, y):
 parser.add_argument('Y', type=int, help='Y')
 
 
-class HelloWorld(Resource):
+class Validate(Resource):
     def get(self):
         x = 5
         y = 10
@@ -78,9 +78,13 @@ def get(self, task_id):
         retval = add.AsyncResult(task_id).get(timeout=1.0)
         return repr(retval)
 
-api.add_resource(HelloWorld, '/helloworld')
+api.add_resource(Validate, '/validate')
 api.add_resource(ShowResult, '/helloworld/<string:task_id>')
 
 if __name__ == "__main__":
 
     app.run(host=app.config['HOST'], port=app.config['PORT'])
+
+# TODO: 'Validate' NIDM API (Dataset Descriptor)
+# TODO: Infer NIDM from XNAT + EXCEL (Experiment)
+# TODO: Compute from NIDM (Workflow + Results)

niquery/query.py

@@ -24,43 +24,89 @@ def __init__(self):
         self._bind_prefixes()
         self.sparql_meta = self._get_sparql_meta()
 
-    def _get_sparql_meta(self):
-        self._graph.parse(os.path.join(utils.get_meta_path()), format='turtle')
-        result = self._graph.query(self._queries['meta.rq'])
-        return utils.result_to_dataframe(result)
-
     def _bind_prefixes(self):
+        """
+        Loads the base set of namespaces into rdflib
+        """
         for prefix, namespace in utils.NS.iteritems():
             self._graph.bind(prefix, namespace)
 
+    def _filter_queries(self, ns):
+        """
+        Enables subclasses to filter queries by type (e.g., SELECT queries are
+        filtered using utils.NS.niq.Select.
+        """
+        select_filter = self.sparql_meta.format == str(ns)
+        return self.sparql_meta[select_filter]
+
     def _get_query_string(self, index):
+        """
+        Extracts the actual query text to execute, based on the query index.
+        """
         queries = utils.get_sparql_queries()
         row = self.sparql_meta.iloc[index]
         base = os.path.basename(urlparse.urlsplit(row.downloadURL).path)
         return queries[base]
 
-    def get_graph(self):
-        return self._graph
+    def _get_sparql_meta(self):
+        """
+        Parses the query metadata and load a table of available queries.
+        """
+        self._graph.parse(os.path.join(utils.get_meta_path()),
+                          format='turtle')
+        result = self._graph.query(self._queries['meta.rq'])
+        return utils.result_to_dataframe(result)
 
     def describe_query(self, index):
+        """
+        Uses the index of a query to return a description
+        """
         return self.sparql_meta.iloc[index]
 
+    def execute(self, query_index, turtle_file=None, turtle_url=None):
+        """
+        Execute a query using the index
+
+        Subclasses define specific parameters and returns
+        """
+        pass
+
+    def get_graph(self):
+        """
+        Returns the currently loaded graph
+        """
+        return self._graph
+
 
 class SelectQuery(QueryBase):
     def __init__(self):
         super(SelectQuery, self).__init__()
-        self.sparql_meta = self._filter_queries()
-
-    def _filter_queries(self):
-        select_filter = self.sparql_meta.format == str(utils.NS.niq.Select)
-        return self.sparql_meta[select_filter]
+        self.sparql_meta = self._filter_queries(utils.NS.niq.Select)
 
     def execute(self, query_index, turtle_file=None, turtle_url=None):
+        """
+        Execute a query using the index
+
+        Parameters
+        ----------
+        query_index : int
+        turtle_file : str, optional
+        turtle)url : string, optional
+
+        Returns
+        -------
+        df : pandas.Dataframe
+            Dataframe object of SELECT SPARQL query
+        """
         query = self._get_query_string(query_index)
-        self._graph.parse(source=turtle_file, location=turtle_url, format='turtle')
+        self._graph.parse(source=turtle_file,
+                          location=turtle_url,
+                          format='turtle')
         result = self._graph.query(query)
         return utils.result_to_dataframe(result)
 
-# TODO: 'Validate' NIDM API (Dataset Descriptor)
-# TODO: Infer NIDM from XNAT + EXCEL (Experiment)
-# TODO: Compute from NIDM (Workflow + Results)
+
+class AskQuery(QueryBase):
+    def __init__(self):
+        super(AskQuery, self).__init__()
+

niquery/tests/test_query.py

@@ -0,0 +1,45 @@
+__author__ = 'Nolan Nichols <orcid.org/0000-0003-1099-3328>'
+
+import unittest
+
+import rdflib
+import pandas as pd
+from mock import patch
+
+from niquery.query import QueryBase, SelectQuery, AskQuery
+
+
+class QueryBaseTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.query = QueryBase()
+
+    def test_init(self):
+        self.assertIsInstance(self.query, QueryBase)
+
+    def test_describe_query(self):
+        res = self.query.describe_query(1)
+        self.assertGreater(len(res), 1)
+
+    def test_execute(self):
+        res = self.query.execute(0)
+        self.assertIsNone(res)
+
+    def test_get_graph(self):
+        self.assertIsInstance(self.query.get_graph(), rdflib.Graph)
+
+
+class SelectQueryTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.query = SelectQuery()
+
+    def test_init(self):
+        self.assertIsInstance(self.query, SelectQuery)
+        self.assertGreater(len(self.query.sparql_meta), 0)
+
+    def test_execute(self):
+        self.assertRaises(Exception, self.query.execute, 0)
+
+if __name__ == '__main__':
+    unittest.main()