simo 1.7.20__py3-none-any.whl → 2.0.1__py3-none-any.whl

simo/core/drf_braces/tests/test_utils.py

@@ -0,0 +1,73 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import unittest
+
+from rest_framework import fields
+
+from ..utils import (
+    find_class_args,
+    find_function_args,
+    get_attr_from_base_classes,
+    get_class_name_with_new_suffix,
+)
+
+
+class TestUtils(unittest.TestCase):
+    def test_get_class_name_with_new_suffix(self):
+        new_name = get_class_name_with_new_suffix(
+            klass=fields.IntegerField,
+            existing_suffix='Field',
+            new_suffix='StrawberryFields'
+        )
+        self.assertEqual(new_name, 'IntegerStrawberryFields')
+
+        new_name = get_class_name_with_new_suffix(
+            klass=fields.IntegerField,
+            existing_suffix='straws',
+            new_suffix='Blueberries'
+        )
+        self.assertEqual(new_name, 'IntegerFieldBlueberries')
+
+    def test_get_attr_from_base_classes(self):
+        Parent = type(str('Parent'), (), {'fields': 'pancakes'})
+
+        self.assertEqual(
+            get_attr_from_base_classes((Parent,), [], 'fields'), 'pancakes'
+        )
+
+        self.assertEqual(
+            get_attr_from_base_classes(
+                (Parent,), {'fields': 'mushrooms'}, 'fields'
+            ),
+            'mushrooms'
+        )
+
+        self.assertEqual(
+            get_attr_from_base_classes((Parent,), [], '', default='maple_syrup'),
+            'maple_syrup'
+        )
+
+        with self.assertRaises(AttributeError):
+            get_attr_from_base_classes(
+                (Parent,), {'fields': 'mushrooms'}, 'catchmeifyoucan'
+            )
+
+    def test_find_function_args(self):
+        def foo(a, b, c):
+            pass
+
+        self.assertListEqual(find_function_args(foo), ['a', 'b', 'c'])
+
+    def test_find_function_args_invalid(self):
+        self.assertListEqual(find_function_args(None), [])
+
+    def test_find_class_args(self):
+        class Bar(object):
+            def __init__(self, a, b):
+                pass
+
+        class Foo(Bar):
+            def __init__(self, c, d):
+                super(Foo, self).__init__(None, None)
+                pass
+
+        self.assertSetEqual(set(find_class_args(Foo)), {'a', 'b', 'c', 'd'})

simo/core/drf_braces/utils.py

@@ -0,0 +1,209 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import inspect
+import itertools
+
+
+IGNORE_ARGS = ['self', 'cls']
+
+
+def find_function_args(func):
+    """
+    Get the list of parameter names which function accepts.
+    """
+    func_args = []
+    try:
+        spec = inspect.getfullargspec(func) if hasattr(inspect, 'getfullargspec') else inspect.getargspec(func)
+    except TypeError:
+        return []
+
+    func_args.extend([i for i in spec[0] if i not in IGNORE_ARGS])
+    func_args.extend([i for i in spec.kwonlyargs])
+
+    return func_args
+
+def find_class_args(klass):
+    """
+    Find all class arguments (parameters) which can be passed in ``__init__``.
+    """
+    args = set()
+
+    for i in klass.__mro__:
+        if i is object or not hasattr(i, '__init__'):
+            continue
+        args |= set(find_function_args(i.__init__))
+
+    return list(args)
+
+
+def find_matching_class_kwargs(reference_object, klass):
+    return {
+        i: getattr(reference_object, i) for i in find_class_args(klass)
+        if hasattr(reference_object, i)
+    }
+
+
+def add_base_class_to_instance(instance, base_class=None, new_name=None):
+    """
+    Generic utility for adding a base class to an instance.
+
+    This function returns a copy of the given instance which
+    will then include the new base_class in its ``__mro__``.
+
+    The way that is done internally is it creates a brand new
+    class with correct bases. Then the newly created class is
+    instantiated. Since ``__init__`` could be expensive operation
+    in any of the base classes of the original instance mro,
+    nto make it cheap, we temporarily switch __init__ with
+    super simple implementation which does nothing but only
+    instantiates class. Once instantiated, then we copy all of the
+    instance attributes to the newly created instance.
+    Finally, then we pop our mock ``__init__`` implementation.
+
+    Args:
+        instance (object): Instance of any object
+        base_class (type): Any class which will be added as first class
+            in the newly copied instance mro.
+
+    Returns:
+        Shallow copy of ``instance`` which will also inherit ``base_class``.
+    """
+    # overwrite __init__ since that is mainly responsible for setting
+    # instance state but since we explicitly copy it, we can
+    # make __init__ a noop method
+    def __init__(self, *args, **kwargs):
+        pass
+
+    if base_class is not None and base_class not in instance.__class__.mro():
+        base_classes = (base_class, instance.__class__)
+    else:
+        base_classes = (instance.__class__,)
+
+    new_field_class = type(
+        str(new_name or instance.__class__.__name__),
+        base_classes,
+        {'__init__': __init__}
+    )
+
+    new_instance = new_field_class()
+    new_instance.__dict__.update(instance.__dict__)
+
+    # we added __init__ just for faster instantiation
+    # since then we dont have to copy all the parameters
+    # when creating new instance and then update its state
+    # however after we instantiated the class, we want to
+    # pop our silly __init__ implementation so that if somebody
+    # wants to instantiate instance.__class__(), it will
+    # use the original __init__ method
+    del new_field_class.__init__
+
+    return new_instance
+
+
+def initialize_class_using_reference_object(reference_object, klass, **kwargs):
+    """
+    Utility function which instantiates ``klass`` by extracting ``__init__``
+    kwargs from ``reference_object`` attributes.
+
+    Args:
+        reference_object (object): Any object instance from which matching
+            attributes will be used as ``klass``'s ``__init__`` kwargs.
+        klass (type): Class which will be instantiated by using
+            ``reference_object`` attributes.
+        **kwargs: Any additional kwargs which will be passed during instantiation.
+
+    Returns:
+        Instantiated ``klass`` object.
+    """
+    _kwargs = find_matching_class_kwargs(reference_object, klass)
+    _kwargs.update(kwargs)
+
+    return klass(**_kwargs)
+
+
+def get_class_name_with_new_suffix(klass, existing_suffix, new_suffix):
+    """
+    Generates new name by replacing the existing suffix with a new one.
+
+    Args:
+        klass (type): original class from which new name is generated
+        existing_suffix (str): the suffix which needs to remain where it is
+        new_suffix (str): the new suffix desired
+
+    Example:
+        >>> get_class_name_with_new_suffix(FooForm, 'Form', 'NewForm')
+        'FooNewForm'
+
+    Returns:
+        new_name (str): the name with the new suffix
+    """
+    class_name = klass.__name__
+
+    if existing_suffix in class_name:
+        prefix, suffix = class_name.rsplit(existing_suffix, 1)
+    else:
+        prefix, suffix = class_name, ''
+
+    new_name = str('{}{}{}'.format(prefix, new_suffix, suffix))
+
+    return new_name
+
+
+def get_attr_from_base_classes(bases, attrs, attr, default=None):
+    """
+    The attribute is retrieved from the base classes if they are not already
+    present on the object.
+
+    Args:
+        bases (tuple, list): The base classes for a class.
+        attrs (dict): The attributes of the class.
+        attr (str): Specific attribute being looked for.
+        default (any): Whatever default value is expected if the
+            attr is not found.
+
+    Returns:
+        attribute value as found in base classes or a default when attribute
+        is not found and default is provided.
+
+    Raises:
+        AttributeError: When the attribute is not present anywhere in the
+            call chain hierarchy specified through bases and the attributes
+            of the class itself
+    """
+    if attr in attrs:
+        return attrs[attr]
+
+    for base in bases:
+        try:
+            return getattr(base, attr)
+        except AttributeError:
+            continue
+
+    if default is not None:
+        return default
+
+    raise AttributeError(
+        'None of the bases have {} attribute'
+        ''.format(attr)
+    )
+
+
+def reduce_attr_dict_from_base_classes(bases, getter, default=None):
+    data = (default or {}).copy()
+
+    # get all field mappings from super methods
+    for base in itertools.chain(*[reversed(i.mro()) for i in reversed(bases)]):
+        data.update(getter(base) or {})
+
+    return data
+
+
+def reduce_attr_dict_from_instance(self, getter, default=None):
+    data = reduce_attr_dict_from_base_classes(type(self).mro(), getter, default)
+
+    # this should of been picked by reduce_attr_dict_from_base_classes
+    # however that only accounts base classes and not instance
+    # attribute which can be modified in __init__, etc so we
+    # explicitly account for it
+    data.update(getter(self) or {})
+
+    return data

simo/core/events.py

@@ -30,10 +30,10 @@ class ObjMqttAnnouncement:
         assert self.data is not None
         mqtt_publish.single(
             self.get_topic(), json.dumps(self.data, default=str),
+            retain=retain,
             hostname=settings.MQTT_HOST,
             port=settings.MQTT_PORT,
             auth={'username': 'root', 'password': settings.SECRET_KEY},
-            retain=retain
         )
 
     def get_topic(self):
@@ -54,8 +54,8 @@ class ObjectChangeEvent(ObjMqttAnnouncement):
         return f"{self.TOPIC}/{self.instance.id if self.instance else 'global'}/" \
                f"{type(self.obj).__name__}-{self.data['obj_pk']}"
 
-    def publish(self, retain=False):
-        return super().publish(retain=True)
+    def publish(self, retain=True):
+        return super().publish(retain=retain)
 
 
 class GatewayObjectCommand(ObjMqttAnnouncement):

simo/core/forms.py

@@ -1,6 +1,7 @@
 import os
 import traceback
 import requests
+from dal import forward
 from django import forms
 from django.contrib.admin.forms import AdminAuthenticationForm as OrgAdminAuthenticationForm
 from django.db import models
@@ -22,6 +23,7 @@ from .widgets import SVGFileWidget, PythonCode, LogOutputWidget
 from .widgets import ImageWidget
 from .utils.helpers import get_random_string
 from .utils.formsets import FormsetField
+from .utils.validators import validate_slaves
 
 
 class HubConfigForm(forms.Form):
@@ -156,7 +158,9 @@ class ConfigFieldsMixin:
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.model_fields = [f.name for f in Component._meta.fields]
+        self.model_fields = [
+            f.name for f in Component._meta.fields
+        ] + ['slaves', ]
         self.config_fields = []
         for field_name, field in self.fields.items():
             if field_name in self.model_fields:
@@ -164,21 +168,22 @@ class ConfigFieldsMixin:
             self.config_fields.append(field_name)
         if self.instance.pk:
             for field_name in self.config_fields:
-                if self.instance.config.get(field_name) != None:
-                    if hasattr(self.fields[field_name], 'queryset'):
-                        if isinstance(self.instance.config[field_name], list):
-                            self.fields[field_name].initial = \
-                                self.fields[field_name].queryset.filter(
-                                    pk__in=self.instance.config[field_name]
-                                )
-                        else:
-                            self.fields[field_name].initial = \
-                                self.fields[field_name].queryset.filter(
-                                    pk=self.instance.config[field_name]
-                                ).first()
+                if field_name not in self.instance.config:
+                    continue
+                if hasattr(self.fields[field_name], 'queryset'):
+                    if isinstance(self.instance.config.get(field_name), list):
+                        self.fields[field_name].initial = \
+                            self.fields[field_name].queryset.filter(
+                                pk__in=self.instance.config.get(field_name)
+                            )
                     else:
                         self.fields[field_name].initial = \
-                            self.instance.config[field_name]
+                            self.fields[field_name].queryset.filter(
+                                pk=self.instance.config.get(field_name)
+                            ).first()
+                else:
+                    self.fields[field_name].initial = \
+                        self.instance.config.get(field_name)
 
     def save(self, commit=True):
         for field_name in self.config_fields:
@@ -272,7 +277,7 @@ class ComponentAdminForm(forms.ModelForm):
         fields = '__all__'
         exclude = (
             'gateway', 'controller_uid', 'base_type',
-            'alive', 'value_type', 'value'
+            'alive', 'value_type', 'value', 'arm_status',
         )
         widgets = {
             'icon': autocomplete.ModelSelect2(
@@ -289,29 +294,31 @@ class ComponentAdminForm(forms.ModelForm):
 
     def __init__(self, *args, **kwargs):
         self.request = kwargs.pop('request', None)
-        if 'gateway' in kwargs:
-            self.gateway = kwargs.pop('gateway')
-            self.controller_cls = kwargs.pop('controller_cls')
+        self.controller_uid = kwargs.pop('controller_uid', '')
         super().__init__(*args, **kwargs)
         if self.instance.pk:
             self.gateway = self.instance.gateway
             self.controller = self.instance.controller
         else:
-            self.controller = self.controller_cls(self.instance)
-            self.instance.gateway = self.gateway
-            self.instance.controller_uid = self.controller_cls.uid
-            self.instance.base_type = self.controller.base_type
-            self.instance.value = self.controller.default_value
-            self.instance.value_previous = self.controller.default_value
-            self.instance.config = self.controller.default_config
-            self.instance.meta = self.controller.default_meta
-
-
+            from .utils.type_constants import get_controller_types_map
+            ControllerClass = get_controller_types_map().get(self.controller_uid)
+            if ControllerClass:
+                self.controller = ControllerClass(self.instance)
+                self.gateway = Gateway.objects.filter(
+                    type=ControllerClass.gateway_class.uid
+                ).first()
+                self.instance.gateway = self.gateway
+                self.instance.controller_uid = ControllerClass.uid
+                self.instance.base_type = self.controller.base_type
+                self.instance.value = self.controller.default_value
+                self.instance.value_previous = self.controller.default_value
+                self.instance.config = self.controller.default_config
+                self.instance.meta = self.controller.default_meta
 
     @classmethod
     def get_admin_fieldsets(cls, request, obj=None):
         main_fields = (
-            'name', 'icon', 'zone', 'category', 'tags',
+            'name', 'icon', 'zone', 'category',
             'show_in_app', 'battery_level',
             'instance_methods', 'value_units',
             'alarm_category', 'arm_status',
@@ -323,7 +330,7 @@ class ComponentAdminForm(forms.ModelForm):
         base_fields.append('zone')
         base_fields.append('category')
 
-        for field_name in cls.base_fields:
+        for field_name in cls.declared_fields:
             if field_name not in main_fields:
                 base_fields.append(field_name)
 
@@ -384,6 +391,8 @@ class ComponentAdminForm(forms.ModelForm):
         return self.cleaned_data['instance_methods']
 
 
+
+
 class BaseComponentForm(ConfigFieldsMixin, ComponentAdminForm):
     pass
 
@@ -405,8 +414,8 @@ class ValueLimitsMixin:
 
 
 class NumericSensorForm(BaseComponentForm):
-    widget = forms.TypedChoiceField(
-        coerce=str, initial='numeric-sensor', choices=(
+    widget = forms.ChoiceField(
+        initial='numeric-sensor', choices=(
             ('numeric-sensor', "Basic Sensor"),
             ('numeric-sensor-graph', "Graph"),
         )
@@ -470,6 +479,28 @@ class MultiSensorConfigForm(BaseComponentForm):
     has_icon = False
 
 
+class SwitchForm(BaseComponentForm):
+    slaves = forms.ModelMultipleChoiceField(
+        required=False,
+        queryset=Component.objects.filter(
+            base_type__in=(
+                'dimmer', 'switch', 'blinds', 'script'
+            )
+        ),
+        widget=autocomplete.ModelSelect2Multiple(
+            url='autocomplete-component', attrs={'data-html': True},
+            forward=(forward.Const(
+                ['dimmer', 'switch', 'blinds', 'script'], 'base_type'),
+            )
+        )
+    )
+
+    def clean_slaves(self):
+        if not self.cleaned_data['slaves'] or not self.instance:
+            return self.cleaned_data['slaves']
+        return validate_slaves(self.cleaned_data['slaves'], self.instance)
+
+
 class DoubleSwitchConfigForm(BaseComponentForm):
     icon_1 = forms.ModelChoiceField(
         queryset=Icon.objects.all(),
@@ -580,6 +611,21 @@ class DimmerConfigForm(BaseComponentForm):
     inverse = forms.BooleanField(
         label=_("Inverse dimmer signal"), required=False
     )
+    slaves = forms.ModelMultipleChoiceField(
+        required=False,
+        queryset=Component.objects.filter(
+            base_type__in='dimmer',
+        ),
+        widget=autocomplete.ModelSelect2Multiple(
+            url='autocomplete-component', attrs={'data-html': True},
+            forward=(forward.Const(['dimmer', ], 'base_type'),)
+        )
+    )
+
+    def clean_slaves(self):
+        if not self.cleaned_data['slaves'] or not self.instance:
+            return self.cleaned_data['slaves']
+        return validate_slaves(self.cleaned_data['slaves'], self.instance)
 
 
 class DimmerPlusConfigForm(BaseComponentForm):
@@ -600,8 +646,4 @@ class DimmerPlusConfigForm(BaseComponentForm):
 class RGBWConfigForm(BaseComponentForm):
     has_white = forms.BooleanField(
         label=_("Has WHITE color channel"), required=False,
-    )
-
-
-
-
+    )

simo/core/gateways.py

@@ -3,6 +3,7 @@ import time
 import json
 import paho.mqtt.client as mqtt
 from django.conf import settings
+from django.db import close_old_connections
 from abc import ABC, abstractmethod
 from simo.core.utils.helpers import classproperty
 from simo.core.events import GatewayObjectCommand, get_event_obj
@@ -59,7 +60,7 @@ class BaseObjectCommandsGatewayHandler(BaseGatewayHandler):
 
         for task, period in self.periodic_tasks:
             threading.Thread(
-                target=self._run_periodic_task, args=(task, period), daemon=True
+                target=self._run_periodic_task, args=(self.exit, task, period), daemon=True
             ).start()
 
         self.mqtt_client.connect(host=settings.MQTT_HOST, port=settings.MQTT_PORT)
@@ -70,8 +71,8 @@ class BaseObjectCommandsGatewayHandler(BaseGatewayHandler):
 
         self.mqtt_client.loop_stop()
 
-    def _run_periodic_task(self, task, period):
-        while not self.exit.is_set():
+    def _run_periodic_task(self, exit, task, period):
+        while not exit.is_set():
             try:
                 print(f"Run periodic task {task}!")
                 getattr(self, task)()
@@ -86,19 +87,35 @@ class BaseObjectCommandsGatewayHandler(BaseGatewayHandler):
         self.mqtt_client.subscribe(command.get_topic())
 
     def _on_mqtt_message(self, client, userdata, msg):
-        payload = json.loads(msg.payload)
-        if 'set_val' not in payload:
-            return
         from simo.core.models import Component
-        component = get_event_obj(payload, Component)
-        if not component:
-            return
-        print(f"Perform Value ({str(payload['set_val'])}) Send to {component}")
-        try:
-            self.perform_value_send(component, payload['set_val'])
-        except Exception as e:
-            self.logger.error(e, exc_info=True)
+        payload = json.loads(msg.payload)
+        if 'set_val' in payload:
+            component = get_event_obj(payload, Component)
+            if not component:
+                return
+            print(f"Perform Value ({str(payload['set_val'])}) Send to {component}")
+            try:
+                self.perform_value_send(component, payload['set_val'])
+            except Exception as e:
+                self.logger.error(e, exc_info=True)
+
+        if 'bulk_send' in payload:
+            self.perform_bulk_send(payload['bulk_send'])
 
     def perform_value_send(self, component, value):
         raise NotImplemented()
 
+    def perform_bulk_send(self, data):
+        from simo.core.models import Component
+        for comp_id, val in data.items():
+            component = Component.objects.filter(
+                pk=comp_id, gateway=self.gateway_instance
+            ).first()
+            if not component:
+                continue
+            try:
+                self.perform_value_send(component, val)
+            except Exception as e:
+                self.logger.error(e, exc_info=True)
+
+

simo/core/management/commands/gateways_manager.py

@@ -31,7 +31,6 @@ class GatewayRunHandler(multiprocessing.Process):
         self.exit_event = multiprocessing.Event()
         self.logger = get_gw_logger(self.gateway_id)
 
-
     def run(self):
         db_connection.connect()
         try:

simo/core/managers.py

@@ -0,0 +1,81 @@
+import sys
+import traceback
+from .middleware import get_current_instance
+from django.utils import timezone
+from django.db import models
+
+
+class ZonesManager(models.Manager):
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        instance = get_current_instance()
+        if instance:
+            qs = qs.filter(instance=instance)
+        return qs
+
+
+class CategoriesManager(models.Manager):
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        instance = get_current_instance()
+        if instance:
+            qs = qs.filter(instance=instance)
+        return qs
+
+
+class ComponentsManager(models.Manager):
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        instance = get_current_instance()
+        if instance:
+            qs = qs.filter(zone__instance=instance)
+        return qs
+
+    def bulk_send(self, data):
+        """
+        :param data: {component1: True, component2: False, component3: 55.0}
+        :return:
+        """
+        from .models import Component
+        from .controllers import BEFORE_SEND
+        from simo.users.middleware import get_current_user
+        from .events import GatewayObjectCommand
+
+        for component, value in data.items():
+            assert isinstance(component, Component), \
+                "Component: value map is required!"
+
+        gateway_components = {}
+        for comp, value in data.items():
+            try:
+                value = comp.controller._validate_val(value, BEFORE_SEND)
+            except:
+                print(traceback.format_exc(), file=sys.stderr)
+                continue
+
+            comp.change_init_by = get_current_user()
+            comp.change_init_date = timezone.now()
+            comp.save(
+                update_fields=['change_init_by', 'change_init_date']
+            )
+            try:
+                value = comp.controller._prepare_for_send(value)
+            except:
+                print(traceback.format_exc(), file=sys.stderr)
+                continue
+
+            if comp.gateway not in gateway_components:
+                gateway_components[comp.gateway] = {}
+            gateway_components[comp.gateway][comp.id] = value
+
+        print("BULK SEND: ", gateway_components)
+        for gateway, send_vals in gateway_components.items():
+            GatewayObjectCommand(gateway, bulk_send=send_vals).publish(
+                retain=False
+            )
+
+
+