replace everywhere: 'is [not] None' -> '(==|!=) None'

framework/conformance.py

@@ -4,6 +4,8 @@ from state.base import State
 from typing import Dict, Tuple, Set, Any, List
 from pprint import pprint
 
+import functools
+
 
 class Conformance:
     def __init__(self, state: State, model: UUID, type_model: UUID):
@@ -21,8 +23,8 @@ class Conformance:
         }
         self.type_model_names = {
             # map type model elements to their names to prevent iterating too much
-            self.bottom.read_outgoing_elements(self.type_model, e)[0]: e
-            for e in self.bottom.read_keys(self.type_model)
+            self.bottom.read_outgoing_elements(self.type_model, e)[0]
+                : e for e in self.bottom.read_keys(self.type_model)
         }
         self.sub_types: Dict[str, Set[str]] = {
             k: set() for k in self.bottom.read_keys(self.type_model)
@@ -192,8 +194,8 @@ class Conformance:
                 self.abstract_types.append(tm_name)
             if lc or uc:
                 mult = (
-                    lc if lc is not None else float("-inf"),
-                    uc if uc is not None else float("inf")
+                    lc if lc != None else float("-inf"),
+                    uc if uc != None else float("inf")
                 )
                 self.multiplicities[tm_name] = mult
             # multiplicities for associations
@@ -201,21 +203,21 @@ class Conformance:
             suc = self.read_attribute(tm_element, "source_upper_cardinality")
             if slc or suc:
                 mult = (
-                    slc if slc is not None else float("-inf"),
-                    suc if suc is not None else float("inf")
+                    slc if slc != None else float("-inf"),
+                    suc if suc != None else float("inf")
                 )
                 self.source_multiplicities[tm_name] = mult
             tlc = self.read_attribute(tm_element, "target_lower_cardinality")
             tuc = self.read_attribute(tm_element, "target_upper_cardinality")
             if tlc or tuc:
                 mult = (
-                    tlc if tlc is not None else float("-inf"),
-                    tuc if tuc is not None else float("inf")
+                    tlc if tlc != None else float("-inf"),
+                    tuc if tuc != None else float("inf")
                 )
                 self.target_multiplicities[tm_name] = mult
             # optional for attribute links
             opt = self.read_attribute(tm_element, "optional")
-            if opt is not None:
+            if opt != None:
                 self.source_multiplicities[tm_name] = (0 if opt else 1, 1)
                 self.target_multiplicities[tm_name] = (0, 1)
 
@@ -245,7 +247,9 @@ class Conformance:
                     sub_tm = UUID(self.bottom.read_value(tm_element))
                     if not Conformance(self.state, sub_m, sub_tm).check_nominal():
                         raise RuntimeError(f"Incorrectly model reference: {m_name}")
-            except ValueError:
+            except ValueError as e:
+                import traceback
+                traceback.format_exc(e)
                 # no or too many morphism links found
                 raise RuntimeError(f"Incorrectly typed element: {m_name}")
         return True
@@ -259,7 +263,7 @@ class Conformance:
             m_element, = self.bottom.read_outgoing_elements(self.model, m_name)
             m_source = self.bottom.read_edge_source(m_element)
             m_target = self.bottom.read_edge_target(m_element)
-            if m_source is None or m_target is None:
+            if m_source == None or m_target == None:
                 # element is not a link
                 continue
             tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
@@ -367,7 +371,7 @@ class Conformance:
             if tm_name != "GlobalConstraint":
                 tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
                 code = self.read_attribute(tm_element, "constraint")
-                if code is not None:
+                if code != None:
                     morphisms = self.bottom.read_incoming_elements(tm_element, "Morphism")
                     morphisms = [m for m in morphisms if m in self.model_names]
                     for m_element in morphisms:
@@ -379,7 +383,7 @@ class Conformance:
             if tm_name == "GlobalConstraint":
                 tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
                 code = self.read_attribute(tm_element, "constraint")
-                if code is not None:
+                if code != None:
                     if not self.evaluate_constraint(code, model=self.model):
                         raise RuntimeError(f"Global constraint {tm_name} not satisfied.")
         return True
@@ -460,14 +464,17 @@ class Conformance:
         ref_element, = self.bottom.read_outgoing_elements(self.scd_model, "ModelRef")
         # matching
         for m_element, m_name in self.model_names.items():
-            is_edge = self.bottom.read_edge_source(m_element) is not None
+            is_edge = self.bottom.read_edge_source(m_element) != None
+            print('element:', m_element, 'name:', m_name, 'is_edge', is_edge)
             for type_name, structure in self.structures.items():
                 tm_element, = self.bottom.read_outgoing_elements(self.type_model, type_name)
-                type_is_edge = self.bottom.read_edge_source(tm_element) is not None
+                type_is_edge = self.bottom.read_edge_source(tm_element) != None
                 if is_edge == type_is_edge:
+                    print('  type_name:', type_name, 'type_is_edge:', type_is_edge, "structure:", structure)
                     mismatch = False
                     matched = 0
                     for name, optional, attr_type in structure:
+                        print('    name:', name, "optional:", optional, "attr_type:", attr_type)
                         try:
                             attr, = self.bottom.read_outgoing_elements(self.model, f"{m_name}.{name}")
                             attr_tm, = self.bottom.read_outgoing_elements(self.type_model, attr_type)
@@ -485,26 +492,34 @@ class Conformance:
                             else:
                                 # eval constraints
                                 code = self.read_attribute(attr_tm, "constraint")
-                                if code is not None:
+                                if code != None:
                                     attr_conforms = self.evaluate_constraint(code, element=attr)
                             if attr_conforms:
                                 matched += 1
-                        except ValueError:
+                                print("     attr_conforms -> matched:", matched)
+                        except ValueError as e:
                             # attr not found or failed parsing UUID
                             if optional:
+                                print("     skipping:", e)
                                 continue
                             else:
+                                # did not match mandatory attribute
+                                print("     breaking:", e)
                                 mismatch = True
                                 break
+
+                    print('  matched:', matched, 'len(structure):', len(structure))
                     # if matched == len(structure):
                     if not mismatch:
+                        print('  add to candidates:', m_name, type_name)
                         self.candidates.setdefault(m_name, set()).add(type_name)
         # filter out candidates for links based on source and target types
         for m_element, m_name in self.model_names.items():
-            is_edge = self.bottom.read_edge_source(m_element) is not None
+            is_edge = self.bottom.read_edge_source(m_element) != None
             if is_edge and m_name in self.candidates:
                 m_source = self.bottom.read_edge_source(m_element)
                 m_target = self.bottom.read_edge_target(m_element)
+                print(self.candidates)
                 source_candidates = self.candidates[self.model_names[m_source]]
                 target_candidates = self.candidates[self.model_names[m_target]]
                 remove = set()

framework/interactive_prompt.py

@@ -35,11 +35,11 @@ def main():
     man = Manager(state)
 
     while True:
-        if man.current_model is not None and man.current_context is None:
+        if man.current_model != None and man.current_context == None:
             # we have selected a model, so we display typing questions
             answer = prompt(questions.MODEL_SELECTED)
             ctx = man
-        elif man.current_model is not None and man.current_context is not None:
+        elif man.current_model != None and man.current_context != None:
             # we have selected both a model and a context, so we display available services
             qs = generate_context_question(type(man.current_context), man.get_services())
             answer = prompt(qs)
@@ -79,7 +79,7 @@ def main():
             args = {k: types[k](v) if len(v) > 0 else None for k, v in args.items()}
             try:
                 output = method(**args)
-                if output is not None:
+                if output != None:
                     try:
                         if isinstance(output, str):
                             raise TypeError

framework/manager.py

@@ -1,5 +1,6 @@
 from state.base import State
 from bootstrap.scd import bootstrap_scd
+from bootstrap.pn import bootstrap_pn
 from services import implemented as services
 from framework.conformance import Conformance
 from uuid import UUID
@@ -11,6 +12,7 @@ class Manager:
         self.current_context = None
         self.state = state
         bootstrap_scd(state)
+        # bootstrap_pn(state, "PN")
         scd_node = self.state.read_dict(self.state.read_root(), "SCD")
         for key_node in self.state.read_dict_keys(self.state.read_root()):
             model_node = self.state.read_dict_node(self.state.read_root(), key_node)
@@ -39,7 +41,7 @@ class Manager:
         """
         root = self.state.read_root()
         type_model_node = self.state.read_dict(root, type_model_name)
-        if type_model_node is None:
+        if type_model_node == None:
             raise RuntimeError(f"No type model with name {type_model_name} found.")
         else:
             # check if model is a linguistic type model
@@ -71,7 +73,7 @@ class Manager:
         """
         root = self.state.read_root()
         model_node = self.state.read_dict(root, name)
-        if model_node is None:
+        if model_node == None:
             raise RuntimeError(f"No model with name {name} found.")
         model_root = UUID(self.state.read_value(model_node))
         self.current_model = (name, model_root)
@@ -94,7 +96,7 @@ class Manager:
             Names of the model's types
         """
         root = self.state.read_root()
-        if self.current_model is None:
+        if self.current_model == None:
             raise RuntimeError(f"No model currently selected.")
         name, model = self.current_model
         model_id = self.state.read_dict(root, name)
@@ -142,9 +144,9 @@ class Manager:
         Returns:
             Functions exposed by the current context's implementation
         """
-        if self.current_model is None:
+        if self.current_model == None:
             raise RuntimeError(f"No model currently selected.")
-        if self.current_context is None:
+        if self.current_context == None:
             raise RuntimeError(f"No context currently selected.")
         yield from [
             getattr(self.current_context, func)
@@ -171,14 +173,16 @@ class Manager:
         """
         root = self.state.read_root()
         type_model_node = self.state.read_dict(root, type_model_name)
-        if type_model_node is None:
+        if type_model_node == None:
             raise RuntimeError(f"No type model with name {type_model_name} found.")
         model_node = self.state.read_dict(root, model_name)
-        if model_node is None:
+        if model_node == None:
             raise RuntimeError(f"No model with name {model_node} found.")
         types = self.state.read_outgoing(model_node)
         types = [self.state.read_edge(e)[1] for e in types]
-        if type_model_node not in types:
+        # if type_model_node not in types:
+        if True:
+            print("checking structural conformance")
             conf = Conformance(self.state,
                                UUID(self.state.read_value(model_node)),
                                UUID(self.state.read_value(type_model_node))).check_structural(log=True)
@@ -186,6 +190,7 @@ class Manager:
                 self.state.create_edge(model_node, type_model_node)
             return conf
         else:
+            print("checking nominal conformance")
             return Conformance(self.state,
                                UUID(self.state.read_value(model_node)),
                                UUID(self.state.read_value(type_model_node))).check_nominal(log=True)
@@ -206,6 +211,9 @@ class Manager:
         with open("state.p", "rb") as file:
             self.state = pickle.load(file)
 
+    def to_graphviz(self):
+        self.state.dump("state.dot")
+
 
 if __name__ == '__main__':
     from state.devstate import DevState

framework/prompt_questions.py

@@ -28,6 +28,7 @@ MODEL_MGMT = [
             Separator(),
             'load state',
             'dump state',
+            'to graphviz',
             Separator(),
             'exit'
         ],

services/bottom/V0.py

@@ -21,7 +21,7 @@ class Bottom:
         Returns:
             UUID of the node.
         """
-        if value is None:
+        if value == None:
             return self.state.create_node()
         else:
             return self.state.create_nodevalue(value)
@@ -38,7 +38,7 @@ class Bottom:
         Returns:
             UUID of the edge.
         """
-        if label is None:
+        if label == None:
             return self.state.create_edge(source, target)
         else:
             return self.state.create_dict(source, label, target)
@@ -66,7 +66,7 @@ class Bottom:
             UUID of source element of the edge
         """
         result = self.state.read_edge(edge)
-        return result[0] if result is not None else result
+        return result[0] if result != None else result
 
     def read_edge_target(self, edge: UUID) -> UUID:
         """
@@ -79,7 +79,7 @@ class Bottom:
             UUID of target element of the edge
         """
         result = self.state.read_edge(edge)
-        return result[1] if result is not None else result
+        return result[1] if result != None else result
 
     def read_incoming_edges(self, target: UUID, label=None) -> List[UUID]:
         """
@@ -102,9 +102,9 @@ class Bottom:
                 return None
 
         edges = self.state.read_incoming(target)
-        if edges is None:
+        if edges == None:
             return []
-        if label is not None:
+        if label != None:
             edges = [e for e in edges if read_label(e) == label]
         return edges
 
@@ -129,9 +129,9 @@ class Bottom:
                 return None
 
         edges = self.state.read_outgoing(source)
-        if edges is None:
+        if edges == None:
             return []
-        if label is not None:
+        if label != None:
             edges = [e for e in edges if read_label(e) == label]
         return edges
 
@@ -148,7 +148,7 @@ class Bottom:
             List of UUIDs of elements connected via incoming edges
         """
         edges = self.read_incoming_edges(target, label)
-        if edges is None or len(edges) == 0:
+        if edges == None or len(edges) == 0:
             return []
         else:
             return [self.read_edge_source(e) for e in edges]
@@ -166,7 +166,7 @@ class Bottom:
             List of UUIDs of elements connected via outgoing edges
         """
         edges = self.read_outgoing_edges(source, label)
-        if edges is None or len(edges) == 0:
+        if edges == None or len(edges) == 0:
             return []
         else:
             return [self.read_edge_target(e) for e in edges]
@@ -196,7 +196,7 @@ class Bottom:
             Nothing
         """
         src, tgt = self.state.read_edge(element)
-        if src is None and tgt is None:
+        if src == None and tgt == None:
             # node
             self.state.delete_node(element)
         else:

services/bottom/V1.py

@@ -25,7 +25,7 @@ class Bottom:
         Returns:
             Nothing
         """
-        if value is None:
+        if value == None:
             n = self.bottom.create_node()
         else:
             n = self.bottom.create_node(value)

services/point/cartesian.py

@@ -28,7 +28,7 @@ class PointCartesian:
         Returns:
             Nothing.
         """
-        if self.point is None:
+        if self.point == None:
             self.point = (x, y)
         else:
             raise RuntimeError("A PointCartesian model can contain at most 1 point.")
@@ -40,7 +40,7 @@ class PointCartesian:
         Returns:
             Textual representation of the point data.
         """
-        if self.point is None:
+        if self.point == None:
             raise RuntimeError("No point found in model.")
         else:
             return f"(X = {self.point[0]}, Y = {self.point[1]})"
@@ -65,7 +65,7 @@ class PointCartesian:
         Returns:
             Nothing.
         """
-        if self.point is not None:
+        if self.point != None:
             self.point = (self.point[0] + delta_x, self.point[1] + delta_y)
         else:
             raise RuntimeError("No point found in model.")

services/point/polar.py

@@ -30,7 +30,7 @@ class PointPolar:
         Returns:
             Nothing.
         """
-        if self.point is None:
+        if self.point == None:
             self.point = (r, theta)
         else:
             raise RuntimeError("A PointPolar model can contain at most 1 point.")
@@ -42,7 +42,7 @@ class PointPolar:
         Returns:
             Textual representation of the point data.
         """
-        if self.point is None:
+        if self.point == None:
             raise RuntimeError("No point found in model.")
         else:
             return f"(r = {self.point[0]}, \u03B8 = {self.point[1]})"
@@ -67,7 +67,7 @@ class PointPolar:
         Returns:
             Nothing.
         """
-        if self.point is not None:
+        if self.point != None:
             self.point = (self.point[0] + delta_r, self.point[1] + delta_theta)
         else:
             raise RuntimeError("No point found in model.")

services/scd.py

@@ -55,7 +55,7 @@ class SCD:
         self.bottom.create_edge(self.model, class_node, name)  # attach to model
         scd_node, = self.bottom.read_outgoing_elements(self.scd_model, "Class")  # retrieve type
         self.bottom.create_edge(class_node, scd_node, "Morphism")  # create morphism link
-        if abstract is not None:
+        if abstract != None:
             # operations similar to set_cardinality function defined above
             abstract_model = self.bottom.create_node()
             Boolean(abstract_model, self.bottom.state).create(abstract)
@@ -67,9 +67,9 @@ class SCD:
             scd_link, = self.bottom.read_outgoing_elements(self.scd_model, "Class_abstract")
             self.bottom.create_edge(abstract_node, scd_node, "Morphism")
             self.bottom.create_edge(abstract_link, scd_link, "Morphism")
-        if min_c is not None:
+        if min_c != None:
             set_cardinality("lower", min_c)
-        if max_c is not None:
+        if max_c != None:
             set_cardinality("upper", max_c)
 
     def create_association(self, name: str, source: str, target: str,
@@ -118,13 +118,13 @@ class SCD:
         self.bottom.create_edge(self.model, assoc_edge, name)  # attach to model
         scd_node, = self.bottom.read_outgoing_elements(self.scd_model, "Association")  # retrieve type
         self.bottom.create_edge(assoc_edge, scd_node, "Morphism")  # create morphism link
-        if src_min_c is not None:
+        if src_min_c != None:
             set_cardinality("source_lower", src_min_c)
-        if src_max_c is not None:
+        if src_max_c != None:
             set_cardinality("source_upper", src_max_c)
-        if tgt_min_c is not None:
+        if tgt_min_c != None:
             set_cardinality("target_lower", tgt_min_c)
-        if tgt_max_c is not None:
+        if tgt_max_c != None:
             set_cardinality("target_upper", tgt_max_c)
 
     def create_global_constraint(self, name: str):

state/devstate.py

@@ -42,7 +42,7 @@ class DevState(PyState):
                 f.write("\"a_%s\" -> \"a_%s\";\n" % (i.int, e[1].int))
             f.write("}")
 
-        if png_path is not None:
+        if png_path != None:
             # generate png from dot-file
             bashCommand = f"dot -Tpng {path} -o {png_path}"
             import subprocess

state/neo4jstate.py

@@ -48,7 +48,7 @@ class Neo4jState(State):
             return result.single()[0]
 
         node = self._run_and_return(query, nid=str(self.new_id()))
-        return UUID(node) if node is not None else None
+        return UUID(node) if node != None else None
 
     def create_edge(self, source: Element, target: Element) -> Optional[Edge]:
         def query(tx, eid, sid, tid):
@@ -66,7 +66,7 @@ class Neo4jState(State):
                 return None
 
         edge = self._run_and_return(query, eid=str(self.new_id()), sid=str(source), tid=str(target))
-        return UUID(edge) if edge is not None else None
+        return UUID(edge) if edge != None else None
 
     def create_nodevalue(self, value: Any) -> Optional[Node]:
         def query(tx, nid, val):
@@ -80,7 +80,7 @@ class Neo4jState(State):
             return None
 
         node = self._run_and_return(query, nid=str(self.new_id()), val=repr(value))
-        return UUID(node) if node is not None else None
+        return UUID(node) if node != None else None
 
     def create_dict(self, source: Element, value: Any, target: Element) -> Optional[Tuple[Edge, Edge, Node]]:
         if not self.is_valid_datavalue(value):
@@ -88,7 +88,7 @@ class Neo4jState(State):
 
         edge_node = self.create_edge(source, target)
         val_node = self.create_nodevalue(value)
-        if edge_node is not None and val_node is not None:
+        if edge_node != None and val_node != None:
             self.create_edge(edge_node, val_node)
 
     def read_root(self) -> Node:
@@ -107,7 +107,7 @@ class Neo4jState(State):
                 return None
 
         value = self._run_and_return(query, nid=str(node))
-        return literal_eval(value) if value is not None else None
+        return literal_eval(value) if value != None else None
 
     def read_outgoing(self, elem: Element) -> Optional[List[Edge]]:
         def query(tx, eid):
@@ -117,10 +117,10 @@ class Neo4jState(State):
                             eid=eid)
             return result.value()
 
-        source_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
+        source_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
         if source_exists:
             result = self._run_and_return(query, eid=str(elem))
-            return [UUID(x) for x in result] if result is not None else None
+            return [UUID(x) for x in result] if result != None else None
 
     def read_incoming(self, elem: Element) -> Optional[List[Edge]]:
         def query(tx, eid):
@@ -130,10 +130,10 @@ class Neo4jState(State):
                             eid=eid)
             return result.value()
 
-        target_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
+        target_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
         if target_exists:
             result = self._run_and_return(query, eid=str(elem))
-            return [UUID(x) for x in result] if result is not None else None
+            return [UUID(x) for x in result] if result != None else None
 
     def read_edge(self, edge: Edge) -> Tuple[Optional[Node], Optional[Node]]:
         def query(tx, eid):
@@ -143,7 +143,7 @@ class Neo4jState(State):
                             eid=eid)
             return result.single()
 
-        edge_exists = self._run_and_return(self._existence_check, eid=str(edge), label="Edge") is not None
+        edge_exists = self._run_and_return(self._existence_check, eid=str(edge), label="Edge") != None
         if edge_exists:
             try:
                 src, tgt = self._run_and_return(query, eid=str(edge))
@@ -167,12 +167,12 @@ class Neo4jState(State):
                 # No edge found with given label
                 return None
 
-        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
+        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
         if elem_exists:
             if isinstance(value, UUID):
                 return None
             result = self._run_and_return(query, eid=str(elem), label_value=repr(value))
-            return UUID(result) if result is not None else None
+            return UUID(result) if result != None else None
 
     def read_dict_keys(self, elem: Element) -> Optional[List[Any]]:
         def query(tx, eid):
@@ -187,10 +187,10 @@ class Neo4jState(State):
                 # No edge found with given label
                 return None
 
-        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
+        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
         if elem_exists:
             result = self._run_and_return(query, eid=str(elem))
-            return [UUID(x) for x in result if x is not None]
+            return [UUID(x) for x in result if x != None]
 
     def read_dict_edge(self, elem: Element, value: Any) -> Optional[Edge]:
         def query(tx, eid, label_value):
@@ -206,10 +206,10 @@ class Neo4jState(State):
                 # No edge found with given label
                 return None
 
-        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
+        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
         if elem_exists:
             result = self._run_and_return(query, eid=str(elem), label_value=repr(value))
-            return UUID(result) if result is not None else None
+            return UUID(result) if result != None else None
 
     def read_dict_node(self, elem: Element, value_node: Node) -> Optional[Element]:
         def query(tx, eid, label_id):
@@ -225,10 +225,10 @@ class Neo4jState(State):
                 # No edge found with given label
                 return None
 
-        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
+        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
         if elem_exists:
             result = self._run_and_return(query, eid=str(elem), label_id=str(value_node))
-            return UUID(result) if result is not None else None
+            return UUID(result) if result != None else None
 
     def read_dict_node_edge(self, elem: Element, value_node: Node) -> Optional[Edge]:
         def query(tx, eid, label_id):
@@ -244,10 +244,10 @@ class Neo4jState(State):
                 # No edge found with given label
                 return None
 
-        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
+        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
         if elem_exists:
             result = self._run_and_return(query, eid=str(elem), label_id=str(value_node))
-            return UUID(result) if result is not None else None
+            return UUID(result) if result != None else None
 
     def read_reverse_dict(self, elem: Element, value: Any) -> Optional[List[Element]]:
         def query(tx, eid, label_value):
@@ -263,10 +263,10 @@ class Neo4jState(State):
                 # No edge found with given label
                 return None
 
-        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
+        elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
         if elem_exists:
             result = self._run_and_return(query, eid=str(elem), label_value=repr(value))
-            return [UUID(x) for x in result if x is not None]
+            return [UUID(x) for x in result if x != None]
 
     def delete_node(self, node: Node) -> None:
         def query(tx, nid):
@@ -279,7 +279,7 @@ class Neo4jState(State):
             return result.value()
 
         to_be_deleted = self._run_and_return(query, nid=str(node))
-        to_be_deleted = [UUID(x) for x in to_be_deleted if x is not None]
+        to_be_deleted = [UUID(x) for x in to_be_deleted if x != None]
         for edge in to_be_deleted:
             self.delete_edge(edge)
 
@@ -296,6 +296,6 @@ class Neo4jState(State):
             return result.value()
 
         to_be_deleted = self._run_and_return(query, eid=str(edge))
-        to_be_deleted = [UUID(x) for x in to_be_deleted if x is not None]
+        to_be_deleted = [UUID(x) for x in to_be_deleted if x != None]
         for edge in to_be_deleted:
             self.delete_edge(edge)

state/pystate.py

@@ -67,7 +67,7 @@ class PyState(State):
         else:
             n = self.create_nodevalue(value)
             e = self.create_edge(source, target)
-            assert n is not None and e is not None
+            assert n != None and e != None
             e2 = self.create_edge(e, n)
             self.cache.setdefault(source, {})[value] = e
             self.cache_node.setdefault(source, {})[n] = e
@@ -107,7 +107,7 @@ class PyState(State):
 
     def read_dict(self, elem: Element, value: Any) -> Optional[Element]:
         e = self.read_dict_edge(elem, value)
-        if e is None:
+        if e == None:
             return None
         else:
             return self.edges[e][1]
@@ -142,7 +142,7 @@ class PyState(State):
 
     def read_dict_node(self, elem: Element, value_node: Node) -> Optional[Element]:
         e = self.read_dict_node_edge(elem, value_node)
-        if e is None:
+        if e == None:
             return None
         else:
             self.cache_node.setdefault(elem, {})[value_node] = e

state/test/test_create_dict.py

@@ -5,11 +5,11 @@ import pytest
 def test_create_dict_simple(state):
     id1 = state.create_node()
     id2 = state.create_node()
-    assert id1 is not None
-    assert id2 is not None
+    assert id1 != None
+    assert id2 != None
 
     n = state.create_dict(id1, "abc", id2)
-    assert n is None
+    assert n == None
 
     v = state.read_dict(id1, "abc")
     assert v == id2
@@ -19,23 +19,23 @@ def test_create_dict_simple(state):
 def test_create_dict_no_source(state):
     id1 = 100000
     id2 = state.create_node()
-    assert id2 is not None
+    assert id2 != None
 
     n = state.create_dict(id1, "abc", id2)
-    assert n is None
+    assert n == None
 
     v = state.read_dict(id1, "abc")
-    assert v is None
+    assert v == None
 
 
 @pytest.mark.usefixtures("state")
 def test_create_dict_no_target(state):
     id2 = 100000
     id1 = state.create_node()
-    assert id1 is not None
+    assert id1 != None
 
     n = state.create_dict(id1, "abc", id2)
-    assert n is None
+    assert n == None
 
     v = state.read_dict(id1, "abc")
-    assert v is None
+    assert v == None

state/test/test_create_edge.py

@@ -5,20 +5,20 @@ import pytest
 def test_create_edge_invalid_source(state):
     a = -1
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     e = state.create_edge(a, b)
-    assert e is None
+    assert e == None
 
 
 @pytest.mark.usefixtures("state")
 def test_create_edge_invalid_target(state):
     b = -1
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     e = state.create_edge(a, b)
-    assert e is None
+    assert e == None
 
 
 @pytest.mark.usefixtures("state")
@@ -26,32 +26,32 @@ def test_create_edge_invalid_both(state):
     a = -1
     b = -1
     e = state.create_edge(a, b)
-    assert e is None
+    assert e == None
 
 
 @pytest.mark.usefixtures("state")
 def test_create_edge_node_to_node(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     edge = state.create_edge(a, b)
-    assert edge is not None
+    assert edge != None
 
 
 @pytest.mark.usefixtures("state")
 def test_create_edge_multiple(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     edge1 = state.create_edge(a, b)
-    assert edge1 is not None
+    assert edge1 != None
 
     edge2 = state.create_edge(a, b)
-    assert edge2 is not None
+    assert edge2 != None
 
     assert edge1 != edge2
 
@@ -61,12 +61,12 @@ def test_create_edge_many(state):
     v = set()
     for i in range(1000):
         a = state.create_node()
-        assert a is not None
+        assert a != None
         b = state.create_node()
-        assert b is not None
+        assert b != None
 
         edge = state.create_edge(a, b)
-        assert edge is not None
+        assert edge != None
 
         v.add(edge)
     assert len(v) == 1000
@@ -75,15 +75,15 @@ def test_create_edge_many(state):
 @pytest.mark.usefixtures("state")
 def test_create_edge_edge_to_node(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     edge1 = state.create_edge(a, b)
-    assert edge1 is not None
+    assert edge1 != None
 
     edge2 = state.create_edge(edge1, b)
-    assert edge2 is not None
+    assert edge2 != None
 
     assert edge1 != edge2
 
@@ -91,15 +91,15 @@ def test_create_edge_edge_to_node(state):
 @pytest.mark.usefixtures("state")
 def test_create_edge_node_to_edge(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     edge1 = state.create_edge(a, b)
-    assert edge1 is not None
+    assert edge1 != None
 
     edge2 = state.create_edge(a, edge1)
-    assert edge2 is not None
+    assert edge2 != None
 
     assert edge1 != edge2
 
@@ -107,38 +107,38 @@ def test_create_edge_node_to_edge(state):
 @pytest.mark.usefixtures("state")
 def test_create_edge_edge_to_edge(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     edge1 = state.create_edge(a, b)
-    assert edge1 is not None
+    assert edge1 != None
 
     edge2 = state.create_edge(a, b)
-    assert edge2 is not None
+    assert edge2 != None
 
     assert edge1 != edge2
 
     edge3 = state.create_edge(edge1, edge2)
-    assert edge3 is not None
+    assert edge3 != None
 
 
 @pytest.mark.usefixtures("state")
 def test_create_edge_loop_node(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     edge = state.create_edge(a, a)
-    assert edge is not None
+    assert edge != None
 
 
 @pytest.mark.usefixtures("state")
 def test_create_edge_loop_edge(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     edge1 = state.create_edge(a, a)
-    assert edge1 is not None
+    assert edge1 != None
 
     edge2 = state.create_edge(edge1, edge1)
-    assert edge2 is not None
+    assert edge2 != None

state/test/test_create_node.py

@@ -4,9 +4,9 @@ import pytest
 @pytest.mark.usefixtures("state")
 def test_create_node_different_id_simple(state):
     id1 = state.create_node()
-    assert id1 is not None
+    assert id1 != None
     id2 = state.create_node()
-    assert id2 is not None
+    assert id2 != None
 
     assert id1 != id2
 
@@ -16,7 +16,7 @@ def test_create_node_different_id_long(state):
     results = set()
     for i in range(1000):
         v = state.create_node()
-        assert v is not None
+        assert v != None
         results.add(v)
 
     assert len(results) == 1000

state/test/test_create_nodevalue.py

@@ -6,15 +6,15 @@ def test_create_nodevalue_different_id_simple(state):
     id1 = state.create_nodevalue(1)
     id2 = state.create_nodevalue(1)
 
-    assert id1 is not None
-    assert id2 is not None
+    assert id1 != None
+    assert id2 != None
     assert id1 != id2
 
 
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_read(state):
     id1 = state.create_nodevalue(1)
-    assert id1 is not None
+    assert id1 != None
     val = state.read_value(id1)
     assert val == 1
 
@@ -26,7 +26,7 @@ def test_create_nodevalue_integer_ib_zero(state):
     size = 0
     for i in range(-10, 10):
         id1 = state.create_nodevalue(i)
-        assert id1 is not None
+        assert id1 != None
         size += 1
         v.add(id1)
     assert len(v) == size
@@ -37,8 +37,8 @@ def test_create_nodevalue_boolean(state):
     id1 = state.create_nodevalue(True)
     id2 = state.create_nodevalue(False)
 
-    assert id1 is not None
-    assert id2 is not None
+    assert id1 != None
+    assert id2 != None
     assert id1 != id2
 
 
@@ -47,15 +47,15 @@ def test_create_nodevalue_boolean_same(state):
     id1 = state.create_nodevalue(True)
     id2 = state.create_nodevalue(True)
 
-    assert id1 is not None
-    assert id2 is not None
+    assert id1 != None
+    assert id2 != None
     assert id1 != id2
 
 
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_float_keeps_type(state):
     id1 = state.create_nodevalue(0.0)
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert type(v) == float
@@ -65,7 +65,7 @@ def test_create_nodevalue_float_keeps_type(state):
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_string_empty(state):
     id1 = state.create_nodevalue("")
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert type(v) == str
@@ -75,7 +75,7 @@ def test_create_nodevalue_string_empty(state):
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_string_normal(state):
     id1 = state.create_nodevalue("ABC")
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert type(v) == str
@@ -85,28 +85,28 @@ def test_create_nodevalue_string_normal(state):
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_string_not_parsed(state):
     id1 = state.create_nodevalue("1")
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert type(v) == str
     assert v == "1"
 
     id1 = state.create_nodevalue("1.0")
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert type(v) == str
     assert v == "1.0"
 
     id1 = state.create_nodevalue("-1.0")
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert type(v) == str
     assert v == "-1.0"
 
     id1 = state.create_nodevalue("True")
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert type(v) == str
@@ -119,13 +119,13 @@ def test_create_nodevalue_junk(state):
         pass
 
     n = state.create_nodevalue(Unknown())
-    assert n is None
+    assert n == None
 
 
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_type_type(state):
     id1 = state.create_nodevalue(("Type",))
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert v == ("Type",)
@@ -134,7 +134,7 @@ def test_create_nodevalue_type_type(state):
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_integer_type(state):
     id1 = state.create_nodevalue(("Integer",))
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert v == ("Integer",)
@@ -143,7 +143,7 @@ def test_create_nodevalue_integer_type(state):
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_float_type(state):
     id1 = state.create_nodevalue(("Float",))
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert v == ("Float",)
@@ -152,7 +152,7 @@ def test_create_nodevalue_float_type(state):
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_boolean_type(state):
     id1 = state.create_nodevalue(("Boolean",))
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert v == ("Boolean",)
@@ -161,7 +161,7 @@ def test_create_nodevalue_boolean_type(state):
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_string_type(state):
     id1 = state.create_nodevalue(("String",))
-    assert id1 is not None
+    assert id1 != None
 
     v = state.read_value(id1)
     assert v == ("String",)
@@ -170,4 +170,4 @@ def test_create_nodevalue_string_type(state):
 @pytest.mark.usefixtures("state")
 def test_create_nodevalue_invalid_type(state):
     id1 = state.create_nodevalue(("Class",))
-    assert id1 is None
+    assert id1 == None

state/test/test_delete_edge.py

@@ -4,25 +4,25 @@ import pytest
 @pytest.mark.usefixtures("state")
 def test_delete_edge_no_exists(state):
     e = state.delete_edge(1)
-    assert e is None
+    assert e == None
 
 
 @pytest.mark.usefixtures("state")
 def test_delete_edge_node(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     e = state.delete_edge(a)
-    assert e is None
+    assert e == None
 
 
 @pytest.mark.usefixtures("state")
 def test_delete_edge_nodevalue(state):
     a = state.create_nodevalue(1)
-    assert a is not None
+    assert a != None
 
     e = state.delete_edge(a)
-    assert e is None
+    assert e == None
 
 
 @pytest.mark.usefixtures("state")
@@ -30,27 +30,27 @@ def test_delete_edge_normal(state):
     a = state.create_nodevalue(1)
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     n = state.delete_edge(c)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -60,35 +60,35 @@ def test_delete_edge_remove_recursive(state):
     b = state.create_node()
     c = state.create_edge(a, b)
     d = state.create_edge(c, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
 
     n = state.delete_edge(c)
-    assert n is None
+    assert n == None
 
     l = state.read_value(a)
     assert l == 1
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(c)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     s, t = state.read_edge(d)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -102,60 +102,60 @@ def test_delete_edge_remove_edge_recursive_deep(state):
     f = state.create_node()
     g = state.create_edge(f, e)
     h = state.create_edge(b, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
-    assert f is not None
-    assert g is not None
-    assert h is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
+    assert f != None
+    assert g != None
+    assert h != None
 
     n = state.delete_edge(d)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     s, t = state.read_edge(d)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     s, t = state.read_edge(e)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     s, t = state.read_edge(g)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(h)
@@ -173,40 +173,40 @@ def test_delete_edge_remove_edge_recursive_steps(state):
     f = state.create_node()
     g = state.create_edge(f, e)
     h = state.create_edge(b, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
-    assert f is not None
-    assert g is not None
-    assert h is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
+    assert f != None
+    assert g != None
+    assert h != None
 
     n = state.delete_edge(g)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([d])
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([d])
 
     l = state.read_outgoing(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h, e])
 
     s, t = state.read_edge(d)
@@ -214,11 +214,11 @@ def test_delete_edge_remove_edge_recursive_steps(state):
     assert t == b
 
     l = state.read_outgoing(d)
-    assert l is not None
+    assert l != None
     assert set(l) == set([e])
 
     l = state.read_incoming(d)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(e)
@@ -226,29 +226,29 @@ def test_delete_edge_remove_edge_recursive_steps(state):
     assert t == c
 
     l = state.read_outgoing(e)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(e)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(g)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(g)
-    assert l is None
+    assert l == None
 
     l = state.read_incoming(g)
-    assert l is None
+    assert l == None
 
     l = state.read_outgoing(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(h)
@@ -256,30 +256,30 @@ def test_delete_edge_remove_edge_recursive_steps(state):
     assert t == c
 
     n = state.delete_edge(e)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([d])
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([d])
 
     l = state.read_outgoing(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     s, t = state.read_edge(d)
@@ -287,39 +287,39 @@ def test_delete_edge_remove_edge_recursive_steps(state):
     assert t == b
 
     l = state.read_outgoing(d)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(d)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(e)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(e)
-    assert l is None
+    assert l == None
 
     l = state.read_incoming(e)
-    assert l is None
+    assert l == None
 
     s, t = state.read_edge(g)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(g)
-    assert l is None
+    assert l == None
 
     l = state.read_incoming(g)
-    assert l is None
+    assert l == None
 
     l = state.read_outgoing(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(h)
@@ -327,55 +327,55 @@ def test_delete_edge_remove_edge_recursive_steps(state):
     assert t == c
 
     n = state.delete_edge(d)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     s, t = state.read_edge(d)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(d)
-    assert l is None
+    assert l == None
 
     l = state.read_incoming(d)
-    assert l is None
+    assert l == None
 
     s, t = state.read_edge(e)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(e)
-    assert l is None
+    assert l == None
 
     l = state.read_incoming(e)
-    assert l is None
+    assert l == None
 
     s, t = state.read_edge(g)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(g)
     assert l == None
@@ -384,11 +384,11 @@ def test_delete_edge_remove_edge_recursive_steps(state):
     assert l == None
 
     l = state.read_outgoing(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(h)

state/test/test_delete_node.py

@@ -4,31 +4,31 @@ import pytest
 @pytest.mark.usefixtures("state")
 def test_delete_node_no_exists(state):
     n = state.delete_node(-1)
-    assert n is None
+    assert n == None
 
 
 @pytest.mark.usefixtures("state")
 def test_delete_node_no_value(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     n = state.delete_node(a)
-    assert n is None
+    assert n == None
 
 
 @pytest.mark.usefixtures("state")
 def test_delete_node_value(state):
     a = state.create_nodevalue(1)
-    assert a is not None
+    assert a != None
 
     d = state.read_value(a)
     assert d == 1
 
     n = state.delete_node(a)
-    assert n is None
+    assert n == None
 
     d = state.read_value(a)
-    assert d is None
+    assert d == None
 
 
 @pytest.mark.usefixtures("state")
@@ -36,12 +36,12 @@ def test_delete_node_edge(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     n = state.delete_node(c)
-    assert n is None
+    assert n == None
 
 
 @pytest.mark.usefixtures("state")
@@ -49,22 +49,22 @@ def test_delete_node_remove_edge_outgoing(state):
     a = state.create_nodevalue(1)
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     n = state.delete_node(a)
-    assert n is None
+    assert n == None
 
     d = state.read_value(a)
-    assert d is None
+    assert d == None
 
     s, t = state.read_edge(c)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     d = state.read_outgoing(b)
-    assert d is not None
+    assert d != None
     assert set(d) == set([])
 
 
@@ -73,22 +73,22 @@ def test_delete_node_remove_edge_incoming(state):
     a = state.create_nodevalue(1)
     b = state.create_node()
     c = state.create_edge(b, a)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     n = state.delete_node(a)
-    assert n is None
+    assert n == None
 
     d = state.read_value(a)
-    assert d is None
+    assert d == None
 
     s, t = state.read_edge(c)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     d = state.read_outgoing(b)
-    assert d is not None
+    assert d != None
     assert set(d) == set([])
 
 
@@ -99,32 +99,32 @@ def test_delete_node_remove_edge_both(state):
     c = state.create_edge(a, b)
     e = state.create_node()
     f = state.create_edge(e, a)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert e is not None
-    assert f is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert e != None
+    assert f != None
 
     n = state.delete_node(a)
-    assert n is None
+    assert n == None
 
     d = state.read_value(a)
-    assert d is None
+    assert d == None
 
     s, t = state.read_edge(c)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     d = state.read_incoming(b)
-    assert d is not None
+    assert d != None
     assert set(d) == set([])
 
     s, t = state.read_edge(f)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     d = state.read_outgoing(e)
-    assert d is not None
+    assert d != None
     assert set(d) == set([])
 
 
@@ -134,27 +134,27 @@ def test_delete_node_remove_edge_recursive(state):
     b = state.create_node()
     c = state.create_edge(a, b)
     d = state.create_edge(c, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
 
     n = state.delete_node(a)
-    assert n is None
+    assert n == None
 
     d = state.read_value(a)
-    assert d is None
+    assert d == None
 
     s, t = state.read_edge(c)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     s, t = state.read_edge(d)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     d = state.read_outgoing(b)
-    assert d is not None
+    assert d != None
     assert set(d) == set([])
 
 
@@ -168,58 +168,58 @@ def test_delete_node_remove_edge_recursive_deep(state):
     f = state.create_node()
     g = state.create_edge(f, e)
     h = state.create_edge(b, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
-    assert f is not None
-    assert g is not None
-    assert h is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
+    assert f != None
+    assert g != None
+    assert h != None
 
     n = state.delete_node(a)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(a)
-    assert l is None
+    assert l == None
 
     l = state.read_incoming(a)
-    assert l is None
+    assert l == None
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([h])
 
     s, t = state.read_edge(d)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     s, t = state.read_edge(e)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     s, t = state.read_edge(g)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
     l = state.read_outgoing(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     s, t = state.read_edge(h)

state/test/test_read_dict.py

@@ -3,25 +3,25 @@ import pytest
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_no_exists(state):
-    assert state.read_dict(-1, "abc") is None
+    assert state.read_dict(-1, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_not_found_node(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict(a, "abc") is None
+    assert state.read_dict(a, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_not_found_nodevalue(state):
     a = state.create_nodevalue(1)
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict(a, "abc") is None
+    assert state.read_dict(a, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
@@ -29,21 +29,21 @@ def test_read_dict_not_found_edge(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict(c, "abc") is None
+    assert state.read_dict(c, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_no_primitive(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict(a, a) is None
+    assert state.read_dict(a, a) == None
 
 
 @pytest.mark.usefixtures("state")
@@ -53,11 +53,11 @@ def test_read_dict_node_simple(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_dict(a, "f")
     assert l == b
@@ -70,20 +70,20 @@ def test_read_dict_node_multi(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     g = state.create_node()
     h = state.create_nodevalue("k")
     i = state.create_edge(a, g)
     j = state.create_edge(i, h)
-    assert g is not None
-    assert h is not None
-    assert i is not None
-    assert j is not None
+    assert g != None
+    assert h != None
+    assert i != None
+    assert j != None
 
     l = state.read_dict(a, "f")
     assert l == b
@@ -91,4 +91,4 @@ def test_read_dict_node_multi(state):
     l = state.read_dict(a, "k")
     assert l == g
 
-    assert state.read_dict(a, "l") is None
+    assert state.read_dict(a, "l") == None

state/test/test_read_dict_edge.py

@@ -3,25 +3,25 @@ import pytest
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_edge_no_exists(state):
-    assert state.read_dict_edge(-1, "abc") is None
+    assert state.read_dict_edge(-1, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_edge_not_found_node(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict_edge(a, "abc") is None
+    assert state.read_dict_edge(a, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_edge_not_found_nodevalue(state):
     a = state.create_nodevalue(1)
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict_edge(a, "abc") is None
+    assert state.read_dict_edge(a, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
@@ -29,21 +29,21 @@ def test_read_dict_edge_not_found_edge(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict_edge(c, "abc") is None
+    assert state.read_dict_edge(c, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_edge_no_primitive(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict_edge(a, a) is None
+    assert state.read_dict_edge(a, a) == None
 
 
 @pytest.mark.usefixtures("state")
@@ -53,11 +53,11 @@ def test_read_dict_edge_node_simple(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_dict_edge(a, "f")
     assert l == d
@@ -70,20 +70,20 @@ def test_read_dict_edge_node_multi(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     g = state.create_node()
     h = state.create_nodevalue("k")
     i = state.create_edge(a, g)
     j = state.create_edge(i, h)
-    assert g is not None
-    assert h is not None
-    assert i is not None
-    assert j is not None
+    assert g != None
+    assert h != None
+    assert i != None
+    assert j != None
 
     l = state.read_dict_edge(a, "f")
     assert l == d
@@ -91,4 +91,4 @@ def test_read_dict_edge_node_multi(state):
     l = state.read_dict_edge(a, "k")
     assert l == i
 
-    assert state.read_dict_edge(a, "l") is None
+    assert state.read_dict_edge(a, "l") == None

state/test/test_read_dict_keys.py

@@ -3,7 +3,7 @@ import pytest
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_keys_no_exists(state):
-    assert state.read_dict_keys(100000) is None
+    assert state.read_dict_keys(100000) == None
 
 
 @pytest.mark.usefixtures("state")
@@ -13,14 +13,14 @@ def test_read_dict_keys_simple(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_dict_keys(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c])
 
 
@@ -31,21 +31,21 @@ def test_read_dict_keys_multi(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     g = state.create_node()
     h = state.create_nodevalue("k")
     i = state.create_edge(a, g)
     j = state.create_edge(i, h)
-    assert g is not None
-    assert h is not None
-    assert i is not None
-    assert j is not None
+    assert g != None
+    assert h != None
+    assert i != None
+    assert j != None
 
     l = state.read_dict_keys(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, h])

state/test/test_read_dict_node.py

@@ -3,7 +3,7 @@ import pytest
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_node_no_exists(state):
-    assert state.read_dict_node(-1, "abc") is None
+    assert state.read_dict_node(-1, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
@@ -11,21 +11,21 @@ def test_read_dict_node_not_found_edge(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict_node(c, "abc") is None
+    assert state.read_dict_node(c, "abc") == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_dict_node_no_primitive(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
-    assert state.read_dict_node(a, a) is None
+    assert state.read_dict_node(a, a) == None
 
 
 @pytest.mark.usefixtures("state")
@@ -35,11 +35,11 @@ def test_read_dict_node_node_simple(state):
     c = state.create_node()
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_dict_node(a, c)
     assert l == b
@@ -52,20 +52,20 @@ def test_read_dict_node_multi(state):
     c = state.create_node()
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     g = state.create_node()
     h = state.create_node()
     i = state.create_edge(a, g)
     j = state.create_edge(i, h)
-    assert g is not None
-    assert h is not None
-    assert i is not None
-    assert j is not None
+    assert g != None
+    assert h != None
+    assert i != None
+    assert j != None
 
     l = state.read_dict_node(a, c)
     assert l == b

state/test/test_read_edge.py

@@ -4,28 +4,28 @@ import pytest
 @pytest.mark.usefixtures("state")
 def test_read_edge_node(state):
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     s, t = state.read_edge(b)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_edge_no_exists(state):
     s, t = state.read_edge(-1)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_edge_nodevalue(state):
     b = state.create_nodevalue(1)
-    assert b is not None
+    assert b != None
 
     s, t = state.read_edge(b)
-    assert s is None
-    assert t is None
+    assert s == None
+    assert t == None
 
 
 @pytest.mark.usefixtures("state")
@@ -33,9 +33,9 @@ def test_read_edge_normal(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     s, t = state.read_edge(c)
     assert s == a
@@ -49,11 +49,11 @@ def test_read_edge_edge_to_edge(state):
     c = state.create_edge(a, b)
     d = state.create_edge(a, b)
     e = state.create_edge(c, d)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     s, t = state.read_edge(c)
     assert s == a
@@ -74,10 +74,10 @@ def test_read_edge_edge_to_node(state):
     b = state.create_node()
     c = state.create_edge(a, b)
     d = state.create_edge(c, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
 
     s, t = state.read_edge(c)
     assert s == a
@@ -94,10 +94,10 @@ def test_read_edge_node_to_edge(state):
     b = state.create_node()
     c = state.create_edge(a, b)
     d = state.create_edge(b, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
 
     s, t = state.read_edge(c)
     assert s == a
@@ -113,9 +113,9 @@ def test_read_edge_node_to_nodevalue(state):
     a = state.create_node()
     b = state.create_nodevalue(1)
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     s, t = state.read_edge(c)
     assert s == a
@@ -127,9 +127,9 @@ def test_read_edge_nodevalue_to_nodevalue(state):
     a = state.create_nodevalue(1)
     b = state.create_nodevalue(1)
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     s, t = state.read_edge(c)
     assert s == a

state/test/test_read_incoming.py

@@ -4,10 +4,10 @@ import pytest
 @pytest.mark.usefixtures("state")
 def test_read_incoming_node_none(state):
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -16,16 +16,16 @@ def test_read_incoming_node_one(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c])
 
 
@@ -36,18 +36,18 @@ def test_read_incoming_node_multi(state):
     c = state.create_edge(a, b)
     d = state.create_edge(a, b)
     e = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, d, e])
 
 
@@ -58,25 +58,25 @@ def test_read_incoming_node_multi_others_unaffected(state):
     c = state.create_edge(a, b)
     d = state.create_edge(a, b)
     e = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     f = state.create_node()
-    assert f is not None
+    assert f != None
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, d, e])
 
     l = state.read_incoming(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -85,12 +85,12 @@ def test_read_incoming_edge_none(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     l = state.read_incoming(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -101,22 +101,22 @@ def test_read_incoming_edge_one(state):
     c = state.create_edge(a, b)
     d = state.create_edge(c, a)
     e = state.create_edge(a, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_incoming(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([e])
 
     l = state.read_incoming(d)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(e)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -128,41 +128,41 @@ def test_read_incoming_edge_multi(state):
     d = state.create_edge(a, c)
     e = state.create_edge(b, c)
     f = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
-    assert f is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
+    assert f != None
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c])
 
     l = state.read_incoming(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([d, e, f])
 
     l = state.read_incoming(d)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(e)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
 @pytest.mark.usefixtures("state")
 def test_read_incoming_nodevalue_none(state):
     b = state.create_nodevalue(1)
-    assert b is not None
+    assert b != None
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -171,16 +171,16 @@ def test_read_incoming_nodevalue_one(state):
     a = state.create_nodevalue(1)
     b = state.create_node()
     c = state.create_edge(b, a)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -191,18 +191,18 @@ def test_read_incoming_nodevalue_multi(state):
     c = state.create_edge(b, a)
     d = state.create_edge(b, a)
     e = state.create_edge(b, a)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, d, e])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -213,50 +213,50 @@ def test_read_incoming_nodevalue_multi_others_unaffected(state):
     c = state.create_edge(b, a)
     d = state.create_edge(b, a)
     e = state.create_edge(b, a)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     f = state.create_nodevalue(1)
-    assert f is not None
+    assert f != None
 
     l = state.read_incoming(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, d, e])
 
     l = state.read_incoming(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_incoming(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
 @pytest.mark.usefixtures("state")
 def test_read_incoming_node_deleted(state):
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     n = state.delete_node(b)
-    assert n is None
+    assert n == None
 
     l = state.read_incoming(b)
-    assert l is None
+    assert l == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_incoming_nodevalue_deleted(state):
     b = state.create_nodevalue(1)
-    assert b is not None
+    assert b != None
 
     n = state.delete_node(b)
-    assert n is None
+    assert n == None
 
     l = state.read_incoming(b)
-    assert l is None
+    assert l == None
 
 
 @pytest.mark.usefixtures("state")
@@ -264,12 +264,12 @@ def test_read_incoming_edge_deleted(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     n = state.delete_edge(c)
-    assert n is None
+    assert n == None
 
     l = state.read_incoming(c)
-    assert l is None
+    assert l == None

state/test/test_read_outgoing.py

@@ -4,10 +4,10 @@ import pytest
 @pytest.mark.usefixtures("state")
 def test_read_outgoing_node_none(state):
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -16,16 +16,16 @@ def test_read_outgoing_node_one(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -36,18 +36,18 @@ def test_read_outgoing_node_multi(state):
     c = state.create_edge(a, b)
     d = state.create_edge(a, b)
     e = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, d, e])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -58,25 +58,25 @@ def test_read_outgoing_node_multi_others_unaffected(state):
     c = state.create_edge(a, b)
     d = state.create_edge(a, b)
     e = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     f = state.create_node()
-    assert f is not None
+    assert f != None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, d, e])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -85,12 +85,12 @@ def test_read_outgoing_edge_none(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     l = state.read_outgoing(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -100,17 +100,17 @@ def test_read_outgoing_edge_one(state):
     b = state.create_node()
     c = state.create_edge(a, b)
     d = state.create_edge(c, a)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
 
     l = state.read_outgoing(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([d])
 
     l = state.read_outgoing(d)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -122,37 +122,37 @@ def test_read_outgoing_edge_multi(state):
     d = state.create_edge(c, a)
     e = state.create_edge(c, b)
     f = state.create_edge(c, d)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
-    assert f is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
+    assert f != None
 
     l = state.read_outgoing(c)
-    assert l is not None
+    assert l != None
     assert set(l) == set([d, e, f])
 
     l = state.read_outgoing(d)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(e)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
 @pytest.mark.usefixtures("state")
 def test_read_outgoing_nodevalue_none(state):
     b = state.create_nodevalue(1)
-    assert b is not None
+    assert b != None
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -161,16 +161,16 @@ def test_read_outgoing_nodevalue_one(state):
     a = state.create_nodevalue(1)
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -181,18 +181,18 @@ def test_read_outgoing_nodevalue_multi(state):
     c = state.create_edge(a, b)
     d = state.create_edge(a, b)
     e = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, d, e])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
@@ -203,50 +203,50 @@ def test_read_outgoing_nodevalue_multi_others_unaffected(state):
     c = state.create_edge(a, b)
     d = state.create_edge(a, b)
     e = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     f = state.create_nodevalue(1)
-    assert f is not None
+    assert f != None
 
     l = state.read_outgoing(a)
-    assert l is not None
+    assert l != None
     assert set(l) == set([c, d, e])
 
     l = state.read_outgoing(b)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
     l = state.read_outgoing(f)
-    assert l is not None
+    assert l != None
     assert set(l) == set([])
 
 
 @pytest.mark.usefixtures("state")
 def test_read_outgoing_node_deleted(state):
     b = state.create_node()
-    assert b is not None
+    assert b != None
 
     n = state.delete_node(b)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(b)
-    assert l is None
+    assert l == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_outgoing_nodevalue_deleted(state):
     b = state.create_nodevalue(1)
-    assert b is not None
+    assert b != None
 
     n = state.delete_node(b)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(b)
-    assert l is None
+    assert l == None
 
 
 @pytest.mark.usefixtures("state")
@@ -254,12 +254,12 @@ def test_read_outgoing_edge_deleted(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     n = state.delete_edge(c)
-    assert n is None
+    assert n == None
 
     l = state.read_outgoing(c)
-    assert l is None
+    assert l == None

state/test/test_read_reverse_dict.py

@@ -4,13 +4,13 @@ import pytest
 @pytest.mark.usefixtures("state")
 def test_read_reverse_dict_no_exists(state):
     l = state.read_reverse_dict(-1, "abc")
-    assert l is None
+    assert l == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_reverse_dict_not_found_node(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
     l = state.read_reverse_dict(a, "abc")
@@ -20,7 +20,7 @@ def test_read_reverse_dict_not_found_node(state):
 @pytest.mark.usefixtures("state")
 def test_read_reverse_dict_not_found_nodevalue(state):
     a = state.create_nodevalue(1)
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
     l = state.read_reverse_dict(a, "abc")
@@ -32,9 +32,9 @@ def test_read_reverse_dict_not_found_edge(state):
     a = state.create_node()
     b = state.create_node()
     c = state.create_edge(a, b)
-    assert a is not None
-    assert b is not None
-    assert c is not None
+    assert a != None
+    assert b != None
+    assert c != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
     l = state.read_reverse_dict(c, "abc")
@@ -44,7 +44,7 @@ def test_read_reverse_dict_not_found_edge(state):
 @pytest.mark.usefixtures("state")
 def test_read_reverse_dict_no_primitive(state):
     a = state.create_node()
-    assert a is not None
+    assert a != None
 
     # Passing data is not enforced, as the data will be interpreted if necessary
     l = state.read_reverse_dict(a, a)
@@ -58,11 +58,11 @@ def test_read_reverse_dict_node_simple(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_reverse_dict(b, "f")
     assert set(l) == set([a])
@@ -75,11 +75,11 @@ def test_read_reverse_dict_no_match(state):
     c = state.create_nodevalue("g")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     l = state.read_reverse_dict(b, "f")
     assert l == []
@@ -92,20 +92,20 @@ def test_read_reverse_dict_node_multi(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     g = state.create_node()
     h = state.create_nodevalue("k")
     i = state.create_edge(a, g)
     j = state.create_edge(i, h)
-    assert g is not None
-    assert h is not None
-    assert i is not None
-    assert j is not None
+    assert g != None
+    assert h != None
+    assert i != None
+    assert j != None
 
     l = state.read_reverse_dict(b, "f")
     assert set(l) == set([a])
@@ -124,20 +124,20 @@ def test_read_reverse_dict_node_multi_ambiguous(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(b, a)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     g = state.create_node()
     h = state.create_nodevalue("f")
     i = state.create_edge(g, a)
     j = state.create_edge(i, h)
-    assert g is not None
-    assert h is not None
-    assert i is not None
-    assert j is not None
+    assert g != None
+    assert h != None
+    assert i != None
+    assert j != None
 
     l = state.read_reverse_dict(a, "f")
     assert set(l) == set([b, g])
@@ -150,16 +150,16 @@ def test_read_reverse_dict_node_uncertain(state):
     c = state.create_nodevalue("f")
     d = state.create_edge(a, b)
     e = state.create_edge(d, c)
-    assert a is not None
-    assert b is not None
-    assert c is not None
-    assert d is not None
-    assert e is not None
+    assert a != None
+    assert b != None
+    assert c != None
+    assert d != None
+    assert e != None
 
     h = state.create_nodevalue("g")
     i = state.create_edge(d, h)
-    assert h is not None
-    assert i is not None
+    assert h != None
+    assert i != None
 
     l = state.read_reverse_dict(b, "f")
     assert set(l) == set([a])

state/test/test_read_value.py

@@ -5,8 +5,8 @@ import pytest
 def test_read_value_different_id_simple(state):
     id1 = state.create_nodevalue(1)
     id2 = state.create_nodevalue(2)
-    assert id1 is not None
-    assert id2 is not None
+    assert id1 != None
+    assert id2 != None
 
     v1 = state.read_value(id1)
     v2 = state.read_value(id2)
@@ -19,7 +19,7 @@ def test_read_value_integer_ib_negative(state):
     # Just within range
     for i in range(-2 ** 63, -2 ** 63 + 10):
         id1 = state.create_nodevalue(i)
-        assert id1 is not None
+        assert id1 != None
 
         v = state.read_value(id1)
         assert v == i
@@ -30,7 +30,7 @@ def test_read_value_integer_ib_zero(state):
     # Nicely within range
     for i in range(-10, 10):
         id1 = state.create_nodevalue(i)
-        assert id1 is not None
+        assert id1 != None
 
         v = state.read_value(id1)
         assert v == i
@@ -41,7 +41,7 @@ def test_read_value_integer_ib_positive(state):
     # Just within range
     for i in range(2 ** 63 - 10, 2 ** 63):
         id1 = state.create_nodevalue(i)
-        assert id1 is not None
+        assert id1 != None
 
         v = state.read_value(id1)
         assert v == i
@@ -51,8 +51,8 @@ def test_read_value_integer_ib_positive(state):
 def test_read_value_boolean(state):
     id1 = state.create_nodevalue(True)
     id2 = state.create_nodevalue(False)
-    assert id1 is not None
-    assert id2 is not None
+    assert id1 != None
+    assert id2 != None
 
     v1 = state.read_value(id1)
     v2 = state.read_value(id2)
@@ -64,8 +64,8 @@ def test_read_value_boolean(state):
 def test_read_nodevalue_boolean_same(state):
     id1 = state.create_nodevalue(True)
     id2 = state.create_nodevalue(True)
-    assert id1 is not None
-    assert id2 is not None
+    assert id1 != None
+    assert id2 != None
 
     v1 = state.read_value(id1)
     v2 = state.read_value(id2)
@@ -76,13 +76,13 @@ def test_read_nodevalue_boolean_same(state):
 @pytest.mark.usefixtures("state")
 def test_read_value_no_exist(state):
     v1 = state.read_value(100000)
-    assert v1 is None
+    assert v1 == None
 
 
 @pytest.mark.usefixtures("state")
 def test_read_value_no_value(state):
     id1 = state.create_node()
-    assert id1 is not None
+    assert id1 != None
 
     v1 = state.read_value(id1)
-    assert v1 is None
+    assert v1 == None

transformation/ramify.py

@@ -116,7 +116,7 @@ def ramify(state: State, model: UUID) -> UUID:
         #   - min-card: 0
         #   - max-card: same as original
         upper_card = find_cardinality(class_node, class_upper_card_node)
-        print('creating class', class_name, "with upper card", upper_card)
+        print('creating class', class_name, "with card 0 ..", upper_card)
         ramified_scd.create_class(class_name, abstract=None, max_c=upper_card)
 
         for (attr_name, attr_type) in get_attributes(class_node):
@@ -137,9 +137,7 @@ def ramify(state: State, model: UUID) -> UUID:
         src = scd.get_class_name(bottom.read_edge_source(assoc_node))
         tgt = scd.get_class_name(bottom.read_edge_target(assoc_node))
         print('creating assoc', src, "->", tgt, ", name =", assoc_name, ", src card = 0 ..", src_upper_card, "and tgt card = 0 ..", tgt_upper_card)
-        ramified_scd.create_association(assoc_name,
-            src,
-            tgt,
+        ramified_scd.create_association(assoc_name, src, tgt,
             src_max_c=src_upper_card,
             tgt_max_c=tgt_upper_card)