LateralContribution.py

# -*- 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 = "", status = None):
        super(LateralContribution, self).__init__()

        self._status = status

        self._name = name
        self._type = ""
        self._edge = None
        self._begin_kp = 0.0
        self._end_kp = 0.0
        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
        self._status.modified()

    @property
    def lctype(self):
        return self._type

    @property
    def edge(self):
        return self._edge

    @edge.setter
    def edge(self, edge):
        self._edge = edge
        if edge is not None:
            self._begin_kp = self._edge.reach.get_kp_min()
            self._end_kp = self._edge.reach.get_kp_max()
        self._status.modified()

    def has_edge(self):
        return self._edge is not None

    @property
    def begin_kp(self):
        return self._begin_kp

    @begin_kp.setter
    def begin_kp(self, begin_kp):
        if self._edge is None:
            self._begin_kp = begin_kp
        else:
            _min = self._edge.reach.get_kp_min()
            _max = self._edge.reach.get_kp_max()

            if _min <= begin_kp <= _max:
                self._begin_kp = begin_kp

        self._status.modified()

    @property
    def end_kp(self):
        return self._end_kp

    @end_kp.setter
    def end_kp(self, end_kp):
        if self._edge is None:
            self._end_kp = end_kp
        else:
            _min = self._edge.reach.get_kp_min()
            _max = self._edge.reach.get_kp_max()

            if _min <= end_kp <= _max:
                self._end_kp = end_kp

        self._status.modified()

    @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)
        self._status.modified()
        return value

    def insert(self, index:int, value):
        self._data.insert(index, value)
        self._status.modified()

    def delete_i(self, indexes):
        self._data = list(
            map(
                lambda e: e[1],
                filter(
                    lambda e: e[0] not in indexes,
                    enumerate(self.data)
                )
            )
        )
        self._status.modified()

    def delete(self, els):
        self._data = list(
            filter(
                lambda e: e not in els,
                self.data
            )
        )
        self._status.modified()

    def sort(self, _reverse=False, key=None):
        if key is None:
            self._data.sort(reverse=_reverse)
        else:
            self._data.sort(reverse=_reverse, key=key)
        self._status.modified()

    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)
        self._status.modified()

    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, status = self._status)
        new.edge = self.edge
        new.begin_kp = self.begin_kp
        new.end_kp = self.end_kp

        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])

        self._status.modified()
        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]
            self._status.modified()

    def move_down(self, index):
        if index >= 0:
            prev = index + 1
            d = self._data
            d[index], d[prev] = d[prev], d[index]
            self._status.modified()