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

simo/core/controllers.py

@@ -11,11 +11,13 @@ from django.utils.translation import gettext_lazy as _
 from simo.users.middleware import introduce, get_current_user
 from simo.users.utils import get_device_user
 from .utils.helpers import is_hex_color, classproperty
+# from django.utils.functional import classproperty
 from .gateways import BaseGatewayHandler
 from .app_widgets import *
 from .forms import (
     BaseComponentForm, NumericSensorForm,
-    MultiSensorConfigForm, DoubleSwitchConfigForm,
+    MultiSensorConfigForm,
+    SwitchForm, DoubleSwitchConfigForm,
     TrippleSwitchConfigForm, QuadrupleSwitchConfigForm,
     QuintupleSwitchConfigForm, DimmerConfigForm, DimmerPlusConfigForm,
     RGBWConfigForm
@@ -31,6 +33,7 @@ class ControllerBase(ABC):
     admin_widget_template = 'admin/controller_widgets/generic.html'
     default_config = {}
     default_meta = {}
+    discovery_msg = None
 
     @property
     @abstractmethod
@@ -83,7 +86,7 @@ class ControllerBase(ABC):
         assert issubclass(self.config_form, BaseComponentForm)
         assert issubclass(self.app_widget, BaseAppWidget)
         assert self.base_type in ALL_BASE_TYPES, \
-            "base_type must be defined in BASE_TYPES"
+            f"{self.base_type} must be defined in BASE_TYPES!"
 
     @classproperty
     @classmethod
@@ -98,6 +101,15 @@ class ControllerBase(ABC):
         """
         return cls.config_form
 
+    @classproperty
+    @classmethod
+    def is_discoverable(cls):
+        return hasattr(
+            cls, 'init_discovery'
+        ) and hasattr(
+            cls, '_process_discovery'
+        )
+
     def _aggregate_values(self, values):
         if type(values[0]) in (float, int):
             return [statistics.mean(values)]
@@ -165,7 +177,38 @@ class ControllerBase(ABC):
             else:
                 return self.component.change_init_by
 
+    def send(self, value):
+        self.component.refresh_from_db()
+
+        # Bulk send if it is a switch or dimmer and has slaves
+        if self.component.base_type in ('switch', 'dimmer') \
+        and self.component.slaves.count():
+            bulk_send_map = {self.component: value}
+            for slave in self.component.slaves.all():
+                bulk_send_map[slave] = value
+            from .models import Component
+            Component.objects.bulk_send(bulk_send_map)
+            return
+
+        # Regular send
+        value = self._validate_val(value, BEFORE_SEND)
+
+        self.component.change_init_by = get_current_user()
+        self.component.change_init_date = timezone.now()
+        self.component.save(
+            update_fields=['change_init_by', 'change_init_date']
+        )
+        value = self._prepare_for_send(value)
+        GatewayObjectCommand(
+            self.component.gateway, self.component, set_val=value
+        ).publish()
+        if value != self.component.value:
+            self.component.value_previous = self.component.value
+            self.component.value = value
+
     def set(self, value, actor=None):
+        value = self._validate_val(value, BEFORE_SET)
+
         if not actor:
             actor = self._get_actor(value)
         if not actor:
@@ -175,8 +218,6 @@ class ControllerBase(ABC):
         # in relation to the change of this component
         introduce(actor)
 
-        value = self.component.translate_before_set(value)
-        value = self._validate_val(value, BEFORE_SET)
         self.component.refresh_from_db()
         if value != self.component.value:
             self.component.value_previous = self.component.value
@@ -187,16 +228,15 @@ class ControllerBase(ABC):
         self.component.change_init_fingerprint = None
         self.component.save()
 
-    def _send_to_device(self, value):
-        GatewayObjectCommand(
-            self.component.gateway, self.component, set_val=value
-        ).publish()
-
     def _receive_from_device(self, value, is_alive=True):
         value = self._prepare_for_set(value)
         actor = self._get_actor(value)
+
+        init_by_device = False
         if not actor:
+            init_by_device = True
             actor = get_device_user()
+
         # Introducing user to this thread for changes that might happen to other components
         # in relation to the change of this component
         introduce(actor)
@@ -204,27 +244,17 @@ class ControllerBase(ABC):
         self.component.save(update_fields=['alive'])
         self.set(value, actor)
 
-    def _prepare_for_send(self, value):
-        return value
-
-    def _prepare_for_set(self, value):
-        return value
-
-    def send(self, value):
-        self.component.refresh_from_db()
-        value = self.component.translate_before_send(value)
-        value = self._validate_val(value, BEFORE_SEND)
-
-        self.component.change_init_by = get_current_user()
-        self.component.change_init_date = timezone.now()
-        self.component.save(
-            update_fields=['change_init_by', 'change_init_date']
-        )
-        value = self._prepare_for_send(value)
-        self._send_to_device(value)
-        if value != self.component.value:
-            self.component.value_previous = self.component.value
-            self.component.value = value
+        if init_by_device and self.component.slaves.count():
+            slaves_qs = self.component.slaves.all()
+            # slaves are being controlled by colonels internally
+            if self.component.controller_uid.startswith('simo.fleet.') \
+            and self.component.config.get('colonel'):
+                slaves_qs = slaves_qs.exclude(
+                    config__colonel=self.component.config['colonel']
+                )
+            bulk_send_map = {s: value for s in slaves_qs}
+            from .models import Component
+            Component.objects.bulk_send(bulk_send_map)
 
     def history_display(self, values):
         assert type(values) in (list, tuple)
@@ -245,6 +275,16 @@ class ControllerBase(ABC):
                  'val': icon if any(values) else None}
             ]
 
+    def poke(self):
+        '''Use this when component is dead to try and wake it up'''
+        pass
+
+    def _prepare_for_send(self, value):
+        return value
+
+    def _prepare_for_set(self, value):
+        return value
+
 
 class TimerMixin:
 
@@ -399,7 +439,19 @@ class BinarySensor(ControllerBase):
         return value
 
 
-class Dimmer(ControllerBase, TimerMixin):
+class OnOffPokerMixin:
+    _poke_toggle = False
+
+    def poke(self):
+        if self._poke_toggle:
+            self._poke_toggle = False
+            self.turn_on()
+        else:
+            self._poke_toggle = True
+            self.turn_off()
+
+
+class Dimmer(ControllerBase, TimerMixin, OnOffPokerMixin):
     name = _("Dimmer")
     base_type = 'dimmer'
     app_widget = KnobWidget
@@ -408,8 +460,23 @@ class Dimmer(ControllerBase, TimerMixin):
     default_config = {'min': 0.0, 'max': 100.0, 'inverse': False}
     default_value = 0
 
+
+    def _prepare_for_send(self, value):
+        if isinstance(value, bool):
+            if value:
+                self.component.refresh_from_db()
+                if self.component.value:
+                    return self.component.value
+                else:
+                    if self.component.value_previous:
+                        return self.component.value_previous
+                    return self.component.config.get('max', 100.0)
+            else:
+                return 0
+        return value
+
     def _validate_val(self, value, occasion=None):
-        if value > self.component.config.get('max', 1.0):
+        if value > self.component.config.get('max', 100.0):
             raise ValidationError("Value to big.")
         elif value < self.component.config.get('min', 0.0):
             raise ValidationError("Value to small.")
@@ -434,7 +501,8 @@ class Dimmer(ControllerBase, TimerMixin):
             self.turn_on()
 
 
-class DimmerPlus(ControllerBase, TimerMixin):
+
+class DimmerPlus(ControllerBase, TimerMixin, OnOffPokerMixin):
     name = _("Dimmer Plus")
     base_type = 'dimmer-plus'
     app_widget = KnobPlusWidget
@@ -508,13 +576,13 @@ class DimmerPlus(ControllerBase, TimerMixin):
                 })
 
     def toggle(self):
-        if self.component.value:
+        if self.component.value.get('main'):
             self.turn_off()
         else:
             self.turn_on()
 
 
-class RGBWLight(ControllerBase, TimerMixin):
+class RGBWLight(ControllerBase, TimerMixin, OnOffPokerMixin):
     name = _("RGB(W) Light")
     base_type = 'rgbw-light'
     app_widget = RGBWidget
@@ -598,10 +666,11 @@ class MultiSwitchBase(ControllerBase):
         return value
 
 
-class Switch(MultiSwitchBase, TimerMixin):
+class Switch(MultiSwitchBase, TimerMixin, OnOffPokerMixin):
     name = _("Switch")
     base_type = 'switch'
     app_widget = SingleSwitchWidget
+    config_form = SwitchForm
     admin_widget_template = 'admin/controller_widgets/switch.html'
     default_value = False
 
@@ -642,6 +711,11 @@ class DoubleSwitch(MultiSwitchBase):
     config_form = DoubleSwitchConfigForm
     default_value = [False, False]
 
+    def _prepare_for_send(self, value):
+        if isinstance(value, bool):
+            return [value, value]
+        return value
+
 
 class TripleSwitch(MultiSwitchBase):
     name = _("Triple Switch")
@@ -650,6 +724,11 @@ class TripleSwitch(MultiSwitchBase):
     config_form = TrippleSwitchConfigForm
     default_value = [False, False, False]
 
+    def _prepare_for_send(self, value):
+        if isinstance(value, bool):
+            return [value, value, value]
+        return value
+
 
 class QuadrupleSwitch(MultiSwitchBase):
     name = _("Quadruple Switch")
@@ -658,6 +737,11 @@ class QuadrupleSwitch(MultiSwitchBase):
     config_form = QuadrupleSwitchConfigForm
     default_value = [False, False, False, False]
 
+    def _prepare_for_send(self, value):
+        if isinstance(value, bool):
+            return [value, value, value, value]
+        return value
+
 
 class QuintupleSwitch(MultiSwitchBase):
     name = _("Quintuple Switch")
@@ -666,6 +750,11 @@ class QuintupleSwitch(MultiSwitchBase):
     config_form = QuintupleSwitchConfigForm
     default_value = [False, False, False, False, False]
 
+    def _prepare_for_send(self, value):
+        if isinstance(value, bool):
+            return [value, value, value, value, value]
+        return value
+
 
 class Lock(Switch):
     name = _("Lock")
@@ -702,3 +791,12 @@ class Lock(Switch):
                     f"one of available values [{available_values}] for lock."
                 )
         return value
+
+    def set(self, value, actor=None):
+        super().set(value, actor=actor)
+        if actor and value in ('locking', 'unlocking'):
+            self.component.change_init_by = actor
+            self.component.change_init_date = timezone.now()
+            self.component.save(
+                update_fields=['change_init_by', 'change_init_date']
+            )

simo/core/db_backend/base.py

@@ -2,6 +2,7 @@ import random, time
 from django.contrib.gis.db.backends.postgis.base import (
     DatabaseWrapper as PostGisPsycopg2DatabaseWrapper
 )
+from django.db import close_old_connections, connection as db_connection
 from django.utils.asyncio import async_unsafe
 from django.db.utils import InterfaceError
 from django.conf import settings
@@ -9,28 +10,12 @@ from django.conf import settings
 
 class DatabaseWrapper(PostGisPsycopg2DatabaseWrapper):
 
-    # connection already closed raised by default django postgresql db backend
-    # which means that ensure_connection didn't ensured connection!
-    # It happens when connection to the postgresql server is already lost,
-    # but this backend handler knows nothing about it.
-    # So we set connection to None immediately, therefore if there
-    # is other thread trying to access the cursor
-    # new connection will be established by ensure_connection() method.
-    # We also wait for 0 - 10s, to not overwhelm anything in case
-    # there are many multiple threads trying to access the same
-    # db connection.
-
-
-    def _cursor(self, name=None):
-        self.ensure_connection()
-        with self.wrap_database_errors:
-            try:
-                return self._prepare_cursor(self.create_cursor(name))
-            except InterfaceError:
-
-                self.connection = None
-                time.sleep(random.randint(0, 100) / 10)
-                return self._cursor(name)
+    @async_unsafe
+    def create_cursor(self, name=None):
+        if not self.is_usable():
+            close_old_connections()
+            db_connection.connect()
+        return super().create_cursor(name=name)
 
 
 

simo/core/drf_braces/README

@@ -0,0 +1,3 @@
+Remove this from here once this pulll request is resolved
+
+https://github.com/dealertrack/django-rest-framework-braces/pull/36

simo/core/drf_braces/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+__author__ = 'Miroslav Shubernetskiy'
+__email__ = 'miroslav@miki725.com'
+__version__ = '0.3.4'

simo/core/drf_braces/fields/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ._fields import *  # noqa
+from .custom import *  # noqa
+from .modified import *  # noqa

simo/core/drf_braces/fields/_fields.py

@@ -0,0 +1,48 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import inspect
+
+from rest_framework import fields
+from rest_framework.fields import *  # noqa
+from rest_framework.fields import _UnvalidatedField  # noqa
+
+from .mixins import AllowBlankNullFieldMixin, EmptyStringFieldMixin
+
+
+FIELDS = [
+    'BooleanField',
+    'CharField',
+    'ChoiceField',
+    'DateField',
+    'DateTimeField',
+    'DecimalField',
+    'DurationField',
+    'EmailField',
+    'FileField',
+    'FloatField',
+    'HiddenField',
+    'ImageField',
+    'IntegerField',
+    'IPAddressField',
+    'MultipleChoiceField',
+    'RegexField',
+    'SlugField',
+    'TimeField',
+    'URLField',
+    'UUIDField',
+]
+
+
+def get_updated_fields(fields, base_classes):
+    fields = [globals()[i] for i in fields]
+    return {
+        field.__name__: type(field.__name__, base_classes + (field,), {})
+        for field in fields
+    }
+
+
+locals().update(
+    get_updated_fields(FIELDS, (EmptyStringFieldMixin, AllowBlankNullFieldMixin))
+)
+
+__all__ = [name for name, value in locals().items()
+           if inspect.isclass(value) and issubclass(value, fields.Field)]

simo/core/drf_braces/fields/custom.py

@@ -0,0 +1,107 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import inspect
+from decimal import Decimal, getcontext
+
+import pytz
+import six
+from django.utils.translation import gettext as _
+
+from . import _fields as fields
+from .mixins import ValueAsTextFieldMixin
+
+
+class UnvalidatedField(fields._UnvalidatedField):
+    """
+    Same as DRF's ``_UnvalidatedField``, except this is a public class.
+    """
+
+    def run_validators(self, value):
+        return
+
+
+class PositiveIntegerField(fields.IntegerField):
+    """
+    Enhanced DRF's ``IntegerField`` as this default ``min_value`` to be 0
+    hence only allowing positive numbers.
+    """
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('min_value', 0)
+        super(PositiveIntegerField, self).__init__(*args, **kwargs)
+
+
+class UTCDateTimeField(fields.DateTimeField):
+    """
+    Same as DateTimeField except this field guarantees to return time-zone aware dates.
+    """
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('default_timezone', pytz.utc)
+        super(UTCDateTimeField, self).__init__(*args, **kwargs)
+
+
+class NonValidatingChoiceField(fields.ChoiceField):
+    """
+    ChoiceField subclass that skips the validation of "choices".
+    It does apply 'required' validation, and any other validation
+    done by the parent drf.Field class.
+    """
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('choices', [])
+        super(NonValidatingChoiceField, self).__init__(*args, **kwargs)
+
+    def to_internal_value(self, data):
+        try:
+            return self.choice_strings_to_values[six.text_type(data)]
+        except KeyError:
+            return six.text_type(data)
+
+
+class NumericField(ValueAsTextFieldMixin, fields.IntegerField):
+    default_error_messages = {
+        'invalid': _('Enter a whole number.'),
+    }
+
+
+class RoundedDecimalField(fields.DecimalField):
+    """
+    Currency field subclass of Decimal used for rounding currencies
+    to two decimal places.
+    """
+
+    def __init__(self, max_digits=None, decimal_places=2, rounding=None, *args, **kwargs):
+        super(RoundedDecimalField, self).__init__(
+            max_digits=max_digits,
+            decimal_places=decimal_places,
+            *args, **kwargs
+        )
+        self.rounding = rounding
+
+    def to_internal_value(self, data):
+        return self.quantize(super(RoundedDecimalField, self).to_internal_value(data))
+
+    def validate_precision(self, data):
+        return data
+
+    def quantize(self, data):
+        """
+        Quantize the decimal value to the configured precision.
+        """
+        if self.decimal_places is None:
+            return data
+
+        context = getcontext().copy()
+
+        if self.max_digits is not None:
+            context.prec = self.max_digits
+        if self.rounding is not None:
+            context.rounding = self.rounding
+        return data.quantize(
+            Decimal('.1') ** self.decimal_places,
+            context=context
+        )
+
+
+__all__ = [name for name, value in locals().items()
+           if inspect.isclass(value) and issubclass(value, fields.Field)]

simo/core/drf_braces/fields/mixins.py

@@ -0,0 +1,58 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+import six
+from rest_framework.fields import CharField, empty
+
+
+class EmptyStringFieldMixin(object):
+    def validate_empty_values(self, data):
+        is_empty, data = super(EmptyStringFieldMixin, self).validate_empty_values(data)
+        if not is_empty and data == '':
+            if self.required:
+                self.fail('required')
+            else:
+                return True, data
+        return is_empty, data
+
+    def to_representation(self, value):
+        if value in ('', None) and not self.required:
+            return value
+        return super(EmptyStringFieldMixin, self).to_representation(value)
+
+
+class AllowBlankNullFieldMixin(object):
+    def __init__(self, *args, **kwargs):
+        super(AllowBlankNullFieldMixin, self).__init__(*args, **kwargs)
+
+        # some DRF fields explicitly do not allow some kwargs
+        # therefore we adjust the field attributes directly
+        if not self.required:
+            if all([isinstance(self, CharField),
+                    hasattr(self, 'allow_blank'),
+                    'allow_blank' not in kwargs]):
+                self.allow_blank = True
+            if all([hasattr(self, 'allow_null'),
+                    'allow_null' not in kwargs]):
+                self.allow_null = True
+
+
+class ValueAsTextFieldMixin(object):
+    def to_string_value(self, data):
+        if data:
+            return six.text_type(data)
+        return data
+
+    def prepare_value_for_validation(self, data):
+        return data
+
+    def run_validation(self, value=empty):
+        (is_empty_value, value) = self.validate_empty_values(value)
+        if is_empty_value:
+            return value
+
+        value = self.prepare_value_for_validation(value)
+        value = self.to_internal_value(value)
+        self.run_validators(value)
+        value = self.to_string_value(value)
+
+        return value

simo/core/drf_braces/fields/modified.py

@@ -0,0 +1,41 @@
+from __future__ import absolute_import, print_function, unicode_literals
+import inspect
+
+from . import _fields as fields
+
+
+class BooleanField(fields.BooleanField):
+    def __init__(self, *args, **kwargs):
+        self.TRUE_VALUES = self.TRUE_VALUES | set(kwargs.pop('true_values', []))
+        self.FALSE_VALUES = self.FALSE_VALUES | set(kwargs.pop('false_values', []))
+        super(BooleanField, self).__init__(*args, **kwargs)
+
+
+class DecimalField(fields.DecimalField):
+    def __init__(self, max_digits=None, decimal_places=None, *args, **kwargs):
+        super(DecimalField, self).__init__(
+            max_digits=max_digits, decimal_places=decimal_places,
+            *args, **kwargs
+        )
+
+    def quantize(self, value):
+        if self.max_digits is None or self.decimal_places is None:
+            return value
+        return super(DecimalField, self).quantize(value)
+
+
+class DateTimeField(fields.DateTimeField):
+    def __init__(self, *args, **kwargs):
+        super(DateTimeField, self).__init__(*args, **kwargs)
+        # allow fo the case when default_timezone is passed as None
+        # since super will in that use Django's default timezone
+        if 'default_timezone' in kwargs:
+            # DRF >= 3.3
+            if callable(self.default_timezone):
+                self.timezone = kwargs['default_timezone']
+            else:
+                self.default_timezone = kwargs['default_timezone']
+
+
+__all__ = [name for name, value in locals().items()
+           if inspect.isclass(value) and issubclass(value, fields.Field)]

simo/core/drf_braces/forms/fields.py

@@ -0,0 +1,20 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+import six
+from dateutil.parser import parse
+from django import forms
+from rest_framework import ISO_8601
+
+
+class ISO8601DateTimeField(forms.DateTimeField):
+    def to_python(self, value):
+        if value in self.empty_values:
+            return
+
+        if isinstance(value, six.string_types) and ISO_8601 in self.input_formats:
+            try:
+                return parse(value)
+            except ValueError:
+                raise forms.ValidationError(self.error_messages['invalid'], code='invalid')
+
+        return super(ISO8601DateTimeField, self).to_python(value)