retworkx 0.8.0

A python graph library implemented in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

// Licensed under the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.

use std::collections::BTreeMap;
use std::io::prelude::*;

use petgraph::visit::{
    Data, EdgeRef, GraphBase, GraphProp, IntoEdgeReferences,
    IntoNodeReferences, NodeIndexable, NodeRef,
};
use pyo3::prelude::*;

static TYPE: [&str; 2] = ["graph", "digraph"];
static EDGE: [&str; 2] = ["--", "->"];

pub fn build_dot<G, T>(
    py: Python,
    graph: G,
    file: &mut T,
    graph_attrs: Option<BTreeMap<String, String>>,
    node_attrs: Option<PyObject>,
    edge_attrs: Option<PyObject>,
) -> PyResult<()>
where
    T: Write,
    G: GraphBase
        + IntoEdgeReferences
        + IntoNodeReferences
        + NodeIndexable
        + GraphProp,
    G: Data<NodeWeight = PyObject, EdgeWeight = PyObject>,
{
    writeln!(file, "{} {{", TYPE[graph.is_directed() as usize])?;
    if let Some(graph_attr_map) = graph_attrs {
        for (key, value) in graph_attr_map.iter() {
            writeln!(file, "{}={} ;", key, value)?;
        }
    }

    for node in graph.node_references() {
        writeln!(
            file,
            "{} {};",
            graph.to_index(node.id()),
            attr_map_to_string(py, node_attrs.as_ref(), &node.weight())?
        )?;
    }
    for edge in graph.edge_references() {
        writeln!(
            file,
            "{} {} {} {};",
            graph.to_index(edge.source()),
            EDGE[graph.is_directed() as usize],
            graph.to_index(edge.target()),
            attr_map_to_string(py, edge_attrs.as_ref(), &edge.weight())?
        )?;
    }
    writeln!(file, "}}")?;
    Ok(())
}

/// Convert an attr map to an output string
fn attr_map_to_string<'a>(
    py: Python,
    attrs: Option<&'a PyObject>,
    weight: &'a PyObject,
) -> PyResult<String> {
    if attrs.is_none() {
        return Ok("".to_string());
    }
    let attr_callable =
        |node: &'a PyObject| -> PyResult<BTreeMap<String, String>> {
            let res = attrs.unwrap().call1(py, (node,))?;
            res.extract(py)
        };

    let attrs = attr_callable(weight)?;
    if attrs.is_empty() {
        return Ok("".to_string());
    }

    let attr_string = attrs
        .iter()
        .map(|(key, value)| {
            if key == "label" {
                format!("{}=\"{}\"", key, value)
            } else {
                format!("{}={}", key, value)
            }
        })
        .collect::<Vec<String>>()
        .join(", ");
    Ok(format!("[{}]", attr_string))
}