simo 2.5.42__py3-none-any.whl → 2.6.2__py3-none-any.whl

simo/automation/gateways.py

@@ -0,0 +1,257 @@
+import sys
+import logging
+import pytz
+import json
+import time
+import multiprocessing
+import threading
+import traceback
+from django.conf import settings
+from django.utils import timezone
+from django.db import connection as db_connection
+from django.db.models import Q
+import paho.mqtt.client as mqtt
+from simo.core.models import Component
+from simo.core.middleware import introduce_instance, drop_current_instance
+from simo.core.gateways import BaseObjectCommandsGatewayHandler
+from simo.core.forms import BaseGatewayForm
+from simo.core.utils.logs import StreamToLogger
+from simo.core.events import GatewayObjectCommand, get_event_obj
+from simo.core.loggers import get_gw_logger, get_component_logger
+
+
+class ScriptRunHandler(multiprocessing.Process):
+    '''
+      Threading offers better overall stability, but we use
+      multiprocessing for Scripts so that they are better isolated and
+      we are able to kill them whenever we need.
+    '''
+    component = None
+    logger = None
+
+    def __init__(self, component_id, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.component_id = component_id
+
+    def run(self):
+        db_connection.connect()
+        self.component = Component.objects.get(id=self.component_id)
+        try:
+            tz = pytz.timezone(self.component.zone.instance.timezone)
+        except:
+            tz = pytz.timezone('UTC')
+        timezone.activate(tz)
+        introduce_instance(self.component.zone.instance)
+        self.logger = get_component_logger(self.component)
+        sys.stdout = StreamToLogger(self.logger, logging.INFO)
+        sys.stderr = StreamToLogger(self.logger, logging.ERROR)
+        self.component.set('running')
+
+        if hasattr(self.component.controller, '_run'):
+            def run_code():
+                self.component.controller._run()
+        else:
+            code = self.component.config.get('code')
+            def run_code():
+                start = time.time()
+                exec(code, globals())
+                if 'class Automation:' in code and time.time() - start < 1:
+                    Automation().run()
+
+            if not code:
+                self.component.value = 'finished'
+                self.component.save(update_fields=['value'])
+                return
+        print("------START-------")
+        try:
+            run_code()
+        except:
+            print("------ERROR------")
+            self.component.set('error')
+            raise
+        else:
+            print("------FINISH-----")
+            self.component.set('finished')
+            return
+
+
+class AutomationsGatewayHandler(BaseObjectCommandsGatewayHandler):
+    name = "Automation"
+    config_form = BaseGatewayForm
+
+    running_scripts = {}
+    periodic_tasks = (
+        ('watch_scripts', 10),
+    )
+
+    terminating_scripts = set()
+
+
+    def watch_scripts(self):
+        drop_current_instance()
+        # observe running scripts and drop the ones that are no longer alive
+        dead_scripts = False
+        for id, process in list(self.running_scripts.items()):
+            comp = Component.objects.filter(id=id).first()
+            if process.is_alive():
+                if not comp and id not in self.terminating_scripts:
+                    # script is deleted, or instance deactivated
+                    process.kill()
+                continue
+            else:
+                if id not in self.terminating_scripts:
+                    dead_scripts = True
+                    if comp:
+                        logger = get_component_logger(comp)
+                        logger.log(logging.INFO, "-------DEAD!-------")
+                    self.stop_script(comp, 'error')
+
+        if dead_scripts:
+            # give 10s air before we wake these dead scripts up!
+            return
+
+        from .controllers import Script
+        for script in Component.objects.filter(
+            controller_uid=Script.uid,
+            config__keep_alive=True
+        ).exclude(value__in=('running', 'stopped', 'finished')):
+            self.start_script(script)
+
+    def run(self, exit):
+        drop_current_instance()
+        self.exit = exit
+        self.logger = get_gw_logger(self.gateway_instance.id)
+        for task, period in self.periodic_tasks:
+            threading.Thread(
+                target=self._run_periodic_task, args=(exit, task, period), daemon=True
+            ).start()
+
+        from .controllers import Script
+
+        mqtt_client = mqtt.Client()
+        mqtt_client.username_pw_set('root', settings.SECRET_KEY)
+        mqtt_client.on_connect = self.on_mqtt_connect
+        mqtt_client.on_message = self.on_mqtt_message
+        mqtt_client.connect(host=settings.MQTT_HOST, port=settings.MQTT_PORT)
+
+        # We presume that this is the only running gateway, therefore
+        # if there are any running scripts, that is not true.
+        for component in Component.objects.filter(
+            controller_uid=Script.uid, value='running'
+        ):
+            component.value = 'error'
+            component.save()
+
+        # Start scripts that are designed to be autostarted
+        # as well as those that are designed to be kept alive, but
+        # got terminated unexpectedly
+        for script in Component.objects.filter(
+            base_type='script',
+        ).filter(
+            Q(config__autostart=True) |
+            Q(value='error', config__keep_alive=True)
+        ).distinct():
+            self.start_script(script)
+
+        print("GATEWAY STARTED!")
+        while not exit.is_set():
+            mqtt_client.loop()
+        mqtt_client.disconnect()
+
+        script_ids = [id for id in self.running_scripts.keys()]
+        for id in script_ids:
+            self.stop_script(
+                Component.objects.get(id=id), 'error'
+            )
+
+        time.sleep(0.5)
+        while len(self.running_scripts.keys()):
+            print("Still running scripts: ", self.running_scripts.keys())
+            time.sleep(0.5)
+
+    def on_mqtt_connect(self, mqtt_client, userdata, flags, rc):
+        command = GatewayObjectCommand(self.gateway_instance)
+        mqtt_client.subscribe(command.get_topic())
+
+    def on_mqtt_message(self, client, userdata, msg):
+        print("Mqtt message: ", msg.payload)
+        from .controllers import Script
+        payload = json.loads(msg.payload)
+        drop_current_instance()
+        component = get_event_obj(payload, Component)
+        if not component:
+            return
+        introduce_instance(component.zone.instance)
+        if not isinstance(component.controller, Script):
+            return
+
+        if payload.get('set_val') == 'start':
+            self.start_script(component)
+        elif payload.get('set_val') == 'stop':
+            self.stop_script(component)
+
+
+    def start_script(self, component):
+        print("START SCRIPT %s" % str(component))
+        if component.id in self.running_scripts:
+            if component.id not in self.terminating_scripts:
+                if component.value != 'running':
+                    component.value = 'running'
+                    component.save()
+                    return
+            else:
+                good_to_go = False
+                for i in range(12): # wait for 3s
+                    time.sleep(0.2)
+                    component.refresh_from_db()
+                    if component.id not in self.running_scripts:
+                        good_to_go = True
+                        break
+                if not good_to_go:
+                    return self.stop_script(component, 'error')
+
+        self.running_scripts[component.id] = ScriptRunHandler(
+            component.id, daemon=True
+        )
+        self.running_scripts[component.id].start()
+
+    def stop_script(self, component, stop_status='stopped'):
+        self.terminating_scripts.add(component.id)
+        if component.id not in self.running_scripts:
+            if component.value == 'running':
+                component.value = stop_status
+                component.save(update_fields=['value'])
+            return
+
+        tz = pytz.timezone(component.zone.instance.timezone)
+        timezone.activate(tz)
+        logger = get_component_logger(component)
+        if stop_status == 'error':
+            logger.log(logging.INFO, "-------GATEWAY STOP-------")
+        else:
+            logger.log(logging.INFO, "-------STOP-------")
+        self.running_scripts[component.id].terminate()
+
+        def kill():
+            start = time.time()
+            terminated = False
+            while start > time.time() - 2:
+                if not self.running_scripts[component.id].is_alive():
+                    terminated = True
+                    break
+                time.sleep(0.1)
+            if not terminated:
+                if stop_status == 'error':
+                    logger.log(logging.INFO, "-------GATEWAY KILL-------")
+                else:
+                    logger.log(logging.INFO, "-------KILL!-------")
+                self.running_scripts[component.id].kill()
+
+            component.set(stop_status)
+            self.terminating_scripts.remove(component.id)
+            # making sure it's fully killed along with it's child processes
+            self.running_scripts[component.id].kill()
+            self.running_scripts.pop(component.id, None)
+            logger.handlers = []
+
+        threading.Thread(target=kill, daemon=True).start()

simo/automation/migrations/0001_initial.py

@@ -0,0 +1,39 @@
+# Generated by Django 4.2.10 on 2024-11-27 07:40
+
+from django.db import migrations
+
+
+def forwards_func(apps, schema_editor):
+    Component = apps.get_model("core", "Component")
+    Gateway = apps.get_model('core', "Gateway")
+
+    automation, new = Gateway.objects.get_or_create(
+        type='simo.automation.gateways.AutomationsGatewayHandler'
+    )
+
+    for script in Component.objects.filter(
+        controller_uid__in=(
+            'simo.generic.controllers.PresenceLighting',
+            'simo.generic.controllers.Script',
+        )
+    ):
+        script.controller_uid = script.controller_uid.replace(
+            'simo.generic', 'simo.automation'
+        )
+        script.gateway = automation
+        script.save()
+
+
+def reverse_func(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('generic', '0002_auto_20241126_0726'),
+    ]
+
+    operations = [
+        migrations.RunPython(forwards_func, reverse_func, elidable=True),
+    ]

simo/automation/migrations/0002_update_helpers_in_scripts.py

@@ -0,0 +1,29 @@
+# Generated by Django 4.2.10 on 2024-11-27 08:23
+
+from django.db import migrations
+
+def forwards_func(apps, schema_editor):
+    Component = apps.get_model("core", "Component")
+
+    for script in Component.objects.filter(
+        controller_uid='simo.automation.controllers.Script'
+    ):
+        script.config['code'] = script.config['code'].replace(
+            'simo.generic.scripting.helpers', 'simo.automation.helpers'
+        )
+        script.save()
+
+
+def reverse_func(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('automation', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RunPython(forwards_func, reverse_func, elidable=True),
+    ]

simo/automation/templates/automations/auto_away.py

@@ -0,0 +1,55 @@
+import time
+from django.utils import timezone
+from simo.core.middleware import get_current_instance
+from simo.core.models import Component
+from simo.users.models import InstanceUser
+from simo.automation.helpers import (
+    get_day_evening_night_morning, LocalSun
+)
+
+
+class Automation:
+    STATE_COMP_ID = {{ state_comp_id }}
+    INACTIVITY_MINUTES = 30
+
+    def __init__(self):
+        self.instance = get_current_instance()
+        self.state = Component.objects.get(id=self.STATE_COMP_ID)
+        self.sensors_on_watch = set()
+        self.last_sensor_action = time.time()
+        self.sun = LocalSun(self.instance.location)
+
+    def sensor_change(self, sensor=None):
+        self.last_sensor_action = time.time()
+
+    def check_away(self):
+        if InstanceUser.objects.filter(
+            is_active=True, at_home=True
+        ).count():
+            return False
+
+        return (
+            time.time() - self.last_sensor_action
+        ) // 60 >= self.INACTIVITY_MINUTES
+
+    def run(self):
+        while True:
+            for sensor in Component.objects.filter(
+                base_type='binary-sensor',
+                alarm_category='security'
+            ):
+                if sensor.id not in self.sensors_on_watch:
+                    sensor.on_change(self.sensor_change)
+                    self.sensors_on_watch.add(sensor.id)
+
+            self.state.refresh_from_db()
+            if self.check_away():
+                if self.state.value != 'away':
+                    print("AWAY!")
+                    self.state.send('away')
+            else:
+                if self.state.value == 'away':
+                    new_state = get_day_evening_night_morning(
+                        self.sun, timezone.localtime()
+                    )
+                    print(f"{new_state.upper()}!")

simo/automation/templates/automations/auto_state_script.py

@@ -0,0 +1,31 @@
+import time
+import random
+from django.utils import timezone
+from simo.core.middleware import get_current_instance
+from simo.core.models import Component
+from simo.automation.helpers import (
+    LocalSun, get_day_evening_night_morning
+)
+
+
+class Automation:
+    STATE_COMPONENT_ID = {{ state_comp_id }}
+
+    def __init__(self):
+        self.state = Component.objects.get(id=self.STATE_COMPONENT_ID)
+        self.sun = LocalSun(get_current_instance().location)
+
+    def run(self):
+        while True:
+            self.state.refresh_from_db()
+            if self.state.value in ('day', 'night', 'evening', 'morning'):
+
+                current_state = get_day_evening_night_morning(
+                    self.sun, timezone.localtime()
+                )
+                if current_state != self.state.value:
+                    print(f"New state - {current_state}")
+                    self.state.send(current_state)
+
+            # randomize script check times
+            time.sleep(random.randint(20, 40))

simo/{core/templates/core/auto_night_day_script.py → automation/templates/automations/phones_sleep_script.py}

@@ -4,7 +4,9 @@ from django.utils import timezone
 from simo.core.middleware import get_current_instance
 from simo.core.models import Component
 from simo.users.models import InstanceUser
-from simo.generic.scripting.helpers import LocalSun
+from simo.automation.helpers import (
+    LocalSun, get_day_evening_night_morning
+)
 
 
 class Automation:
@@ -14,23 +16,26 @@ class Automation:
         self.instance = get_current_instance()
         self.state = Component.objects.get(id=self.STATE_COMPONENT_ID)
         self.sun = LocalSun(self.instance.location)
-        self.night_is_on = False
+        self.sleep_is_on = False
 
     def check_owner_phones(self, state, instance_users, datetime):
-        if not self.night_is_on:
-            if not (datetime.hour >= 22 or datetime.hour < 6):
+        if not self.sleep_is_on:
+            if not (datetime.hour >= 21 or datetime.hour < 6):
                 return
 
             for iuser in instance_users:
+                # ignoring inactive and non owner users
+                if not iuser.is_active or not iuser.role.is_owner:
+                    continue
                 # skipping users that are not at home
                 if not iuser.at_home:
                     continue
                 if not iuser.phone_on_charge:
                     # at least one user's phone is not yet on charge
                     return
-            self.night_is_on = True
-            print("Night!")
-            return 'night'
+            self.sleep_is_on = True
+            print("Let's turn on the sleep mode!")
+            return 'sleep'
         else:
             if datetime.hour >= 22 or datetime.hour < 6:
                 return
@@ -38,6 +43,9 @@ class Automation:
             # at home, none of them have their phones on charge
             # and current state is still night
             for iuser in instance_users:
+                # ignoring inactive and non owner users
+                if not iuser.is_active or not iuser.role.is_owner:
+                    continue
                 # skipping users that are not at home
                 if not iuser.at_home:
                     continue
@@ -45,16 +53,20 @@ class Automation:
                     # at least one user's phone is still on charge
                     return
 
-            self.night_is_on = False
-            if not self.night_is_on and state.value == 'night':
-                print("Day has come!")
-                return 'day'
+            self.sleep_is_on = False
+
+            if not self.sleep_is_on and state.value == 'sleep':
+                new_state = get_day_evening_night_morning(
+                    self.sun, timezone.localtime()
+                )
+                print(f"Switch state back to {new_state}!")
+                return new_state
 
     def run(self):
         while True:
             instance_users = InstanceUser.objects.filter(
                 is_active=True, role__is_owner=True
-            )
+            ).prefetch_related('role')
             self.state.refresh_from_db()
             new_state = self.check_owner_phones(
                 self.state, instance_users, timezone.localtime()
@@ -62,5 +74,5 @@ class Automation:
             if new_state:
                 self.state.send(new_state)
 
-            # randomize script load
+            # randomize script check times
             time.sleep(random.randint(20, 40))

simo/core/admin.py

@@ -22,7 +22,7 @@ from .forms import (
     CompTypeSelectForm,
     BaseComponentForm
 )
-from .filters import ZonesFilter
+from .filters import ZonesFilter, AvailableChoicesFilter
 from .widgets import AdminImageWidget
 from simo.conf import dynamic_settings
 
@@ -255,7 +255,8 @@ class ComponentPermissionInline(admin.TabularInline):
 class ComponentAdmin(EasyObjectsDeleteMixin, admin.ModelAdmin):
     form = BaseComponentForm
     list_display = (
-        'id', 'name_display', 'value_display', 'base_type', 'alive', 'battery_level',
+        'id', 'name_display', 'value_display', 'base_type', 'controller_uid',
+        'alive', 'battery_level',
         'alarm_category', 'show_in_app',
     )
     readonly_fields = (
@@ -264,8 +265,10 @@ class ComponentAdmin(EasyObjectsDeleteMixin, admin.ModelAdmin):
         'control', 'value', 'arm_status', 'history', 'meta'
     )
     list_filter = (
-        'gateway', 'base_type', ('zone', ZonesFilter), 'category', 'alive',
-        'alarm_category', 'arm_status'
+        'gateway', 'base_type', ('zone', ZonesFilter), 'category',
+        #'controller_uid',
+        ('controller_uid', AvailableChoicesFilter),
+        'alive', 'alarm_category', 'arm_status',
     )
 
     search_fields = 'id', 'name', 'value', 'config', 'meta', 'notes'

simo/core/filters.py

@@ -1,4 +1,10 @@
 from django.contrib import admin
+from django.contrib.admin.utils import (
+    get_model_from_relation,
+    prepare_lookup_value,
+    reverse_field_path,
+)
+from django.utils.translation import gettext_lazy as _
 
 
 class ZonesFilter(admin.RelatedFieldListFilter):
@@ -10,3 +16,58 @@ class ZonesFilter(admin.RelatedFieldListFilter):
             include_blank=False, ordering=ordering,
             limit_choices_to=limit_to
         )
+
+
+class AvailableChoicesFilter(admin.ChoicesFieldListFilter):
+    """
+    presents as choices to filter only those choices that are present in a queryset
+    """
+
+    def __init__(self, field, request, params, model, model_admin, field_path):
+        super().__init__(field, request, params, model, model_admin, field_path)
+        parent_model, reverse_path = reverse_field_path(model, field_path)
+        # Obey parent ModelAdmin queryset when deciding which options to show
+        if model == parent_model:
+            queryset = model_admin.get_queryset(request)
+        else:
+            queryset = parent_model._default_manager.all()
+        self.lookup_choices = (
+            queryset.distinct().order_by(field.name).values_list(
+                field.name, flat=True
+            )
+        )
+
+
+    def choices(self, changelist):
+        yield {
+            "selected": self.lookup_val is None,
+            "query_string": changelist.get_query_string(
+                remove=[self.lookup_kwarg, self.lookup_kwarg_isnull]
+            ),
+            "display": _("All"),
+        }
+        none_title = ""
+
+        titles_map = {l:t for l, t in self.field.flatchoices}
+
+        for val in self.lookup_choices:
+            if val is None:
+                none_title = titles_map.get(val, val)
+                continue
+            val = str(val)
+            yield {
+                "selected": self.lookup_val == val,
+                "query_string": changelist.get_query_string(
+                    {self.lookup_kwarg: val}, [self.lookup_kwarg_isnull]
+                ),
+                "display": titles_map.get(val, val),
+            }
+
+        if none_title:
+            yield {
+                "selected": bool(self.lookup_val_isnull),
+                "query_string": changelist.get_query_string(
+                    {self.lookup_kwarg_isnull: "True"}, [self.lookup_kwarg]
+                ),
+                "display": none_title,
+            }