arthexis 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

ocpp/store.py

@@ -6,9 +6,16 @@ from pathlib import Path
 from datetime import datetime
 import json
 import re
+import asyncio
 
-connections = {}
-transactions = {}
+from core.log_paths import select_log_dir
+
+IDENTITY_SEPARATOR = "#"
+AGGREGATE_SLUG = "all"
+PENDING_SLUG = "pending"
+
+connections: dict[str, object] = {}
+transactions: dict[str, object] = {}
 logs: dict[str, dict[str, list[str]]] = {"charger": {}, "simulator": {}}
 # store per charger session logs before they are flushed to disk
 history: dict[str, dict[str, object]] = {}
@@ -17,10 +24,184 @@ simulators = {}
 # mapping of charger id / cp_path to friendly names used for log files
 log_names: dict[str, dict[str, str]] = {"charger": {}, "simulator": {}}
 
-LOG_DIR = Path(__file__).resolve().parent.parent / "logs"
-LOG_DIR.mkdir(exist_ok=True)
+BASE_DIR = Path(__file__).resolve().parent.parent
+LOG_DIR = select_log_dir(BASE_DIR)
 SESSION_DIR = LOG_DIR / "sessions"
 SESSION_DIR.mkdir(exist_ok=True)
+LOCK_DIR = BASE_DIR / "locks"
+LOCK_DIR.mkdir(exist_ok=True)
+SESSION_LOCK = LOCK_DIR / "charging.lck"
+_lock_task: asyncio.Task | None = None
+
+
+def connector_slug(value: int | str | None) -> str:
+    """Return the canonical slug for a connector value."""
+
+    if value in (None, "", AGGREGATE_SLUG):
+        return AGGREGATE_SLUG
+    try:
+        return str(int(value))
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def identity_key(serial: str, connector: int | str | None) -> str:
+    """Return the identity key used for in-memory store lookups."""
+
+    return f"{serial}{IDENTITY_SEPARATOR}{connector_slug(connector)}"
+
+
+def pending_key(serial: str) -> str:
+    """Return the key used before a connector id has been negotiated."""
+
+    return f"{serial}{IDENTITY_SEPARATOR}{PENDING_SLUG}"
+
+
+def _candidate_keys(serial: str, connector: int | str | None) -> list[str]:
+    """Return possible keys for lookups with fallbacks."""
+
+    keys: list[str] = []
+    if connector not in (None, "", AGGREGATE_SLUG):
+        keys.append(identity_key(serial, connector))
+    else:
+        keys.append(identity_key(serial, None))
+        prefix = f"{serial}{IDENTITY_SEPARATOR}"
+        for key in connections.keys():
+            if key.startswith(prefix) and key not in keys:
+                keys.append(key)
+    keys.append(pending_key(serial))
+    keys.append(serial)
+    seen: set[str] = set()
+    result: list[str] = []
+    for key in keys:
+        if key and key not in seen:
+            seen.add(key)
+            result.append(key)
+    return result
+
+
+def iter_identity_keys(serial: str) -> list[str]:
+    """Return all known keys for the provided serial."""
+
+    prefix = f"{serial}{IDENTITY_SEPARATOR}"
+    keys = [key for key in connections.keys() if key.startswith(prefix)]
+    if serial in connections:
+        keys.append(serial)
+    return keys
+
+
+def is_connected(serial: str, connector: int | str | None = None) -> bool:
+    """Return whether a connection exists for the provided charger identity."""
+
+    if connector in (None, "", AGGREGATE_SLUG):
+        prefix = f"{serial}{IDENTITY_SEPARATOR}"
+        return (
+            any(key.startswith(prefix) for key in connections) or serial in connections
+        )
+    return any(key in connections for key in _candidate_keys(serial, connector))
+
+
+def get_connection(serial: str, connector: int | str | None = None):
+    """Return the websocket consumer for the requested identity, if any."""
+
+    for key in _candidate_keys(serial, connector):
+        conn = connections.get(key)
+        if conn is not None:
+            return conn
+    return None
+
+
+def set_connection(serial: str, connector: int | str | None, consumer) -> str:
+    """Store a websocket consumer under the negotiated identity."""
+
+    key = identity_key(serial, connector)
+    connections[key] = consumer
+    return key
+
+
+def pop_connection(serial: str, connector: int | str | None = None):
+    """Remove a stored connection for the given identity."""
+
+    for key in _candidate_keys(serial, connector):
+        conn = connections.pop(key, None)
+        if conn is not None:
+            return conn
+    return None
+
+
+def get_transaction(serial: str, connector: int | str | None = None):
+    """Return the active transaction for the provided identity."""
+
+    for key in _candidate_keys(serial, connector):
+        tx = transactions.get(key)
+        if tx is not None:
+            return tx
+    return None
+
+
+def set_transaction(serial: str, connector: int | str | None, tx) -> str:
+    """Store an active transaction under the provided identity."""
+
+    key = identity_key(serial, connector)
+    transactions[key] = tx
+    return key
+
+
+def pop_transaction(serial: str, connector: int | str | None = None):
+    """Remove and return an active transaction for the identity."""
+
+    for key in _candidate_keys(serial, connector):
+        tx = transactions.pop(key, None)
+        if tx is not None:
+            return tx
+    return None
+
+
+def reassign_identity(old_key: str, new_key: str) -> str:
+    """Move any stored data from ``old_key`` to ``new_key``."""
+
+    if old_key == new_key:
+        return new_key
+    if not old_key:
+        return new_key
+    for mapping in (connections, transactions, history):
+        if old_key in mapping:
+            mapping[new_key] = mapping.pop(old_key)
+    for log_type in logs:
+        store = logs[log_type]
+        if old_key in store:
+            store[new_key] = store.pop(old_key)
+    for log_type in log_names:
+        names = log_names[log_type]
+        if old_key in names:
+            names[new_key] = names.pop(old_key)
+    return new_key
+
+
+async def _touch_lock() -> None:
+    try:
+        while True:
+            SESSION_LOCK.touch()
+            await asyncio.sleep(60)
+    except asyncio.CancelledError:
+        pass
+
+
+def start_session_lock() -> None:
+    global _lock_task
+    SESSION_LOCK.touch()
+    loop = asyncio.get_event_loop()
+    if _lock_task is None or _lock_task.done():
+        _lock_task = loop.create_task(_touch_lock())
+
+
+def stop_session_lock() -> None:
+    global _lock_task
+    if _lock_task:
+        _lock_task.cancel()
+        _lock_task = None
+    if SESSION_LOCK.exists():
+        SESSION_LOCK.unlink()
 
 
 def register_log_name(cid: str, name: str, log_type: str = "charger") -> None:
@@ -86,10 +267,12 @@ def add_session_message(cid: str, message: str) -> None:
     sess = history.get(cid)
     if not sess:
         return
-    sess["messages"].append({
-        "timestamp": datetime.utcnow().isoformat() + "Z",
-        "message": message,
-    })
+    sess["messages"].append(
+        {
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "message": message,
+        }
+    )
 
 
 def end_session_log(cid: str) -> None:
@@ -107,15 +290,33 @@ def end_session_log(cid: str) -> None:
         json.dump(sess["messages"], handle, ensure_ascii=False, indent=2)
 
 
-def get_logs(cid: str, log_type: str = "charger") -> list[str]:
-    """Return all log entries for the given id and type."""
+def _log_key_candidates(cid: str, log_type: str) -> list[str]:
+    """Return log identifiers to inspect for the requested cid."""
+
+    if IDENTITY_SEPARATOR not in cid:
+        return [cid]
+    serial, slug = cid.split(IDENTITY_SEPARATOR, 1)
+    slug = slug or AGGREGATE_SLUG
+    if slug != AGGREGATE_SLUG:
+        return [cid]
+    keys: list[str] = [identity_key(serial, None)]
+    prefix = f"{serial}{IDENTITY_SEPARATOR}"
+    for source in (log_names[log_type], logs[log_type]):
+        for key in source.keys():
+            if key.startswith(prefix) and key not in keys:
+                keys.append(key)
+    return keys
+
+
+def _resolve_log_identifier(cid: str, log_type: str) -> tuple[str, str | None]:
+    """Return the canonical key and friendly name for ``cid``."""
 
     names = log_names[log_type]
-    # Try to find a matching log name case-insensitively
     name = names.get(cid)
     if name is None:
+        lower = cid.lower()
         for key, value in names.items():
-            if key.lower() == cid.lower():
+            if key.lower() == lower:
                 cid = key
                 name = value
                 break
@@ -132,14 +333,17 @@ def get_logs(cid: str, log_type: str = "charger") -> list[str]:
                 else:
                     from .models import Charger
 
-                    ch = Charger.objects.filter(charger_id__iexact=cid).first()
+                    serial = cid.split(IDENTITY_SEPARATOR, 1)[0]
+                    ch = Charger.objects.filter(charger_id__iexact=serial).first()
                     if ch and ch.name:
-                        cid = ch.charger_id
                         name = ch.name
                         names[cid] = name
             except Exception:  # pragma: no cover - best effort lookup
                 pass
+    return cid, name
+
 
+def _log_file_for_identifier(cid: str, name: str | None, log_type: str) -> Path:
     path = _file_path(cid, log_type)
     if not path.exists():
         target = f"{log_type}.{_safe_name(name or cid).lower()}"
@@ -147,29 +351,53 @@ def get_logs(cid: str, log_type: str = "charger") -> list[str]:
             if file.stem.lower() == target:
                 path = file
                 break
+    return path
 
-    if path.exists():
-        return path.read_text(encoding="utf-8").splitlines()
 
+def _memory_logs_for_identifier(cid: str, log_type: str) -> list[str]:
     store = logs[log_type]
+    lower = cid.lower()
     for key, entries in store.items():
-        if key.lower() == cid.lower():
+        if key.lower() == lower:
             return entries
     return []
 
 
+def get_logs(cid: str, log_type: str = "charger") -> list[str]:
+    """Return all log entries for the given id and type."""
+
+    entries: list[str] = []
+    seen_paths: set[Path] = set()
+    seen_keys: set[str] = set()
+    for key in _log_key_candidates(cid, log_type):
+        resolved, name = _resolve_log_identifier(key, log_type)
+        path = _log_file_for_identifier(resolved, name, log_type)
+        if path.exists() and path not in seen_paths:
+            entries.extend(path.read_text(encoding="utf-8").splitlines())
+            seen_paths.add(path)
+        memory_entries = _memory_logs_for_identifier(resolved, log_type)
+        lower_key = resolved.lower()
+        if memory_entries and lower_key not in seen_keys:
+            entries.extend(memory_entries)
+            seen_keys.add(lower_key)
+    return entries
+
+
 def clear_log(cid: str, log_type: str = "charger") -> None:
     """Remove any stored logs for the given id and type."""
-
-    store = logs[log_type]
-    key = next((k for k in list(store.keys()) if k.lower() == cid.lower()), cid)
-    store.pop(key, None)
-    path = _file_path(key, log_type)
-    if not path.exists():
-        target = f"{log_type}.{_safe_name(log_names[log_type].get(key, key)).lower()}"
-        for file in LOG_DIR.glob(f"{log_type}.*.log"):
-            if file.stem.lower() == target:
-                path = file
-                break
-    if path.exists():
-        path.unlink()
+    for key in _log_key_candidates(cid, log_type):
+        store_map = logs[log_type]
+        resolved = next(
+            (k for k in list(store_map.keys()) if k.lower() == key.lower()),
+            key,
+        )
+        store_map.pop(resolved, None)
+        path = _file_path(resolved, log_type)
+        if not path.exists():
+            target = f"{log_type}.{_safe_name(log_names[log_type].get(resolved, resolved)).lower()}"
+            for file in LOG_DIR.glob(f"{log_type}.*.log"):
+                if file.stem.lower() == target:
+                    path = file
+                    break
+        if path.exists():
+            path.unlink()

ocpp/tasks.py

@@ -5,23 +5,27 @@ from celery import shared_task
 from django.utils import timezone
 from django.db.models import Q
 
-from .models import MeterReading
+from .models import MeterValue
 
 logger = logging.getLogger(__name__)
 
 
 @shared_task
-def purge_meter_readings() -> int:
-    """Delete meter readings older than 7 days.
+def purge_meter_values() -> int:
+    """Delete meter values older than 7 days.
 
-    Readings tied to transactions without a recorded meter_stop are preserved so
+    Values tied to transactions without a recorded meter_stop are preserved so
     that ongoing or incomplete sessions retain their energy data.
-    Returns the number of deleted readings.
+    Returns the number of deleted rows.
     """
     cutoff = timezone.now() - timedelta(days=7)
-    qs = MeterReading.objects.filter(timestamp__lt=cutoff).filter(
+    qs = MeterValue.objects.filter(timestamp__lt=cutoff).filter(
         Q(transaction__isnull=True) | Q(transaction__meter_stop__isnull=False)
     )
     deleted, _ = qs.delete()
-    logger.info("Purged %s meter readings", deleted)
+    logger.info("Purged %s meter values", deleted)
     return deleted
+
+
+# Backwards compatibility alias
+purge_meter_readings = purge_meter_values

ocpp/test_export_import.py

@@ -10,7 +10,7 @@ from django.utils import timezone
 from django.urls import reverse
 from django.contrib.auth import get_user_model
 
-from ocpp.models import Charger, Transaction, MeterReading
+from ocpp.models import Charger, Transaction, MeterValue
 from core.models import EnergyAccount
 
 
@@ -29,12 +29,11 @@ class TransactionExportImportTests(TestCase):
             charger=self.ch2,
             start_time=now,
         )
-        MeterReading.objects.create(
+        MeterValue.objects.create(
             charger=self.ch1,
             transaction=self.tx_old,
             timestamp=now - timedelta(days=5),
-            value=1,
-            unit="kW",
+            energy=1,
         )
 
     def test_export_filters_and_import_creates_chargers(self):
@@ -55,7 +54,7 @@ class TransactionExportImportTests(TestCase):
         self.assertEqual(len(data["transactions"]), 1)
         self.assertEqual(data["transactions"][0]["charger"], "C2")
 
-        MeterReading.objects.all().delete()
+        MeterValue.objects.all().delete()
         Transaction.objects.all().delete()
         Charger.objects.all().delete()
 
@@ -117,7 +116,7 @@ class TransactionAdminExportImportTests(TestCase):
                     "meter_stop": 0,
                     "start_time": timezone.now().isoformat(),
                     "stop_time": None,
-                    "meter_readings": [],
+                    "meter_values": [],
                 }
             ],
         }
@@ -126,4 +125,6 @@ class TransactionAdminExportImportTests(TestCase):
         response = self.client.post(url, {"file": json_file})
         self.assertEqual(response.status_code, 302)
         self.assertTrue(Charger.objects.filter(charger_id="C9").exists())
-        self.assertEqual(Transaction.objects.filter(charger__charger_id="C9").count(), 1)
+        self.assertEqual(
+            Transaction.objects.filter(charger__charger_id="C9").count(), 1
+        )