LC: Add code base (don't working).

src/Model/LateralContribution/LateralContribution.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+
+from tools import trace, timer, old_pamhyr_date_to_timestamp
+
+from Model.Except import NotImplementedMethodeError
+
+class LateralContribution(object):
+    def __init__(self, name:str = ""):
+        super(LateralContribution, self).__init__()
+
+        self._name = name
+        self._type = ""
+        self._edge = None
+        self._data = []
+        self._header = []
+        self._types = [float, float]
+
+    def __len__(self):
+        return len(self._data)
+
+    @classmethod
+    def compatibility(cls):
+        return ["liquid", "solid", "suspenssion"]
+
+    @classmethod
+    def time_convert(cls, data):
+        if type(data) == str and data.count(":") == 3:
+            return old_pamhyr_date_to_timestamp(data)
+
+        return int(data)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+
+    @property
+    def bctype(self):
+        return self._type
+
+    @property
+    def edge(self):
+        return self._edge
+
+    @edge.setter
+    def edge(self, edge):
+        self._edge = edge
+
+    def has_edge(self):
+        return self._edge is not None
+
+    @property
+    def header(self):
+        return self._header.copy()
+
+    @property
+    def data(self):
+        return self._data.copy()
+
+    def get_type_column(self, column):
+        if 0 <= column < 2:
+            return self._types[column]
+        return None
+
+    @property
+    def _default_0(self):
+        return self._types[0](0)
+
+    @property
+    def _default_1(self):
+        return self._types[1](0.0)
+
+    def is_define(self):
+        return self._data is not None
+
+    def new_from_data(self, header, data):
+        new_0 = self._default_0
+        new_1 = self._default_1
+
+        if len(header) != 0:
+            for i in [0,1]:
+                for j in range(len(header)):
+                    if self._header[i] == header[j]:
+                        if i == 0:
+                            new_0 = self._types[i](data[j].replace(",", "."))
+                        else:
+                            new_1 = self._types[i](data[j].replace(",", "."))
+        else:
+            new_0 = self._types[0](data[0].replace(",", "."))
+            new_1 = self._types[1](data[1].replace(",", "."))
+
+        return (new_0, new_1)
+
+    def add(self, index:int):
+        value = (self._default_0, self._default_1)
+        self._data.insert(index, value)
+        return value
+
+    def insert(self, index:int, value):
+        self._data.insert(index, value)
+
+    def delete_i(self, indexes):
+        self._data = list(
+            map(
+                lambda e: e[1],
+                filter(
+                    lambda e: e[0] not in indexes,
+                    enumerate(self.data)
+                )
+            )
+        )
+
+    def delete(self, els):
+        self._data = list(
+            filter(
+                lambda e: e not in els,
+                self.data
+            )
+        )
+
+    def sort(self, _reverse=False, key=None):
+        if key is None:
+            self._data.sort(reverse=_reverse)
+        else:
+            self._data.sort(reverse=_reverse, key=key)
+
+    def get_i(self, index):
+        return self.data[index]
+
+    def get_range(self, _range):
+        l = []
+        for r in _range:
+            l.append(r)
+        return l
+
+
+    def _set_i_c_v(self, index, column, value):
+        v = list(self._data[index])
+        v[column] = self._types[column](value)
+        self._data[index] = tuple(v)
+
+    def set_i_0(self, index:int, value):
+        self._set_i_c_v(index, 0, value)
+
+    def set_i_1(self, index:int, value):
+        self._set_i_c_v(index, 1, value)
+
+    @timer
+    def convert(self, cls):
+        new = cls(name = self.name)
+        for i, _ in self.data:
+            new.add(i)
+
+        for i in [0,1]:
+            for j in [0,1]:
+                if self._header[i] == new.header[j]:
+                    for ind, v in self.data:
+                        new._set_i_c_v(ind, j, v[i])
+
+        return new
+
+    def move_up(self, index):
+        if index < len(self):
+            next = index - 1
+            d = self._data
+            d[index], d[next] = d[next], d[index]
+
+    def move_down(self, index):
+        if index >= 0:
+            prev = index + 1
+            d = self._data
+            d[index], d[prev] = d[prev], d[index]

src/Model/LateralContribution/LateralContributionList.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+
+from copy import copy
+from tools import trace, timer
+
+from Model.Except import NotImplementedMethodeError
+
+from Model.LateralContribution.LateralContributionTypes import (
+    NotDefined,
+    PonctualContribution,
+    TimeOverZ, TimeOverDebit, ZOverDebit
+)
+
+class LateralContributionList(object):
+    def __init__(self):
+        super(LateralContributionList, self).__init__()
+
+        self._tabs = {
+            "liquid" : [],
+            "solid" : [],
+            "suspenssion" : []
+        }
+
+    def len(self, lst):
+        return len(self._tabs[lst])
+
+    def get_tab(self, lst):
+        return self._tabs[lst].copy()
+
+    def get(self, lst, row):
+        return self._tabs[lst][row]
+
+    def set(self, lst, row, new):
+        self._tabs[lst][row] = new
+
+    def new(self, lst, index):
+        n = NotDefined()
+        self._tabs[lst].insert(index, n)
+        return n
+
+    def insert(self, lst, index, new):
+        self._tabs[lst].insert(index, new)
+
+    def delete(self, lst, bcs):
+        for bc in bcs:
+            self._tabs[lst].remove(bc)
+
+    def delete_i(self, lst, indexes):
+        bcs = list(
+            map(
+                lambda x: x[1],
+                filter(
+                    lambda x: x[0] in indexes,
+                    enumerate(self._tabs[lst])
+                )
+            )
+        )
+        self.delete(lst, bcs)
+
+    def sort(self, lst, reverse=False, key=None):
+        self._tabs[lst].sort(reverse=reverse, key=key)
+
+    def move_up(self, lst, index):
+        if index < len(self._tabs[lst]):
+            next = index - 1
+
+            l = self._tabs[lst]
+            l[index], l[next] = l[next], l[index]
+
+    def move_down(self, lst, index):
+        if index >= 0:
+            prev = index + 1
+
+            l = self._tabs[lst]
+            l[index], l[prev] = l[prev], l[index]
+
+    def __copy__(self):
+        new = LateralContributionList()
+
+        for l in self._tabs:
+            new.tabs[l] = self._tabs[l].copy()
+
+        return new
+
+    def __deepcopy__(self):
+        new = LateralContributionList()
+
+        for l in self._tabs:
+            new.tabs[l] = self._tabs[l].deepcopy()
+
+        return new
+
+    def copy(self):
+        return copy(self)

src/Model/LateralContribution/LateralContributionTypes.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+from Model.Except import NotImplementedMethodeError
+
+from Model.LateralContribution.LateralContribution import LateralContribution
+
+
+class NotDefined(LateralContribution):
+    def __init__(self, name:str = ""):
+        super(NotDefined, self).__init__(name=name)
+
+        self._type = "ND"
+        self._header = ["x", "y"]
+
+    @property
+    def _default_0(self):
+        return 0.0
+
+class PonctualContribution(LateralContribution):
+    def __init__(self, name:str = ""):
+        super(PonctualContribution, self).__init__(name=name)
+
+        self._type = "PC"
+        self._header = ["time", "debit"]
+        self._types = [PonctualContribution.time_convert, float]
+
+    @classmethod
+    def compatibility(cls):
+        return ["liquid"]
+
+class TimeOverZ(LateralContribution):
+    def __init__(self, name:str = ""):
+        super(TimeOverZ, self).__init__(name=name)
+
+        self._type = "TZ"
+        self._header = ["time", "z"]
+        self._types = [TimeOverZ.time_convert, float]
+
+    @classmethod
+    def compatibility(cls):
+        return ["liquid"]
+
+class TimeOverDebit(LateralContribution):
+    def __init__(self, name:str = ""):
+        super(TimeOverDebit, self).__init__(name=name)
+
+        self._type = "TD"
+        self._header = ["time", "debit"]
+        self._types = [TimeOverDebit.time_convert, float]
+
+    @classmethod
+    def compatibility(cls):
+        return ["liquid"]
+
+class ZOverDebit(LateralContribution):
+    def __init__(self, name:str = ""):
+        super(ZOverDebit, self).__init__(name=name)
+
+        self._type = "ZD"
+        self._header = ["z", "debit"]
+        self._types = [float, float]
+
+    @classmethod
+    def compatibility(cls):
+        return ["liquid"]
+
+    @property
+    def _default_0(self):
+        return 0.0