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

simo/automation/app_widgets.py

@@ -0,0 +1,8 @@
+from django.utils.translation import gettext_lazy as _
+from simo.core.app_widgets import BaseAppWidget
+
+
+class ScriptWidget(BaseAppWidget):
+    uid = 'script'
+    name = _("Script")
+    size = [2, 1]

simo/automation/controllers.py

@@ -0,0 +1,273 @@
+import time
+import json
+import requests
+import traceback
+import sys
+import random
+from bs4 import BeautifulSoup
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+from simo.conf import dynamic_settings
+from simo.users.middleware import get_current_user
+from simo.core.models import RUN_STATUS_CHOICES_MAP, Component
+from simo.core.utils.operations import OPERATIONS
+from simo.core.middleware import get_current_instance
+from simo.core.controllers import (
+    BEFORE_SEND, BEFORE_SET, ControllerBase, TimerMixin,
+)
+from .gateways import AutomationsGatewayHandler
+from .app_widgets import ScriptWidget
+from .forms import (
+    ScriptConfigForm, PresenceLightingConfigForm
+)
+from .state import get_current_state
+from .serializers import UserSerializer
+
+
+class Script(ControllerBase, TimerMixin):
+    name = _("AI Script")
+    base_type = 'script'
+    gateway_class = AutomationsGatewayHandler
+    app_widget = ScriptWidget
+    config_form = ScriptConfigForm
+    admin_widget_template = 'admin/controller_widgets/script.html'
+    default_config = {'autostart': True, 'autorestart': True}
+    default_value = 'stopped'
+
+    def _validate_val(self, value, occasion=None):
+        if occasion == BEFORE_SEND:
+            if value not in ('start', 'stop'):
+                raise ValidationError("Must be 'start' or 'stop'")
+        elif occasion == BEFORE_SET:
+            if value not in RUN_STATUS_CHOICES_MAP.keys():
+                raise ValidationError(
+                    "Invalid script controller status!"
+                )
+        return value
+
+    def _prepare_for_send(self, value):
+        if value == 'start':
+            new_code = getattr(self.component, 'new_code', None)
+            if new_code:
+                self.component.new_code = None
+                self.component.refresh_from_db()
+                self.component.config['code'] = new_code
+                self.component.save(update_fields=['config'])
+        return value
+
+    def _val_to_success(self, value):
+        if value == 'start':
+            return 'running'
+        else:
+            return 'stopped'
+
+    def start(self, new_code=None):
+        if new_code:
+            self.component.new_code = new_code
+        self.send('start')
+
+    def play(self):
+        return self.start()
+
+    def stop(self):
+        self.send('stop')
+
+    def toggle(self):
+        self.component.refresh_from_db()
+        if self.component.value == 'running':
+            self.send('stop')
+        else:
+            self.send('start')
+
+    def ai_assistant(self, wish):
+        try:
+            request_data = {
+                'hub_uid': dynamic_settings['core__hub_uid'],
+                'hub_secret': dynamic_settings['core__hub_secret'],
+                'instance_uid': get_current_instance().uid,
+                'system_data': json.dumps(get_current_state()),
+                'wish': wish,
+            }
+        except Exception as e:
+            print(traceback.format_exc(), file=sys.stderr)
+            return {'status': 'error', 'result': f"Internal error: {e}"}
+        user = get_current_user()
+        if user:
+            request_data['current_user'] = UserSerializer(user, many=False).data
+        try:
+            response = requests.post(
+                'https://simo.io/hubs/ai-assist/scripts/', json=request_data
+            )
+        except:
+            return {'status': 'error', 'result': "Connection error"}
+
+        if response.status_code != 200:
+            content = response.content.decode()
+            if '<html' in content:
+                # Parse the HTML content
+                soup = BeautifulSoup(response.content, 'html.parser')
+                content = F"Server error {response.status_code}: {soup.title.string}"
+            return {'status': 'error', 'result': content}
+
+        return {
+            'status': 'success',
+            'result': response.json()['script'],
+            'description': response.json()['description']
+        }
+
+
+class PresenceLighting(Script):
+    masters_only = False
+    name = _("Presence lighting")
+    config_form = PresenceLightingConfigForm
+
+    # script specific variables
+    sensors = {}
+    condition_comps = {}
+    light_org_values = {}
+    is_on = False
+    turn_off_task = None
+    last_presence = 0
+    hold_time = 60
+    conditions = []
+
+    def _run(self):
+        self.hold_time = self.component.config.get('hold_time', 0) * 10
+        for id in self.component.config['presence_sensors']:
+            sensor = Component.objects.filter(id=id).first()
+            if sensor:
+                sensor.on_change(self._on_sensor)
+                self.sensors[id] = sensor
+
+        for light_params in self.component.config['lights']:
+            light = Component.objects.filter(
+                id=light_params.get('light')
+            ).first()
+            if not light or not light.controller:
+                continue
+            light.on_change(self._on_light_change)
+
+        for condition in self.component.config.get('conditions', []):
+            comp = Component.objects.filter(
+                id=condition.get('component', 0)
+            ).first()
+            if comp:
+                condition['component'] = comp
+                self.conditions.append(condition)
+                comp.on_change(self._on_condition)
+                self.condition_comps[comp.id] = comp
+
+        while True:
+            self._regulate(on_val_change=False)
+            time.sleep(random.randint(5, 15))
+
+    def _on_sensor(self, sensor=None):
+        if sensor:
+            self.sensors[sensor.id] = sensor
+            self._regulate()
+
+    def _on_condition(self, condition_comp=None):
+        if condition_comp:
+            for condition in self.conditions:
+                if condition['component'].id == condition_comp.id:
+                    condition['component'] = condition_comp
+            self._regulate()
+
+    def _on_light_change(self, light):
+        if self.is_on:
+            self.light_org_values[light.id] = light.value
+
+    def _regulate(self, on_val_change=True):
+        presence_values = [s.value for id, s in self.sensors.items()]
+        if self.component.config.get('act_on', 0) == 0:
+            must_on = any(presence_values)
+        else:
+            must_on = all(presence_values)
+
+        if must_on and on_val_change:
+            print("Presence detected!")
+
+        additional_conditions_met = True
+        for condition in self.conditions:
+
+            comp = condition['component']
+
+            op = OPERATIONS.get(condition.get('op'))
+            if not op:
+                continue
+
+            if condition['op'] == 'in':
+                if comp.value not in self._string_to_vals(condition['value']):
+                    if must_on and on_val_change:
+                        print(
+                            f"Condition not met: [{comp} value:{comp.value} "
+                            f"{condition['op']} {condition['value']}]"
+                        )
+                    additional_conditions_met = False
+                    break
+
+            if not op(comp.value, condition['value']):
+                if must_on and on_val_change:
+                    print(
+                        f"Condition not met: [{comp} value:{comp.value} "
+                        f"{condition['op']} {condition['value']}]"
+                    )
+                additional_conditions_met = False
+                break
+
+        if must_on and additional_conditions_met and not self.is_on:
+            print("Turn the lights ON!")
+            self.is_on = True
+            self.light_org_values = {}
+            for light_params in self.component.config['lights']:
+                comp = Component.objects.filter(
+                    id=light_params.get('light')
+                ).first()
+                if not comp or not comp.controller:
+                    continue
+                self.light_org_values[comp.id] = comp.value
+                print(f"Send {light_params['on_value']} to {comp}!")
+                comp.controller.send(light_params['on_value'])
+            return
+
+        if self.is_on:
+            if not additional_conditions_met:
+                return self._turn_it_off()
+            if not any(presence_values):
+                if not self.component.config.get('hold_time', 0):
+                    return self._turn_it_off()
+
+                if not self.last_presence:
+                    self.last_presence = time.time()
+
+                if self.hold_time and (
+                    time.time() - self.hold_time > self.last_presence
+                ):
+                    self._turn_it_off()
+
+
+    def _turn_it_off(self):
+        print("Turn the lights OFF!")
+        self.is_on = False
+        self.last_presence = 0
+        for light_params in self.component.config['lights']:
+            comp = Component.objects.filter(
+                id=light_params.get('light')
+            ).first()
+            if not comp or not comp.controller:
+                continue
+
+            if not light_params.get('off_value', 0):
+                off_val = 0
+            else:
+                off_val = self.light_org_values.get(comp.id, 0)
+            print(f"Send {off_val} to {comp}!")
+            comp.send(off_val)
+
+
+# TODO: Night lighting
+#
+# Lights: components (switches, dimmers)
+# On value: 40
+# Sunset offset (mins): negative = earlier, positive = later
+# Save energy at night: 1 - 6 turn the lights completely off at night.

simo/automation/forms.py

@@ -0,0 +1,290 @@
+import time
+from django import forms
+from django.forms import formset_factory
+from django.utils.translation import gettext_lazy as _
+from django.urls.base import get_script_prefix
+from django.contrib.contenttypes.models import ContentType
+from simo.core.forms import BaseComponentForm
+from simo.core.models import Component
+from simo.core.controllers import BEFORE_SET
+from simo.core.widgets import PythonCode, LogOutputWidget
+from dal import forward
+from simo.core.utils.formsets import FormsetField
+from simo.core.form_fields import (
+    Select2ModelChoiceField,
+    Select2ModelMultipleChoiceField
+)
+
+
+class ScriptConfigForm(BaseComponentForm):
+    autostart = forms.BooleanField(
+        initial=True, required=False,
+        help_text="Start automatically on system boot."
+    )
+    keep_alive = forms.BooleanField(
+        initial=True, required=False,
+        help_text="Restart the script if it fails. "
+    )
+    assistant_request = forms.CharField(
+        label="Request for AI assistant", required=False, max_length=1000,
+        widget=forms.Textarea(
+            attrs={'placeholder':
+                    "Close the blind and turn on the main light "
+                    "in my living room when it get's dark."
+            }
+        ),
+        help_text="Clearly describe in your own words what kind of automation "
+                  "you want to happen with this scenario script. <br>"
+                  "The more defined, exact and clear is your description the more "
+                  "accurate automation script SIMO.io AI assistanw will generate.<br>"
+                  "Use component, zone and category id's for best accuracy. <br>"
+                  "SIMO.io AI will re-generate your automation code and update it's description in Notes field "                  
+                  "every time this field is changed and it might take up to 60s to do it. <br>"
+                  "Actual script code can only be edited via SIMO.io Admin.",
+    )
+    code = forms.CharField(widget=PythonCode, required=False)
+    log = forms.CharField(
+        widget=forms.HiddenInput, required=False
+    )
+
+    app_exclude_fields = ('alarm_category', 'code', 'log')
+
+    _ai_resp = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.basic_fields.extend(['autostart', 'keep_alive'])
+        if self.instance.pk:
+            prefix = get_script_prefix()
+            if prefix == '/':
+                prefix = ''
+            if 'log' in self.fields:
+                self.fields['log'].widget = LogOutputWidget(
+                    prefix + '/ws/log/%d/%d/' % (
+                        ContentType.objects.get_for_model(Component).id,
+                        self.instance.id
+                    )
+                )
+
+    @classmethod
+    def get_admin_fieldsets(cls, request, obj=None):
+        base_fields = (
+            'id', 'gateway', 'base_type', 'name', 'icon', 'zone', 'category',
+            'show_in_app', 'autostart', 'keep_alive',
+            'assistant_request', 'notes', 'code', 'control', 'log'
+        )
+
+        fieldsets = [
+            (_("Base settings"), {'fields': base_fields}),
+            (_("History"), {
+                'fields': ('history',),
+                'classes': ('collapse',),
+            }),
+        ]
+        return fieldsets
+
+
+    def clean(self):
+        if self.cleaned_data.get('assistant_request'):
+            if self.instance.pk:
+                org = Component.objects.get(pk=self.instance.pk)
+                call_assistant = org.config.get('assistant_request') \
+                                 != self.cleaned_data['assistant_request']
+            else:
+                call_assistant = True
+            call_assistant = False
+            if call_assistant:
+                resp = self.instance.ai_assistant(
+                    self.cleaned_data['assistant_request'],
+                )
+                if resp['status'] == 'success':
+                    self._ai_resp = resp
+                elif resp['status'] == 'error':
+                    self.add_error('assistant_request', resp['result'])
+
+        return self.cleaned_data
+
+    def save(self, commit=True):
+        if commit and self._ai_resp:
+            self.instance.config['code'] = self._ai_resp['result']
+            self.instance.notes = self._ai_resp['description']
+            if 'code' in self.cleaned_data:
+                self.cleaned_data['code'] = self._ai_resp['result']
+            if 'notes' in self.cleaned_data:
+                self.cleaned_data['notes'] = self._ai_resp['description']
+        obj = super().save(commit)
+        if commit:
+            obj.controller.stop()
+            if self.cleaned_data.get('keep_alive') \
+            or self.cleaned_data.get('autostart'):
+                time.sleep(2)
+                obj.controller.start()
+        return obj
+
+
+class ConditionForm(forms.Form):
+    component = Select2ModelChoiceField(
+        queryset=Component.objects.all(),
+        url='autocomplete-component',
+    )
+    op = forms.ChoiceField(
+        initial="==", choices=(
+            ('==', "is equal to"),
+            ('>', "is greather than"), ('>=', "Is greather or equal to"),
+            ('<', "is lower than"), ('<=', "is lower or equal to"),
+            ('in', "is one of")
+        )
+    )
+    value = forms.CharField()
+    prefix = 'breach_events'
+
+    def clean(self):
+        if not self.cleaned_data.get('component'):
+            return self.cleaned_data
+        if not self.cleaned_data.get('op'):
+            return self.cleaned_data
+        component = self.cleaned_data.get('component')
+
+        if self.cleaned_data['op'] == 'in':
+            self.cleaned_data['value'] = self.cleaned_data['value']\
+                .strip('(').strip('[').rstrip(')').rstrip(']').strip()
+            values = self.cleaned_data['value'].split(',')
+        else:
+            values = [self.cleaned_data['value']]
+
+        final_values = []
+        controller_val_type = type(component.controller.default_value)
+        for val in values:
+            val = val.strip()
+            if controller_val_type == 'bool':
+                if val.lower() in ('0', 'false', 'none', 'null'):
+                    final_val = False
+                else:
+                    final_val = True
+            else:
+                try:
+                    final_val = controller_val_type(val)
+                except:
+                    self.add_error(
+                        'value', f"{val} bad value type for selected component."
+                    )
+                    continue
+            try:
+                component.controller._validate_val(final_val, BEFORE_SET)
+            except Exception as e:
+                self.add_error(
+                    'value', f"{val} is not compatible with selected component."
+                )
+                continue
+            final_values.append(final_val)
+
+        if self.cleaned_data['op'] == 'in':
+            self.cleaned_data['value'] = ', '.join(str(v) for v in final_values)
+        elif final_values:
+            self.cleaned_data['value'] = final_values[0]
+
+        return self.cleaned_data
+
+
+class LightTurnOnForm(forms.Form):
+    light = Select2ModelChoiceField(
+        queryset=Component.objects.filter(
+            base_type__in=('switch', 'dimmer', 'rgbw-light', 'rgb-light')
+        ),
+        required=True,
+        url='autocomplete-component',
+        forward=(
+            forward.Const(['switch', 'dimmer', 'rgbw-light', 'rgb-light'],
+                          'base_type'),
+        )
+    )
+    on_value = forms.IntegerField(
+        min_value=0, initial=100,
+        help_text="Value applicable for dimmers. "
+                  "Switches will receive turn on command."
+    )
+    off_value = forms.TypedChoiceField(
+        coerce=int, initial=1, choices=(
+            (0, "0"), (1, "Original value before turning the light on.")
+        )
+    )
+
+
+class PresenceLightingConfigForm(BaseComponentForm):
+    presence_sensors = Select2ModelMultipleChoiceField(
+        queryset=Component.objects.filter(
+            base_type__in=('binary-sensor', 'switch')
+        ),
+        required=True,
+        url='autocomplete-component',
+        forward=(forward.Const(['binary-sensor', 'switch'], 'base_type'),)
+    )
+    act_on = forms.TypedChoiceField(
+        coerce=int, initial=0, choices=(
+            (0, "At least one sensor detects presence"),
+            (1, "All sensors detect presence"),
+        )
+    )
+    hold_time = forms.TypedChoiceField(
+        initial=3, coerce=int, required=False, choices=(
+            (0, '----'),
+            (1, "10 s"), (2, "20 s"), (3, "30 s"), (4, "40 s"), (5, "50 s"),
+            (6, "1 min"), (9, "1.5 min"), (12, "2 min"), (18, "3 min"),
+            (30, "5 min"), (60, "10 min"), (120, "20 min"), (180, "30 min"),
+            (3600, "1 h")
+        ),
+        help_text="Hold off time after last presence detector is deactivated."
+    )
+    conditions = FormsetField(
+        formset_factory(
+            ConditionForm, can_delete=True, can_order=True, extra=0
+        ), label='Additional conditions'
+    )
+
+    lights = FormsetField(
+        formset_factory(
+            LightTurnOnForm, can_delete=True, can_order=True, extra=0
+        ), label='Lights'
+    )
+
+
+    autostart = forms.BooleanField(
+        initial=True, required=False,
+        help_text="Start automatically on system boot."
+    )
+    keep_alive = forms.BooleanField(
+        initial=True, required=False,
+        help_text="Restart the script if it fails. "
+    )
+    log = forms.CharField(
+        widget=forms.HiddenInput, required=False
+    )
+
+    app_exclude_fields = ('alarm_category', 'code', 'log')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.basic_fields.extend(
+            ['lights', 'on_value', 'off_value', 'presence_sensors',
+             'act_on', 'hold_time', 'conditions', 'autostart', 'keep_alive']
+        )
+        if self.instance.pk and 'log' in self.fields:
+            prefix = get_script_prefix()
+            if prefix == '/':
+                prefix = ''
+            self.fields['log'].widget = LogOutputWidget(
+                prefix + '/ws/log/%d/%d/' % (
+                    ContentType.objects.get_for_model(Component).id,
+                    self.instance.id
+                )
+            )
+
+    def save(self, commit=True):
+        obj = super().save(commit)
+        if commit:
+            obj.controller.stop()
+            if self.cleaned_data.get('keep_alive') \
+                    or self.cleaned_data.get('autostart'):
+                time.sleep(2)
+                obj.controller.start()
+        return obj