simo 2.0.5__py3-none-any.whl → 2.0.6__py3-none-any.whl

simo/core/admin.py

@@ -9,8 +9,7 @@ from django.views.decorators.csrf import csrf_protect
 from django.shortcuts import redirect, render
 from simo.users.models import ComponentPermission
 from .utils.type_constants import (
-    ALL_BASE_TYPES,
-    get_all_gateways, get_controller_types_map
+    ALL_BASE_TYPES, GATEWAYS_MAP, CONTROLLERS_BY_GATEWAY
 )
 from .models import Instance, Icon, Gateway, Component, Zone, Category
 from .forms import (
@@ -22,7 +21,6 @@ from .forms import (
 )
 from .filters import ZonesFilter
 from .widgets import AdminImageWidget
-from .middleware import get_current_instance
 from simo.conf import dynamic_settings
 
 csrf_protect_m = method_decorator(csrf_protect)
@@ -156,7 +154,7 @@ class GatewayAdmin(admin.ModelAdmin):
         }
         if request.session.get('gateway_type'):
             try:
-                formClass = get_all_gateways().get(
+                formClass = GATEWAYS_MAP.get(
                     request.session.get('gateway_type')
                 ).config_form
             except:
@@ -188,7 +186,7 @@ class GatewayAdmin(admin.ModelAdmin):
                     )
                 except:
                     ctx['error'] = '%s gateway already exists!' \
-                                   % get_all_gateways().get(
+                                   % GATEWAYS_MAP.get(
                         request.session.get('gateway_type'), 'None'
                     ).name
                 else:
@@ -210,7 +208,7 @@ class GatewayAdmin(admin.ModelAdmin):
 
     def get_form(self, request, obj=None, change=False, **kwargs):
         if obj:
-            gateway_class = get_all_gateways().get(obj.type)
+            gateway_class = GATEWAYS_MAP.get(obj.type)
             if gateway_class:
                 return gateway_class.config_form
         return BaseGatewayForm
@@ -323,8 +321,8 @@ class ComponentAdmin(admin.ModelAdmin):
 
             if request.session.get('add_comp_type'):
                 try:
-                    controller_cls = get_controller_types_map(
-                        gateway
+                    controller_cls = CONTROLLERS_BY_GATEWAY.get(
+                        gateway, {}
                     )[request.session['add_comp_type']]
                 except:
                     request.session.pop('add_comp_type')
@@ -430,8 +428,8 @@ class ComponentAdmin(admin.ModelAdmin):
     def get_form(self, request, obj=None, change=False, **kwargs):
         if obj:
             try:
-                self.form = get_controller_types_map(
-                    obj.gateway
+                self.form = CONTROLLERS_BY_GATEWAY.get(
+                    obj.gateway, {}
                 )[obj.controller_uid].config_form
             except KeyError:
                 pass

simo/core/api.py

@@ -182,7 +182,6 @@ class ComponentViewSet(InstanceMixin, viewsets.ModelViewSet):
         return singular
 
     def perform_controller_method(self, json_data, component):
-        component.prepare_controller()
         for method_name, param in json_data.items():
             if not hasattr(component, method_name):
                 raise APIValidationError(
@@ -584,10 +583,10 @@ class ControllerTypes(InstanceMixin, viewsets.GenericViewSet):
         return permissions
 
     def list(self, request, *args, **kwargs):
-        from .utils.type_constants import get_controller_types_map
+        from .utils.type_constants import CONTROLLER_TYPES_MAP
         data = {}
 
-        for uid, cls in get_controller_types_map().items():
+        for uid, cls in CONTROLLER_TYPES_MAP.items():
             if cls.gateway_class.name not in data:
                 data[cls.gateway_class.name] = []
             data[cls.gateway_class.name].append({

simo/core/forms.py

@@ -260,10 +260,12 @@ class CompTypeSelectForm(forms.Form):
     def __init__(self, gateway, *args, **kwargs):
         super().__init__(*args, **kwargs)
         if gateway:
-            from .utils.type_constants import get_controller_types_choices
-            self.fields['controller_type'].choices = get_controller_types_choices(
-                gateway
-            )
+            from .utils.type_constants import CONTROLLERS_BY_GATEWAY
+            self.fields['controller_type'].choices = [
+                (cls.uid, cls.name) for cls in CONTROLLERS_BY_GATEWAY.get(
+                    gateway.handler.uid, {}
+                ).values()
+            ]
 
 
 class ComponentAdminForm(forms.ModelForm):
@@ -300,8 +302,8 @@ class ComponentAdminForm(forms.ModelForm):
             self.gateway = self.instance.gateway
             self.controller = self.instance.controller
         else:
-            from .utils.type_constants import get_controller_types_map
-            ControllerClass = get_controller_types_map().get(self.controller_uid)
+            from .utils.type_constants import CONTROLLER_TYPES_MAP
+            ControllerClass = CONTROLLER_TYPES_MAP.get(self.controller_uid)
             if ControllerClass:
                 self.controller = ControllerClass(self.instance)
                 self.gateway = Gateway.objects.filter(

simo/core/models.py

@@ -217,16 +217,11 @@ class Gateway(DirtyFieldsMixin, models.Model, SimoAdminMixin):
         return self.type
 
     def __init__(self, *args, **kwargs):
-        from .utils.type_constants import get_all_gateways
-        ALL_GATEWAYS = get_all_gateways()
-        GATEWAYS_CHOICES = [
-            (slug, cls.name) for slug, cls in ALL_GATEWAYS.items()
-        ]
-        GATEWAYS_CHOICES.sort(key=lambda e: e[1])
+        from .utils.type_constants import GATEWAYS_MAP, GATEWAYS_CHOICES
         self._meta.get_field('type').choices = GATEWAYS_CHOICES
         super().__init__(*args, **kwargs)
 
-        gateway_class = ALL_GATEWAYS.get(self.type)
+        gateway_class = GATEWAYS_MAP.get(self.type)
         if gateway_class:
             self.handler = gateway_class(self)
             if hasattr(self.handler, 'run'):
@@ -272,8 +267,8 @@ class Gateway(DirtyFieldsMixin, models.Model, SimoAdminMixin):
 
     def process_discovery(self, data):
         self.refresh_from_db()
-        from .utils.type_constants import get_controller_types_map
-        ControllerClass = get_controller_types_map().get(
+        from .utils.type_constants import CONTROLLER_TYPES_MAP
+        ControllerClass = CONTROLLER_TYPES_MAP.get(
             self.discovery['controller_uid']
         )
         if ControllerClass and hasattr(
@@ -403,18 +398,7 @@ def is_in_alarm(self):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        # Goes in zero seconds!
-        if self.instance_methods:
-            custom_methods = {}
-            funcType = type(self.save)
-            try:
-                exec(self.instance_methods, None, custom_methods)
-            except:
-                pass
-            for key, val in custom_methods.items():
-                if not callable(val):
-                    continue
-                setattr(self, key, funcType(val, self))
+        self.prepare_controller()
 
     def __str__(self):
         if self.zone:
@@ -424,40 +408,40 @@ def is_in_alarm(self):
     @cached_property
     def controller(self):
         from .utils.type_constants import (
-            get_controller_types_map,
-            get_controller_types_choices
+            CONTROLLERS_BY_GATEWAY,
+            CONTROLLER_TYPES_CHOICES
         )
-        self._meta.get_field('controller_uid').choices = \
-            get_controller_types_choices()
+        self._meta.get_field('controller_uid').choices = CONTROLLER_TYPES_CHOICES
         if self.controller_uid:
             controller_cls = None
-            if self.id and not 'test' in sys.argv:
-                try:
-                    controller_cls = cache.get('c_%d_contr_cls' % self.id)
-                except:
-                    pass
             if not controller_cls:
-                controller_cls = get_controller_types_map(
-                    self.gateway
+                controller_cls = CONTROLLERS_BY_GATEWAY.get(
+                    self.gateway.type, {}
                 ).get(self.controller_uid)
-                if controller_cls and self.id and not 'test' in sys.argv:
-                    cache.set(
-                        'c_%d_contr_cls' % self.id,
-                        controller_cls, None
-                    )
             if controller_cls:
                 return controller_cls(self)
 
     def prepare_controller(self):
-        if not self.controller:
-            return
-        controller_methods = [m for m in inspect.getmembers(
-            self.controller, predicate=inspect.ismethod
-        ) if not m[0].startswith('_')]
-        for method in controller_methods:
-            setattr(self, method[0], method[1])
-        if not self.id:
-            self.value = self.controller.default_value
+        if self.controller:
+            controller_methods = [m for m in inspect.getmembers(
+                self.controller, predicate=inspect.ismethod
+            ) if not m[0].startswith('_')]
+            for method in controller_methods:
+                setattr(self, method[0], method[1])
+            if not self.id:
+                self.value = self.controller.default_value
+
+        if self.instance_methods:
+            custom_methods = {}
+            funcType = type(self.save)
+            try:
+                exec(self.instance_methods, None, custom_methods)
+            except:
+                pass
+            for key, val in custom_methods.items():
+                if not callable(val):
+                    continue
+                setattr(self, key, funcType(val, self))
 
     def get_socket_url(self):
         return reverse_lazy(

simo/core/serializers.py

@@ -284,10 +284,9 @@ class ComponentSerializer(FormSerializer):
     def set_form_cls(self):
         self.Meta.form = ComponentAdminForm
         if not isinstance(self.instance, Iterable):
-            from .utils.type_constants import get_controller_types_map
-            controllers_map = get_controller_types_map()
+            from .utils.type_constants import CONTROLLER_TYPES_MAP
             if not self.instance:
-                controller = controllers_map.get(
+                controller = CONTROLLER_TYPES_MAP.get(
                     #'simo.generic.controllers.AlarmClock'
                     self.context['request'].META.get('HTTP_CONTROLLER')
                 )

simo/core/utils/type_constants.py

@@ -19,20 +19,32 @@ def get_controller_types_map(gateway=None):
         except ModuleNotFoundError:
             continue
         for cls_name, cls in configs.__dict__.items():
-            if inspect.isclass(cls) and issubclass(cls, ControllerBase) \
-                and not inspect.isabstract(cls):
-                if gateway:
+            if not inspect.isclass(cls):
+                continue
+            if not issubclass(cls, ControllerBase):
+                continue
+            if inspect.isabstract(cls):
+                continue
+            if gateway:
+                if issubclass(gateway, BaseGatewayHandler) \
+                or isinstance(gateway, BaseGatewayHandler):
+                    if gateway.uid != cls.gateway_class.uid:
+                        continue
+                else:
                     try:
-                        same = gateway.type == cls.gateway_class.uid
+                        same = gateway.handler.uid == cls.gateway_class.uid
                     except:
                         continue
                     else:
                         if not same:
                             continue
-                controllers_map[cls.uid] = cls
+            controllers_map[cls.uid] = cls
     return controllers_map
 
 
+CONTROLLER_TYPES_MAP = get_controller_types_map()
+
+
 def get_controller_types_choices(gateway=None):
     choices = []
     for controller_cls in get_controller_types_map(gateway).values():
@@ -40,11 +52,8 @@ def get_controller_types_choices(gateway=None):
     return choices
 
 
-#ALL_CONTROLLER_TYPES = get_controller_types_map()
-# CONTROLLER_TYPE_CHOICES = [
-#     (slug, cls.name) for slug, cls in ALL_CONTROLLER_TYPES.items()
-# ]
-# CONTROLLER_TYPE_CHOICES.sort(key=lambda e: e[0])
+CONTROLLER_TYPES_CHOICES = get_controller_types_choices()
+
 
 def get_all_gateways():
     all_gateways = {}
@@ -65,13 +74,25 @@ def get_all_gateways():
     return all_gateways
 
 
+GATEWAYS_MAP = get_all_gateways()
+
+
 def get_gateway_choices():
     choices = [
-        (slug, cls.name) for slug, cls in get_all_gateways().items()
+        (slug, cls.name) for slug, cls in GATEWAYS_MAP.items()
     ]
     choices.sort(key=lambda e: e[1])
     return choices
 
+GATEWAYS_CHOICES = get_gateway_choices()
+
+
+CONTROLLERS_BY_GATEWAY = {}
+for gateway_slug, gateway_cls in GATEWAYS_MAP.items():
+    CONTROLLERS_BY_GATEWAY[gateway_slug] = {}
+    for ctrl_uid, ctrl_cls in get_controller_types_map(gateway_cls).items():
+        CONTROLLERS_BY_GATEWAY[gateway_slug][ctrl_uid] = ctrl_cls
+
 
 ALL_BASE_TYPES = {}
 for name, app in apps.app_configs.items():