git: Rename some directory.

src/Model/AModelComponent.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+class AbstractModelComponent(object):
+    def __init__(self):
+        super(AbstractModelComponent, self).__init__()
+
+    def new(self, filename):
+
+
+    def export(self, filename):

src/Model/Network/Edge.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+
+from Model.Network.Node import Node
+
+class Edge(object):
+    def __init__(self, id:str, name:str,
+                 node1:Node = None,
+                 node2:Node = None):
+        super(Edge, self).__init__()
+
+        self.id = id
+        self.name = name if name != "" else f"{node1.name} -> {node2.name}"
+
+        self.node1 = node1
+        self.node2 = node2
+
+        self.enable = True
+
+    def __getitem__(self, name):
+        ret = None
+
+        if name == "name":
+            ret = self.name
+        elif name == "id":
+            ret = self.id
+        elif name == "node1":
+            ret = self.node1.name
+        elif name == "node2":
+            ret = self.node2.name
+        elif name == "enable":
+            ret = self.enable
+
+        return ret
+
+    def __setitem__(self, name, value):
+        if name == "name":
+            self.name = value
+        elif name == "id":
+            self.id = value
+        elif name == "node1":
+            self.node1 = value
+        elif name == "node2":
+            self.node2 = value
+        elif name == "enable":
+            self.enable = value
+
+    def enable(self):
+        self.enable = True
+
+    def disable(self):
+        self.enable = False

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

src/Model/Network/Node.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+from Model.Network.Point import Point
+
+class Node(object):
+    def __init__(self, id:str, name:str,
+                 x:float = 0.0, y:float = 0.0):
+        super(Node, self).__init__()
+
+        self.id = id
+        self.name = name
+        self.pos = Point(x, y)
+
+    def __getitem__(self, name):
+        ret = None
+
+        if name == "name":
+            ret = self.name
+        elif name == "id":
+            ret = self.id
+        elif name == "pos":
+            ret = f"({self.pos.x},{self.pos.y})"
+
+        return ret
+
+    def __setitem__(self, name, value):
+        if name == "name":
+            self.name = value
+        elif name == "id":
+            self.id = value
+
+    def setPos(self, x, y):
+        self.pos.x = x
+        self.pos.y = y

src/Model/Network/Point.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+class Point(object):
+    def __init__(self, x:float, y:float):
+        super(Point, self).__init__()
+
+        self.x = x
+        self.y = y
+
+    def __repr__(self):
+        return f"({self.x}, {self.y})"
+
+    def set_pos(self, x, y):
+        self.x = x
+        self.y = y

src/Model/Serializable.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+import pickle
+
+class Serializable():
+    def __init__(self, filename):
+        self.filename = filename
+
+    @classmethod
+    def open(cls, filename):
+        with open(filename, 'rb') as in_file:
+            me = pickle.load(in_file)
+        return me
+
+    def save(self):
+        with open(self.filename, 'wb') as out_file:
+            pickle.dump(self, out_file)

src/Model/Study.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+import os
+from datetime import datetime
+from Model.Serializable import Serializable
+
+class Study(Serializable):
+    def __init__(self):
+        # Serialization information
+        super(Study, self).__init__("")
+        self.filename = ""
+
+        # Study general information
+        self.name = ""
+        self.description = ""
+
+        self.creation_date = datetime.now()
+        self.last_modification_date = datetime.now()
+        self.last_save_date = datetime.now()
+
+        # Study data
+        self.data = {}
+
+    @classmethod
+    def new(cls):
+        return cls()
+
+    @classmethod
+    def new(cls, name, description):
+        me = cls()
+        me.name = name
+        me.description = description
+        return me