"added dataclassed"

.gitignore

@@ -11,4 +11,7 @@ cbpi/extension/ui
 node_modules
 .DS_STORE
 .vscode
-.DS_Store 
+.DS_Store 
+.vscode/
+config/
+logs/

cbpi/__init__.py

@@ -1 +1 @@
-__version__ = "4.0.0.20"
+__version__ = "4.0.0.21"

cbpi/api/__init__.py

@@ -14,8 +14,7 @@
            "SensorException",
            "ActorException",
            "CBPiSensor",
-           "CBPiStep",
-           "Stop_Reason"]
+           "CBPiStep"]
 
 from cbpi.api.actor import *
 from cbpi.api.sensor import *

cbpi/api/actor.py

@@ -26,19 +26,36 @@ def init(self):
 
     def log_data(self, value):
         self.cbpi.log.log_data(self.id, value)
-
-    async def run(self):
-        while self.running:
-            await asyncio.sleep(1)
 
     def get_state(self):
         return dict(state=self.state)
 
     async def start(self):
-        self.running = True
+        pass
 
     async def stop(self):
-        self.running = False
+        pass
+
+    async def on_start(self):
+        pass
+
+    async def on_stop(self):
+        pass
+
+    async def run(self):
+        pass
+
+    async def _run(self):
+
+        try:
+            await self.on_start()
+            self.cancel_reason = await self.run()
+        except asyncio.CancelledError as e:
+            pass
+        finally:
+            await self.on_stop()
+
+
 
     def get_static_config_value(self,name,default):
         return self.cbpi.static_config.get(name, default)

cbpi/api/base.py

@@ -24,7 +24,7 @@ def get_kettle(self,id):
         return self.cbpi.kettle.find_by_id(id)
 
     def get_kettle_target_temp(self,id):
-        return self.cbpi.kettle.find_by_id(id).get("target_temp")
+        return self.cbpi.kettle.find_by_id(id).target_temp
 
     async def set_target_temp(self,id, temp):
         await self.cbpi.kettle.set_target_temp(id, temp)
@@ -33,6 +33,7 @@ def get_sensor(self,id):
         return self.cbpi.sensor.find_by_id(id)
 
     def get_sensor_value(self,id):
+
         return self.cbpi.sensor.get_sensor_value(id)
 
     def get_actor(self,id):
@@ -46,22 +47,17 @@ def get_actor_state(self,id):
             logging.error("Faild to read actor state in step - actor {}".format(id))
             return None
 
-
-
     async def actor_on(self,id):
 
         try:
-            print("\n\n ON\n\n\n\n" )
             await self.cbpi.actor.on(id)
         except Exception as e:
             pass
 
     async def actor_off(self,id):
         try:
-            print("\n\n OFF\n\n\n\n" )
             await self.cbpi.actor.off(id)
         except Exception as e:
-            print("E", e)
             pass
 
 

cbpi/api/dataclasses.py

@@ -0,0 +1,144 @@
+from cbpi.api.config import ConfigType
+from enum import Enum
+from typing import Any
+from cbpi.api.step import StepState
+from dataclasses import dataclass
+
+class Props:
+
+    def __init__(self, data={}):
+        super(Props, self).__setattr__('__data__', {})
+        for key, value in data.items():
+            self.__setattr__(key, value)
+    def __getattr__(self, name):
+        return self.__data__.get(name)
+
+    def __setattr__(self, name, value):
+        self.__data__[name] = value
+
+    def __str__(self):
+        return self.__data__.__str__()
+
+
+    def __getitem__(self, key):
+        return self.__data__[key]
+
+    def __setitem__(self, key, value):
+        self.__data__[key] = value
+
+    def __contains__(self, key):
+        return key in self.__data__
+
+    def get(self, key, d=None):
+        if key in self.__data__:
+            return self.__data__[key]
+        else:
+            return d
+
+    def to_dict(self):
+
+        def parse_object(value):
+            if isinstance(value, Props):
+                return value.to_dict()
+            elif isinstance(value, list):
+                return list(map(parse_object, value))
+            else:
+                return value
+
+        return dict((key, parse_object(value)) for (key, value) in self.__data__.items())
+
+
+
+@dataclass
+class Actor:
+    id: str = None
+    name: str = None
+    props: Props = Props()
+    state: bool = False
+    type: str = None
+    instance: str = None
+
+    def __str__(self):
+        return "name={} props={}, state={}, type={}".format(self.name, self.props, self.state, self.type)
+    def to_dict(self):
+        return dict(id=self.id, name=self.name, type=self.type, props=self.props.to_dict(), state=self.instance.get_state())
+
+
+@dataclass
+class Sensor:
+    id: str = None
+    name: str = None
+    props: Props = Props()
+    state: bool = False
+    type: str = None
+    instance: str = None
+
+    def __str__(self):
+        return "name={} props={}, state={}".format(self.name, self.props, self.state)
+    def to_dict(self):
+        return dict(id=self.id, name=self.name, type=self.type, props=self.props.to_dict(), state=self.state)
+
+@dataclass
+class Kettle:
+    id: str = None
+    name: str = None
+    props: Props = Props()
+    instance: str = None
+    agitator: Actor = None
+    heater: Actor = None
+    sensor: Sensor = None
+    type: str = None
+    target_temp: int = 0
+
+    def __str__(self):
+        return "name={} props={} temp={}".format(self.name, self.props, self.target_temp)
+    def to_dict(self):
+
+        if self.instance is not None:
+
+            state = self.instance.state
+            print("READ STATE", state)
+        else:
+            state = False
+        return dict(id=self.id, name=self.name, state=state,  target_temp=self.target_temp, heater=self.heater, agitator=self.agitator, sensor=self.sensor, type=self.type, props=self.props.to_dict())
+
+@dataclass
+class Step:
+    id: str = None
+    name: str = None
+    props: Props = Props()
+    type: str = None
+    status: StepState = StepState.INITIAL
+    instance: str = None
+
+    def __str__(self):
+        return "name={} props={}, type={}, instance={}".format(self.name, self.props, self.type, self.instance)
+    def to_dict(self):
+
+        msg = self.instance.summary if self.instance is not None else ""
+
+        return dict(id=self.id, name=self.name, state_text=msg, type=self.type, status=self.status.value, props=self.props.to_dict())
+
+
+
+class ConfigType(Enum):
+    STRING="string"
+    ACTOR="actor"
+    SENSOR="sensor"
+    KETTLE="kettle"
+    NUMBER="number"
+    SELECT="select"
+
+@dataclass  
+class Config:
+
+    name: str = None
+    value: Any = None
+    description: str = None
+    type: ConfigType = ConfigType.STRING
+    options: Any = None
+
+    def __str__(self):
+        return "....name={} value={}".format(self.name, self.value)
+    def to_dict(self):  
+        return dict(name=self.name, value=self.value, type=self.type.value, description=self.description, options=self.options)