simo 2.11.4__py3-none-any.whl → 3.0.4__py3-none-any.whl

simo/core/forms.py

@@ -17,6 +17,7 @@ from .form_fields import Select2ModelMultipleChoiceField
 from .widgets import SVGFileWidget, LogOutputWidget, PythonCode
 from .utils.formsets import FormsetField
 from .utils.validators import validate_slaves
+from .base_types import BaseComponentType
 
 
 class HiddenField(forms.CharField):
@@ -265,7 +266,14 @@ class ComponentAdminForm(forms.ModelForm):
                 ).first()
                 self.instance.gateway = self.gateway
                 self.instance.controller_uid = ControllerClass.uid
-                self.instance.base_type = self.controller.base_type
+                # Normalize controller base_type to slug for storage
+                bt = getattr(ControllerClass, 'base_type', None)
+                if isinstance(bt, str):
+                    self.instance.base_type = bt
+                elif isinstance(bt, type) and issubclass(bt, BaseComponentType):
+                    self.instance.base_type = bt.slug
+                else:
+                    self.instance.base_type = getattr(bt, 'slug', None) or str(bt)
                 self.instance.value = self.controller.default_value
                 self.instance.value_units = self.controller.default_value_units
                 self.instance.value_previous = self.controller.default_value
@@ -657,4 +665,4 @@ class DimmerPlusConfigForm(BaseComponentForm):
 class RGBWConfigForm(BaseComponentForm):
     has_white = forms.BooleanField(
         label=_("Has WHITE color channel"), required=False,
-    )
+    )

simo/core/management/_hub_template/hub/nginx.conf

@@ -1,52 +1,8 @@
-server{
+server {
+    listen 80 default_server;
     listen [::]:80 default_server;
-    listen      80 default_server;
-
-    charset     utf-8;
-
-    client_max_body_size 100M;
-
-
-    location /protected/static {
-        internal;
-        alias {{ project_dir }}/_var/static;
-    }
-
-    location /protected/media {
-        internal;
-        alias {{ project_dir }}/_var/media;
-    }
-
-    location /public_media{
-        alias {{ project_dir }}/_var/public_media;
-        access_log off;
-        expires max;
-    }
-
-    # daphne
-    location /ws {
-        include proxy_params;
-
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
-
-        proxy_pass http://unix:/tmp/http.sock;
-    }
-
-    # gunicorn
-    location / {
-        include proxy_params;
-        proxy_connect_timeout       600;
-        proxy_send_timeout          600;
-        proxy_read_timeout          600;
-        send_timeout                600;
-        proxy_pass http://unix:/tmp/gunicorn.sock;
-    }
-}
-
-server{
-    listen [::]:443 default_server ssl;
-    listen      443 default_server ssl;
+    listen 443 ssl http2 default_server;
+    listen [::]:443 ssl http2 default_server;
 
     charset     utf-8;
 
@@ -80,7 +36,6 @@ server{
         expires max;
     }
 
-    # daphne
     location /ws {
         include proxy_params;
 
@@ -90,7 +45,25 @@ server{
         proxy_pass http://unix:/tmp/http.sock;
     }
 
-    # gunicorn
+    location = /mcp {
+        return 301 /mcp/;
+    }
+
+    location ^~ /mcp/ {
+        proxy_pass http://0.0.0.0:3333/;
+        proxy_set_header Host              $host;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
+        proxy_set_header Authorization     $http_authorization;
+
+        proxy_http_version 1.1;
+        proxy_buffering off;
+        proxy_request_buffering off;
+        proxy_read_timeout 3600s;
+        proxy_send_timeout 3600s;
+    }
+
+
     location / {
         include proxy_params;
         proxy_connect_timeout       600;

simo/core/management/_hub_template/hub/supervisor.conf

@@ -47,6 +47,21 @@ killasgroup=true
 environment=PYTHONUNBUFFERED=1
 
 
+[program:simo-mcp]
+directory={{ project_dir }}/hub/
+command={{ venv_path }}/uvicorn simo.mcp_server.server:create_app --factory --host 0.0.0.0 --port 3333
+process_name=%(program_name)s
+user=root
+stdout_logfile=/var/log/simo/mcp.log
+stdout_logfile_maxbytes=1MB
+stdout_logfile_backups=3
+redirect_stderr=true
+autostart=true
+autorestart=true
+stopwaitsecs=15
+killasgroup=true
+
+
 [program:simo-gateways]
 command={{ venv_path }}/python {{ project_dir }}/hub/manage.py gateways_manager
 process_name=%(program_name)s

simo/core/mcp.py

@@ -0,0 +1,154 @@
+import pytz
+import datetime
+import logging
+import json
+from asgiref.sync import sync_to_async
+from django.utils import timezone
+from simo.mcp_server.app import mcp
+from fastmcp.tools.tool import ToolResult
+from simo.users.utils import get_current_user, introduce_user, get_ai_user
+from simo.core.middleware import get_current_instance
+from .models import Zone, Component, ComponentHistory
+from .serializers import MCPBasicZoneSerializer, MCPFullComponentSerializer
+from .utils.type_constants import BASE_TYPE_CLASS_MAP
+
+log = logging.getLogger(__name__)
+
+
+@mcp.tool(name="core.get_state")
+async def get_state() -> dict:
+    """
+    PRIMARY RESOURCE – returns full current system state.
+    """
+    def _build():
+        inst = get_current_instance()
+        data = {
+            "unix_timestamp": int(timezone.now().timestamp()),
+            "ai_memory": inst.ai_memory,
+            "zones": MCPBasicZoneSerializer(
+                Zone.objects.filter(instance=inst).prefetch_related(
+                    "components", "components__category",
+                    "components__gateway", "components__slaves"
+                ),
+                many=True,
+            ).data,
+            "component_base_types": {},
+        }
+        for slug, cls in BASE_TYPE_CLASS_MAP.items():
+            data["component_base_types"][slug] = {
+                "name": str(cls.name),
+                "description": str(cls.description),
+                "purpose": str(cls.purpose),
+                "basic_methods": str(cls.required_methods),
+            }
+        return data
+
+    return await sync_to_async(_build, thread_sensitive=True)()
+
+
+@mcp.tool(name="core.get_component")
+async def get_component(id: str) -> dict:
+    """
+    Returns full component state, configs, metadata, methods, values, etc.
+    """
+    def _load(component_id: str):
+        component = (
+            Component.objects.filter(pk=component_id, zone__instance=get_current_instance())
+            .select_related("zone", "category", "gateway")
+            .first()
+        )
+        return MCPFullComponentSerializer(component).data
+
+    return await sync_to_async(_load, thread_sensitive=True)(id)
+
+
+@mcp.tool(name="core.get_component_value_change_history")
+async def get_component_value_change_history(
+    start: int, end: int, component_ids: str
+) -> list:
+    """
+    Returns up to 100 component value change history records.
+
+    - start: unix epoch seconds (older than)
+    - end:   unix epoch seconds (younger than)
+    - component_ids: ids joined by '-' OR '-' to include all
+    """
+    def _load(_start: int, _end: int, _ids: str):
+        inst = get_current_instance()
+        tz = pytz.timezone(inst.timezone)
+        qs = (
+            ComponentHistory.objects.filter(
+                component__zone__instance=inst,
+                date__gt=datetime.datetime.fromtimestamp(int(_start), tz=timezone.utc),
+                date__lt=datetime.datetime.fromtimestamp(int(_end), tz=timezone.utc),
+            )
+            .select_related("user")
+            .order_by("-date")
+        )
+        if _ids != "-":
+            ids = [int(c_id) for c_id in _ids.split("-")]
+            qs = qs.filter(component__id__in=ids)
+        history = []
+        for item in qs[:100]:
+            history.append({
+                "component_id": item.component.id,
+                "datetime": timezone.localtime(item.date, tz).strftime("%Y-%m-%d %H:%M:%S"),
+                "type": item.type,
+                "value": item.value,
+                "alive": item.alive,
+                "user": item.user.name if item.user_id else None,
+            })
+        return history
+
+    return await sync_to_async(_load, thread_sensitive=True)(start, end, component_ids)
+
+
+@mcp.tool(name="core.call_component_method")
+async def call_component_method(
+    component_id: int,
+    method_name: str,
+    args: list | None = None,
+    kwargs: dict | None = None,
+):
+    """
+    Calls a method on a component with given args/kwargs and returns the result if any.
+    """
+    def _execute():
+        log.debug("Call component [%s] %s(*%s, **%s)", component_id, method_name, args, kwargs)
+        current_user = get_current_user()
+        if not current_user:
+            introduce_user(get_ai_user())
+        component = Component.objects.get(
+            pk=component_id, zone__instance=get_current_instance()
+        )
+        fn = getattr(component, method_name)
+        if args and kwargs:
+            return fn(*args, **kwargs)
+        if args:
+            return fn(*args)
+        if kwargs:
+            return fn(**kwargs)
+        return fn()
+
+    return await sync_to_async(_execute, thread_sensitive=True)()
+
+
+@mcp.tool(name="core.update_ai_memory")
+async def update_ai_memory(text):
+    """
+    Overrides ai_memory with new memory text
+    """
+    def _execute(text):
+        inst = get_current_instance()
+        inst.ai_memory = text
+        inst.save(update_fields=['ai_memory'])
+
+    return await sync_to_async(_execute, thread_sensitive=True)(text)
+
+
+@mcp.tool(name="core.get_unix_timestamp")
+async def get_unix_timestamp() -> int:
+    """
+    Get current unix timestamp epoch seconds
+    """
+    return int(timezone.now().timestamp())

simo/core/migrations/0051_instance_ai_memory.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.10 on 2025-09-24 07:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0050_componenthistory_alive'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='instance',
+            name='ai_memory',
+            field=models.TextField(blank=True, default='', help_text='Used by AI assistant.'),
+        ),
+    ]

simo/core/models.py

@@ -109,6 +109,9 @@ class Instance(DirtyFieldsMixin, models.Model, SimoAdminMixin):
         User, null=True, blank=True, on_delete=models.SET_NULL,
         editable=False
     )
+    ai_memory = models.TextField(
+        blank=True, default='',  help_text="Used by AI assistant."
+    )
 
     #objects = InstanceManager()
 

simo/core/serializers.py

@@ -3,6 +3,7 @@ import datetime
 import re
 import json
 from django import forms
+from django.utils import timezone
 from collections import OrderedDict
 from django.conf import settings
 from django.forms.utils import pretty_name
@@ -651,3 +652,122 @@ class ActionSerializer(serializers.ModelSerializer):
     def get_value(self, obj):
         return obj.data.get('value')
 
+
+class MCPBasicCategorySerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Category
+        fields = 'id', 'name', 'icon'
+
+
+class MCPBasicComponentSerializer(serializers.ModelSerializer):
+    category = MCPBasicCategorySerializer(read_only=True)
+    gateway = serializers.SerializerMethodField()
+    slave_components = serializers.SerializerMethodField()
+    last_change = TimestampField(read_only=True)
+
+    class Meta:
+        model = Component
+        fields = (
+            'id', 'name', 'icon', 'category', 'gateway', 'base_type', 'value',
+            'value_units',
+            'slave_components', 'last_change', 'alive', 'error_msg',
+            'battery_level', 'show_in_app', 'alarm_category', 'arm_status'
+        )
+
+    def get_gateway(self, obj):
+        return obj.gateway.type
+
+    def get_slave_components(self, obj):
+        return [c['id'] for c in obj.slaves.all().values('id')]
+
+
+class MCPBasicZoneSerializer(serializers.ModelSerializer):
+    components = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Zone
+        fields = 'id', 'name', 'components'
+
+    def get_components(self, obj):
+        return MCPBasicComponentSerializer(
+            obj.components.all(), many=True, context=self.context
+        ).data
+
+
+class MCPFullComponentSerializer(serializers.ModelSerializer):
+    category = MCPBasicCategorySerializer(read_only=True)
+    gateway = serializers.SerializerMethodField()
+    slave_components = serializers.SerializerMethodField()
+    last_change = TimestampField(read_only=True)
+    info = serializers.SerializerMethodField()
+    controller_methods = serializers.SerializerMethodField()
+    unix_timestamp = serializers.SerializerMethodField()
+
+
+    class Meta:
+        model = Component
+        fields = (
+            'id', 'name', 'icon', 'zone', 'category', 'gateway',
+            'base_type', 'controller_uid', 'config', 'meta', 'value',
+            'value_units', 'value_translation', 'alive', 'error_msg',
+            'battery_level', 'show_in_app', 'alarm_category', 'arm_status',
+            'info', 'controller_methods', 'slave_components', 'last_change',
+            'unix_timestamp'
+        )
+
+
+    def get_gateway(self, obj):
+        return obj.gateway.type
+
+    def get_info(self, obj):
+        return obj.info()
+
+    def get_controller_methods(self, obj):
+        methods = {}
+        # Collect controller public methods with signatures and docstrings
+        for name, method in inspect.getmembers(obj.controller, predicate=inspect.ismethod):
+            if name.startswith('_'):
+                continue
+            if name in ('info', 'set'):
+                continue
+            if name == 'send' and not obj.controller.accepts_value:
+                continue
+            try:
+                sig = str(inspect.signature(method))
+            except Exception:
+                sig = '()'
+            doc = inspect.getdoc(method) or ''
+            methods[name] = {
+                'name': name,
+                'signature': sig,
+                'doc': doc
+            }
+
+        # If component has alarm capabilities, ensure arm/disarm are exposed
+        if obj.alarm_category:
+            for extra in ('arm', 'disarm'):
+                if extra in methods:
+                    continue
+                cm = getattr(obj, extra, None)
+                if cm and callable(cm):
+                    try:
+                        sig = str(inspect.signature(cm))
+                    except Exception:
+                        sig = '()'
+                    doc = inspect.getdoc(cm) or ''
+                    methods[extra] = {
+                        'name': extra,
+                        'signature': sig,
+                        'doc': doc,
+                    }
+
+        # Return as a list sorted by method name for stability
+        return [methods[k] for k in sorted(methods.keys())]
+
+    def get_slave_components(self, obj):
+        return [c['id'] for c in obj.slaves.all().values('id')]
+
+    def get_unix_timestamp(self, obj):
+        return timezone.now().timestamp()
+

simo/core/signal_receivers.py

@@ -185,7 +185,7 @@ def post_save_change_events(sender, instance, created, **kwargs):
 
     transaction.on_commit(post_update)
 
-    if created:
+    if created and isinstance(instance, Component):
         def clear_api_cache():
             cache.delete(f"main-components-{instance.zone.instance.id}")
             from simo.users.models import User

simo/core/tasks.py

@@ -234,9 +234,7 @@ def sync_with_remote():
         ).first()
         if weather_component:
             if weather:
-                weather_component.alive = True
-                weather_component.controller.set(weather)
-                weather_component.save()
+                weather_component.controller.set(weather, alive=True)
             else:
                 weather_component.alive = False
                 weather_component.save()

simo/core/utils/type_constants.py

@@ -3,6 +3,68 @@ import inspect
 from django.apps import apps
 from ..gateways import BaseGatewayHandler
 from ..app_widgets import BaseAppWidget
+from ..base_types import BaseComponentType
+
+
+# ----- Base type discovery (must be defined before controller discovery) -----
+def get_base_type_class_map():
+    """Discover BaseComponentType subclasses across installed apps.
+
+    Returns a dict mapping slug -> type class.
+    """
+    base_types = {}
+    for name, app in apps.app_configs.items():
+        if name in (
+            'auth', 'admin', 'contenttypes', 'sessions', 'messages',
+            'staticfiles'
+        ):
+            continue
+        try:
+            module = importlib.import_module(f'{app.name}.base_types')
+        except ModuleNotFoundError:
+            continue
+        for cls_name, cls in module.__dict__.items():
+            if not inspect.isclass(cls):
+                continue
+            if not issubclass(cls, BaseComponentType) or cls is BaseComponentType:
+                continue
+            if not getattr(cls, 'slug', None):
+                continue
+            if cls.slug in base_types:
+                raise RuntimeError(
+                    f"Duplicate base type slug '{cls.slug}' defined by "
+                    f"{base_types[cls.slug].__module__}.{base_types[cls.slug].__name__} "
+                    f"and {cls.__module__}.{cls.__name__}"
+                )
+            base_types[cls.slug] = cls
+    return base_types
+
+
+BASE_TYPE_CLASS_MAP = get_base_type_class_map()
+
+
+def get_all_base_types():
+    """Build a combined map of slug -> name from classes and legacy dicts."""
+    all_types = {slug: cls.name for slug, cls in BASE_TYPE_CLASS_MAP.items()}
+    # Backward-compatible: merge any legacy dict entries not covered by classes
+    for name, app in apps.app_configs.items():
+        if name in (
+            'auth', 'admin', 'contenttypes', 'sessions', 'messages',
+            'staticfiles'
+        ):
+            continue
+        try:
+            configs = importlib.import_module('%s.base_types' % app.name)
+        except ModuleNotFoundError:
+            continue
+        for slug, display in configs.__dict__.get('BASE_TYPES', {}).items():
+            if slug not in all_types:
+                all_types[slug] = display
+    return all_types
+
+
+ALL_BASE_TYPES = get_all_base_types()
+BASE_TYPE_CHOICES = sorted(list(ALL_BASE_TYPES.items()), key=lambda e: e[0])
 
 
 def get_controller_types_map(gateway=None, user=None):
@@ -41,6 +103,22 @@ def get_controller_types_map(gateway=None, user=None):
             if user and not user.is_master and cls.masters_only:
                 continue
 
+            # Validate controller against its base type contract if available.
+            # Support either `base_type_cls` or legacy `base_type` (slug or class).
+            declared = getattr(cls, 'base_type_cls', None)
+            slug = None
+            if declared and inspect.isclass(declared) and issubclass(declared, BaseComponentType):
+                slug = declared.slug
+            else:
+                bt = getattr(cls, 'base_type', None)
+                if isinstance(bt, str):
+                    slug = bt
+                elif inspect.isclass(bt) and issubclass(bt, BaseComponentType):
+                    slug = bt.slug
+            bt_cls = BASE_TYPE_CLASS_MAP.get(slug) if slug else None
+            if bt_cls:
+                bt_cls.validate_controller(cls)
+
             controllers_map[cls.uid] = cls
     return controllers_map
 
@@ -97,21 +175,6 @@ for gateway_slug, gateway_cls in GATEWAYS_MAP.items():
         CONTROLLERS_BY_GATEWAY[gateway_slug][ctrl_uid] = ctrl_cls
 
 
-ALL_BASE_TYPES = {}
-for name, app in apps.app_configs.items():
-    if name in (
-        'auth', 'admin', 'contenttypes', 'sessions', 'messages',
-        'staticfiles'
-    ):
-        continue
-    try:
-        configs = importlib.import_module('%s.base_types' % app.name)
-    except ModuleNotFoundError:
-        continue
-    ALL_BASE_TYPES.update(configs.__dict__.get('BASE_TYPES', {}))
-
-BASE_TYPE_CHOICES = list(ALL_BASE_TYPES.items())
-BASE_TYPE_CHOICES.sort(key=lambda e: e[0])
 
 
 APP_WIDGETS = {}
@@ -134,5 +197,3 @@ for name, app in apps.app_configs.items():
 
 APP_WIDGET_CHOICES = [(slug, cls.name) for slug, cls in APP_WIDGETS.items()]
 APP_WIDGET_CHOICES.sort(key=lambda e: e[1])
-
-

simo/fleet/admin.py

@@ -61,7 +61,7 @@ class ColonelAdmin(admin.ModelAdmin):
     readonly_fields = (
         'type', 'uid', 'connected', 'last_seen',
         'firmware_version', 'newer_firmware_available',
-        'history',
+        'history', 'wake_stats', 'last_wake', 'is_vo_active'
     )
 
     actions = (
@@ -83,6 +83,10 @@ class ColonelAdmin(admin.ModelAdmin):
             'fields': ('history',),
             'classes': ('collapse',),
         }),
+        ("AI Voice Assistant", {
+            'fields': ('wake_stats', 'last_wake', 'is_vo_active'),
+            'classes': ('collapse',),
+        })
     )
 
     def get_queryset(self, request):

simo/fleet/api.py

@@ -5,13 +5,11 @@ from rest_framework import viewsets
 from rest_framework.response import Response as RESTResponse
 from rest_framework.decorators import action
 from rest_framework.exceptions import ValidationError as APIValidationError
-from django_filters.rest_framework import DjangoFilterBackend
 from simo.core.api import InstanceMixin
 from simo.core.permissions import IsInstanceSuperuser
-from .models import InstanceOptions, Colonel, Interface, CustomDaliDevice
+from .models import InstanceOptions, Colonel, Interface
 from .serializers import (
-    InstanceOptionsSerializer, ColonelSerializer, ColonelInterfaceSerializer,
-    CustomDaliDeviceSerializer
+    InstanceOptionsSerializer, ColonelSerializer, ColonelInterfaceSerializer
 )
 
 
@@ -106,26 +104,3 @@ class InterfaceViewSet(
     def get_queryset(self):
         return Interface.objects.filter(colonel__instance=self.instance)
 
-
-class CustomDaliDeviceViewSet(InstanceMixin, viewsets.ModelViewSet):
-    url = 'fleet/custom-dali-devices'
-    basename = 'custom-dali-devices'
-    serializer_class = CustomDaliDeviceSerializer
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['uid', 'random_address', 'name']
-
-    def get_permissions(self):
-        permissions = super().get_permissions()
-        permissions.append(IsInstanceSuperuser())
-        return permissions
-
-    def get_queryset(self):
-        return CustomDaliDevice.objects.filter(instance=self.instance)
-
-    def perform_destroy(self, instance):
-        if instance.components.all().count():
-            raise APIValidationError(
-                _('Deleting colonel which has components is not allowed!'),
-                code=400
-            )
-        instance.delete()