simo 2.11.3__py3-none-any.whl → 3.0.1__py3-none-any.whl

simo/asgi.py

@@ -1,4 +1,4 @@
-import importlib, datetime, sys
+import importlib, importlib.util, datetime, sys, traceback
 from django.core.asgi import get_asgi_application
 from channels.auth import AuthMiddlewareStack
 from channels.routing import ProtocolTypeRouter, URLRouter
@@ -13,13 +13,32 @@ for name, app in apps.app_configs.items():
         'staticfiles'
     ):
         continue
+
+    module_path = f"{app.name}.routing"
+
+    # Only attempt import if the module exists
+    spec = importlib.util.find_spec(module_path)
+    if spec is None:
+        continue
+
+    # Import and collect urlpatterns; on failure, print full traceback and continue
+    try:
+        routing = importlib.import_module(module_path)
+    except Exception:
+        print(
+            f"Failed to import {module_path}:\n{traceback.format_exc()}"
+        )
+        continue
+
     try:
-        routing = importlib.import_module('%s.routing' % app.name)
-    except ModuleNotFoundError:
+        app_urlpatterns = getattr(routing, 'urlpatterns', None)
+        if isinstance(app_urlpatterns, list):
+            urlpatterns.extend(app_urlpatterns)
+    except Exception:
+        print(
+            f"Error while processing urlpatterns from {module_path}:\n{traceback.format_exc()}"
+        )
         continue
-    for var_name, item in routing.__dict__.items():
-        if isinstance(item, list) and var_name == 'urlpatterns':
-            urlpatterns.extend(item)
 
 
 class TimestampedStream:

simo/automation/controllers.py

@@ -63,24 +63,38 @@ class Script(ControllerBase, TimerMixin):
             return 'stopped'
 
     def start(self, new_code=None):
+        """Start the script process (optionally updating source code).
+
+        Parameters:
+        - new_code (str|None): Optional Python script to persist before start.
+        """
         if new_code:
             self.component.new_code = new_code
         self.send('start')
 
     def play(self):
+        """Alias for `start()` to harmonize with media-like controls."""
         return self.start()
 
     def stop(self):
+        """Stop the running script process."""
         self.send('stop')
 
     def toggle(self):
+        """Toggle script run state between running and stopped."""
         self.component.refresh_from_db()
         if self.component.value == 'running':
             self.send('stop')
         else:
             self.send('start')
 
-    def ai_assistant(self, wish):
+    def ai_assistant(self, wish, current_code=None):
+        """Request an AI-generated script for the given natural-language wish.
+
+        Parameters:
+        - wish (str): User intent in natural language.
+        Returns: dict with status, generated script, and description.
+        """
         try:
             request_data = {
                 'hub_uid': dynamic_settings['core__hub_uid'],
@@ -88,6 +102,7 @@ class Script(ControllerBase, TimerMixin):
                 'instance_uid': get_current_instance().uid,
                 'system_data': json.dumps(get_current_state()),
                 'wish': wish,
+                'current_code': current_code
             }
         except Exception as e:
             print(traceback.format_exc(), file=sys.stderr)
@@ -97,7 +112,7 @@ class Script(ControllerBase, TimerMixin):
             request_data['current_user'] = UserSerializer(user, many=False).data
         try:
             response = requests.post(
-                'https://simo.io/hubs/ai-assist/scripts/', json=request_data
+                'https://simo.io/ai/scripts/', json=request_data
             )
         except:
             return {'status': 'error', 'result': "Connection error"}
@@ -121,6 +136,7 @@ class PresenceLighting(Script):
     masters_only = False
     name = _("Presence lighting")
     config_form = PresenceLightingConfigForm
+    accepts_value = False
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)

simo/automation/forms.py

@@ -33,13 +33,12 @@ class ScriptConfigForm(BaseComponentForm):
                     "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 "
+        help_text="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>"
+                  "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 "                  
+                  "every time you enter something in this field. <br>"
+                  "Takes 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)
@@ -85,24 +84,16 @@ class ScriptConfigForm(BaseComponentForm):
 
 
     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') \
-                and org.config.get('assistant_request') \
-                    != self.cleaned_data['assistant_request']
-            else:
-                call_assistant = True
-
-            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'])
-
+        if self.cleaned_data['assistant_request']:
+            resp = self.instance.ai_assistant(
+                self.cleaned_data['assistant_request'],
+                self.instance.config.get('code')
+            )
+            if resp['status'] == 'success':
+                self._ai_resp = resp
+                self.cleaned_data['assistant_request'] = None
+            elif resp['status'] == 'error':
+                self.add_error('assistant_request', resp['result'])
         return self.cleaned_data
 
     def save(self, commit=True):

simo/core/admin.py

@@ -352,9 +352,10 @@ class ComponentAdmin(EasyObjectsDeleteMixin, admin.ModelAdmin):
 
                 ctx['is_last'] = True
                 ctx['current_step'] = 3
-                ctx['selected_type'] = ALL_BASE_TYPES.get(
-                    controller_cls.base_type, controller_cls.base_type
-                )
+                # Normalize controller base type to slug for display
+                bt = getattr(controller_cls, 'base_type', None)
+                slug = bt if isinstance(bt, str) else getattr(bt, 'slug', None)
+                ctx['selected_type'] = ALL_BASE_TYPES.get(slug or bt, slug or bt)
                 ctx['info'] = controller_cls.info(controller_cls)
                 if request.method == 'POST':
                     ctx['form'] = add_form(
@@ -506,4 +507,4 @@ class ComponentAdmin(EasyObjectsDeleteMixin, admin.ModelAdmin):
                 'value_history': obj.history.filter(type='value').order_by('-date')[:50],
                 'arm_status_history': obj.history.filter(type='security').order_by('-date')[:50]
             }
-        )
+        )

simo/core/base_types.py

@@ -1,23 +1,196 @@
 """
-  This is where apps define custom component base types.
+Component base types as first-class, self-describing classes.
+
+Apps can define their base types in their own `<app>.base_types` module
+by subclassing `BaseComponentType`. For backward compatibility, each
+module should also export a `BASE_TYPES` mapping `{slug: name}`; this
+file exports such mapping automatically from declared classes.
 """
 
+from abc import ABC
 from django.utils.translation import gettext_lazy as _
 
-BASE_TYPES = {
-    'numeric-sensor': _("Numeric sensor"),
-    'multi-sensor': _("Multi sensor"),
-    'binary-sensor': _("Binary sensor"),
-    'button': _("Button"),
-    'dimmer': _("Dimmer"),
-    'dimmer-plus': _("Dimmer Plus"),
-    'rgbw-light': _('RGB(W) light'),
-    'switch': _("Switch"),
-    'switch-double': _("Switch Double"),
-    'switch-triple': _("Switch Triple"),
-    'switch-quadruple': _("Switch Quadruple"),
-    'switch-quintuple': _("Switch Quintuple"),
-    'lock': _("Lock"),
-    'gate': _("Gate"),
-    'blinds': _("Blinds"),
-}
+
+class BaseComponentType(ABC):
+    """Abstract base for component base types.
+
+    Subclasses should set:
+    - slug: string identifier stored in Component.base_type
+    - name: human-friendly name (lazy-translated)
+    - description: short explanation of what this type represents
+    - purpose: when/why to use this type
+    - required_methods: tuple of controller method names that must be
+      implemented by controllers of this base type (optional).
+    """
+
+    slug: str = ''
+    name: str = ''
+    description: str = ''
+    purpose: str = ''
+    required_methods: tuple = tuple()
+
+    @classmethod
+    def describe(cls) -> dict:
+        return {
+            'slug': cls.slug,
+            'name': cls.name,
+            'description': cls.description,
+            'purpose': cls.purpose,
+            'required_methods': list(cls.required_methods or ()),
+        }
+
+    @classmethod
+    def validate_controller(cls, controller_cls):
+        """Validate that a controller satisfies this type's contract.
+
+        Raises TypeError with a helpful message on mismatch.
+        """
+        # If there are no explicit requirements, nothing to validate.
+        if not cls.required_methods:
+            return
+
+        missing = []
+        for method in cls.required_methods:
+            attr = getattr(controller_cls, method, None)
+            if not callable(attr):
+                missing.append(method)
+        if missing:
+            reqs = ', '.join(cls.required_methods)
+            raise TypeError(
+                f"Controller {controller_cls.__module__}.{controller_cls.__name__} "
+                f"for base type '{cls.slug}' is missing required method(s): "
+                f"{', '.join(missing)}. Expected: {reqs}"
+            )
+
+
+# ---- Core base types -------------------------------------------------
+
+
+class NumericSensorType(BaseComponentType):
+    slug = 'numeric-sensor'
+    name = _("Numeric sensor")
+    description = _("Represents a single numeric value that changes over time.")
+    purpose = _("Use for temperature, humidity, light level, etc.")
+
+
+class MultiSensorType(BaseComponentType):
+    slug = 'multi-sensor'
+    name = _("Multi sensor")
+    description = _("Represents several labeled readings in one component.")
+    purpose = _("Use when a single device reports multiple values.")
+
+
+class BinarySensorType(BaseComponentType):
+    slug = 'binary-sensor'
+    name = _("Binary sensor")
+    description = _("A boolean on/off style sensor.")
+    purpose = _("Use for motion, door, presence, and similar states.")
+
+
+class ButtonType(BaseComponentType):
+    slug = 'button'
+    name = _("Button")
+    description = _("Momentary button events like click, double-click, hold.")
+    purpose = _("Use to model input-only button devices.")
+
+
+class SwitchType(BaseComponentType):
+    slug = 'switch'
+    name = _("Switch")
+    description = _("Binary on/off actuator.")
+    purpose = _("Use to control relays, power sockets, or generic toggles.")
+    required_methods = ('turn_on', 'turn_off', 'toggle')
+
+
+class DoubleSwitchType(BaseComponentType):
+    slug = 'switch-double'
+    name = _("Switch Double")
+    description = _("Two-channel on/off actuator.")
+    purpose = _("Use to control two separate loads in one device.")
+
+
+class TripleSwitchType(BaseComponentType):
+    slug = 'switch-triple'
+    name = _("Switch Triple")
+    description = _("Three-channel on/off actuator.")
+    purpose = _("Use to control three separate loads in one device.")
+
+
+class QuadrupleSwitchType(BaseComponentType):
+    slug = 'switch-quadruple'
+    name = _("Switch Quadruple")
+    description = _("Four-channel on/off actuator.")
+    purpose = _("Use to control four loads in one device.")
+
+
+class QuintupleSwitchType(BaseComponentType):
+    slug = 'switch-quintuple'
+    name = _("Switch Quintuple")
+    description = _("Five-channel on/off actuator.")
+    purpose = _("Use to control five loads in one device.")
+
+
+class DimmerType(BaseComponentType):
+    slug = 'dimmer'
+    name = _("Dimmer")
+    description = _("Continuous actuator with settable output level.")
+    purpose = _("Use to control lights or devices with variable output.")
+    required_methods = ('turn_on', 'turn_off', 'toggle', 'output_percent', 'max_out')
+
+
+class DimmerPlusType(BaseComponentType):
+    slug = 'dimmer-plus'
+    name = _("Dimmer Plus")
+    description = _("Multi-channel dimmer with main and secondary outputs.")
+    purpose = _("Use for fixtures with multiple dimmable channels.")
+
+
+class RGBWLightType(BaseComponentType):
+    slug = 'rgbw-light'
+    name = _("RGB(W) light")
+    description = _("Color-capable light with optional white channel.")
+    purpose = _("Use for RGB/RGBW lighting control.")
+    required_methods = ('turn_on', 'turn_off', 'toggle')
+
+
+class LockType(BaseComponentType):
+    slug = 'lock'
+    name = _("Lock")
+    description = _("Door lock actuator with state reporting.")
+    purpose = _("Use to control smart locks and display their status.")
+    required_methods = ('lock', 'unlock')
+
+
+class GateType(BaseComponentType):
+    slug = 'gate'
+    name = _("Gate")
+    description = _("Gate/door opener with open/close/call commands.")
+    purpose = _("Use to manage gates with impulse or directional control.")
+    required_methods = ('open', 'close', 'call')
+
+
+class BlindsType(BaseComponentType):
+    slug = 'blinds'
+    name = _("Blinds")
+    description = _("Window coverings with position and optional angle control.")
+    purpose = _("Use to control roller blinds, shades, or venetians.")
+    required_methods = ('open', 'close', 'stop')
+
+
+def _export_base_types_dict():
+    """Derive legacy BASE_TYPES mapping from declared classes.
+
+    Returns {slug: name} for compatibility with legacy loaders.
+    """
+    import inspect as _inspect
+    mapping = {}
+    g = globals()
+    for _name, _obj in g.items():
+        if _inspect.isclass(_obj) and issubclass(_obj, BaseComponentType) \
+                and _obj is not BaseComponentType and getattr(_obj, 'slug', None):
+            mapping[_obj.slug] = _obj.name
+    return mapping
+
+
+# Backwards-compatible export for code still expecting a dict.
+BASE_TYPES = _export_base_types_dict()