Пример #1
0
 def test_dm_parser_limit(self):
     dm = dotmotif.Motif(limit=3)
     dm.from_motif(_DEMO_G_MIN)
     self.assertTrue("LIMIT 3" in Neo4jExecutor.motif_to_cypher(dm).strip())
     dm = dotmotif.Motif()
     dm.from_motif(_DEMO_G_MIN)
     self.assertFalse("LIMIT" in Neo4jExecutor.motif_to_cypher(dm).strip())
Пример #2
0
    def test_alphanumeric_variables(self):
        exp = """\
        edge(A, B) {
            A -> B
        }
        dualedge(A1, B) {
            # Nested-inside comment!
            edge(A1, B) # inline comment
            B -> A1
        }

        dualedge(foo_1, bar_2) # inline comment
        # standalone comment
        foo_1 -> bar_2 # inline comment
        """
        dm = dotmotif.Motif(exp)
        edges = list(dm._g.edges(data=True))
        self.assertEqual(len(edges), 2)
        self.assertEqual(list(dm._g.nodes()), ["foo_1", "bar_2"])
        self.assertEqual(type(list(dm._g.nodes())[0]), str)

        new_exp = """
        L1 -> Mi1
        L1 -> Tm3
        L3 -> Mi9
        """
        dm = dotmotif.Motif(new_exp)
        self.assertEqual(list(dm._g.nodes()),
                         ["L1", "Mi1", "Tm3", "L3", "Mi9"])
Пример #3
0
    def test_node_macro_attr(self):
        exp = """\
        macro(A) {
            A.type = "excitatory"
            A.size >= 4.0
        }
        Aaa -> Ba
        macro(Aaa)
        """
        dm = dotmotif.Motif(exp)
        self.assertEqual(len(dm.list_node_constraints()), 1)
        self.assertEqual(list(dm.list_node_constraints().keys()), ["Aaa"])

        exp = """\
        macro(A) {
            A.type = "excitatory"
            A.size >= 4.0
        }
        Aaa -> Ba
        macro(Aaa)
        macro(Ba)
        """
        dm = dotmotif.Motif(exp)
        self.assertEqual(len(dm.list_node_constraints()), 2)
        self.assertEqual(list(dm.list_node_constraints().keys()),
                         ["Aaa", "Ba"])
Пример #4
0
    def test_automorphism_reduction(self):

        G = nx.DiGraph()
        G.add_edge("X", "Z")
        G.add_edge("Y", "Z")

        motif = dotmotif.Motif("""
            A -> C
            B -> C

            A === B
            """)

        res = GrandIsoExecutor(graph=G).find(motif)
        self.assertEqual(len(res), 2)

        motif = dotmotif.Motif(exclude_automorphisms=True).from_motif("""
            A -> C
            B -> C

            A === B
            """)

        res = GrandIsoExecutor(graph=G).find(motif)
        self.assertEqual(len(res), 1)
Пример #5
0
    def test_dm_parser_actions(self):
        dm = dotmotif.Motif(_THREE_CYCLE)
        self.assertEqual([e[2]["action"] for e in dm._g.edges(data=True)],
                         ["SYN"] * 3)

        dm = dotmotif.Motif(_THREE_CYCLE_INH)
        self.assertEqual([e[2]["action"] for e in dm._g.edges(data=True)],
                         ["INH"] * 3)
Пример #6
0
    def test_dm_parser_edge_exists(self):
        dm = dotmotif.Motif(_THREE_CYCLE)
        self.assertEqual([e[2]["exists"] for e in dm._g.edges(data=True)],
                         [True] * 3)

        dm = dotmotif.Motif(_THREE_CYCLE_NEG)
        self.assertEqual([e[2]["exists"] for e in dm._g.edges(data=True)],
                         [False] * 3)

        dm = dotmotif.Motif(_THREE_CYCLE_NEG_INH)
        self.assertEqual([e[2]["exists"] for e in dm._g.edges(data=True)],
                         [False] * 3)
Пример #7
0
 def test_dm_parser_no_direction(self):
     dm = dotmotif.Motif(ignore_direction=True)
     dm.from_motif(_DEMO_G_MIN)
     self.assertEqual(
         Neo4jExecutor.motif_to_cypher(dm).strip(),
         _DEMO_G_MIN_CYPHER.strip().replace("->", "-"),
     )
Пример #8
0
    def test_node_and_edge_full_example(self):

        H = nx.DiGraph()
        H.add_edge("X", "Y", weight=10)
        H.add_edge("Y", "Z", weight=9)
        H.add_edge("Z", "X", weight=8)
        motif = dotmotif.Motif("""
            A -> B [weight>=7]
        """.strip())

        res = GrandIsoExecutor(graph=H).find(motif)
        self.assertEqual(len(res), 3)

        H.add_edge("Z", "C", weight=7)
        res = GrandIsoExecutor(graph=H).find(motif)
        self.assertEqual(len(res), 4)

        H.add_edge("Z", "D", weight="no")
        res = GrandIsoExecutor(graph=H).find(motif)
        self.assertEqual(len(res), 4)

        H.add_edge("y", "a")
        self.assertEqual(len(GrandIsoExecutor(graph=H).find(motif)), 4)

        H.add_edge("y", "a", other_weight=7, weight=8)
        self.assertEqual(len(GrandIsoExecutor(graph=H).find(motif)), 5)
Пример #9
0
 def test_dm_parser_no_pretty_print(self):
     dm = dotmotif.Motif(pretty_print=False)
     dm.from_motif(_DEMO_G_MIN)
     self.assertEqual(
         Neo4jExecutor.motif_to_cypher(dm).strip(),
         _DEMO_G_MIN_CYPHER.strip().replace("\n", " "),
     )
Пример #10
0
 def test_edge_multi_attr(self):
     exp = """\
     Aa -> Ba [type != 1, type != 12]
     """
     dm = dotmotif.Motif(exp)
     self.assertEqual(len(dm._g.edges()), 1)
     u, v, d = list(dm._g.edges(data=True))[0]
     self.assertEqual(d["constraints"]["type"], {"!=": [1, 12]})
Пример #11
0
 def test_macro_not_added(self):
     exp = """\
     edge(A, B) {
         A -> B
     }
     """
     dm = dotmotif.Motif(exp)
     self.assertEqual(len(dm._g.edges()), 0)
Пример #12
0
 def test_automatic_autos(self):
     exp = """\
     A -> C
     B -> C
     """
     dm = dotmotif.Motif(exp, exclude_automorphisms=True)
     cypher = Neo4jExecutor.motif_to_cypher(dm)
     self.assertIn("id(A) < id(B)", cypher)
Пример #13
0
 def test_simple_macro(self):
     exp = """\
     edge(A, B) {
         A -> B
     }
     edge(C, D)
     """
     dm = dotmotif.Motif(exp)
     self.assertEqual(len(dm._g.edges()), 1)
Пример #14
0
 def test_dm_parser_inequality(self):
     dm = dotmotif.Motif(enforce_inequality=True)
     dm.from_motif(_DEMO_G_MIN)
     self.assertTrue("A<>B" in Neo4jExecutor.motif_to_cypher(dm).strip()
                     or "B<>A" in Neo4jExecutor.motif_to_cypher(dm).strip())
     self.assertTrue("B<>C" in Neo4jExecutor.motif_to_cypher(dm).strip()
                     or "C<>B" in Neo4jExecutor.motif_to_cypher(dm).strip())
     self.assertTrue("A<>C" in Neo4jExecutor.motif_to_cypher(dm).strip()
                     or "C<>A" in Neo4jExecutor.motif_to_cypher(dm).strip())
Пример #15
0
 def test_basic_node_attr(self):
     exp = """\
     A -> C
     B -> C
     A === B
     """
     dm = dotmotif.Motif(exp)
     cypher = Neo4jExecutor.motif_to_cypher(dm)
     self.assertIn("id(A) < id(B)", cypher)
Пример #16
0
    def test_basic_node_attr(self):
        exp = """\
        Aa -> Ba

        Aa.type = "excitatory"
        """
        dm = dotmotif.Motif(exp)
        self.assertEqual(len(dm.list_node_constraints()), 1)
        self.assertEqual(list(dm.list_node_constraints().keys()), ["Aa"])
Пример #17
0
    def test_multi_node_attr(self):
        exp = """\
        Aa -> Ba

        Aa.type = "excitatory"
        Ba.size=4.0
        """
        dm = dotmotif.Motif(exp)
        self.assertEqual(len(dm.list_node_constraints()), 2)
        self.assertEqual(list(dm.list_node_constraints().keys()), ["Aa", "Ba"])
Пример #18
0
    def test_mini_example(self):

        H = nx.DiGraph()
        H.add_edge("y", "x", ATTRIBUTE=7)
        H.add_edge("y", "z", ATTRIBUTE=7)
        motif = dotmotif.Motif("""
        A -> B [ATTRIBUTE>=7]
        """.strip())

        self.assertEqual(len(GrandIsoExecutor(graph=H).find(motif)), 2)
Пример #19
0
    def test_edge_attribute_equality(self):
        dm = dotmotif.Motif("""
        A->B [weight==10, area==4]
        """)

        H = nx.DiGraph()
        H.add_edge("z", "x", weight=10, area=4)
        H.add_edge("x", "y")
        H.add_edge("y", "z", weight=5)
        self.assertEqual(len(NetworkXExecutor(graph=H).find(dm)), 1)
Пример #20
0
    def test_cypher_edge_many_attributes(self):
        dm = dotmotif.Motif()
        dm.from_motif("""
            A -> B [weight=4, area<=10, area<=20]
            X -> Y [weight=2]
        """)

        self.assertEqual(
            Neo4jExecutor.motif_to_cypher(dm).strip(),
            _DEMO_EDGE_ATTR_CYPHER_2.strip())
Пример #21
0
 def test_basic_edge_attr(self):
     exp = """\
     Aa -> Ba [type == 1]
     """
     dm = dotmotif.Motif(exp)
     self.assertEqual(len(dm._g.edges()), 1)
     u, v, d = list(dm._g.edges(["Aa", "Bb"], data=True))[0]
     self.assertEqual(type(list(dm._g.nodes())[0]), str)
     self.assertEqual(type(list(dm._g.nodes())[1]), str)
     self.assertEqual(d["constraints"]["type"], {"==": [1]})
Пример #22
0
    def test_edgecount_motif(self):
        dm = dotmotif.Motif("""A->B""")

        H = nx.DiGraph()
        H.add_edge("x", "y")
        self.assertEqual(len(NetworkXExecutor(graph=H).find(dm)), 1)
        H.add_edge("x", "y")
        self.assertEqual(len(NetworkXExecutor(graph=H).find(dm)), 1)
        H.add_edge("x", "z")
        self.assertEqual(len(NetworkXExecutor(graph=H).find(dm)), 2)
Пример #23
0
    def test_one_instance(self):

        H = nx.DiGraph()
        H.add_edge("x", "y", weight=1)
        H.add_edge("y", "z", weight=10)
        H.add_edge("z", "x", weight=5)
        motif = dotmotif.Motif("""
        A -> B [weight>=11]
        """.strip())

        self.assertEqual(len(GrandIsoExecutor(graph=H).find(motif)), 0)
Пример #24
0
    def test_from_nx_import(self):
        G = nx.Graph()
        G.add_edge("A", "B")
        G.add_edge("B", "C")

        g = nx.Graph()
        g.add_edge("A", "B")
        dm = dotmotif.Motif(ignore_direction=True).from_nx(g)

        E = NetworkXExecutor(graph=G)
        self.assertEqual(len(E.find(dm)), 4)
Пример #25
0
 def test_wrong_args_macro(self):
     exp = """\
     edge(A, B) {
         A -> B
         B -> A
     }
     edge(C, D, E)
     """
     # with self.assertRaises(ValueError):
     with self.assertRaises(Exception):
         dotmotif.Motif(exp)
Пример #26
0
 def test_simple_macro_construction(self):
     exp = """\
     edge(A, B) {
         A -> B
     }
     edge(C, D)
     """
     dm = dotmotif.Motif(exp)
     exp_edge = list(dm._g.edges(data=True))[0]
     self.assertEqual(exp_edge[0], "C")
     self.assertEqual(exp_edge[1], "D")
Пример #27
0
 def test_dynamic_constraints_in_cypher(self):
     dm = dotmotif.Motif(enforce_inequality=True)
     dm.from_motif("""
     A -> B
     A.radius >= B.radius
     A.zorf != B.zorf
     """)
     self.assertIn(
         "WHERE A.radius >= B.radius AND A.zorf <> B.zorf",
         Neo4jExecutor.motif_to_cypher(dm).strip(),
     )
Пример #28
0
 def test_undefined_macro(self):
     exp = """\
     dualedge(A, B) {
         A -> B
         B -> A
     }
     foo(C, D)
     """
     # with self.assertRaises(ValueError):
     with self.assertRaises(Exception):
         dotmotif.Motif(exp)
Пример #29
0
 def test_more_complex_macro(self):
     exp = """\
     tri(A, B, C) {
         A -> B
         B -> C
         C -> A
     }
     tri(C, D, E)
     """
     dm = dotmotif.Motif(exp)
     edges = list(dm._g.edges(data=True))
     self.assertEqual(len(edges), 3)
Пример #30
0
    def test_cypher_node_attributes(self):
        dm = dotmotif.Motif()
        dm.from_motif("""
        A -> B
        A.size = "big"
        """)

        self.assertEqual(
            Neo4jExecutor.motif_to_cypher(dm).strip(),
            """MATCH (A:Neuron)-[A_B:SYN]->(B:Neuron)\nWHERE A.size = "big"\nRETURN DISTINCT A,B"""
            .strip(),
        )