[models] fix type casting (issue #30)

pyheatpump/models/variable.py

 
     def exists(self):
         try:
-            self.type_slabel = self.type.slabel
-
             return bool(next(DB.sql(
             """SELECT 1 FROM variable
-            WHERE type=:type_slabel AND address=:address
-            """, self.__dict__)))
+            WHERE type=:type AND address=:address
+            """, {
+                'type': self.type.slabel,
+                'address': self.address
+            })))
         except StopIteration:
             return False
 
             row['address']: Variable(**dict(row))
             for row in DB.sql(
             """SELECT * FROM variable
-            WHERE var_type = :slabel
+            WHERE type = :slabel
                 AND address >= :start_address
                 AND address <= :end_address""", {
 
 
     @staticmethod
     def getall_values_of_type_since(var_type: VariableType, since: int) -> dict:
+        """
         floatcast = lambda x: round(float(x) / 10, 2)
         cast_fct = floatcast if type.slabel == 'A' else lambda x: x
+        """
+        if not var_type.cast:
+            raise Exception('var_type has no cast property')
+
         params = {
             'slabel': var_type.slabel,
             'start_address': var_type.start_address,
         }
 
         return {
-            row['address']: cast_fct(row['value'])
+            row['address']: var_type.cast(row['value'])
 
             for row in DB.sql(
             """SELECT var.address as address, val.value as value

pyheatpump/models/variable_type.py

         return self.slabel or self.label[0]
 
 
+    @property
     def cast(self):
-        return ({
-            'float': float,
-            'int': int,
-            'bool': bool
-        }).get(self.type, None)
-
+        complement = lambda x: x - (1 << 16 if x & (1 << 15) else 0)
+
+        # Function to convert numbers > 2**15 to negative numbers (issue #30)
+        if self.type == 'bool':
+            # returns a boolean
+            return lambda x: bool(x)
+        elif self.type == 'float':
+            # returns a signed float
+            return lambda x: round(complement(x) / 10, 2)
+        elif self.type == 'int':
+            # returns the signed integer
+            return lambda x: int(complement(x))
+
+        return None
 
     def select(self):
         try:

pyheatpump/models/variable_value.py

     value: int = None
 
     def __init__(self, **kwargs):
-        if 'type' in kwargs.keys() and isinstance(kwargs['type'], VariableType):
+        if 'type' in kwargs.keys() and not isinstance(kwargs['type'], VariableType):
             kwargs['type'] = VariableType.get(kwargs['type'])
 
 
 
 
     def get_value(self):
-        return self.type.cast()(self.value)
+        return self.type.cast(self.value)
 
     def equals(self, var_value):
         return self.get_value() == var_value.get_value()
             LIMIT 1""", {
                 'type':str(var_type), 'address':address, 'time':int(time.strftime('%s'))+1
             }))
-            return VariableValue(**dict(row))
+            return VariableValue(**{ **dict(row), **{ 'type': var_type } })
         except StopIteration as e:
             raise e