fix

.woodpecker/config.yml

@@ -1,9 +1,6 @@
 when:
   event: [tag]
 
-depends_on:
-  - namespace
-
 steps:
   apply_configuration:
     image: quay.io/wollud1969/k8s-admin-helper:0.3.4

.woodpecker/namespace.yml

@@ -3,7 +3,11 @@ when:
   ref:
     exclude:
       - refs/tags/*-configchange
+<<<<<<< HEAD
+      
+=======
 
+>>>>>>> main
 steps:
   create_namespace:
     image: quay.io/wollud1969/k8s-admin-helper:0.3.4

apps/abstraction/main.py

@@ -15,7 +15,7 @@ import uuid
 from aiomqtt import Client
 from pydantic import ValidationError
 
-from packages.home_capabilities import LightState, ThermostatState, ContactState, TempHumidityState, RelayState, ThreePhasePowerState
+from packages.home_capabilities import LightState, ThermostatState, ContactState, TempHumidityState, RelayState, ThreePhasePowerState, SwitchState
 from apps.abstraction.transformation import (
     transform_abstract_to_vendor,
     transform_vendor_to_abstract
@@ -174,6 +174,10 @@ async def handle_abstract_set(
             # Contact sensors are read-only - SET commands should not occur
             logger.warning(f"Contact sensor {device_id} received SET command - ignoring (read-only device)")
             return
+        elif device_type == "switch":
+            # Switches are read-only - SET commands should not occur
+            logger.warning(f"Switch {device_id} received SET command - ignoring (read-only device)")
+            return
     except ValidationError as e:
         logger.error(f"Validation failed for {device_type} SET {device_id}: {e}")
         return
@@ -227,6 +231,9 @@ async def handle_vendor_state(
         elif device_type == "three_phase_powermeter":
             # Validate three-phase powermeter state
             ThreePhasePowerState.model_validate(abstract_payload)
+        elif device_type == "switch":
+            # Validate switch state
+            SwitchState.model_validate(abstract_payload)
     except ValidationError as e:
         logger.error(f"Validation failed for {device_type} STATE {device_id}: {e}")
         return

apps/abstraction/transformation.py

@@ -15,7 +15,6 @@ from apps.abstraction.vendors import (
     simulator,
     zigbee2mqtt,
     max,
-    test,
     shelly,
     tasmota,
     hottis_pv_modbus,
@@ -41,7 +40,6 @@ for vendor_name, vendor_module in [
     ("simulator", simulator),
     ("zigbee2mqtt", zigbee2mqtt),
     ("max", max),
-    ("test", test),
     ("shelly", shelly),
     ("tasmota", tasmota),
     ("hottis_pv_modbus", hottis_pv_modbus),

apps/abstraction/vendors/test.py

@@ -1,62 +0,0 @@
-"""test vendor transformations."""
-
-import json
-import logging
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-def transform_contact_sensor_to_vendor(payload: dict[str, Any]) -> str:
-    """Transform abstract contact sensor payload to MAX! format.
-    
-    Contact sensors are read-only.
-    """
-    logger.warning("Contact sensors are read-only - SET commands should not be used")
-    return json.dumps(payload)
-
-
-def transform_contact_sensor_to_abstract(payload: str) -> dict[str, Any]:
-    try:
-        contact_value = payload.strip().lower()
-        return {
-            "contact": "open" if (contact_value == "open") else "closed"
-        }
-    except (ValueError, TypeError) as e:
-        logger.error(f"contact sensor failed to parse: {payload}, error: {e}")
-        return {"contact": "closed"}
-
-
-def transform_thermostat_to_vendor(payload: dict[str, Any]) -> str:
-    if "target" not in payload:
-        logger.warning(f"thermostat payload missing 'target': {payload}")
-        return "21"
-    
-    target_temp = payload["target"]
-    
-    if isinstance(target_temp, (int, float)):
-        int_temp = int(round(target_temp))
-        return str(int_temp)
-    
-    logger.warning(f"invalid target temperature type: {type(target_temp)}")
-    return "21"
-
-
-def transform_thermostat_to_abstract(payload: str) -> dict[str, Any]:
-    target_temp = float(payload.strip())
-    
-    return {
-        "target": target_temp,
-        "mode": "heat"
-    }
-
-
-# Registry of handlers for this vendor
-HANDLERS = {
-    ("contact_sensor", "to_vendor"): transform_contact_sensor_to_vendor,
-    ("contact_sensor", "to_abstract"): transform_contact_sensor_to_abstract,
-    ("contact", "to_vendor"): transform_contact_sensor_to_vendor,
-    ("contact", "to_abstract"): transform_contact_sensor_to_abstract,
-    ("thermostat", "to_vendor"): transform_thermostat_to_vendor,
-    ("thermostat", "to_abstract"): transform_thermostat_to_abstract,
-}

apps/abstraction/vendors/zigbee2mqtt.py

@@ -161,6 +161,24 @@ def transform_temp_humidity_sensor_to_abstract(payload: str) -> dict[str, Any]:
     return payload
 
 
+def transform_switch_to_vendor(payload: dict[str, Any]) -> str:
+    """Transform abstract switch payload to zigbee2mqtt format.
+    
+    Switches are read-only, so this should not be called for SET commands.
+    """
+    logger.warning("Switches are read-only - SET commands should not be used")
+    return json.dumps(payload)
+
+
+def transform_switch_to_abstract(payload: str) -> dict[str, Any]:
+    """Transform zigbee2mqtt switch payload to abstract format.
+    
+    Passthrough - zigbee2mqtt provides action, battery, linkquality directly.
+    """
+    payload = json.loads(payload)
+    return payload
+
+
 def transform_relay_to_vendor(payload: dict[str, Any]) -> str:
     """Transform abstract relay payload to zigbee2mqtt format.
     
@@ -204,6 +222,8 @@ HANDLERS = {
     ("temp_humidity_sensor", "to_abstract"): transform_temp_humidity_sensor_to_abstract,
     ("temp_humidity", "to_vendor"): transform_temp_humidity_sensor_to_vendor,
     ("temp_humidity", "to_abstract"): transform_temp_humidity_sensor_to_abstract,
+    ("switch", "to_vendor"): transform_switch_to_vendor,
+    ("switch", "to_abstract"): transform_switch_to_abstract,
     ("relay", "to_vendor"): transform_relay_to_vendor,
     ("relay", "to_abstract"): transform_relay_to_abstract,
 }

apps/rules/impl/window_setback.py

@@ -18,7 +18,6 @@ class WindowSetbackObjects(BaseModel):
     thermostats: list[str] = Field(..., min_length=1, description="Thermostats to control")
 
 
-
 class WindowSetbackRule(Rule):
     """
     Window setback automation rule.
@@ -32,55 +31,22 @@ class WindowSetbackRule(Rule):
             thermostats: List of thermostat device IDs to control (required, min 1)
         params:
             eco_target: Temperature to set when window opens (default: 16.0)
+            open_min_secs: Minimum seconds window must be open before triggering (default: 20)
+            close_min_secs: Minimum seconds window must be closed before restoring (default: 20)
             previous_target_ttl_secs: How long to remember previous temperature (default: 86400)
     
     State storage (Redis keys):
+        rule:{rule_id}:contact:{device_id}:state -> "open" | "closed"
+        rule:{rule_id}:contact:{device_id}:ts -> ISO timestamp of last change
         rule:{rule_id}:thermo:{device_id}:current_target -> Current target temp (updated on every STATE)
         rule:{rule_id}:thermo:{device_id}:previous -> Previous target temp (saved on window open, deleted on restore)
-        rule:{rule_id}:contact:{device_id}:is_open -> "1" if open, "0" if closed    
+    
-        rule:{rule_id}:state -> Overall rule state -> "1" if thermostats set to eco, "0" otherwise
-            
     Logic:
         1. Thermostat STATE events → update current_target in Redis
         2. Window opens → copy current_target to previous, then set to eco_target
         3. Window closes → restore from previous, then delete previous key
     """
-
+    
-    @staticmethod
-    def __get_redis_key_current_target(rule_id: str, thermo_id: str) -> str:
-        """Get Redis key for current target temperature of a thermostat"""
-        return f"rule:{rule_id}:thermo:{thermo_id}:current_target"
-    @staticmethod
-    def __get_redis_key_previous_target(rule_id: str, thermo_id: str) -> str:
-        """Get Redis key for previous target temperature of a thermostat"""
-        return f"rule:{rule_id}:thermo:{thermo_id}:previous"
-    @staticmethod
-    def __get_redis_key_contact_state(rule_id: str, contact_id: str) -> str:
-        """Get Redis key for contact sensor state"""
-        return f"rule:{rule_id}:contact:{contact_id}:is_open"
-    @staticmethod
-    def __get_redis_key_rule_state(rule_id: str) -> str:
-        """Get Redis key for overall rule state"""
-        return f"rule:{rule_id}:state"
-    @staticmethod
-    async def __redis_get(ctx: RuleContext, key: str) -> Any:
-        """Helper to get value from Redis"""
-        v = await ctx.redis.get(key)
-        ctx.logger.debug(f"Redis GET {key} -> {v}")
-        return v
-    @staticmethod
-    async def __redis_set(ctx: RuleContext, key: str, value: Any) -> None:
-        """Helper to set value in Redis"""
-        ctx.logger.debug(f"Redis SET {key} = {value}")       
-        await ctx.redis.set(key, value)
-    @staticmethod
-    async def __redis_delete(ctx: RuleContext, key: str) -> None:
-        """Helper to delete key from Redis"""
-        ctx.logger.debug(f"Redis DEL {key}")
-        await ctx.redis.delete(key)
-
-
-
     def __init__(self):
         super().__init__()
         self._validated_objects: dict[str, WindowSetbackObjects] = {}
@@ -158,54 +124,49 @@ class WindowSetbackRule(Rule):
         """Handle contact sensor state change."""
         device_id = evt['device_id']
         contact_state = evt['payload'].get('contact')  # "open" or "closed"
+        event_ts = evt.get('ts', ctx.now().isoformat())
         
         if not contact_state:
             ctx.logger.warning(f"Contact event missing 'contact' field: {evt}")
             return
-                
+        
-        contact_state_key = WindowSetbackRule.__get_redis_key_contact_state(desc.id, device_id)
+        # Store current state and timestamp
-        await WindowSetbackRule.__redis_set(ctx, contact_state_key, '1' if contact_state == 'open' else '0')
+        state_key = f"rule:{desc.id}:contact:{device_id}:state"
-
+        ts_key = f"rule:{desc.id}:contact:{device_id}:ts"
-        # Check if any contact is open
+        
-        is_open = False
+        await ctx.redis.set(state_key, contact_state)
-        for contact_id in desc.objects.get('contacts', []):
+        await ctx.redis.set(ts_key, event_ts)
-            state_key = WindowSetbackRule.__get_redis_key_contact_state(desc.id, contact_id)
+        
-            state_val = await WindowSetbackRule.__redis_get(ctx, state_key)
+        if contact_state == 'open':
-            if state_val == '1':
+            await self._on_window_opened(desc, ctx)
-                is_open = True
+        elif contact_state == 'closed':
-                break
+            await self._on_window_closed(desc, ctx)
-
+    
-        rule_state_key = WindowSetbackRule.__get_redis_key_rule_state(desc.id)
+    async def _on_window_opened(self, desc: RuleDescriptor, ctx: RuleContext) -> None:
-        current_rule_state = await WindowSetbackRule.__redis_get(ctx, rule_state_key)
+        """
-        if is_open and current_rule_state != '1':
+        Window opened - save current temperatures, then set thermostats to eco.
-            # At least one contact is open, and we are not already in eco mode
+        
-            await self._set_eco_mode(desc, ctx)
+        Important: We must save the current target BEFORE setting to eco,
-            await WindowSetbackRule.__redis_set(ctx, rule_state_key, '1')
+        otherwise we'll save the eco temperature instead of the original.
-        elif not is_open and current_rule_state != '0':
+        """
-            # All contacts are closed, and we are currently in eco mode
+        eco_target = desc.params.get('eco_target', 16.0)
-            await self._unset_eco_mode(desc, ctx)
-            await WindowSetbackRule.__redis_set(ctx, rule_state_key, '0')
-
-
-    async def _set_eco_mode(self, desc: RuleDescriptor, ctx: RuleContext) -> None:
-        """Set thermostats to eco temperature when window opens."""
-        eco_target = desc.params.get('eco_target', 7.0)
         target_thermostats = desc.objects.get('thermostats', [])
+        ttl_secs = desc.params.get('previous_target_ttl_secs', 86400)
         
         ctx.logger.info(
-            f"Rule {desc.id}: At least one window is opened, setting {len(target_thermostats)} "
+            f"Rule {desc.id}: Window opened, setting {len(target_thermostats)} "
             f"thermostats to eco temperature {eco_target}°C"
         )
         
         # FIRST: Save current target temperatures as "previous" (before we change them!)
         for thermo_id in target_thermostats:
-            current_key = WindowSetbackRule.__get_redis_key_current_target(desc.id, thermo_id)
+            current_key = f"rule:{desc.id}:thermo:{thermo_id}:current_target"
-            current_temp_str = await WindowSetbackRule.__redis_get(ctx, current_key)
+            current_temp_str = await ctx.redis.get(current_key)
             
             if current_temp_str:
                 # Save current as previous (with TTL)
-                prev_key = WindowSetbackRule.__get_redis_key_previous_target(desc.id, thermo_id)
+                prev_key = f"rule:{desc.id}:thermo:{thermo_id}:previous"
-                await WindowSetbackRule.__redis_set(ctx, prev_key, current_temp_str)
+                await ctx.redis.set(prev_key, current_temp_str, ttl_secs=ttl_secs)
                 ctx.logger.debug(
                     f"Saved previous target for {thermo_id}: {current_temp_str}°C"
                 )
@@ -221,21 +182,25 @@ class WindowSetbackRule(Rule):
                 ctx.logger.debug(f"Set {thermo_id} to {eco_target}°C")
             except Exception as e:
                 ctx.logger.error(f"Failed to set {thermo_id}: {e}")
-
+    
-
+    async def _on_window_closed(self, desc: RuleDescriptor, ctx: RuleContext) -> None:
-    async def _unset_eco_mode(self, desc: RuleDescriptor, ctx: RuleContext) -> None:
+        """
-        """Restore thermostats to previous temperature when window closes."""
+        Window closed - restore previous temperatures.
+        
+        Note: This is simplified. A production implementation would check
+        close_min_secs and use a timer/scheduler.
+        """
         target_thermostats = desc.objects.get('thermostats', [])
         
         ctx.logger.info(
-            f"Rule {desc.id}: All windows closed, restoring {len(target_thermostats)} "
+            f"Rule {desc.id}: Window closed, restoring {len(target_thermostats)} "
             f"thermostats to previous temperatures"
         )
         
         # Restore previous temperatures
         for thermo_id in target_thermostats:
-            prev_key = WindowSetbackRule.__get_redis_key_previous_target(desc.id, thermo_id)
+            prev_key = f"rule:{desc.id}:thermo:{thermo_id}:previous"
-            prev_temp_str = await WindowSetbackRule.__redis_get(ctx, prev_key)
+            prev_temp_str = await ctx.redis.get(prev_key)
             
             if prev_temp_str:
                 try:
@@ -244,7 +209,7 @@ class WindowSetbackRule(Rule):
                     ctx.logger.debug(f"Restored {thermo_id} to {prev_temp}°C")
                     
                     # Delete the previous key after restoring
-                    await WindowSetbackRule.__redis_delete(ctx, prev_key)
+                    await ctx.redis.delete(prev_key)
                 except Exception as e:
                     ctx.logger.error(f"Failed to restore {thermo_id}: {e}")
             else:
@@ -275,8 +240,10 @@ class WindowSetbackRule(Rule):
             return  # No target in this state update
         
         # Store current target (always update, even if it's the eco temperature)
-        current_key = WindowSetbackRule.__get_redis_key_current_target(desc.id, device_id)
+        current_key = f"rule:{desc.id}:thermo:{device_id}:current_target"
-        await WindowSetbackRule.__redis_set(ctx, current_key, str(current_target))
+        ttl_secs = desc.params.get('previous_target_ttl_secs', 86400)
+        
+        await ctx.redis.set(current_key, str(current_target), ttl_secs=ttl_secs)
         
         ctx.logger.debug(
             f"Rule {desc.id}: Updated current target for {device_id}: {current_target}°C"

config/devices.yaml

@@ -1152,38 +1152,3 @@ devices:
   topics:
     state: "zigbee2mqtt/0x842e14fffefe4ba4"
     set: "zigbee2mqtt/0x842e14fffefe4ba4/set"
-
-- device_id: kontakt_test_1
-  homekit_aid: 97
-  name: Kontakt Test 1
-  type: contact
-  cap_version: contact_sensor@1.0.0
-  technology: test
-  topics:
-    state: test/kontakt1/state
-  features: {}
-- device_id: kontakt_test_2
-  homekit_aid: 98
-  name: Kontakt Test 2
-  type: contact
-  cap_version: contact_sensor@1.0.0
-  technology: test
-  topics:
-    state: test/kontakt2/state
-  features: {}
-- device_id: thermostat_test
-  homekit_aid: 99
-  name: Thermostat Test
-  type: thermostat
-  cap_version: "thermostat@1.0.0"
-  technology: test
-  features:
-    heating: true
-    temperature_range:
-    - 5
-    - 30
-    temperature_step: 0.5
-  topics:
-    state: "test/thermostat1/state"
-    set: "test/thermostat1/set"
-  

config/rules.yaml

@@ -115,17 +115,3 @@ rules:
     eco_target: 5.0
     open_min_secs: 20
     close_min_secs: 20
-- id: window_setback_test
-  enabled: true
-  name: Fensterabsenkung Test
-  type: window_setback@1.0
-  objects:
-    contacts:
-    - kontakt_test_1
-    - kontakt_test_2
-    thermostats:
-    - thermostat_test
-  params:
-    eco_target: 7.0
-    open_min_secs: 20
-    close_min_secs: 20

packages/home_capabilities/__init__.py

@@ -8,6 +8,8 @@ from packages.home_capabilities.contact_sensor import CAP_VERSION as CONTACT_SEN
 from packages.home_capabilities.contact_sensor import ContactState
 from packages.home_capabilities.temp_humidity_sensor import CAP_VERSION as TEMP_HUMIDITY_SENSOR_VERSION
 from packages.home_capabilities.temp_humidity_sensor import TempHumidityState
+from packages.home_capabilities.switch import CAP_VERSION as SWITCH_VERSION
+from packages.home_capabilities.switch import SwitchState
 from packages.home_capabilities.relay import CAP_VERSION as RELAY_VERSION
 from packages.home_capabilities.relay import RelayState
 from packages.home_capabilities.three_phase_powermeter import CAP_VERSION as THREE_PHASE_POWERMETER_VERSION
@@ -42,6 +44,8 @@ __all__ = [
     "CONTACT_SENSOR_VERSION",
     "TempHumidityState",
     "TEMP_HUMIDITY_SENSOR_VERSION",
+    "SwitchState",
+    "SWITCH_VERSION",
     "RelayState",
     "RELAY_VERSION",
     "DeviceTile",

packages/home_capabilities/switch.py

@@ -0,0 +1,69 @@
+"""Switch Capability - Wireless Button/Switch (read-only).
+
+This module defines the SwitchState model for wireless switches/buttons.
+These devices report action events (e.g., button presses) and are read-only devices.
+
+Capability Version: switch@1.0.0
+"""
+
+from datetime import datetime
+from typing import Annotated
+
+from pydantic import BaseModel, Field
+
+
+# Capability metadata
+CAP_VERSION = "switch@1.0.0"
+DISPLAY_NAME = "Switch"
+
+
+class SwitchState(BaseModel):
+    """State model for wireless switches/buttons.
+    
+    Wireless switches are read-only devices that report button actions such as
+    single press, double press, long press, etc. They typically also report 
+    battery level and signal quality.
+    
+    Attributes:
+        action: Action type (e.g., "single", "double", "long", "hold", etc.)
+        battery: Battery level percentage (0-100), optional
+        linkquality: MQTT link quality indicator, optional
+        voltage: Battery voltage in mV, optional
+        ts: Timestamp of the action event, optional
+    
+    Examples:
+        >>> SwitchState(action="single")
+        SwitchState(action='single', battery=None, ...)
+        
+        >>> SwitchState(action="double", battery=95, linkquality=87)
+        SwitchState(action='double', battery=95, linkquality=87, ...)
+    """
+    
+    action: str = Field(
+        ...,
+        description="Action type: 'single', 'double', 'long', 'hold', etc."
+    )
+    
+    battery: Annotated[int, Field(ge=0, le=100)] | None = Field(
+        None,
+        description="Battery level in percent (0-100)"
+    )
+    
+    linkquality: int | None = Field(
+        None,
+        description="Link quality indicator (typically 0-255)"
+    )
+    
+    voltage: int | None = Field(
+        None,
+        description="Battery voltage in millivolts"
+    )
+    
+    ts: datetime | None = Field(
+        None,
+        description="Timestamp of the action event"
+    )
+
+
+# Public API
+__all__ = ["SwitchState", "CAP_VERSION", "DISPLAY_NAME"]