pyHeatpump/pyheatpump/models/variable.py

from pyheatpump.db import RowClass
from pyheatpump.db import DB
from datetime import date
from pyheatpump.modbus import rtu

from .variable_type import VariableType
from .variable_value import VariableValue

class Variable(RowClass):
    address: int = None
    unit: str = None
    last_update: date = None
    type: VariableType = None

    def __init__(self, **kwargs):
        if 'type' in kwargs.keys() and type(kwargs['type']) != VariableType:
            kwargs['type'] = VariableType.get(kwargs['type'])

        super().__init__(**kwargs)


    def insert(self):

        try:
            DB.sql(
            """INSERT INTO variable
            (type, address)
            VALUES
            (:type, :address)
            """, self.__dict__)
            return True
        except Exception as e:
            print(e)
            return False


    def exists(self):
        try:
            return bool(next(DB.sql(
            """SELECT 1 FROM variable
            WHERE type=:type AND address=:address
            """, self.__dict__)))
        except StopIteration:
            return False

    @staticmethod
    def getall():
        return dict([
            (str(row), Variable.getall_of_type(row))
            for _, row in VariableType.getall().items()
        ])


    @staticmethod
    def getall_of_type(type: VariableType) -> dict:
        return {
            row['address']: Variable(**dict(row))
            for row in DB.sql(
            """SELECT * FROM variable
            WHERE type = :slabel
                AND address >= :start_address
                AND address <= :end_address""",
            type.__dict__)
       }


    @staticmethod
    def getall_values_of_type(type: VariableType) -> dict:
        return Variable.getall_values_of_type_since(type, 0)


    @staticmethod
    def getall_values_of_type_since(type: VariableType, since: int) -> dict:
        floatcast = lambda x: round(float(x) / 10, 2)
        cast_fct = floatcast if type.slabel == 'A' else lambda x: x
        type.__dict__.update({'since': since})

        return {
            row['address']: cast_fct(row['value'])
            for row in DB.sql(
            """SELECT var.address as address, val.value
            FROM variable var
            LEFT JOIN var_value val ON
                var.type = val.type
                AND var.address = val.address
                AND var.last_update = val.time
            WHERE
                var.type = :slabel
                AND var.address >= :start_address
                AND var.address <= :end_address
                AND var.last_update > :since""",
            type.__dict__)
        }



    def modbus_update(self):
        if self.type == 'A':
            pass
        elif self.type == 'I':
            pass
        elif self.type == 'D':
            pass