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]