Graph.py

# -*- coding: utf-8 -*-

from functools import reduce

from model.network.Node import Node
from model.network.Edge import Edge

class Graph(object):
    def __init__(self):
        super(Graph, self).__init__()

        self._nodes_ids = 0
        self._edges_ids = 0

        self._nodes = []
        self._edges = []

    def __repr__(self):
        return f"Graph {{nodes: {self._nodes}, edges: {self._edges}}}"

    def nodes(self):
        return self._nodes

    def nodes_names(self):
        return list(map(lambda n: n.name, self._nodes))

    def edges(self):
        return self._edges

    def nodes_counts(self):
        return len(self._nodes)

    def edges_counts(self):
        return len(self._edges)

    def is_node_exists(self, node_name):
        return reduce(
            lambda acc, n: (acc or (n.name == node_name)),
            self._nodes,
            False
        )

    def is_edge_exists(self, edge_name):
        return reduce(
            lambda acc, e: (acc or (e.name == edge_name)),
            self._edges,
            False
        )

    def node(self, node_name:str):
        return list(filter(lambda n: n.name == node_name, self._nodes))[0]

    def add_node(self, x:float = 0.0, y:float = 0.0):
        node = Node(
            self._nodes_ids,
            f"Node {self._nodes_ids}",
            x = x, y = y
        )
        self._nodes.append(node)
        self._nodes_ids += 1
        return node

    def add_edge(self, n1:Node, n2:Node):
        edge = Edge(self._edges_ids, f"Edge {self._edges_ids}", n1, n2)
        self._edges.append(edge)
        self._edges_ids += 1
        return edge

    def remove_node(self, node_name:str):
        self._nodes = list(filter(lambda n: n.name != node_name, self._nodes))

    def remove_edge(self, edge_name:str):
        self._edges = list(filter(lambda e: e.name != edge_name, self._edges))

    def is_upstream_node(self, node):
        return reduce(
            lambda acc, e: (acc and (e.node2 != node)),
            self._edges,
            True
        )

    def is_downstream_node(self, node):
        return reduce(
            lambda acc, e: (acc and (e.node1 != node)),
            self._edges,
            True
        )