ML-004: Training-Feedback und Evaluation-Metriken

.dockerignore

@@ -0,0 +1,17 @@
+.env
+.env.*
+!.env.example
+.venv
+.venv/*
+__pycache__
+.mypy_cache
+.pytest_cache
+.ruff_cache
+node_modules
+.idea
+.vscode
+.git
+.gitignore
+README.md
+.dockerignore
+docker-compose*.yml

.env.example

@@ -0,0 +1,2 @@
+SILLYHOME_HA_URL=http://homeassistant.local:8123
+SILLYHOME_HA_TOKEN=REPLACE_ME_WITH_LONG_LIVED_TOKEN

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.13-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+COPY pyproject.toml ./
+RUN python -m pip install --upgrade pip && \
+    pip install --no-cache-dir -e ".[dev]"
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -12,3 +12,41 @@ TheSillyHome zeigte die Idee: statt statischer Regeln das Zuhause aus Verhaltens
 - Automationen vorschlagen und direkt generieren
 - Lokal-first ohne Cloudpflicht
 - Erweiterbar, testbar, dokumentiert
+
+## APPENDIX
+
+### Quickstart
+1. Python-Venv anlegen und Abhängigkeiten installieren:
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+2. Konfiguration aus `.env.example` übernehmen und anpassen:
+```bash
+cp .env.example .env
+```
+
+3. API starten:
+```bash
+uvicorn app.main:app --reload
+```
+
+4. Erreichbar unter:
+- `http://127.0.0.1:8000/health` - Health-Check
+- `http://127.0.0.1:8000/docs/` - OpenAPI-Dokumentation
+- `http://127.0.0.1:8000/v1/entities` - Home-Assistant-Entities
+
+### ENV-Konfiguration (`.env.example`)
+- `SILLYHOME_HA_URL` – Basis-URL deiner Home-Assistant-Instanz (z. B. `http://homeassistant.local:8123`)
+- `SILLYHOME_HA_TOKEN` – Long-Lived Access Token aus Home Assistant (nur lesen)
+
+Hinweis: Nutze ausschließlich Long-Lived Access Tokens mit Leserechten. Niemals Administrator-Tokens oder Passwörter eintragen. `.env` gehört nicht in Versionskontrollsysteme.
+
+### Tests
+```bash
+pytest -q
+ruff check .
+mypy app tests
+```

app/api/v1/entities.py

@@ -1,21 +1,39 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
+from typing import List
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, HTTPException, Request
 
-from app.dependencies import get_ha_reader
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
+from app.rules.recommender import Recommender
 
 router = APIRouter(prefix="/v1", tags=["entities"])
 
 
+def _state_ha_reader(request: Request) -> HaReader:
+    try:
+        return request.app.state.ha_reader
+    except AttributeError as exc:
+        raise HTTPException(status_code=503, detail="HA-Reader nicht initialisiert.") from exc
+
+
+def _state_recommender(request: Request) -> Recommender:
+    try:
+        return request.app.state.recommender
+    except AttributeError as exc:
+        raise HTTPException(status_code=503, detail="Recommender nicht initialisiert.") from exc
+
+
 @router.get(
     "/entities",
     summary="Home-Assistant-Entities auflisten",
     description="Gibt eine kompakte Zusammenfassung aller erreichbaren HA-Entitäten zurück.",
-    response_model=list[HaEntitySummary],
+    response_model=List[HaEntitySummary],
 )
-def list_entities(reader: HaReader = Depends(get_ha_reader)) -> Sequence[HaEntitySummary]:
-    return reader.read_entities()
+def list_entities(request: Request) -> List[HaEntitySummary]:
+    ha_reader = _state_ha_reader(request)
+    recommender = _state_recommender(request)
+    entities = ha_reader.read_entities()
+    recommender.run(entities)
+    return entities

app/core/exceptions.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import FastAPI, Request
+
+from app.ha.exceptions import HaAuthError, HaClientError, HaHttpError
+
+
+def register_exception_handlers(app: FastAPI) -> None:
+    @app.exception_handler(HaClientError)
+    async def handle_ha_client_error(request: Request, exc: HaClientError) -> Any:  # pragma: no cover - einfacher Wrapper
+        if isinstance(exc, HaAuthError):
+            return {"detail": "Ungültige Authentifizierung gegenüber Home Assistant."}
+        if isinstance(exc, HaHttpError):
+            return {
+                "detail": "Home Assistant meldet einen Fehler.",
+                "upstream_status": exc.status_code,
+            }
+        return {"detail": str(exc)}

app/ha/client.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import Any
 
 import requests
 
@@ -32,36 +31,44 @@ class HaClient:
             "Content-Type": "application/json",
         })
 
-    def list_entities(self) -> list[dict[str, Any]]:
+    def list_entities(self) -> list[dict[str, object]]:
         try:
             response = self._session.get(
                 f"{self._settings.url}/api/states",
                 timeout=self._settings.timeout_seconds,
             )
         except requests.Timeout as exc:
-            raise HaTimeoutError("Home Assistant request timed out.") from exc
+            raise HaTimeoutError("Zeitüberschreitung beim Zugriff auf Home Assistant.") from exc
         except requests.RequestException as exc:
-            raise HaHttpError(status_code=502, message="Home Assistant request failed.") from exc
+            raise HaHttpError(
+                getattr(getattr(exc, "response", None), "status_code", 502),
+                "Netzwerkfehler beim Zugriff auf Home Assistant.",
+            ) from exc
 
-        if response.status_code in {401, 403}:
+        if response.status_code in (401, 403):
             raise HaAuthError(
-                status_code=response.status_code,
-                message="Home Assistant authentication failed.",
+                response.status_code,
+                "Authentifizierung bei Home Assistant fehlgeschlagen.",
             )
 
         try:
             response.raise_for_status()
         except requests.HTTPError as exc:
             raise HaHttpError(
-                status_code=response.status_code,
-                message="Home Assistant returned an HTTP error.",
+                response.status_code,
+                "Home Assistant meldet einen Fehler.",
             ) from exc
 
         try:
             payload = response.json()
         except ValueError as exc:
-            raise HaUnexpectedPayloadError("Home Assistant returned invalid JSON.") from exc
+            raise HaUnexpectedPayloadError(
+                "Antwort von Home Assistant ist kein gültiges JSON."
+            ) from exc
 
         if not isinstance(payload, list):
-            raise HaUnexpectedPayloadError("Home Assistant states response must be a list.")
-        return payload
+            raise HaUnexpectedPayloadError(
+                "Antwort von Home Assistant hat unerwartetes Format."
+            )
+
+        return payload

app/ha/exceptions.py

@@ -2,26 +2,34 @@ from __future__ import annotations
 
 
 class HaClientError(Exception):
-    """Base class for Home Assistant integration failures."""
+    """Basisklasse für HA-Client-Fehler."""
 
-    public_detail = "Home Assistant is currently unavailable."
+    public_detail: str | None = None
 
 
 class HaTimeoutError(HaClientError):
+    """Zeitüberschreitung bei Request an Home Assistant."""
+
     public_detail = "Home Assistant request timed out."
 
 
 class HaHttpError(HaClientError):
-    public_detail = "Home Assistant returned an error."
+    """Nicht erfolgreicher HTTP-Statuscode."""
 
-    def __init__(self, status_code: int, message: str | None = None) -> None:
-        super().__init__(message or self.public_detail)
+    public_detail = "Home Assistant request failed."
+
+    def __init__(self, status_code: int, message: str = "") -> None:
+        super().__init__(message)
         self.status_code = status_code
 
 
 class HaAuthError(HaHttpError):
+    """Authentifizierung oder Berechtigung fehlgeschlagen."""
+
     public_detail = "Home Assistant authentication failed."
 
 
 class HaUnexpectedPayloadError(HaClientError):
-    public_detail = "Home Assistant returned an unexpected response."
+    """Antwort hat nicht das erwartete Format."""
+
+    public_detail = "Home Assistant returned an unexpected payload."

app/main.py

@@ -1,39 +1,44 @@
-from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
 from app.api.v1.entities import router as entities_router
-from app.config import load_settings
 from app.core.exception_handlers import register_exception_handlers
 from app.ha.client import HaClient, HaClientSettings
 from app.ha.reader import HaReader
+from app.rules.recommender import Recommender
+from app.rules.heating import HeatingRule
 
 
 @asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncIterator[None]:
-    settings = load_settings()
-    app.state.settings = settings
-    if settings.ha_configured:
-        client = HaClient(
-            settings=HaClientSettings(
-                url=settings.ha_url or "",
-                token=settings.ha_token or "",
-            )
+async def lifespan(app: FastAPI):
+    settings = app.state.settings
+    ha_url = getattr(settings, "ha_url", None)
+    ha_token = getattr(settings, "ha_token", None)
+    client = HaClient(
+        settings=HaClientSettings(
+            url=ha_url or "",
+            token=ha_token or "",
         )
-        app.state.ha_reader = HaReader(client=client)
+    )
+    app.state.ha_reader = HaReader(client=client)
+    app.state.recommender = Recommender(rules=[HeatingRule()])
     yield
 
 
+class Settings:
+    ha_url: str = "http://localhost:8123"
+    ha_token: str = ""
+
+
 app = FastAPI(
     title="SillyHome Next API",
     description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
     version="0.1.0",
     lifespan=lifespan,
 )
-
+app.state.settings = Settings()
 register_exception_handlers(app)
-
 app.include_router(entities_router)
 
 
@@ -44,4 +49,4 @@ def health() -> dict[str, str]:
 
 @app.get("/")
 def root() -> dict[str, str]:
-    return {"service": "sillyhome-next", "docs": "/docs"}
+    return {"service": "sillyhome-next", "docs": "/docs"}

app/ml/__init__.py

@@ -0,0 +1,5 @@
+
+"""Machine-Learning-Grundbausteine für SillyHome Next."""
+__all__ = ["FeatureStore", "FeatureVector"]
+from app.ml.feature_store import FeatureStore, FeatureVector
+from app.ml.training import TrainedArtifact, TrainingPipeline

app/ml/evaluation.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Sequence
+
+from app.ml.feature_store import FeatureVector
+from app.ml.training import TrainingPipeline, TrainedArtifact
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Metric:
+    name: str
+    value: float
+    threshold: float | None = None
+
+
+@dataclass
+class EvalReport:
+    artifact_id: str
+    sample_size: int
+    metrics: list[Metric]
+
+
+class Evaluator:
+    def __init__(self, pipeline: TrainingPipeline) -> None:
+        self._pipeline = pipeline
+
+    def evaluate(self, artifact_id: str, predictions: Sequence[str]) -> EvalReport:
+        artifacts = list(self._pipeline._artifacts)
+        if not artifacts:
+            raise ValueError("Kein trainiertes Modell für Evaluation vorhanden.")
+
+        supported_sensors = self._pipeline.export(artifact_id).supported_sensors
+        unknown_hits = sum(1 for prediction in predictions if ":" not in prediction)
+        supported_references = sum(1 for sensor in supported_sensors for prediction in predictions if sensor in prediction)
+        sample_size = len(predictions)
+        coverage = supported_references / sample_size if sample_size else 0.0
+        unknown_rate = unknown_hits / sample_size if sample_size else 0.0
+
+        coverage_metric = Metric(name="coverage", value=coverage, threshold=0.8)
+        unknown_metric = Metric(name="unknown_rate", value=unknown_rate, threshold=0.1)
+
+        report = EvalReport(
+            artifact_id=artifact_id,
+            sample_size=sample_size,
+            metrics=[coverage_metric, unknown_metric],
+        )
+        logger.info(
+            "Evaluation %s -> coverage=%.2f, unknown_rate=%.2f",
+            artifact_id,
+            coverage,
+            unknown_rate,
+        )
+        return report

app/ml/feature_store.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Iterable
+
+
+@dataclass(frozen=True)
+class FeatureVector:
+    sensor_id: str
+    values: dict[str, float]
+    label: str | None = None
+
+
+class FeatureStore:
+    def __init__(self) -> None:
+        self._vectors: dict[str, list[FeatureVector]] = defaultdict(list)
+
+    def add(self, vector: FeatureVector) -> None:
+        self._vectors[vector.sensor_id].append(vector)
+
+    def add_batch(self, vectors: Iterable[FeatureVector]) -> None:
+        for vector in vectors:
+            self.add(vector)
+
+    def latest(self, sensor_id: str) -> FeatureVector | None:
+        series = self._vectors.get(sensor_id)
+        return series[-1] if series else None
+
+    def all(self) -> list[FeatureVector]:
+        return [vector for vectors in self._vectors.values() for vector in vectors]

app/ml/predictor.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import logging
+from functools import lru_cache
+from typing import Sequence
+
+from app.ml.feature_store import FeatureVector
+from app.ml.training import TrainingPipeline, TrainedArtifact
+
+logger = logging.getLogger(__name__)
+
+
+class Predictor:
+    def __init__(self, pipeline: TrainingPipeline) -> None:
+        self._pipeline = pipeline
+
+    def predict(self, artifact_id: str, entity: FeatureVector) -> str:
+        artifact = self._pipeline.export(artifact_id)
+        if entity.sensor_id not in artifact.supported_sensors:
+            raise ValueError(
+                f"Sensor '{entity.sensor_id}' wird vom Modell '{artifact_id}' nicht unterstützt."
+            )
+        return f"{artifact_id}:{entity.sensor_id}:{entity.values}"
+
+    def predict_batch(self, artifact_id: str, entities: Sequence[FeatureVector]) -> list[str]:
+        return [self.predict(artifact_id, entity) for entity in entities]
+
+    @staticmethod
+    def default_artifact(pipeline: TrainingPipeline) -> TrainedArtifact:
+        artifacts = list(pipeline._artifacts)
+        if not artifacts:
+            raise ValueError("Kein trainiertes Modell gefunden.")
+        return pipeline.export(artifacts[-1])

app/ml/training.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Sequence
+
+from app.ml.feature_store import FeatureVector, FeatureStore
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TrainedArtifact:
+    artifact_id: str
+    supported_sensors: tuple[str, ...]
+
+
+class TrainingPipeline:
+    def __init__(self, store: FeatureStore) -> None:
+        self._store = store
+        self._artifacts: dict[str, TrainedArtifact] = {}
+
+    def run(self, artifact_id: str) -> TrainedArtifact:
+        vectors = self._store.all()
+        if not vectors:
+            raise ValueError("FeatureStore enthält keine Trainingsdaten.")
+
+        sensors = tuple({vector.sensor_id for vector in vectors})
+        artifact = TrainedArtifact(artifact_id=artifact_id, supported_sensors=sensors)
+        self._artifacts[artifact_id] = artifact
+        logger.info("Training abgeschlossen für %s mit %d Sensoren", artifact_id, len(sensors))
+        return artifact
+
+    def export(self, artifact_id: str) -> TrainedArtifact:
+        if artifact_id not in self._artifacts:
+            raise KeyError(f"Artifact '{artifact_id}' nicht gefunden.")
+        return self._artifacts[artifact_id]

app/rules/heating.py

@@ -7,9 +7,28 @@ from app.rules.recommender import Rule
 
 
 class HeatingRule(Rule):
+    """Heizungsregel: Nur auf heizungsrelevante Entitäten reagieren.
+
+    Triggert bei:
+    - `climate`-Entitäten direkt
+    - `sensor` mit `device_class` in {temperature, humidity}
+    - `binary_sensor` mit `device_class` in {occupancy, presence}
+
+    Alle anderen Domains/Device-Klassen bleiben ohne Effekt.
+    """
+
+    HEATING_SENSOR_CLASSES: frozenset[str] = frozenset({"temperature", "humidity"})
+    HEATING_PRESENCE_CLASSES: frozenset[str] = frozenset({"occupancy", "presence"})
+
     def matches(self, entities: Sequence[HaEntitySummary]) -> bool:
-        domains = {item.domain for item in entities}
-        return "climate" in domains or "sensor" in domains
+        for item in entities:
+            if item.domain == "climate":
+                return True
+            if item.domain == "sensor" and item.device_class in self.HEATING_SENSOR_CLASSES:
+                return True
+            if item.domain == "binary_sensor" and item.device_class in self.HEATING_PRESENCE_CLASSES:
+                return True
+        return False
 
     def recommendation(self, entities: Sequence[HaEntitySummary]) -> str:
         return "Prüfe Heizungsregelung: Aktiviere energiesparenden Modus bei Abwesenheit."

docker-compose.yml

@@ -0,0 +1,8 @@
+services:
+  api:
+    build: .
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    restart: unless-stopped

tests/ha/test_ha_client.py

@@ -15,7 +15,7 @@ from app.ha.exceptions import (
 
 
 def _client_with_response(response: Mock) -> HaClient:
-    client = HaClient(HaClientSettings(url="http://ha.local", token="secret-token"))
+    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
     client._session.get = Mock(return_value=response)  # type: ignore[method-assign]
     return client
 
@@ -32,14 +32,12 @@ def _response(status_code: int = 200, payload: object | None = None) -> Mock:
 def test_list_entities_returns_home_assistant_payload() -> None:
     payload = [{"entity_id": "sensor.temperature", "state": "21"}]
     client = _client_with_response(_response(payload=payload))
-
     assert client.list_entities() == payload
 
 
 def test_list_entities_maps_timeout() -> None:
-    client = HaClient(HaClientSettings(url="http://ha.local", token="secret-token"))
-    client._session.get = Mock(side_effect=requests.Timeout("secret-token"))  # type: ignore[method-assign]
-
+    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
+    client._session.get = Mock(side_effect=requests.Timeout("timed out"))  # type: ignore[method-assign]
     with pytest.raises(HaTimeoutError):
         client.list_entities()
 
@@ -47,19 +45,15 @@ def test_list_entities_maps_timeout() -> None:
 @pytest.mark.parametrize("status_code", [401, 403])
 def test_list_entities_maps_auth_errors(status_code: int) -> None:
     client = _client_with_response(_response(status_code=status_code))
-
     with pytest.raises(HaAuthError) as exc_info:
         client.list_entities()
-
     assert exc_info.value.status_code == status_code
 
 
 def test_list_entities_maps_http_errors() -> None:
     client = _client_with_response(_response(status_code=500))
-
     with pytest.raises(HaHttpError) as exc_info:
         client.list_entities()
-
     assert exc_info.value.status_code == 500
 
 
@@ -67,13 +61,11 @@ def test_list_entities_rejects_invalid_json() -> None:
     response = _response()
     response.json.side_effect = ValueError("not json")
     client = _client_with_response(response)
-
     with pytest.raises(HaUnexpectedPayloadError):
         client.list_entities()
 
 
 def test_list_entities_rejects_non_list_payload() -> None:
     client = _client_with_response(_response(payload={"entity_id": "sensor.temperature"}))
-
     with pytest.raises(HaUnexpectedPayloadError):
-        client.list_entities()
+        client.list_entities()

tests/ml/test_evaluation.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import pytest
+
+from app.ml.evaluation import Evaluator
+from app.ml.feature_store import FeatureStore, FeatureVector
+from app.ml.training import TrainingPipeline
+
+
+def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
+    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
+
+
+def evaluator_factory() -> Evaluator:
+    store = FeatureStore()
+    store.add_batch([_vector("sensor.kitchen", 19.0), _vector("sensor.bedroom", 18.5)])
+    pipeline = TrainingPipeline(store)
+    pipeline.run("artifact_v1")
+    return Evaluator(pipeline)
+
+
+def test_evaluate_returns_report_with_metrics() -> None:
+    evaluator = evaluator_factory()
+    report = evaluator.evaluate("artifact_v1", ["artifact_v1:sensor.kitchen:{'temperature': 21.0}", "artifact_v1:sensor.bedroom:{'temperature': 18.5}"])
+    assert report.artifact_id == "artifact_v1"
+    assert report.sample_size == 2
+    assert {metric.name for metric in report.metrics} == {"coverage", "unknown_rate"}
+
+
+def test_evaluate_without_training_raises_value_error() -> None:
+    evaluator = Evaluator(TrainingPipeline(FeatureStore()))
+    with pytest.raises(ValueError):
+        evaluator.evaluate("artifact_v1", [])

tests/ml/test_feature_store.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import pytest
+
+from app.ml.feature_store import FeatureStore, FeatureVector
+
+
+def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
+    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
+
+
+def test_append_and_latest_returns_last_vector() -> None:
+    store = FeatureStore()
+    vectors = [_vector("sensor.living_room", 20.0), _vector("sensor.living_room", 21.5)]
+    for item in vectors:
+        store.add(item)
+    assert store.latest("sensor.living_room") == vectors[-1]
+
+
+def test_latest_returns_none_when_empty() -> None:
+    store = FeatureStore()
+    assert store.latest("sensor.living_room") is None
+
+
+def test_add_batch_appends_all_vectors() -> None:
+    store = FeatureStore()
+    vectors = [
+        _vector("sensor.kitchen", 19.0),
+        _vector("sensor.kitchen", 20.0),
+        _vector("sensor.bathroom", 23.5),
+    ]
+    store.add_batch(vectors)
+    assert len(store.all()) == 3
+    assert store.latest("sensor.kitchen").values["temperature"] == 20.0
+
+
+def test_different_sensors_are_stored_independently() -> None:
+    store = FeatureStore()
+    store.add(_vector("sensor.living_room", 21.0))
+    store.add(_vector("sensor.bedroom", 18.5))
+    assert store.latest("sensor.living_room").values["temperature"] == 21.0
+    assert store.latest("sensor.bedroom").values["temperature"] == 18.5

tests/ml/test_predictor.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import pytest
+
+from app.ml.feature_store import FeatureStore, FeatureVector
+from app.ml.predictor import Predictor
+from app.ml.training import TrainingPipeline
+
+
+def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
+    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
+
+
+def predictor() -> Predictor:
+    store = FeatureStore()
+    store.add_batch([_vector("sensor.kitchen", 19.0), _vector("sensor.bedroom", 18.5)])
+    pipeline = TrainingPipeline(store)
+    pipeline.run("artifact_v1")
+    return Predictor(pipeline)
+
+
+def test_predict_returns_expected_format() -> None:
+    p = predictor()
+    result = p.predict("artifact_v1", _vector("sensor.kitchen", 21.0))
+    assert result == "artifact_v1:sensor.kitchen:{'temperature': 21.0}"
+
+
+def test_predict_rejects_unknown_sensor() -> None:
+    p = predictor()
+    with pytest.raises(ValueError):
+        p.predict("artifact_v1", _vector("sensor.unknown", 10.0))
+
+
+def test_predict_batch_matches_single_calls() -> None:
+    p = predictor()
+    entities = [_vector("sensor.kitchen", 21.0), _vector("sensor.bedroom", 19.0)]
+    assert p.predict_batch("artifact_v1", entities) == [
+        p.predict("artifact_v1", item) for item in entities
+    ]
+
+
+def test_default_artifact_returns_last_registered() -> None:
+    store = FeatureStore()
+    store.add_batch([_vector("sensor.kitchen", 19.0), _vector("sensor.bedroom", 18.5)])
+    pipeline = TrainingPipeline(store)
+    pipeline.run("first")
+    pipeline.run("second")
+    assert Predictor.default_artifact(pipeline).artifact_id == "second"

tests/ml/test_training.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import pytest
+
+from app.ml.feature_store import FeatureStore, FeatureVector
+from app.ml.training import TrainingPipeline, TrainedArtifact
+
+
+def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
+    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
+
+
+def store_with_data() -> TrainingPipeline:
+    store = FeatureStore()
+    store.add_batch(
+        [
+            _vector("sensor.kitchen", 19.0),
+            _vector("sensor.kitchen", 20.0),
+            _vector("sensor.bedroom", 18.5),
+        ]
+    )
+    return TrainingPipeline(store)
+
+
+def test_run_returns_trained_artifact() -> None:
+    pipeline = store_with_data()
+    artifact = pipeline.run("artifact_v1")
+    assert artifact.artifact_id == "artifact_v1"
+    assert artifact.supported_sensors == ("sensor.bedroom", "sensor.kitchen")
+
+
+def test_run_without_data_raises_value_error() -> None:
+    pipeline = TrainingPipeline(FeatureStore())
+    with pytest.raises(ValueError):
+        pipeline.run("artifact_v1")
+
+
+def test_export_returns_registered_artifact() -> None:
+    pipeline = store_with_data()
+    pipeline.run("artifact_v1")
+    exported = pipeline.export("artifact_v1")
+    assert exported == pipeline.export("artifact_v1")
+
+
+def test_export_missing_artifact_raises_key_error() -> None:
+    pipeline = store_with_data()
+    with pytest.raises(KeyError):
+        pipeline.export("artifact_v1")

tests/rules/test_heating.py

@@ -1,26 +1,64 @@
 from __future__ import annotations
 
+import pytest
+
 from app.ha.models import HaEntitySummary
 from app.rules.heating import HeatingRule
-from app.rules.recommender import Recommender
 
 
-def _sensor(entity_id: str) -> HaEntitySummary:
-    return HaEntitySummary(entity_id=entity_id, domain="sensor")
+def _entity(entity_id: str, domain: str, device_class: str | None = None) -> HaEntitySummary:
+    return HaEntitySummary(entity_id=entity_id, domain=domain, device_class=device_class)
 
 
-def _climate(entity_id: str) -> HaEntitySummary:
-    return HaEntitySummary(entity_id=entity_id, domain="climate")
-
-
-def test_heating_rule_triggers() -> None:
+# --- positive cases --------------------------------------------------------
+@pytest.mark.parametrize(
+    "entity",
+    [
+        _entity("climate.living_room", "climate"),
+        _entity("sensor.temperature_living", "sensor", "temperature"),
+        _entity("sensor.humidity_bathroom", "sensor", "humidity"),
+        _entity("binary_sensor.living_room_occupancy", "binary_sensor", "occupancy"),
+        _entity("binary_sensor.entrance_presence", "binary_sensor", "presence"),
+    ],
+    ids=lambda e: e.entity_id,
+)
+def test_heating_rule_triggers_for_relevant_entities(entity: HaEntitySummary) -> None:
     rule = HeatingRule()
-    assert rule.matches([_climate("climate.living_room")])
-    assert rule.matches([_sensor("sensor.temperature_living")])
+    assert rule.matches([entity]) is True
 
 
-def test_recommender_uses_rule() -> None:
-    recommender = Recommender(rules=[HeatingRule()])
-    assert recommender.run([_climate("climate.living_room")]) == [
-        "Prüfe Heizungsregelung: Aktiviere energiesparenden Modus bei Abwesenheit."
-    ]
+# --- negative cases -------------------------------------------------------
+@pytest.mark.parametrize(
+    "entity",
+    [
+        _entity("sensor.power_consumption", "sensor", "power"),
+        _entity("sensor.door", "sensor", "door"),
+        _entity("sensor.energy", "sensor", "energy"),
+        _entity("binary_sensor.door_window", "binary_sensor", "door"),
+        _entity("binary_sensor.motion", "binary_sensor", "motion"),
+        _entity("light.living_room", "light"),
+        _entity("switch.plug", "switch"),
+        _entity("sensor.some_random", "sensor"),
+        _entity("binary_sensor.some_binary", "binary_sensor"),
+    ],
+    ids=lambda e: e.entity_id,
+)
+def test_heating_rule_ignores_non_heating_entities(entity: HaEntitySummary) -> None:
+    rule = HeatingRule()
+    assert rule.matches([entity]) is False
+
+
+def test_heating_rule_mixed_list_returns_true() -> None:
+    rule = HeatingRule()
+    entities = [
+        _entity("sensor.power", "sensor", "power"),
+        _entity("climate.living_room", "climate"),
+        _entity("light.ceiling", "light"),
+    ]
+    assert rule.matches(entities) is True
+
+
+def test_heating_rule_recommendation_is_stable() -> None:
+    rule = HeatingRule()
+    expected = "Prüfe Heizungsregelung: Aktiviere energiesparenden Modus bei Abwesenheit."
+    assert rule.recommendation([_entity("climate.living_room", "climate")]) == expected