Remove the status variable from the MvS

hybrid_server/classes/mvkcontroller.xml

@@ -9,7 +9,7 @@
             self.mvs = ModelverseState("../bootstrap/bootstrap.m.gz")
             # Enable Garbage Collection
             self.mvs.GC = True
-            self.root = self.mvs.read_root()[0]
+            self.root = self.mvs.read_root()
 
             # Instantiate the kernel.
             self.mvk = ModelverseKernel(self.root)
@@ -121,7 +121,7 @@
                     commands = mvk.execute_yields(taskname, operation, params, reply)
                     if commands is None:
                         break
-                    reply = [mvs_operations[command[0]](*(command[1]))[0] for command in commands]
+                    reply = [mvs_operations[command[0]](*(command[1])) for command in commands]
             except:
                 print("ERROR: " + str(self.mvk.debug_info.get(taskname, "Unknown taskname")))
                 raise
@@ -262,13 +262,13 @@
                                 else:
                                     self.count += 1
                                     self.mvs.garbage_collect()
-                                out = self.mvs.read_outgoing(self.root)[0]
+                                out = self.mvs.read_outgoing(self.root)
                                 for m in out:
-                                    src, task = self.mvs.read_edge(m)[0]
-                                    outgoing = self.mvs.read_outgoing(m)[0]
-                                    first = self.mvs.read_edge(outgoing[0])[0]
+                                    src, task = self.mvs.read_edge(m)
+                                    outgoing = self.mvs.read_outgoing(m)
+                                    first = self.mvs.read_edge(outgoing[0])
                                     dest = first[1]
-                                    name = self.mvs.read_value(dest)[0]
+                                    name = self.mvs.read_value(dest)
                                     if name.startswith("__"):
                                         continue
                                     self.tasks.add(name)

kernel/modelverse_kernel/request_handler.py

@@ -1,24 +1,12 @@
 import sys
 import modelverse_kernel.primitives as primitive_functions
 import modelverse_jit.runtime as jit_runtime
+from collections import defaultdict
 
 class KnownRequestHandled(Exception):
     """An exception that signifies that a known request was handled."""
     pass
 
-class GeneratorStackEntry(object):
-    """An entry in the generator stack of a request handles."""
-    __slots__ = ["generator", "function_name", "source_map", "function_origin", "pending_requests", "finished_requests", "replies"]
-
-    def __init__(self, generator):
-        self.generator = generator
-        self.function_name = None
-        self.source_map = None
-        self.function_origin = None
-        self.pending_requests = None
-        self.finished_requests = True
-        self.replies = None
-
 def format_stack_trace(stack_trace):
     """Formats a list of (function name, debug info, origin) triples."""
     return '\n'.join([jit_runtime.format_stack_frame(*triple) for triple in stack_trace])
@@ -27,11 +15,12 @@ class UnhandledRequestHandlerException(Exception):
     """The type of exception that is thrown when the request handler encounters an
        unhandled exception."""
     def __init__(self, inner_exception, stack_trace):
+        import traceback
         Exception.__init__(
             self,
             """The request handler encountered an unknown exception.\n
                Inner exception: %s\n
-               Stack trace:\n%s\n""" % (inner_exception, format_stack_trace(stack_trace)))
+               Stack trace:\n%s\n""" % (traceback.format_exc(), format_stack_trace(stack_trace)))
         self.inner_exception = inner_exception
         self.stack_trace = stack_trace
 
@@ -70,20 +59,20 @@ class RequestHandler(object):
 
         # Append the server's replies to the list of replies.
         if reply is not None:
-            if self.generator_stack[-1].replies is None:
-                self.generator_stack[-1].replies = reply
+            if self.generator_stack[-1]["replies"] is None:
+                self.generator_stack[-1]["replies"] = reply
             else:
-                self.generator_stack[-1].replies.extend(reply)
+                self.generator_stack[-1]["replies"].extend(reply)
 
         while 1:
             # Silence pylint's warning about catching Exception.
             # pylint: disable=I0011,W0703
             try:
-                while self.generator_stack[-1].finished_requests:
+                while self.generator_stack[-1]["finished_requests"]:
                     gen = self.generator_stack[-1]
-                    gen.pending_requests = gen.generator.send(gen.replies)
-                    gen.finished_requests = False
-                    gen.replies = None
+                    gen["pending_requests"] = gen["generator"].send(gen["replies"])
+                    gen["finished_requests"] = False
+                    gen["replies"] = None
                 else:
                     return self.pop_requests()
 
@@ -120,15 +109,18 @@ class RequestHandler(object):
 
     def set_finished_requests_flag(self):
         """Sets the finished_requests flag in the top-of-stack tuple."""
-        self.generator_stack[-1].finished_requests = True
+        self.generator_stack[-1]["finished_requests"] = True
 
     def has_pending_requests(self):
         """Tests if the top-of-stack generator has pending requests."""
-        return not self.generator_stack[-1].finished_requests
+        return not self.generator_stack[-1]["finished_requests"]
 
     def push_generator(self, gen):
         """Pushes a new generator onto the stack."""
-        self.generator_stack.append(GeneratorStackEntry(gen))
+        dd = defaultdict(lambda : None)
+        dd["generator"] = gen
+        dd["finished_requests"] = True
+        self.generator_stack.append(dd)
         # print('Pushed generator %s. Generator count: %d' % (gen, len(self.generator_stack)))
 
     def pop_generator(self):
@@ -151,10 +143,10 @@ class RequestHandler(object):
 
     def append_reply(self, new_reply):
         """Appends a reply to the top-of-stack generator's list of pending replies."""
-        if self.generator_stack[-1].replies is None:
-            self.generator_stack[-1].replies = [new_reply]
+        if self.generator_stack[-1]["replies"] is None:
+            self.generator_stack[-1]["replies"] = [new_reply]
         else:
-            self.generator_stack[-1].replies.append(new_reply)
+            self.generator_stack[-1]["replies"].append(new_reply)
 
     def handle_exception(self, exception):
         """Handles the given exception. A Boolean is returned that tells if
@@ -176,10 +168,9 @@ class RequestHandler(object):
                 # a single 'TAIL_CALL_ARGS' request. The next iteration will replace
                 # the dummy frame by an actual frame.
                 del self.generator_stack[stack_index:]
-                stack_entry = GeneratorStackEntry(None)
-                stack_entry.pending_requests = [
-                    ('TAIL_CALL_ARGS', [applicable_handler, (exception,)])]
-                stack_entry.finished_requests = False
+                stack_entry = defaultdict(lambda : None)
+                stack_entry["pending_requests"] = [('TAIL_CALL_ARGS', [applicable_handler, (exception,)])]
+                stack_entry["finished_requests"] = False
                 self.generator_stack.append(stack_entry)
                 return None
 
@@ -204,25 +195,25 @@ class RequestHandler(object):
         stack_trace = []
         while len(self.generator_stack) > 0:
             top_entry = self.generator_stack.pop()
-            if top_entry.function_origin is None:
+            if top_entry["function_origin"] is None:
                 # Skip this function.
                 continue
 
             try:
                 # Crash the generator.
-                top_entry.generator.throw(UnwindStackException())
+                top_entry["generator"].throw(UnwindStackException())
             except UnwindStackException:
                 # Find out where the exception was thrown.
                 _, _, exc_traceback = sys.exc_info()
                 line_number = exc_traceback.tb_lineno
-                source_map = top_entry.source_map
+                source_map = top_entry["source_map"]
                 if source_map is not None:
                     debug_info = source_map.get_debug_info(line_number)
                 else:
                     debug_info = None
 
-                function_name = top_entry.function_name
-                stack_trace.append((function_name, debug_info, top_entry.function_origin))
+                function_name = top_entry["function_name"]
+                stack_trace.append((function_name, debug_info, top_entry["function_origin"]))
 
         return stack_trace[::-1]
 
@@ -232,7 +223,7 @@ class RequestHandler(object):
 
            A list of requests and a Boolean are returned. The latter is True
            if there are no more requests to process, and false otherwise."""
-        requests = self.generator_stack[-1].pending_requests
+        requests = self.generator_stack[-1]["pending_requests"]
         if requests is None or len(requests) == 0:
             # Couldn't find a request for the state to handle.
             self.set_finished_requests_flag()
@@ -389,6 +380,5 @@ class RequestHandler(object):
         # encountered.
         # Format: ("DEBUG_INFO", [function_name, source_map])
         top_entry = self.generator_stack[-1]
-        top_entry.function_name, top_entry.source_map, top_entry.function_origin = request_args
+        top_entry["function_name"], top_entry["source_map"], top_entry["function_origin"] = request_args
         self.append_reply(None)
-

state/modelverse_state/main.py

@@ -1,4 +1,3 @@
-from modelverse_state import status
 import sys
 from collections import defaultdict
 import os
@@ -52,7 +51,7 @@ class ModelverseState(object):
             for i, e in self.edges.iteritems():
                 f.write("%s -> %s [label=\"%s\"];\n" % (e[0], e[1], i))
             f.write("}")
-        return (self.root, status.SUCCESS)
+        return self.root
 
     def parse(self, filename):
         picklefile = filename + ".pickle"
@@ -93,18 +92,18 @@ class ModelverseState(object):
                     if element_type == "Node":
                         name = name.split()[0]
                         if values == "":
-                            symbols[name], status = self.create_node()
+                            symbols[name] = self.create_node()
                         else:
                             value = values
                             if value in complex_primitives:
                                 value = string_to_instance(value)
                             else:
                                 value = eval(value)
-                            symbols[name], status = self.create_nodevalue(value)
+                            symbols[name] = self.create_nodevalue(value)
                     elif element_type == "Edge":
                         name = name.split()[0]
                         values = [v.split()[0] for v in values.split(",")]
-                        symbols[name], status = self.create_edge(resolve(values[0]), resolve(values[1]))
+                        symbols[name] = self.create_edge(resolve(values[0]), resolve(values[1]))
                     elif element_type == "Dict":
                         values = [v.split()[0] for v in values.split(",")]
                         if values[1] in complex_primitives:
@@ -115,9 +114,6 @@ class ModelverseState(object):
                     else:
                         raise Exception("Unknown element type: %s" % element_type)
 
-                    if status != 100:
-                        raise Exception("Failed to process line for reason %s: %s" % (status, line))
-
             # Creation successful, now also create a pickle
             with open(picklefile, 'wb') as f:
                 pickle.dump((symbols["root"], self.free_id, self.nodes, self.edges, self.values, self.cache, self.cache_node), f, pickle.HIGHEST_PROTOCOL)
@@ -125,18 +121,18 @@ class ModelverseState(object):
             return symbols["root"]
 
     def read_root(self):
-        return (self.root, status.SUCCESS)
+        return self.root
 
     def create_node(self):
         self.nodes.add(self.free_id)
         self.free_id += 1
-        return (self.free_id - 1, status.SUCCESS)
+        return self.free_id - 1
 
     def create_edge(self, source, target):
         if source not in self.edges and source not in self.nodes:
-            return (None, status.FAIL_CE_SOURCE)
+            return None
         elif target not in self.edges and target not in self.nodes:
-            return (None, status.FAIL_CE_TARGET)
+            return None
         else:
             self.outgoing.setdefault(source, set()).add(self.free_id)
             self.incoming.setdefault(target, set()).add(self.free_id)
@@ -149,7 +145,7 @@ class ModelverseState(object):
                 if target in self.values:
                     self.cache.setdefault(dict_source, {})[self.values[target]] = source
                 self.cache_node.setdefault(dict_source, {})[target] = source
-            return (self.free_id - 1, status.SUCCESS)
+            return self.free_id - 1
 
     def is_valid_datavalue(self, value):
         if isinstance(value, dict):
@@ -165,58 +161,54 @@ class ModelverseState(object):
 
     def create_nodevalue(self, value):
         if not self.is_valid_datavalue(value):
-            return (None, status.FAIL_CNV_OOB)
+            return None
         self.values[self.free_id] = value
         self.nodes.add(self.free_id)
         self.free_id += 1
-        return (self.free_id - 1, status.SUCCESS)
+        return self.free_id - 1
 
     def create_dict(self, source, data, destination):
         if source not in self.nodes and source not in self.edges:
-            return (None, status.FAIL_CDICT_SOURCE)
-        if destination not in self.nodes and destination not in self.edges:
-            return (None, status.FAIL_CDICT_TARGET)
-        if not self.is_valid_datavalue(data):
-            return (None, status.FAIL_CDICT_OOB)
-        n = self.create_nodevalue(data)[0]
-        e = self.create_edge(source, destination)[0]
-        self.create_edge(e, n)
-        self.cache.setdefault(source, {})[data] = e
-        self.cache_node.setdefault(source, {})[n] = e
-
-        return (None, status.SUCCESS)
+            return None
+        elif destination not in self.nodes and destination not in self.edges:
+            return None
+        elif not self.is_valid_datavalue(data):
+            return None
+        else:
+            n = self.create_nodevalue(data)
+            e = self.create_edge(source, destination)
+            self.create_edge(e, n)
+            self.cache.setdefault(source, {})[data] = e
+            self.cache_node.setdefault(source, {})[n] = e
 
     def read_value(self, node):
         if node in self.values:
-            return (self.values[node], status.SUCCESS)
-        elif node not in self.nodes:
-            return (None, status.FAIL_RV_UNKNOWN)
+            return self.values[node]
         else:
-            return (None, status.FAIL_RV_NO_VALUE)
+            return None
 
     def read_outgoing(self, elem):
         if elem in self.edges or elem in self.nodes:
             if elem in self.outgoing:
-                return (list(self.outgoing[elem]), status.SUCCESS)
+                return list(self.outgoing[elem])
             else:
-                return ([], status.SUCCESS)
-        else:
-            return (None, status.FAIL_RO_UNKNOWN)
+                return []
+        return None
 
     def read_incoming(self, elem):
         if elem in self.edges or elem in self.nodes:
             if elem in self.incoming:
-                return (list(self.incoming[elem]), status.SUCCESS)
+                return list(self.incoming[elem])
             else:
-                return ([], status.SUCCESS)
+                return []
         else:
-            return (None, status.FAIL_RI_UNKNOWN)
+            return None
 
     def read_edge(self, edge):
         if edge in self.edges:
-            return ([self.edges[edge][0], self.edges[edge][1]], status.SUCCESS)
+            return [self.edges[edge][0], self.edges[edge][1]]
         else:
-            return ([None, None], status.FAIL_RE_UNKNOWN)
+            return [None, None]
 
     def read_dict(self, node, value):
         try:
@@ -224,23 +216,18 @@ class ModelverseState(object):
             # Got hit, so validate
             if (self.edges[first][0] == node) and \
                 (value in [self.values[self.edges[i][1]] for i in self.outgoing[first]]):
-                return (self.edges[first][1], status.SUCCESS)
+                return self.edges[first][1]
             # Hit but invalid now
             del self.cache[node][value]
         except KeyError:
             # Didn't exist
             pass
-
-        if node not in self.nodes and node not in self.edges:
-            return (None, status.FAIL_RDICT_UNKNOWN)
-        elif not self.is_valid_datavalue(value):
-            return (None, status.FAIL_RDICT_OOB)
-        else:
-            return (None, status.FAIL_RDICT_NOT_FOUND)
+        return None
 
     def read_dict_keys(self, node):
         if node not in self.nodes and node not in self.edges:
-            return (None, status.FAIL_RDICTKEYS_UNKNOWN)
+            return None
+
         result = []
         if node in self.outgoing:
             for e1 in self.outgoing[node]:
@@ -248,7 +235,7 @@ class ModelverseState(object):
                     for e2 in self.outgoing[e1]:
                         result.append(self.edges[e2][1])
         #NOTE cannot just use the cache here, as some keys in the cache might not actually exist; we would have to check all of them anyway
-        return (result, status.SUCCESS)
+        return result
 
     def read_dict_edge(self, node, value):
         try:
@@ -256,31 +243,23 @@ class ModelverseState(object):
             # Got hit, so validate
             if (self.edges[first][0] == node) and \
                 (value in [self.values[self.edges[i][1]] for i in self.outgoing[first]]):
-                return (first, status.SUCCESS)
+                return first
             # Hit but invalid now
             del self.cache[node][value]
         except KeyError:
             # Didn't exist
             pass
 
-        if node not in self.nodes and node not in self.edges:
-            return (None, status.FAIL_RDICTE_UNKNOWN)
-        elif not self.is_valid_datavalue(value):
-            return (None, status.FAIL_RDICTE_OOB)
-        else:
-            return (None, status.FAIL_RDICTE_NOT_FOUND)
+        return None
 
     def read_dict_node(self, node, value_node):
-        e, s = self.read_dict_node_edge(node, value_node)
+        e = self.read_dict_node_edge(node, value_node)
 
-        if s != status.SUCCESS:
-            return (None, {status.FAIL_RDICTNE_UNKNOWN: status.FAIL_RDICTN_UNKNOWN,
-                           status.FAIL_RDICTNE_UNCERTAIN: status.FAIL_RDICTN_UNCERTAIN,
-                           status.FAIL_RDICTNE_AMBIGUOUS: status.FAIL_RDICTN_AMBIGUOUS,
-                           status.FAIL_RDICTNE_OOB: status.FAIL_RDICTN_OOB,
-                           status.FAIL_RDICTNE_NOT_FOUND: status.FAIL_RDICTN_NOT_FOUND}[s])
-        self.cache_node.setdefault(node, {})[value_node] = e
-        return (self.edges[e][1], status.SUCCESS)
+        if e is None:
+            return None
+        else:
+            self.cache_node.setdefault(node, {})[value_node] = e
+            return self.edges[e][1]
 
     def read_dict_node_edge(self, node, value_node):
         try:
@@ -288,23 +267,20 @@ class ModelverseState(object):
             # Got hit, so validate
             if (self.edges[first][0] == node) and \
                 (value_node in [self.edges[i][1] for i in self.outgoing[first]]):
-                return (first, status.SUCCESS)
+                return first
             # Hit but invalid now
             del self.cache_node[node][value_node]
         except KeyError:
             # Didn't exist
             pass
 
-        if node not in self.nodes and node not in self.edges:
-            return (None, status.FAIL_RDICTNE_UNKNOWN)
-        else:
-            return (None, status.FAIL_RDICTNE_NOT_FOUND)
+        return None
 
     def read_reverse_dict(self, node, value):
         if node not in self.nodes and node not in self.edges:
-            return (None, status.FAIL_RRDICT_UNKNOWN)
+            return None
         elif not self.is_valid_datavalue(value):
-            return (None, status.FAIL_RRDICT_OOB)
+            return None
         # Get all outgoing links
         matches = []
         if node in self.incoming:
@@ -318,20 +294,19 @@ class ModelverseState(object):
                         if target in self.values and self.values[target] == value:
                             # Found a match
                             if len(self.outgoing[e1]) > 1:
-                                return (None, status.FAIL_RRDICT_UNCERTAIN)
+                                return None
                             else:
                                 matches.append(e1)
         if len(matches) == 0:
-            return (None, status.FAIL_RRDICT_NOT_FOUND)
+            return None
         else:
-            return ([self.edges[e][0] for e in matches], status.SUCCESS)
+            return [self.edges[e][0] for e in matches]
 
     def delete_node(self, node):
         if node == self.root:
-            return (None, status.FAIL_DN_UNKNOWN)
-
-        if node not in self.nodes:
-            return (None, status.FAIL_DN_UNKNOWN)
+            return None
+        elif node not in self.nodes:
+            return None
 
         self.nodes.remove(node)
 
@@ -356,11 +331,11 @@ class ModelverseState(object):
         if node in self.incoming:
             del self.incoming[node]
 
-        return (None, status.SUCCESS)
+        return None
 
     def delete_edge(self, edge):
         if edge not in self.edges:
-            return (None, status.FAIL_DE_UNKNOWN)
+            return None
 
         s, t = self.edges[edge]
         if t in self.incoming:
@@ -392,8 +367,6 @@ class ModelverseState(object):
             # If they haven't, they will be removed because the source was removed.
             self.to_delete.add(t)
 
-        return (None, status.SUCCESS)
-
     def garbage_collect(self):  
         while self.to_delete:
             t = self.to_delete.pop()

state/modelverse_state/rdf.py

@@ -1,4 +1,3 @@
-from modelverse_state import status
 import sys
 from collections import defaultdict
 import os
@@ -126,42 +125,39 @@ class ModelverseState(object):
 
                 if element_type == "Node":
                     if values == "":
-                        symbols[name], status = self.create_node()
+                        symbols[name] = self.create_node()
                     else:
                         value = values
                         if value in complex_primitives:
                             value = string_to_instance(value)
                         else:
                             value = eval(value)
-                        symbols[name], status = self.create_nodevalue(value)
+                        symbols[name] = self.create_nodevalue(value)
                 elif element_type == "Edge":
                     values = [v.split()[0] for v in values.split(",")]
-                    symbols[name], status = self.create_edge(resolve(values[0]), resolve(values[1]))
+                    symbols[name] = self.create_edge(resolve(values[0]), resolve(values[1]))
                 else:
                     raise Exception("Unknown element type: %s" % element_type)
 
-                if status != 100:
-                    raise Exception("Failed to process line for reason %s: %s" % (status, line))
-
             return symbols["root"]
 
     def read_root(self):
-        return (self.root, status.SUCCESS)
+        return self.root
 
     def create_node(self):
         self.free_id += 1
-        return (rdflib.URIRef("http://modelverse.mv/#%s" % self.free_id), status.SUCCESS)
+        return rdflib.URIRef("http://modelverse.mv/#%s" % self.free_id)
 
     def create_edge(self, source, target):
         if not isinstance(source, rdflib.URIRef):
-            return (None, status.FAIL_CE_SOURCE)
-        if not isinstance(target, rdflib.URIRef):
-            return (None, status.FAIL_CE_TARGET)
+            return None
+        elif not isinstance(target, rdflib.URIRef):
+            return None
         self.free_id += 1
         edge = rdflib.URIRef("http://modelverse.mv/#%s" % self.free_id)
         self.graph.add((edge, self.mv.hasSource, source))
         self.graph.add((edge, self.mv.hasTarget, target))
-        return (edge, status.SUCCESS)
+        return edge
         
     def is_valid_datavalue(self, value):
         if isinstance(value, dict):
@@ -177,57 +173,57 @@ class ModelverseState(object):
 
     def create_nodevalue(self, value):
         if not self.is_valid_datavalue(value):
-            return (None, status.FAIL_CNV_OOB)
+            return None
         self.free_id += 1
         node = rdflib.URIRef("http://modelverse.mv/#%s" % self.free_id)
         self.graph.add((node, self.mv.hasValue, rdflib.Literal(json.dumps(value))))
-        return (node, status.SUCCESS)
+        return node
 
     def create_dict(self, source, data, destination):
         if not isinstance(source, rdflib.URIRef):
-            return (None, status.FAIL_CDICT_SOURCE)
+            return None
         if not isinstance(destination, rdflib.URIRef):
-            return (None, status.FAIL_CDICT_TARGET)
+            return None
         if not self.is_valid_datavalue(data):
-            return (None, status.FAIL_CDICT_OOB)
+            return None
 
         n = self.create_nodevalue(data)[0]
         e = self.create_edge(source, destination)[0]
         self.create_edge(e, n)
-        return (None, status.SUCCESS)
+        return None
 
     def read_value(self, node):
         if not isinstance(node, rdflib.URIRef):
-            return (None, status.FAIL_RV_UNKNOWN)
+            return None
         result = self.graph.query(self.prepared_queries["read_value"], initBindings={"var1": node})
         if len(result) == 0:
-            return (None, status.FAIL_RV_NO_VALUE)
-        return (json.loads(list(result)[0][0]), status.SUCCESS)
+            return None
+        return json.loads(list(result)[0][0])
 
     def read_outgoing(self, elem):
         if not isinstance(elem, rdflib.URIRef):
-            return (None, status.FAIL_RO_UNKNOWN)
+            return None
         result = self.graph.query(self.prepared_queries["read_outgoing"], initBindings={"var1": elem})
-        return ([i[0] for i in result], status.SUCCESS)
+        return [i[0] for i in result]
 
     def read_incoming(self, elem):
         if not isinstance(elem, rdflib.URIRef):
-            return (None, status.FAIL_RI_UNKNOWN)
+            return None
         result = self.graph.query(self.prepared_queries["read_incoming"], initBindings={"var1": elem})
-        return ([i[0] for i in result], status.SUCCESS)
+        return [i[0] for i in result]
 
     def read_edge(self, edge):
         result = self.graph.query(self.prepared_queries["read_edge"], initBindings={"var1": edge})
         if len(result) == 0:
-            return ([None, None], status.FAIL_RE_UNKNOWN)
+            return [None, None]
         else:
-            return ([list(result)[0][0], list(result)[0][1]], status.SUCCESS)
+            return [list(result)[0][0], list(result)[0][1]]
 
     def read_dict(self, node, value):
         if not isinstance(node, rdflib.URIRef):
-            return (None, status.FAIL_RDICT_UNKNOWN)
+            return None
         if not self.is_valid_datavalue(value):
-            return (None, status.FAIL_RDICT_OOB)
+            return None
 
         q = """
             SELECT ?value_node
@@ -241,24 +237,23 @@ class ModelverseState(object):
             """ % (node, json.dumps(value))
         result = self.graph.query(q)
         if len(result) == 0:
-            return (None, status.FAIL_RDICT_NOT_FOUND)
+            return None
         if len(result) != 1:
-            print(value)
             raise Exception("Error!")
-        return (list(result)[0][0], status.SUCCESS)
+        return list(result)[0][0]
 
     def read_dict_keys(self, node):
         if not isinstance(node, rdflib.URIRef):
-            return (None, status.FAIL_RDICT_UNKNOWN)
+            return None
 
         result = self.graph.query(self.prepared_queries["read_dict_keys"], initBindings={"var1": node})
-        return ([i[0] for i in result], status.SUCCESS)
+        return [i[0] for i in result]
 
     def read_dict_edge(self, node, value):
         if not isinstance(node, rdflib.URIRef):
-            return (None, status.FAIL_RDICTE_UNKNOWN)
+            return None
         if not self.is_valid_datavalue(value):
-            return (None, status.FAIL_RDICTE_OOB)
+            return None
         result = self.graph.query(
             """
             SELECT ?main_edge
@@ -271,30 +266,30 @@ class ModelverseState(object):
             }
             """ % (node, json.dumps(value)))
         if len(result) == 0:
-            return (None, status.FAIL_RDICTE_NOT_FOUND)
-        return (list(result)[0][0], status.SUCCESS)
+            return None
+        return list(result)[0][0]
 
     def read_dict_node(self, node, value_node):
         if not isinstance(node, rdflib.URIRef):
-            return (None, status.FAIL_RDICTN_UNKNOWN)
+            return None
         result = self.graph.query(self.prepared_queries["read_dict_node"], initBindings={"var1": node, "var2": value_node})
         if len(result) == 0:
-            return (None, status.FAIL_RDICTN_NOT_FOUND)
-        return (list(result)[0][0], status.SUCCESS)
+            return None
+        return list(result)[0][0]
 
     def read_dict_node_edge(self, node, value_node):
         if not isinstance(node, rdflib.URIRef):
-            return (None, status.FAIL_RDICTNE_UNKNOWN)
+            return None
         result = self.graph.query(self.prepared_queries["read_dict_node_edge"], initBindings={"var1": node, "var2": value_node})
         if len(result) == 0:
-            return (None, status.FAIL_RDICTNE_NOT_FOUND)
-        return (list(result)[0][0], status.SUCCESS)
+            return None
+        return list(result)[0][0]
 
     def read_reverse_dict(self, node, value):
         if not isinstance(node, rdflib.URIRef):
-            return (None, status.FAIL_RRDICT_UNKNOWN)
+            return None
         if not self.is_valid_datavalue(value):
-            return (None, status.FAIL_RRDICT_OOB)
+            return None
         result = self.graph.query(
             """
             SELECT ?source_node
@@ -307,13 +302,13 @@ class ModelverseState(object):
             }
             """ % (node, json.dumps(value)))
 
-        return ([i[0] for i in result], status.SUCCESS)
+        return [i[0] for i in result]
 
     def delete_node(self, node):
         if node == self.root:
-            return (None, status.FAIL_DN_UNKNOWN)
+            return None
         if not isinstance(node, rdflib.URIRef):
-            return (None, status.FAIL_DN_UNKNOWN)
+            return None
         # Remove its value if it exists
         self.graph.remove((node, None, None))
 
@@ -324,11 +319,11 @@ class ModelverseState(object):
         for e in result:
             self.delete_edge(e[0])
 
-        return (None, status.SUCCESS)
+        return None
 
     def delete_edge(self, edge):
         if not isinstance(edge, rdflib.URIRef):
-            return (None, status.FAIL_DN_UNKNOWN)
+            return None
         # Remove its links
         self.graph.remove((edge, None, None))
 
@@ -338,7 +333,7 @@ class ModelverseState(object):
         for e in result:
             self.delete_edge(e[0])
 
-        return (None, status.SUCCESS)
+        return None
 
     def garbage_collect(self):  
         pass

state/modelverse_state/status.py

@@ -1,89 +0,0 @@
-SUCCESS = 100
-
-#########################################################
-################## Interface Errors #####################
-#########################################################
-
-##### Create Edge #####
-FAIL_CE_SOURCE = 200
-FAIL_CE_TARGET = 201
-
-##### Create Node Value #####
-FAIL_CNV_OOB = 202
-
-##### Create Dictionary Entry #####
-FAIL_CDICT_SOURCE = 203
-FAIL_CDICT_OOB = 204
-FAIL_CDICT_TARGET = 205
-
-##### Read Node Value #####
-FAIL_RV_UNKNOWN = 206
-
-##### Read Outgoing Edges #####
-FAIL_RO_UNKNOWN = 207
-
-##### Read Incoming Edges #####
-FAIL_RI_UNKNOWN = 208
-
-##### Read Edge #####
-FAIL_RE_UNKNOWN = 209
-
-##### Read Dictionary #####
-FAIL_RDICT_UNKNOWN = 210
-FAIL_RDICT_OOB = 211
-
-##### Read Dictionary Node #####
-FAIL_RDICTN_UNKNOWN = 212
-FAIL_RDICTN_OOB = 213
-
-##### Read Dictionary Edge #####
-FAIL_RDICTE_UNKNOWN = 214
-FAIL_RDICTE_OOB = 215
-
-##### Read Dictionary Node Edge #####
-FAIL_RDICTNE_UNKNOWN = 216
-FAIL_RDICTNE_OOB = 217
-
-##### Read Dictionary Reverse #####
-FAIL_RRDICT_UNKNOWN = 218
-FAIL_RRDICT_OOB = 219
-
-##### Delete Node #####
-FAIL_DN_UNKNOWN = 220
-
-##### Delete Edge #####
-FAIL_DE_UNKNOWN = 221
-
-##### TO FORMALIZE #####
-FAIL_RDICTKEYS_UNKNOWN = 222
-
-#########################################################
-################## Execution Errors #####################
-#########################################################
-
-##### Read Value #####
-FAIL_RV_NO_VALUE = 300
-
-##### Read Dictionary #####
-FAIL_RDICT_NOT_FOUND = 301
-FAIL_RDICT_UNCERTAIN = 302
-FAIL_RDICT_AMBIGUOUS = 311
-
-##### Read Dictionary Node #####
-FAIL_RDICTN_NOT_FOUND = 303
-FAIL_RDICTN_UNCERTAIN = 304
-FAIL_RDICTN_AMBIGUOUS = 313
-
-##### Read Dictionary Edge #####
-FAIL_RDICTE_NOT_FOUND = 305
-FAIL_RDICTE_UNCERTAIN = 306
-FAIL_RDICTE_AMBIGUOUS = 312
-
-##### Read Dictionary Node Edge #####
-FAIL_RDICTNE_NOT_FOUND = 307
-FAIL_RDICTNE_UNCERTAIN = 308
-FAIL_RDICTNE_AMBIGUOUS = 314
-
-##### Read Reverse Dictionary #####
-FAIL_RRDICT_NOT_FOUND = 309
-FAIL_RRDICT_UNCERTAIN = 310