Passed
Push — master ( 5b3fdd...dd1c2d )
by Guibert
02:21
created

networkx_query.query.prepare_query()   A

Complexity

Conditions 1

Size

Total Lines 14
Code Lines 2

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 1
eloc 2
nop 1
dl 0
loc 14
rs 10
c 0
b 0
f 0
1
"""networkx-query public interace definition."""
2
from typing import Any, Dict, Iterable, Tuple
3
4
from networkx import Graph
5
6
from .definition import Evaluator, ParserException
7
from .parser import compile_ast, parse
8
9
__all__ = ['search_nodes', 'search_edges', 'prepare_query', 'ParserException']
10
11
12
def prepare_query(query: Dict) -> Evaluator:
13
    """Transform expression query as a function.
14
15
    Arguments:
16
        query (Dict): expression query as dictionary
17
18
    Returns:
19
        (Evaluator): evaluator function
20
21
    Exceptions:
22
        (ParserException): if a parse error occurs
23
24
    """
25
    return compile_ast(parse(expra=query))
26
27
28
def search_nodes(graph: Graph, query: Dict) -> Iterable[Any]:
29
    """Search nodes in specified grapg which match query.
30
31
    Arguments:
32
        graph (Graph): networkx graph instance
33
        query (Dict): query expression
34
35
    Returns:
36
        (Iterable[Any]): results as an iterable of node identifier.
37
38
    Exceptions:
39
        (ParserException): if a parse error occurs
40
41
    """
42
    _predicate = prepare_query(query)
43
44
    return map(
45
        lambda n: n[0], filter(lambda n: n[1], map(lambda node: (node[0], _predicate(node[1])), graph.nodes(data=True)))
46
    )
47
48
49
def search_edges(graph: Graph, query: Dict) -> Iterable[Tuple]:
50
    """Search edges in specified grapg which match query.
51
52
    Arguments:
53
        graph (Graph): networkx graph instance
54
        query (Dict): query expression
55
56
    Returns:
57
        (Iterable[Tuple]): results as an iterable of edge identifier (tuple).
58
59
    Exceptions:
60
        (ParserException): if a parse error occurs
61
62
    """
63
    _predicate = prepare_query(query)
64
    return map(
65
        lambda n: n[0],
66
        filter(lambda n: n[1], map(lambda edge: ((edge[0], edge[1]), _predicate(edge[2])), graph.edges(data=True))),
67
    )
68