networkx-query

Versions following Semantic Versioning

Overview

NetworkX Query Tool (preview)

See documentation.

Installation

Install this library directly into an activated virtual environment:

$ pip install networkx-query

or add it to your Poetry project:

$ poetry add networkx-query

Usage

Searching node:

import networkx as nx
from networkx_query import search_nodes, search_edges

g = nx.DiGraph()
g.add_node(1, product="chocolate")
g.add_node(2, product="milk")
g.add_node(3, product="coat")
g.add_edge(1, 2, action="shake")
g.add_edge(3, 2, action="produce")


for node_id in search_nodes(g, {"==": [("product",), "chocolate"]}):
    print(node_id)

>> 1

for edge_id in search_edges(g, {"eq": [("action",), "produce"]}):
    print(edge_id)

>> (3, 2)

You could do the same with edges using search_edges.

API

search_edges and search_nodes are based on prepare_query which return an Evaluator.

Evaluator are function with this signature: (context) -> bool

Context is a dictionnary like structure (with in and [] methods, and support contains or (iter and getitem))

Query language

Define a json query language like json-query-language against nodes or edges attributes.

A Path is a single string or a tuple of string which represente a path in a tree (here a dictionnary).

Expressions

All those expression are evaluate against a context wich is a dictionnary like (as can be a NodeDataView or an EdgeDataView).

Main expression syntax turn around this:

{
    operator_name : parameters
}

Basic matching expression

Test if a node/edge has an attribute named "my_property":

{
    "has" : "my_property"
}

Test if a node/edge has an attribute product : { "definition": { "name": xxx }} with xxx equals to "chocolate".

{
    "eq" : [ ("product", "definition", "name"), "chocolate"]
}

We support this operators:

Boolean composition of matching expression

We support this operators:

By default, a list of expressions is equivalent of an "AND" of this expressions.

Example:

{
    'not': {
        'has': ['group']
    },
    'has': 'application',
    'eq': [('_link', 'other', 'weight'), 2]
}

is equivalent to:

{
    'and': [
        {
            'not': [
                {
                    'has': ['group']
                }
            ]
        },
        {
            'has': ['application']
        },
        {
            'eq': [('_link', 'other', 'weight'), 2]
        }
    ]
}

Wished Features

• add match node, edges, path specification
• add set expression on node/edges with constraints
• add path condition between node