676 lines
23 KiB
Python
676 lines
23 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
|
|
from pydantic import BaseModel, Field
|
|
|
|
from app.actuators.lifecycle import ActuatorReconciliationService
|
|
from app.actuators.models import ActuatorRecord, ReconciliationState
|
|
from app.actuators.store import ActuatorStore
|
|
from app.behavior.engine import BehaviorEngine
|
|
from app.config import Settings
|
|
from app.dependencies import get_ha_reader
|
|
from app.ha.discovery import DiscoveredEntity, EntityRole, discover_entities
|
|
from app.ha.exceptions import HaClientError
|
|
from app.ha.models import HaEntitySummary
|
|
from app.ha.reader import HaReader
|
|
|
|
router = APIRouter(prefix="/v1/actuators", tags=["actuators"])
|
|
|
|
|
|
class ConfigureActuatorRequest(BaseModel):
|
|
actuator_entity_id: str = Field(pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
|
|
enabled: bool = True
|
|
|
|
|
|
class ActivationRequest(BaseModel):
|
|
active: bool
|
|
pause_matching_automations: bool = False
|
|
restore_paused_automations: bool = False
|
|
|
|
|
|
class AutomationControlRequest(BaseModel):
|
|
automation_entity_id: str = Field(pattern=r"^automation\.[a-z0-9_]+$")
|
|
enabled: bool
|
|
|
|
|
|
class ManualAssignmentRequest(BaseModel):
|
|
numeric_entity_id: str | None = Field(default=None, pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
|
|
context_entity_ids: list[str] = Field(default_factory=list)
|
|
note: str | None = Field(default=None, max_length=500)
|
|
|
|
|
|
class FeedbackRequest(BaseModel):
|
|
correct: bool
|
|
expected_state: str | None = Field(default=None, max_length=100)
|
|
|
|
|
|
class ActuatorSuggestion(BaseModel):
|
|
entity_id: str
|
|
domain: str
|
|
friendly_name: str | None = None
|
|
area_name: str | None = None
|
|
device_name: str | None = None
|
|
confidence: float
|
|
reason: str
|
|
related_automation_count: int = 0
|
|
likely_context_count: int = 0
|
|
|
|
|
|
class ActuatorSummary(BaseModel):
|
|
actuator_entity_id: str
|
|
domain: str
|
|
friendly_name: str | None = None
|
|
area_name: str | None = None
|
|
device_name: str | None = None
|
|
enabled: bool
|
|
behavior_mode: str
|
|
behavior_status: str
|
|
lifecycle_status: str
|
|
activation_ready: bool
|
|
activation_reason: str
|
|
sample_count: int
|
|
prediction_target_state: str | None = None
|
|
prediction_confidence: float | None = None
|
|
updated_at: str
|
|
|
|
|
|
class EntityCacheStatus(BaseModel):
|
|
available: bool
|
|
updated_at: str | None = None
|
|
entity_count: int = 0
|
|
|
|
|
|
class DashboardSystemStatus(BaseModel):
|
|
api_status: str = "ok"
|
|
websocket_status: str = "unavailable"
|
|
websocket_error: str | None = None
|
|
reconciliation_last_completed_at: str | None = None
|
|
configured_actuators: int = 0
|
|
trained_models: int = 0
|
|
review_required: int = 0
|
|
|
|
|
|
class DashboardDiscoveryGroup(BaseModel):
|
|
category: str
|
|
role: str
|
|
count: int
|
|
|
|
|
|
class DashboardOverview(BaseModel):
|
|
system: DashboardSystemStatus
|
|
cache: EntityCacheStatus
|
|
actuators: list[ActuatorSummary]
|
|
discovery_groups: list[DashboardDiscoveryGroup]
|
|
|
|
|
|
@router.get("/discovery", response_model=list[HaEntitySummary])
|
|
def discover_actuators(
|
|
request: Request,
|
|
refresh: bool = Query(default=False),
|
|
ha_reader: HaReader = Depends(get_ha_reader),
|
|
) -> list[HaEntitySummary]:
|
|
cached_entities = [] if refresh else _load_cached_entities(request)
|
|
if cached_entities:
|
|
entities = {entity.entity_id: entity for entity in cached_entities}
|
|
else:
|
|
fresh_entities = list(ha_reader.read_entities())
|
|
_save_cached_entities(request, fresh_entities)
|
|
entities = {entity.entity_id: entity for entity in fresh_entities}
|
|
discovered = discover_entities(list(entities.values()))
|
|
actuator_ids = _deduplicate_actuator_ids(
|
|
[
|
|
(entity.entity_id, entity.category)
|
|
for entity in discovered
|
|
if entity.role is EntityRole.ACTUATOR
|
|
],
|
|
entities,
|
|
)
|
|
return [entities[entity_id] for entity_id in actuator_ids if entity_id in entities]
|
|
|
|
|
|
@router.get("/suggestions", response_model=list[ActuatorSuggestion])
|
|
def suggest_actuators(
|
|
request: Request,
|
|
ha_reader: HaReader = Depends(get_ha_reader),
|
|
) -> list[ActuatorSuggestion]:
|
|
entities = {entity.entity_id: entity for entity in ha_reader.read_entities()}
|
|
discovered = {entity.entity_id: entity for entity in discover_entities(list(entities.values()))}
|
|
configured_ids = {record.actuator_entity_id for record in _service(request).list_configured()}
|
|
actuator_ids = _deduplicate_actuator_ids(
|
|
[
|
|
(entity.entity_id, entity.category)
|
|
for entity in discovered.values()
|
|
if entity.role is EntityRole.ACTUATOR
|
|
],
|
|
entities,
|
|
)
|
|
suggestions: list[ActuatorSuggestion] = []
|
|
for entity_id in actuator_ids:
|
|
if entity_id in configured_ids:
|
|
continue
|
|
entity = entities.get(entity_id)
|
|
if entity is None:
|
|
continue
|
|
try:
|
|
automations = ha_reader.find_automations_for_entity(entity_id)
|
|
except Exception:
|
|
automations = []
|
|
context_count = _likely_context_count(entity, entities, discovered)
|
|
if not automations and context_count == 0:
|
|
continue
|
|
confidence = 1.0 if automations else min(0.85, 0.35 + context_count * 0.1)
|
|
reason_parts = []
|
|
if automations:
|
|
reason_parts.append(f"{len(automations)} passende HA-Automation(en)")
|
|
if context_count:
|
|
reason_parts.append(f"{context_count} naheliegende Kontext-Entity(s)")
|
|
suggestions.append(
|
|
ActuatorSuggestion(
|
|
entity_id=entity.entity_id,
|
|
domain=entity.domain,
|
|
friendly_name=entity.friendly_name,
|
|
area_name=entity.area_name,
|
|
device_name=entity.device_name,
|
|
confidence=round(confidence, 4),
|
|
reason=", ".join(reason_parts),
|
|
related_automation_count=len(automations),
|
|
likely_context_count=context_count,
|
|
)
|
|
)
|
|
return sorted(
|
|
suggestions,
|
|
key=lambda item: (
|
|
-item.related_automation_count,
|
|
-item.confidence,
|
|
item.area_name or "",
|
|
item.friendly_name or item.entity_id,
|
|
),
|
|
)[:30]
|
|
|
|
|
|
@router.get("/context-options", response_model=list[HaEntitySummary])
|
|
def context_options(
|
|
request: Request,
|
|
actuator_entity_id: str | None = Query(default=None, pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$"),
|
|
) -> list[HaEntitySummary]:
|
|
if actuator_entity_id is None:
|
|
return []
|
|
try:
|
|
return _service(request).suggest_context_options(actuator_entity_id)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
|
|
|
|
@router.get("/summary", response_model=list[ActuatorSummary])
|
|
def list_configured_summary(request: Request) -> list[ActuatorSummary]:
|
|
records = _service(request).list_configured()
|
|
entity_map = _load_cached_entity_map(
|
|
request,
|
|
{record.actuator_entity_id for record in records},
|
|
)
|
|
return [
|
|
ActuatorSummary(
|
|
actuator_entity_id=record.actuator_entity_id,
|
|
domain=record.actuator_entity_id.split(".", 1)[0],
|
|
friendly_name=(
|
|
entity_map[record.actuator_entity_id].friendly_name
|
|
if record.actuator_entity_id in entity_map
|
|
else None
|
|
),
|
|
area_name=(
|
|
entity_map[record.actuator_entity_id].area_name
|
|
if record.actuator_entity_id in entity_map
|
|
else None
|
|
),
|
|
device_name=(
|
|
entity_map[record.actuator_entity_id].device_name
|
|
if record.actuator_entity_id in entity_map
|
|
else None
|
|
),
|
|
enabled=record.enabled,
|
|
behavior_mode=record.behavior.mode.value,
|
|
behavior_status=record.behavior.status.value,
|
|
lifecycle_status=record.lifecycle.status.value,
|
|
activation_ready=record.behavior.activation_ready,
|
|
activation_reason=record.behavior.activation_reason,
|
|
sample_count=record.behavior.sample_count,
|
|
prediction_target_state=(
|
|
record.behavior.prediction.target_state
|
|
if record.behavior.prediction is not None
|
|
else None
|
|
),
|
|
prediction_confidence=(
|
|
record.behavior.prediction.confidence
|
|
if record.behavior.prediction is not None
|
|
else None
|
|
),
|
|
updated_at=record.updated_at.isoformat(),
|
|
)
|
|
for record in records
|
|
]
|
|
|
|
|
|
@router.get("/dashboard", response_model=DashboardOverview)
|
|
def dashboard_overview(request: Request) -> DashboardOverview:
|
|
cache_payload = _load_entity_cache_payload(request)
|
|
raw_entities = cache_payload.get("entities", [])
|
|
if not isinstance(raw_entities, list):
|
|
raw_entities = []
|
|
raw_updated_at = cache_payload.get("updated_at")
|
|
updated_at = raw_updated_at if isinstance(raw_updated_at, str) else None
|
|
raw_groups = cache_payload.get("discovery_groups", [])
|
|
cached_groups = [
|
|
DashboardDiscoveryGroup.model_validate(group)
|
|
for group in raw_groups
|
|
if isinstance(group, dict)
|
|
] if isinstance(raw_groups, list) else []
|
|
reconciliation = _reconciliation_state_or_default(request)
|
|
ws_status = getattr(request.app.state, "ws_status", None)
|
|
actuators = list_configured_summary(request)
|
|
return DashboardOverview(
|
|
system=DashboardSystemStatus(
|
|
websocket_status=getattr(ws_status, "status", "unavailable"),
|
|
websocket_error=getattr(ws_status, "error", None),
|
|
reconciliation_last_completed_at=(
|
|
reconciliation.last_completed_at.isoformat()
|
|
if reconciliation.last_completed_at is not None
|
|
else None
|
|
),
|
|
configured_actuators=len(actuators),
|
|
trained_models=reconciliation.trained_models,
|
|
review_required=reconciliation.review_required,
|
|
),
|
|
cache=EntityCacheStatus(
|
|
available=bool(raw_entities),
|
|
updated_at=updated_at,
|
|
entity_count=len(raw_entities),
|
|
),
|
|
actuators=actuators,
|
|
discovery_groups=cached_groups,
|
|
)
|
|
|
|
|
|
@router.get("", response_model=list[ActuatorRecord])
|
|
def list_configured(request: Request) -> list[ActuatorRecord]:
|
|
return _service(request).list_configured()
|
|
|
|
|
|
@router.post("", response_model=ActuatorRecord, status_code=201)
|
|
def configure(payload: ConfigureActuatorRequest, request: Request) -> ActuatorRecord:
|
|
try:
|
|
record = _service(request).configure_actuator(
|
|
payload.actuator_entity_id,
|
|
enabled=payload.enabled,
|
|
)
|
|
_behavior(request).train(record.actuator_entity_id)
|
|
return _behavior(request).evaluate(record.actuator_entity_id)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
|
|
|
|
@router.get("/{actuator_entity_id}", response_model=ActuatorRecord)
|
|
def get_actuator(actuator_entity_id: str, request: Request) -> ActuatorRecord:
|
|
try:
|
|
return _service(request).get_actuator(actuator_entity_id)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
|
|
|
|
@router.delete("/{actuator_entity_id}", status_code=204)
|
|
def delete_actuator(actuator_entity_id: str, request: Request) -> None:
|
|
_service(request).delete_actuator(actuator_entity_id)
|
|
|
|
|
|
@router.post("/{actuator_entity_id}/reconcile", response_model=ActuatorRecord)
|
|
def reconcile_actuator(
|
|
actuator_entity_id: str,
|
|
request: Request,
|
|
) -> ActuatorRecord:
|
|
try:
|
|
_service(request).reconcile_actuator(actuator_entity_id, trigger="manual")
|
|
_behavior(request).train(actuator_entity_id)
|
|
return _behavior(request).evaluate(actuator_entity_id)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
|
|
|
|
@router.post("/{actuator_entity_id}/evaluate", response_model=ActuatorRecord)
|
|
def evaluate_actuator(
|
|
actuator_entity_id: str,
|
|
request: Request,
|
|
) -> ActuatorRecord:
|
|
try:
|
|
return _behavior(request).evaluate(actuator_entity_id)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
|
|
|
|
@router.post("/{actuator_entity_id}/feedback", response_model=ActuatorRecord)
|
|
def record_feedback(
|
|
actuator_entity_id: str,
|
|
payload: FeedbackRequest,
|
|
request: Request,
|
|
) -> ActuatorRecord:
|
|
try:
|
|
return _behavior(request).record_feedback(
|
|
actuator_entity_id,
|
|
correct=payload.correct,
|
|
expected_state=payload.expected_state,
|
|
)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
|
|
|
|
@router.post("/{actuator_entity_id}/activation", response_model=ActuatorRecord)
|
|
def set_activation(
|
|
actuator_entity_id: str,
|
|
payload: ActivationRequest,
|
|
request: Request,
|
|
) -> ActuatorRecord:
|
|
try:
|
|
return _behavior(request).set_active(
|
|
actuator_entity_id,
|
|
active=payload.active,
|
|
pause_matching_automations=payload.pause_matching_automations,
|
|
restore_paused_automations=payload.restore_paused_automations,
|
|
)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=409, detail=str(exc)) from exc
|
|
|
|
|
|
@router.post("/{actuator_entity_id}/assignment", response_model=ActuatorRecord)
|
|
def set_manual_assignment(
|
|
actuator_entity_id: str,
|
|
payload: ManualAssignmentRequest,
|
|
request: Request,
|
|
) -> ActuatorRecord:
|
|
try:
|
|
record = _service(request).set_manual_assignment(
|
|
actuator_entity_id,
|
|
numeric_entity_id=payload.numeric_entity_id,
|
|
context_entity_ids=payload.context_entity_ids,
|
|
note=payload.note,
|
|
)
|
|
_behavior(request).train(record.actuator_entity_id)
|
|
return _behavior(request).evaluate(record.actuator_entity_id)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=422, detail=str(exc)) from exc
|
|
|
|
|
|
@router.post(
|
|
"/{actuator_entity_id}/related-automations/refresh",
|
|
response_model=ActuatorRecord,
|
|
)
|
|
def refresh_related_automations(
|
|
actuator_entity_id: str,
|
|
request: Request,
|
|
) -> ActuatorRecord:
|
|
try:
|
|
return _behavior(request).refresh_related_automations(actuator_entity_id)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
except (ValueError, HaClientError) as exc:
|
|
raise HTTPException(status_code=409, detail=str(exc)) from exc
|
|
|
|
|
|
@router.post(
|
|
"/{actuator_entity_id}/related-automations/control",
|
|
response_model=ActuatorRecord,
|
|
)
|
|
def control_related_automation(
|
|
actuator_entity_id: str,
|
|
payload: AutomationControlRequest,
|
|
request: Request,
|
|
) -> ActuatorRecord:
|
|
try:
|
|
return _behavior(request).set_automation_enabled(
|
|
actuator_entity_id,
|
|
payload.automation_entity_id,
|
|
enabled=payload.enabled,
|
|
)
|
|
except KeyError as exc:
|
|
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
|
except (ValueError, HaClientError) as exc:
|
|
raise HTTPException(status_code=409, detail=str(exc)) from exc
|
|
|
|
|
|
@router.get("/reconciliation/state", response_model=ReconciliationState)
|
|
def get_reconciliation_state(request: Request) -> ReconciliationState:
|
|
store = getattr(request.app.state, "actuator_store", None)
|
|
if not isinstance(store, ActuatorStore):
|
|
raise HTTPException(
|
|
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
detail="Actuator Store nicht initialisiert.",
|
|
)
|
|
return store.load_reconciliation_state()
|
|
|
|
|
|
@router.post("/reconciliation/run", response_model=ReconciliationState)
|
|
def run_reconciliation(
|
|
request: Request,
|
|
trigger: str = Query(default="manual", pattern=r"^[a-z0-9_-]{1,32}$"),
|
|
) -> ReconciliationState:
|
|
state = _service(request).reconcile_all(trigger=trigger)
|
|
_behavior(request).train_all()
|
|
_behavior(request).evaluate_all()
|
|
return state
|
|
|
|
|
|
def _service(request: Request) -> ActuatorReconciliationService:
|
|
service = getattr(request.app.state, "actuator_service", None)
|
|
if not isinstance(service, ActuatorReconciliationService):
|
|
raise HTTPException(
|
|
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
detail="Actuator-Reconciliation nicht initialisiert.",
|
|
)
|
|
return service
|
|
|
|
|
|
def _behavior(request: Request) -> BehaviorEngine:
|
|
engine = getattr(request.app.state, "behavior_engine", None)
|
|
if not isinstance(engine, BehaviorEngine):
|
|
raise HTTPException(
|
|
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
detail="Verhaltenslernen ist nicht initialisiert.",
|
|
)
|
|
return engine
|
|
|
|
|
|
def _reconciliation_state_or_default(request: Request) -> ReconciliationState:
|
|
store = getattr(request.app.state, "actuator_store", None)
|
|
if not isinstance(store, ActuatorStore):
|
|
return ReconciliationState()
|
|
try:
|
|
return store.load_reconciliation_state()
|
|
except ValueError:
|
|
return ReconciliationState(last_summary="Reconciliation-Status ist unlesbar.")
|
|
|
|
|
|
def _entity_cache_path(request: Request) -> Path:
|
|
store = getattr(request.app.state, "actuator_store", None)
|
|
settings = getattr(request.app.state, "settings", None)
|
|
if isinstance(store, ActuatorStore):
|
|
base_dir = store._root
|
|
elif isinstance(settings, Settings):
|
|
base_dir = Path(settings.actuator_store).resolve().parent
|
|
else:
|
|
base_dir = Path(".").resolve()
|
|
return Path(os.getenv("SILLYHOME_ENTITY_CACHE", base_dir / "ha_entity_cache.json"))
|
|
|
|
|
|
def _load_cached_entities(request: Request) -> list[HaEntitySummary]:
|
|
payload = _load_entity_cache_payload(request)
|
|
raw_entities = payload.get("entities", [])
|
|
if not isinstance(raw_entities, list):
|
|
return []
|
|
try:
|
|
return [HaEntitySummary.model_validate(entity) for entity in raw_entities]
|
|
except ValueError:
|
|
return []
|
|
|
|
|
|
def _load_cached_entity_map(
|
|
request: Request,
|
|
entity_ids: set[str],
|
|
) -> dict[str, HaEntitySummary]:
|
|
if not entity_ids:
|
|
return {}
|
|
payload = _load_entity_cache_payload(request)
|
|
raw_entities = payload.get("entities", [])
|
|
if not isinstance(raw_entities, list):
|
|
return {}
|
|
result: dict[str, HaEntitySummary] = {}
|
|
for raw_entity in raw_entities:
|
|
if not isinstance(raw_entity, dict):
|
|
continue
|
|
entity_id = raw_entity.get("entity_id")
|
|
if not isinstance(entity_id, str) or entity_id not in entity_ids:
|
|
continue
|
|
try:
|
|
result[entity_id] = HaEntitySummary.model_validate(raw_entity)
|
|
except ValueError:
|
|
continue
|
|
return result
|
|
|
|
|
|
def _load_entity_cache_payload(request: Request) -> dict[str, object]:
|
|
path = _entity_cache_path(request)
|
|
if not path.exists():
|
|
return {}
|
|
try:
|
|
payload = json.loads(path.read_text(encoding="utf-8"))
|
|
return payload if isinstance(payload, dict) else {}
|
|
except (OSError, TypeError, ValueError):
|
|
return {}
|
|
|
|
|
|
def _save_cached_entities(request: Request, entities: list[HaEntitySummary]) -> None:
|
|
path = _entity_cache_path(request)
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
group_counts: dict[tuple[str, str], int] = {}
|
|
for entity in discover_entities(entities):
|
|
key = (entity.category, entity.role.value)
|
|
group_counts[key] = group_counts.get(key, 0) + 1
|
|
payload = {
|
|
"updated_at": datetime.now(timezone.utc).isoformat(),
|
|
"discovery_groups": [
|
|
{"category": category, "role": role, "count": count}
|
|
for (category, role), count in sorted(group_counts.items())
|
|
],
|
|
"entities": [entity.model_dump(mode="json") for entity in entities],
|
|
}
|
|
temporary = path.with_suffix(".json.tmp")
|
|
temporary.write_text(
|
|
json.dumps(payload, ensure_ascii=True, sort_keys=True) + "\n",
|
|
encoding="utf-8",
|
|
)
|
|
os.replace(temporary, path)
|
|
|
|
|
|
def _deduplicate_actuator_ids(
|
|
discovered: list[tuple[str, str]],
|
|
entities: dict[str, HaEntitySummary],
|
|
) -> list[str]:
|
|
priority = {
|
|
"light": 0,
|
|
"cover_shutter": 1,
|
|
"heating": 2,
|
|
"lock": 3,
|
|
"fan": 4,
|
|
"switch_socket": 5,
|
|
"button": 6,
|
|
"helper": 7,
|
|
}
|
|
selected: dict[str, tuple[int, str]] = {}
|
|
for entity_id, category in discovered:
|
|
entity = entities.get(entity_id)
|
|
if entity is None:
|
|
continue
|
|
key = _actuator_duplicate_key(entity, category)
|
|
rank = priority.get(category, 50)
|
|
current = selected.get(key)
|
|
if current is None or (rank, entity_id) < current:
|
|
selected[key] = (rank, entity_id)
|
|
return sorted(entity_id for _, entity_id in selected.values())
|
|
|
|
|
|
def _actuator_duplicate_key(entity: HaEntitySummary, category: str) -> str:
|
|
if entity.device_id and category in {"light", "switch_socket", "button"}:
|
|
return f"device:{entity.device_id}:control"
|
|
if entity.device_name and category in {"light", "switch_socket", "button"}:
|
|
return f"device-name:{entity.device_name.lower()}:control"
|
|
return f"entity:{entity.entity_id}"
|
|
|
|
|
|
def _likely_context_count(
|
|
actuator: HaEntitySummary,
|
|
entities: dict[str, HaEntitySummary],
|
|
discovered: dict[str, DiscoveredEntity],
|
|
) -> int:
|
|
actuator_tokens = _tokens(actuator)
|
|
count = 0
|
|
for entity in entities.values():
|
|
if entity.entity_id == actuator.entity_id:
|
|
continue
|
|
descriptor = discovered.get(entity.entity_id)
|
|
role = descriptor.role if descriptor is not None else None
|
|
if role not in {
|
|
EntityRole.MEASUREMENT,
|
|
EntityRole.BINARY_CONTEXT,
|
|
EntityRole.CONTEXT,
|
|
}:
|
|
continue
|
|
if entity.device_class not in {
|
|
"door",
|
|
"energy",
|
|
"garage_door",
|
|
"humidity",
|
|
"illuminance",
|
|
"motion",
|
|
"occupancy",
|
|
"opening",
|
|
"power",
|
|
"presence",
|
|
"temperature",
|
|
"window",
|
|
}:
|
|
continue
|
|
same_area = bool(
|
|
actuator.area_name
|
|
and entity.area_name
|
|
and actuator.area_name == entity.area_name
|
|
)
|
|
same_device = bool(
|
|
actuator.device_id
|
|
and entity.device_id
|
|
and actuator.device_id == entity.device_id
|
|
)
|
|
token_match = bool(actuator_tokens.intersection(_tokens(entity)))
|
|
if same_area or same_device or token_match:
|
|
count += 1
|
|
return count
|
|
|
|
|
|
def _tokens(entity: HaEntitySummary) -> set[str]:
|
|
values = [
|
|
entity.entity_id,
|
|
entity.friendly_name,
|
|
entity.area_name,
|
|
entity.device_name,
|
|
]
|
|
tokens: set[str] = set()
|
|
for value in values:
|
|
if not value:
|
|
continue
|
|
tokens.update(token for token in value.lower().replace("_", " ").split() if len(token) > 2)
|
|
return tokens
|