arthexis 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

ocpp/simulator.py

@@ -4,7 +4,7 @@ import json
 import random
 import time
 import uuid
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 import threading
 
@@ -34,6 +34,8 @@ class SimulatorConfig:
     password: Optional[str] = None
     serial_number: str = ""
     connector_id: int = 1
+    configuration_keys: list[dict[str, object]] = field(default_factory=list)
+    configuration_unknown_keys: list[str] = field(default_factory=list)
 
 
 class ChargePointSimulator:
@@ -47,6 +49,9 @@ class ChargePointSimulator:
         self.status = "stopped"
         self._connected = threading.Event()
         self._connect_error = ""
+        self._availability_state = "Operative"
+        self._pending_availability: Optional[str] = None
+        self._in_transaction = False
 
     def trigger_door_open(self) -> None:
         """Queue a DoorOpen status notification for the simulator."""
@@ -95,6 +100,298 @@ class ChargePointSimulator:
         )
         await recv()
 
+    async def _send_status_notification(self, send, recv, status: str) -> None:
+        cfg = self.config
+        await send(
+            json.dumps(
+                [
+                    2,
+                    f"status-{uuid.uuid4().hex}",
+                    "StatusNotification",
+                    {
+                        "connectorId": cfg.connector_id,
+                        "errorCode": "NoError",
+                        "status": status,
+                    },
+                ]
+            )
+        )
+        await recv()
+
+    async def _wait_until_operative(self, send, recv) -> bool:
+        cfg = self.config
+        delay = cfg.interval if cfg.interval > 0 else 1.0
+        while self._availability_state != "Operative" and not self._stop_event.is_set():
+            await send(
+                json.dumps(
+                    [
+                        2,
+                        f"hb-wait-{uuid.uuid4().hex}",
+                        "Heartbeat",
+                        {},
+                    ]
+                )
+            )
+            try:
+                await recv()
+            except Exception:
+                return False
+            await self._maybe_send_door_event(send, recv)
+            await asyncio.sleep(delay)
+        return self._availability_state == "Operative" and not self._stop_event.is_set()
+
+    async def _handle_change_availability(self, message_id: str, payload, send, recv) -> None:
+        cfg = self.config
+        requested_type = str((payload or {}).get("type") or "").strip()
+        connector_raw = (payload or {}).get("connectorId")
+        try:
+            connector_value = int(connector_raw)
+        except (TypeError, ValueError):
+            connector_value = None
+        if connector_value in (None, 0):
+            connector_value = 0
+        valid_connectors = {0, cfg.connector_id}
+        send_status: Optional[str] = None
+        status_result = "Rejected"
+        if requested_type in {"Operative", "Inoperative"} and connector_value in valid_connectors:
+            if requested_type == "Inoperative":
+                if self._in_transaction:
+                    self._pending_availability = "Inoperative"
+                    status_result = "Scheduled"
+                else:
+                    self._pending_availability = None
+                    status_result = "Accepted"
+                    if self._availability_state != "Inoperative":
+                        self._availability_state = "Inoperative"
+                        send_status = "Unavailable"
+            else:  # Operative
+                self._pending_availability = None
+                status_result = "Accepted"
+                if self._availability_state != "Operative":
+                    self._availability_state = "Operative"
+                    send_status = "Available"
+        response = [3, message_id, {"status": status_result}]
+        await send(json.dumps(response))
+        if send_status:
+            await self._send_status_notification(send, recv, send_status)
+
+    async def _handle_trigger_message(self, message_id: str, payload, send, recv) -> None:
+        cfg = self.config
+        payload = payload if isinstance(payload, dict) else {}
+        requested = str(payload.get("requestedMessage") or "").strip()
+        connector_raw = payload.get("connectorId")
+        try:
+            connector_value = int(connector_raw) if connector_raw is not None else None
+        except (TypeError, ValueError):
+            connector_value = None
+
+        async def _send_follow_up(action: str, payload_obj: dict) -> None:
+            await send(
+                json.dumps(
+                    [
+                        2,
+                        f"trigger-{uuid.uuid4().hex}",
+                        action,
+                        payload_obj,
+                    ]
+                )
+            )
+            await recv()
+
+        status_result = "NotSupported"
+        follow_up = None
+
+        if requested == "BootNotification":
+            status_result = "Accepted"
+
+            async def _boot_notification() -> None:
+                await _send_follow_up(
+                    "BootNotification",
+                    {
+                        "chargePointVendor": "SimVendor",
+                        "chargePointModel": "Simulator",
+                        "serialNumber": cfg.serial_number,
+                    },
+                )
+
+            follow_up = _boot_notification
+        elif requested == "Heartbeat":
+            status_result = "Accepted"
+
+            async def _heartbeat() -> None:
+                await _send_follow_up("Heartbeat", {})
+
+            follow_up = _heartbeat
+        elif requested == "StatusNotification":
+            valid_connector = connector_value in (None, cfg.connector_id)
+            if valid_connector:
+                status_result = "Accepted"
+
+                async def _status_notification() -> None:
+                    status_label = (
+                        "Available"
+                        if self._availability_state == "Operative"
+                        else "Unavailable"
+                    )
+                    await _send_follow_up(
+                        "StatusNotification",
+                        {
+                            "connectorId": connector_value or cfg.connector_id,
+                            "errorCode": "NoError",
+                            "status": status_label,
+                        },
+                    )
+
+                follow_up = _status_notification
+            else:
+                status_result = "Rejected"
+        elif requested == "MeterValues":
+            valid_connector = connector_value in (None, cfg.connector_id)
+            if valid_connector:
+                status_result = "Accepted"
+
+                async def _meter_values() -> None:
+                    await _send_follow_up(
+                        "MeterValues",
+                        {
+                            "connectorId": connector_value or cfg.connector_id,
+                            "meterValue": [
+                                {
+                                    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                                    "sampledValue": [
+                                        {
+                                            "value": "0",
+                                            "measurand": "Energy.Active.Import.Register",
+                                            "unit": "kW",
+                                        }
+                                    ],
+                                }
+                            ],
+                        },
+                    )
+
+                follow_up = _meter_values
+            else:
+                status_result = "Rejected"
+        elif requested == "DiagnosticsStatusNotification":
+            status_result = "Accepted"
+
+            async def _diagnostics() -> None:
+                await _send_follow_up(
+                    "DiagnosticsStatusNotification",
+                    {"status": "Idle"},
+                )
+
+            follow_up = _diagnostics
+        elif requested == "FirmwareStatusNotification":
+            status_result = "Accepted"
+
+            async def _firmware() -> None:
+                await _send_follow_up(
+                    "FirmwareStatusNotification",
+                    {"status": "Idle"},
+                )
+
+            follow_up = _firmware
+
+        response = [3, message_id, {"status": status_result}]
+        await send(json.dumps(response))
+        if status_result == "Accepted" and follow_up:
+            await follow_up()
+
+    async def _handle_csms_call(self, msg, send, recv) -> bool:
+        if not isinstance(msg, list) or not msg or msg[0] != 2:
+            return False
+        message_id = msg[1] if len(msg) > 1 else ""
+        if not isinstance(message_id, str):
+            message_id = str(message_id)
+        action = msg[2]
+        payload = msg[3] if len(msg) > 3 else {}
+        if action == "ChangeAvailability":
+            await self._handle_change_availability(message_id, payload, send, recv)
+            return True
+        if action == "GetConfiguration":
+            await self._handle_get_configuration(message_id, payload, send)
+            return True
+        if action == "TriggerMessage":
+            await self._handle_trigger_message(message_id, payload, send, recv)
+            return True
+        cfg = self.config
+        action_name = str(action)
+        store.add_log(
+            cfg.cp_path,
+            f"Received unsupported action '{action_name}', replying with CallError",
+            log_type="simulator",
+        )
+        await send(
+            json.dumps(
+                [
+                    4,
+                    message_id,
+                    "NotSupported",
+                    f"Simulator does not implement {action_name}",
+                    {},
+                ]
+            )
+        )
+        return True
+
+    async def _handle_get_configuration(self, message_id: str, payload, send) -> None:
+        cfg = self.config
+        payload = payload if isinstance(payload, dict) else {}
+        requested_keys_raw = payload.get("key")
+        requested_keys: list[str] = []
+        if isinstance(requested_keys_raw, (list, tuple)):
+            for item in requested_keys_raw:
+                if isinstance(item, str):
+                    key_text = item.strip()
+                else:
+                    key_text = str(item).strip()
+                if key_text:
+                    requested_keys.append(key_text)
+
+        configured_entries: list[dict[str, object]] = []
+        for entry in cfg.configuration_keys:
+            if not isinstance(entry, dict):
+                continue
+            key_raw = entry.get("key")
+            key_text = str(key_raw).strip() if key_raw is not None else ""
+            if not key_text:
+                continue
+            if requested_keys and key_text not in requested_keys:
+                continue
+            value = entry.get("value")
+            readonly = entry.get("readonly")
+            payload_entry: dict[str, object] = {"key": key_text}
+            if value is not None:
+                payload_entry["value"] = str(value)
+            if readonly is not None:
+                payload_entry["readonly"] = bool(readonly)
+            configured_entries.append(payload_entry)
+
+        unknown_keys: list[str] = []
+        for key in cfg.configuration_unknown_keys:
+            key_text = str(key).strip()
+            if not key_text:
+                continue
+            if requested_keys and key_text not in requested_keys:
+                continue
+            if key_text not in unknown_keys:
+                unknown_keys.append(key_text)
+
+        if requested_keys:
+            matched = {entry["key"] for entry in configured_entries}
+            for key in requested_keys:
+                if key not in matched and key not in unknown_keys:
+                    unknown_keys.append(key)
+
+        response_payload: dict[str, object] = {}
+        if configured_entries:
+            response_payload["configurationKey"] = configured_entries
+        if unknown_keys:
+            response_payload["unknownKey"] = unknown_keys
+        await send(json.dumps([3, message_id, response_payload]))
+
     @requires_network
     async def _run_session(self) -> None:
         cfg = self.config
@@ -137,26 +434,34 @@ class ChargePointSimulator:
                 store.add_log(cfg.cp_path, f"> {msg}", log_type="simulator")
 
             async def recv() -> str:
-                try:
-                    raw = await asyncio.wait_for(ws.recv(), timeout=60)
-                except asyncio.TimeoutError:
-                    self.status = "stopped"
-                    self._stop_event.set()
-                    store.add_log(
-                        cfg.cp_path,
-                        "Timeout waiting for response from charger",
-                        log_type="simulator",
-                    )
-                    raise
-                except websockets.exceptions.ConnectionClosed:
-                    self.status = "stopped"
-                    self._stop_event.set()
-                    raise
-                except Exception:
-                    self.status = "error"
-                    raise
-                store.add_log(cfg.cp_path, f"< {raw}", log_type="simulator")
-                return raw
+                while True:
+                    try:
+                        raw = await asyncio.wait_for(ws.recv(), timeout=60)
+                    except asyncio.TimeoutError:
+                        self.status = "stopped"
+                        self._stop_event.set()
+                        store.add_log(
+                            cfg.cp_path,
+                            "Timeout waiting for response from charger",
+                            log_type="simulator",
+                        )
+                        raise
+                    except websockets.exceptions.ConnectionClosed:
+                        self.status = "stopped"
+                        self._stop_event.set()
+                        raise
+                    except Exception:
+                        self.status = "error"
+                        raise
+                    store.add_log(cfg.cp_path, f"< {raw}", log_type="simulator")
+                    try:
+                        parsed = json.loads(raw)
+                    except Exception:
+                        return raw
+                    handled = await self._handle_csms_call(parsed, send, recv)
+                    if handled:
+                        continue
+                    return raw
 
             # handshake
             boot = json.dumps(
@@ -203,7 +508,11 @@ class ChargePointSimulator:
                                 {
                                     "connectorId": cfg.connector_id,
                                     "errorCode": "NoError",
-                                    "status": "Available",
+                                    "status": (
+                                        "Available"
+                                        if self._availability_state == "Operative"
+                                        else "Unavailable"
+                                    ),
                                 },
                             ]
                         )
@@ -235,12 +544,14 @@ class ChargePointSimulator:
                                     ],
                                 },
                             ]
+                        )
                     )
-                )
-                await recv()
-                await self._maybe_send_door_event(send, recv)
-                await asyncio.sleep(cfg.interval)
+                    await recv()
+                    await self._maybe_send_door_event(send, recv)
+                    await asyncio.sleep(cfg.interval)
 
+            if not await self._wait_until_operative(send, recv):
+                return
             meter_start = random.randint(1000, 2000)
             await send(
                 json.dumps(
@@ -263,6 +574,7 @@ class ChargePointSimulator:
                 self.status = "error"
                 raise
             tx_id = resp[2].get("transactionId")
+            self._in_transaction = True
 
             meter = meter_start
             steps = max(1, int(cfg.duration / cfg.interval))
@@ -323,6 +635,13 @@ class ChargePointSimulator:
             )
             await recv()
             await self._maybe_send_door_event(send, recv)
+            self._in_transaction = False
+            if self._pending_availability:
+                pending = self._pending_availability
+                self._pending_availability = None
+                self._availability_state = pending
+                status_label = "Available" if pending == "Operative" else "Unavailable"
+                await self._send_status_notification(send, recv, status_label)
         except asyncio.TimeoutError:
             if not self._connected.is_set():
                 self._connect_error = "Timeout waiting for response"
@@ -353,6 +672,7 @@ class ChargePointSimulator:
             self._stop_event.set()
             raise
         finally:
+            self._in_transaction = False
             if ws is not None:
                 await ws.close()
                 store.add_log(

ocpp/status_display.py

@@ -0,0 +1,26 @@
+"""Shared status display constants for charger views and admin."""
+
+from __future__ import annotations
+
+from django.utils.translation import gettext_lazy as _
+
+
+# Map of normalized OCPP status values to human readable labels and colors.
+STATUS_BADGE_MAP: dict[str, tuple[str, str]] = {
+    "available": (_("Available"), "#0d6efd"),
+    "preparing": (_("Preparing"), "#0d6efd"),
+    "charging": (_("Charging"), "#198754"),
+    "suspendedevse": (_("Suspended (EVSE)"), "#fd7e14"),
+    "suspendedev": (_("Suspended (EV)"), "#fd7e14"),
+    "finishing": (_("Finishing"), "#20c997"),
+    "faulted": (_("Faulted"), "#dc3545"),
+    "unavailable": (_("Unavailable"), "#6c757d"),
+    "reserved": (_("Reserved"), "#6f42c1"),
+    "occupied": (_("Occupied"), "#0dcaf0"),
+    "outofservice": (_("Out of Service"), "#6c757d"),
+}
+
+
+# Error codes that indicate "no error" according to the OCPP specification.
+ERROR_OK_VALUES = {"", "noerror", "no_error"}
+

ocpp/store.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from pathlib import Path
+import asyncio
 from datetime import datetime
 import json
+from pathlib import Path
 import re
-import asyncio
+import threading
 
 from core.log_paths import select_log_dir
 
@@ -23,6 +24,8 @@ logs: dict[str, dict[str, list[str]]] = {"charger": {}, "simulator": {}}
 history: dict[str, dict[str, object]] = {}
 simulators = {}
 ip_connections: dict[str, set[object]] = {}
+pending_calls: dict[str, dict[str, object]] = {}
+triggered_followups: dict[str, list[dict[str, object]]] = {}
 
 # mapping of charger id / cp_path to friendly names used for log files
 log_names: dict[str, dict[str, str]] = {"charger": {}, "simulator": {}}
@@ -187,6 +190,111 @@ def pop_transaction(serial: str, connector: int | str | None = None):
     return None
 
 
+def register_pending_call(message_id: str, metadata: dict[str, object]) -> None:
+    """Store metadata about an outstanding CSMS call."""
+
+    pending_calls[message_id] = dict(metadata)
+
+
+def pop_pending_call(message_id: str) -> dict[str, object] | None:
+    """Return and remove metadata for a previously registered call."""
+
+    return pending_calls.pop(message_id, None)
+
+
+def schedule_call_timeout(
+    message_id: str,
+    *,
+    timeout: float = 5.0,
+    action: str | None = None,
+    log_key: str | None = None,
+    log_type: str = "charger",
+    message: str | None = None,
+) -> None:
+    """Schedule a timeout notice if a pending call is not answered."""
+
+    def _notify() -> None:
+        metadata = pending_calls.get(message_id)
+        if not metadata:
+            return
+        if action and metadata.get("action") != action:
+            return
+        if metadata.get("timeout_notice_sent"):
+            return
+        target_log = log_key or metadata.get("log_key")
+        if not target_log:
+            metadata["timeout_notice_sent"] = True
+            return
+        label = message
+        if not label:
+            action_label = action or str(metadata.get("action") or "Call")
+            label = f"{action_label} request timed out"
+        add_log(target_log, label, log_type=log_type)
+        metadata["timeout_notice_sent"] = True
+
+    timer = threading.Timer(timeout, _notify)
+    timer.daemon = True
+    timer.start()
+
+
+def register_triggered_followup(
+    serial: str,
+    action: str,
+    *,
+    connector: int | str | None = None,
+    log_key: str | None = None,
+    target: str | None = None,
+) -> None:
+    """Record that ``serial`` should send ``action`` after a TriggerMessage."""
+
+    entry = {
+        "action": action,
+        "connector": connector_slug(connector),
+        "log_key": log_key,
+        "target": target,
+    }
+    triggered_followups.setdefault(serial, []).append(entry)
+
+
+def consume_triggered_followup(
+    serial: str, action: str, connector: int | str | None = None
+) -> dict[str, object] | None:
+    """Return metadata for a previously registered follow-up message."""
+
+    entries = triggered_followups.get(serial)
+    if not entries:
+        return None
+    connector_slug_value = connector_slug(connector)
+    for index, entry in enumerate(entries):
+        if entry.get("action") != action:
+            continue
+        expected_slug = entry.get("connector")
+        if expected_slug == AGGREGATE_SLUG:
+            matched = True
+        else:
+            matched = connector_slug_value == expected_slug
+        if not matched:
+            continue
+        result = entries.pop(index)
+        if not entries:
+            triggered_followups.pop(serial, None)
+        return result
+    return None
+
+
+def clear_pending_calls(serial: str) -> None:
+    """Remove any pending calls associated with the provided charger id."""
+
+    to_remove = [
+        key
+        for key, value in pending_calls.items()
+        if value.get("charger_id") == serial
+    ]
+    for key in to_remove:
+        pending_calls.pop(key, None)
+    triggered_followups.pop(serial, None)
+
+
 def reassign_identity(old_key: str, new_key: str) -> str:
     """Move any stored data from ``old_key`` to ``new_key``."""