git: Rename some directory.

src/Model/Network/Graph.py

@@ -0,0 +1,124 @@
+# -*- 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):
+        # This edge already exists ?
+        if list(filter(lambda e: (e.node1 == n1 and
+                                  e.node2 == n2),
+                       self._edges)):
+            return None
+
+        edge = 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 or not e.enable)),
+            self._edges,
+            True
+        )
+
+    def is_downstream_node(self, node):
+        return reduce(
+            lambda acc, e: (acc and (e.node1 != node or not e.enable)),
+            self._edges,
+            True
+        )
+
+    def is_enable_node(self, node):
+        return reduce(
+            lambda acc, e: (
+                acc or (
+                    (e.node1 == node or
+                     e.node2 == node)
+                    and e.enable
+                )
+            ),
+            self._edges,
+            False
+        )
+
+    def is_enable_edge(self, edge):
+        return edge.enable