Add all complex types and schedule.

Author: iabdalkader

aiotcloud/__init__.py

@@ -23,11 +23,46 @@
 # THE SOFTWARE.
 from .ucloud import AIOTClient
 from .ucloud import AIOTObject
+from .ucloud import timestamp
+try:
+    import asyncio
+except ImportError:
+    import uasyncio as asyncio
 
 class Location(AIOTObject):
     def __init__(self, name, **kwargs):
         super().__init__(name, keys={"lat", "lon"}, **kwargs)
 
+class Color(AIOTObject):
+    def __init__(self, name, **kwargs):
+        super().__init__(name, keys={"hue", "sat", "bri"}, **kwargs)
+
 class ColoredLight(AIOTObject):
     def __init__(self, name, **kwargs):
         super().__init__(name, keys={"swi", "hue", "sat", "bri"}, **kwargs)
+
+class DimmedLight(AIOTObject):
+    def __init__(self, name, **kwargs):
+        super().__init__(name, keys={"swi", "bri"}, **kwargs)
+
+class Schedule(AIOTObject):
+    def __init__(self, name, **kwargs):
+        kwargs.update({("runnable", True)}) # Force task creation.
+        kwargs.update({("interval", 1.0)})  # Will run on every second
+        self.on_active = kwargs.pop("on_active", None)
+        # Uncomment to allow the schedule to change in runtime.
+        #kwargs["on_write"] = kwargs.get("on_write", lambda aiot, value: None)
+        self.active = False
+        super().__init__(name, keys={"frm", "to", "len", "msk"}, **kwargs)
+
+    async def run(self, aiot):
+        while True:
+            if self.initialized:
+                ts = timestamp() + aiot.get("tz_offset", 0)
+                if ts > self.frm and ts < (self.frm + self.len):
+                    if not self.active and self.on_active is not None:
+                        self.on_active(aiot, self.value)
+                    self.active = True
+                else:
+                    self.active = False
+            await asyncio.sleep(self.interval)

aiotcloud/ucloud.py

@@ -48,6 +48,7 @@ def __init__(self, name, **kwargs):
         self.on_read  = kwargs.pop("on_read", None)
         self.on_write = kwargs.pop("on_write", None)
         self.interval = kwargs.pop("interval", 1.0)
+        self._runnable = kwargs.pop("runnable", False)
         value = kwargs.pop("value", None)
         if keys := kwargs.pop("keys", {}): # Create a complex object (with sub-records).
             mkrec = lambda k, v: AIOTObject(f"{name}:{k}", value=v, callback=self.senml_callback)
@@ -86,6 +87,10 @@ def initialized(self):
             return all(r.initialized for r in self.value.values())
         return self.value is not None
 
+    @property
+    def runnable(self):
+        return self.on_read is not None or self.on_write is not None or self._runnable
+
     @SenmlRecord.value.setter
     def value(self, value):
         if value is not None:
@@ -114,18 +119,16 @@ def __setattr__(self, name, value):
     def _build_rec_dict(self, naming_map, appendTo):
         if isinstance(self.value, dict):
             for r in self.value.values():
-                # NOTE: should filter by updated when it's supported.
-                if r.value is not None: # and r.updated
+                if r.value is not None: # NOTE: should filter by updated when it's supported.
                     r._build_rec_dict(naming_map, appendTo)
         else:
             super()._build_rec_dict(naming_map, appendTo)
 
     def add_to_pack(self, pack):
         if isinstance(self.value, dict):
             for r in self.value.values():
-                # NOTE: should filter by updated when it's supported.
-                if r.value is not None: # and r.updated
-                    pack.add(r)
+                # NOTE: If record value is None it can still be added to the pack for initialization.
+                pack.add(r) # NOTE: should filter by updated when it's supported.
         else:
             pack.add(self)
         self.updated = False
@@ -159,15 +162,26 @@ def __init__(self, device_id, ssl_params=None, server="mqtts-sa.iot.oniudra.cc",
         self.device_topic = b"/a/d/" + device_id + b"/e/i"
         self.senmlpack = SenmlPack("urn:uuid:"+device_id.decode("utf-8"), self.senml_generic_callback)
         self.mqtt_client = MQTTClient(device_id, server, port, ssl_params, keepalive=keepalive, callback=self.mqtt_callback)
-        # Note: this object is set by the cloud discovery protocol.
+        # Note: the following objects are initialized by the cloud.
         self.register("thing_id", value=None, on_write=self.discovery_callback)
+        self.register("tz_offset", value=None)
 
     def __getitem__(self, key):
-        return self.records[key]
+        if isinstance(self.records[key].value, dict):
+            return self.records[key]
+        return self.records[key].value
 
     def __setitem__(self, key, value):
         self.records[key].value = value
 
+    def __contains__(self, key):
+        return key in self.records
+
+    def get(self, key, default=None):
+        if key in self and self[key] is not None:
+            return self[key]
+        return default
+
     def update_systime(self):
         try:
             from aiotcloud import ntptime
@@ -195,7 +209,7 @@ def register(self, aiotobj, **kwargs):
         self.records[aiotobj.name] = aiotobj
 
         # Create a task for this object if it has any callbacks.
-        if aiotobj.on_read is not None or aiotobj.on_write is not None:
+        if aiotobj.runnable:
             self.create_new_task(aiotobj.run, self, name=aiotobj.name)
 
         # Check if object needs to be initialized from the cloud.
@@ -219,14 +233,12 @@ def discovery_callback(self, aiot, thing_id):
         self.thing_id  = bytes(thing_id, "utf-8")
         self.topic_in  = b"/a/t/" + self.thing_id + b"/e/i"
         self.topic_out = b"/a/t/" + self.thing_id + b"/e/o"
-
-        shadow_in = b"/a/t/" + self.thing_id + b"/shadow/i"
-        shadow_out= b"/a/t/" + self.thing_id + b"/shadow/o"
-
         logging.info(f"Subscribing to thing topic {self.topic_in}.")
         self.mqtt_client.subscribe(self.topic_in)
 
         if lastval_record := self.records.pop("r:m", None):
+            shadow_in = b"/a/t/" + self.thing_id + b"/shadow/i"
+            shadow_out= b"/a/t/" + self.thing_id + b"/shadow/o"
             lastval_record.add_to_pack(self.senmlpack)
             logging.info(f"Subscribing to shadow topic {shadow_in}.")
             self.mqtt_client.subscribe(shadow_in)

aiotcloud_example.py

@@ -35,6 +35,7 @@
     from ulogging.ustrftime import strftime
 from aiotcloud import AIOTClient
 from aiotcloud import Location
+from aiotcloud import Schedule
 from aiotcloud import ColoredLight
 from random import randint, choice
 
@@ -98,6 +99,11 @@ async def main():
     # This variable is updated manually from user_main.
     aiot.register("user", value="")
 
+    # This object allows scheduling recurring events from the cloud UI. On activation of the event, if
+    # on_active callback is provided, it gets called with the aiot object and the schedule object value.
+    # The activation status of the object can also be polled using aiot["schedule"].active.
+    aiot.register(Schedule("schedule", on_active=lambda aiot, value: logging.info(f"Schedule activated {value}!")))
+
     # Start the AIoT client.
     await aiot.run(user_main, debug=DEBUG_ENABLED)