simo 2.11.4__py3-none-any.whl → 3.0.4__py3-none-any.whl

simo/fleet/socket_consumers.py

@@ -6,7 +6,6 @@ import traceback
 import sys
 import zlib
 import time
-from django.db import transaction
 from logging.handlers import RotatingFileHandler
 from django.utils import timezone
 from django.conf import settings
@@ -24,12 +23,11 @@ from simo.users.models import Fingerprint
 from .gateways import FleetGatewayHandler
 from .models import Colonel
 from .controllers import TTLock
+from .voice_assistant import VoiceAssistantSession, VoiceAssistantArbitrator
 
 
 @capture_socket_errors
 class FleetConsumer(AsyncWebsocketConsumer):
-
-
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.colonel = None
@@ -37,18 +35,50 @@ class FleetConsumer(AsyncWebsocketConsumer):
         self.connected = False
         self.mqtt_client = None
         self.last_seen = 0
+        self._va = None
+        self._arb = None
 
 
     async def disconnect(self, code):
-        print("Colonel %s socket disconnected!" % str(self.colonel))
+        try:
+            print(f"Colonel {self.colonel} socket disconnected! code={code}")
+        except Exception:
+            print("Colonel socket disconnected!")
         self.connected = False
         if self.mqtt_client:
             self.mqtt_client.loop_stop()
+        try:
+            if self._va and (self._va.active or self.colonel.is_vo_active):
+                await self._va._end_session(cloud_also=True)
+            elif getattr(self.colonel, 'is_vo_active', False):
+                def _save():
+                    self.colonel.is_vo_active = False
+                    self.colonel.save(update_fields=['is_vo_active'])
+                await sync_to_async(_save, thread_sensitive=True)()
+                try:
+                    base = await sync_to_async(lambda: dynamic_settings.get('core__remote_http'), thread_sensitive=True)()
+                    hub_uid = await sync_to_async(lambda: dynamic_settings['core__hub_uid'], thread_sensitive=True)()
+                    hub_secret = await sync_to_async(lambda: dynamic_settings['core__hub_secret'], thread_sensitive=True)()
+                    base = base or 'https://simo.io'
+                    url = base.rstrip('/') + '/ai/finish-session/'
+                    payload = {
+                        'hub_uid': hub_uid,
+                        'hub_secret': hub_secret,
+                        'instance_uid': self.instance.uid,
+                    }
+                    import requests
+                    loop = asyncio.get_running_loop()
+                    await loop.run_in_executor(None, lambda: requests.post(url, json=payload, timeout=5))
+                except Exception:
+                    pass
+        except Exception:
+            pass
 
         def save_disconect():
             if self.colonel:
                 self.colonel.socket_connected = False
-                self.colonel.save(update_fields=['socket_connected'])
+                self.colonel.is_vo_active = False
+                self.colonel.save(update_fields=['socket_connected', 'is_vo_active'])
         await sync_to_async(save_disconect, thread_sensitive=True)()
 
 
@@ -102,9 +132,6 @@ class FleetConsumer(AsyncWebsocketConsumer):
                 'last_seen': timezone.now(),
                 'enabled': True
             }
-            # !!!!! ATETION! !!!!!!!
-            # update_or_create and get_or_create doesn't
-            # provide reliable operation in socket/async environment.
             new = False
             colonel = Colonel.objects.filter(uid=headers['colonel-uid']).first()
             if not colonel:
@@ -138,6 +165,14 @@ class FleetConsumer(AsyncWebsocketConsumer):
         self.connected = True
 
         await self.log_colonel_connected()
+        def _reset_vo():
+            if self.colonel.is_vo_active:
+                self.colonel.is_vo_active = False
+                self.colonel.save(update_fields=['is_vo_active'])
+        try:
+            await sync_to_async(_reset_vo, thread_sensitive=True)()
+        except Exception:
+            pass
 
 
         def get_gateway():
@@ -167,18 +202,6 @@ class FleetConsumer(AsyncWebsocketConsumer):
                                      port=settings.MQTT_PORT)
             self.mqtt_client.loop_start()
 
-            # DO NOT FORCE CONFIG DATA!!!!
-            # as colonels might already have config and want to
-            # send updated values of components, like for example
-            # somebody turned some lights on/off while colonel was
-            # not connected to the main hub.
-            # If we force this, vales get overridden by what is last
-            # known by the hub
-            # config = await self.get_config_data()
-            # await self.send_data(
-            #     'command': 'set_config', 'data': config
-            # })
-
             await self.send_data({'command': 'hello'})
 
         asyncio.create_task(self.watch_connection())
@@ -195,13 +218,15 @@ class FleetConsumer(AsyncWebsocketConsumer):
                     self.colonel.minor_upgrade_available
                 )
 
-            # Default pinging system sometimes get's lost somewhere,
-            # therefore we use our own to ensure connection and understand if
-            # colonel is connected or not
-
             if time.time() - self.last_seen > 2:
                 await self.send_data({'command': 'ping'})
 
+            try:
+                if self._va and self._va.active and (time.time() - self.last_seen) > 60:
+                    await self._va._end_session(cloud_also=True)
+            except Exception:
+                pass
+
             await asyncio.sleep(2)
 
 
@@ -339,7 +364,7 @@ class FleetConsumer(AsyncWebsocketConsumer):
                         config = await self.get_config_data()
                         await self.send_data({
                             'command': 'set_config', 'data': config
-                        }, compress=True)
+                        }, compress=self.colonel.type != 'sentinel')
                     asyncio.run(send_config())
                 elif payload.get('command') == 'discover':
                     print(f"SEND discover command for {payload['type']}")
@@ -385,7 +410,7 @@ class FleetConsumer(AsyncWebsocketConsumer):
                     print("Send config: ", config)
                     await self.send_data({
                         'command': 'set_config', 'data': config
-                    }, compress=True)
+                    }, compress=self.colonel.type != 'sentinel')
                 elif 'comp' in data:
                     try:
                         try:
@@ -450,25 +475,64 @@ class FleetConsumer(AsyncWebsocketConsumer):
                         process_discovery_result, thread_sensitive=True
                     )()
 
-                elif 'dali-raw' in data:
-                    from .custom_dali_operations import process_frame
-                    await sync_to_async(process_frame, thread_sensitive=True)(
-                        self.colonel.id, data['dali-raw'], data['data']
-                    )
 
+                elif 'va' in data and isinstance(data['va'], dict):
+                    va = data['va']
+                    if va.get('session') == 'finish':
+                        if not self._va:
+                            self._va = VoiceAssistantSession(self)
+                        await self._va._end_session(cloud_also=True)
+
+                elif 'wake-stats' in data and self.colonel.type == 'sentinel':
+                    def update_wake_stats():
+                        va_component = Component.objects.filter(
+                            config__colonel=self.colonel.id,
+                            pk=data.get('id', 0)
+                        ).select_related('zone').first()
+                        self.colonel.wake_stats = data['wake-stats']
+                        self.colonel.last_wake = timezone.now()
+                        self.colonel.save()
+                        return va_component
+                    va_component = await sync_to_async(
+                        update_wake_stats, thread_sensitive=True
+                    )()
+                    if not self._va:
+                        self._va = VoiceAssistantSession(self)
+                    self._va.voice = data.get('voice', 'male')
+                    self._va.zone = va_component.zone.id
 
             elif bytes_data:
-                if not self.colonel_logger:
-                    await self.start_logger()
-
-                for logline in bytes_data.decode(errors='replace').split('\n'):
-                    self.colonel_logger.log(logging.INFO, logline)
+                if self.colonel.type == 'sentinel':
+                    if bytes_data[0] == 32:
+                        await self.capture_logs(bytes_data[1:])
+                    else:
+                        if not self._va:
+                            self._va = VoiceAssistantSession(self)
+                        if not self._arb:
+                            self._arb = VoiceAssistantArbitrator(self, self._va)
+                        await self._va.prewarm_on_first_audio()
+                        if await self._arb.maybe_reject_busy():
+                            return
+                        self._arb.start_window_if_needed()
+                        await self._va.on_audio_chunk(bytes_data[1:])
+                else:
+                    if bytes_data[0] == 32:
+                        await self.capture_logs(bytes_data[1:])
+                    else:
+                        await self.capture_logs(bytes_data)
 
             await self.log_colonel_connected()
         except Exception as e:
             print(traceback.format_exc(), file=sys.stderr)
 
 
+    async def capture_logs(self, bytes_data):
+        if not self.colonel_logger:
+            await self.start_logger()
+
+        for logline in bytes_data.decode(errors='replace').split('\n'):
+            self.colonel_logger.log(logging.INFO, logline)
+
 
     async def log_colonel_connected(self):
         self.last_seen = time.time()
@@ -513,6 +577,3 @@ class FleetConsumer(AsyncWebsocketConsumer):
         )
         file_handler.setFormatter(formatter)
         self.colonel_logger.addHandler(file_handler)
-
-
-

simo/fleet/tasks.py

@@ -20,8 +20,7 @@ def check_colonels_connected():
 @celery_app.task
 def check_colonel_components_alive():
     from simo.core.models import Component
-    from .gateways import FleetGatewayHandler
-    from .models import Colonel, CustomDaliDevice
+    from .models import Colonel
     drop_current_instance()
     for lost_colonel in Colonel.objects.filter(
         last_seen__lt=timezone.now() - datetime.timedelta(seconds=60)
@@ -33,28 +32,9 @@ def check_colonel_components_alive():
             print(f"{comp} is no longer alive!")
             comp.alive = False
             comp.save()
-        for interface in lost_colonel.interfaces.all():
-            if interface.type == 'dali':
-                for device in interface.custom_devices.all():
-                    for comp in Component.objects.filter(
-                        gateway__type=FleetGatewayHandler.uid,
-                        config__dali_device=device.id, alive=True
-                    ):
-                        comp.alive = False
-                        comp.save()
-
-    for device in CustomDaliDevice.objects.filter(
-        last_seen__gt=timezone.now() - datetime.timedelta(seconds=60)
-    ):
-        for comp in Component.objects.filter(
-            gateway__type=FleetGatewayHandler.uid,
-            config__dali_device=device.id, alive=True
-        ):
-            comp.alive = False
-            comp.save()
 
 
 @celery_app.on_after_finalize.connect
 def setup_periodic_tasks(sender, **kwargs):
     sender.add_periodic_task(10, check_colonels_connected.s())
-    sender.add_periodic_task(20, check_colonel_components_alive.s())
+    sender.add_periodic_task(20, check_colonel_components_alive.s())