ebus-panel-sim 0.3.0__py3-none-any.whl

ebus_panel_sim/energy_integrator.py

@@ -0,0 +1,89 @@
+"""Per-instance energy accumulator with producer-supplied seed values.
+
+Each tick the producer reports an instantaneous power for an instance. The
+integrator advances ``produced_wh`` and ``consumed_wh`` based on the elapsed
+time since that instance's last tick, computed from ``current_time`` (epoch
+seconds) the producer pushes. Power-sign convention matches the rest of the
+emitter: positive = consumption (load), negative = production (PV/V2G).
+
+Seeding:
+- ``register(instance_id)`` initializes the integrator at zero.
+- ``seed(instance_id, *, consumed_wh, produced_wh)`` overwrites the running
+  accumulators (typical use: producer reads last-known values from persistent
+  storage and seeds at startup before the first tick).
+- The manifest's ``initial-consumed-wh`` / ``initial-produced-wh`` keys are a
+  declarative alternative; ``Emitter`` calls ``seed()`` from those at startup.
+
+Time bookkeeping:
+- The first observation for an instance establishes ``last_tick_time_s`` but
+  does NOT integrate (no prior interval). Subsequent observations integrate
+  ``power * (now - last)``.
+- Backwards or zero ``dt`` is treated as a no-op (clock skew / duplicate tick)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class EnergyState:
+    consumed_wh: float = 0.0
+    produced_wh: float = 0.0
+    last_tick_time_s: float | None = None
+
+
+class EnergyIntegrator:
+    """Accumulators for many instances. One instance per circuit / PV / EVSE."""
+
+    def __init__(self) -> None:
+        self._states: dict[str, EnergyState] = {}
+
+    def register(self, instance_id: str) -> None:
+        """Idempotent — repeated calls leave existing state untouched."""
+        if instance_id not in self._states:
+            self._states[instance_id] = EnergyState()
+
+    def seed(
+        self,
+        instance_id: str,
+        *,
+        consumed_wh: float = 0.0,
+        produced_wh: float = 0.0,
+    ) -> None:
+        """Overwrite accumulators for ``instance_id``. Raises ``KeyError`` if the
+        instance was never registered (catches typos before the first tick)."""
+        if instance_id not in self._states:
+            raise KeyError(
+                f"seed() called for unknown instance_id={instance_id!r}; call register() first"
+            )
+        st = self._states[instance_id]
+        st.consumed_wh = consumed_wh
+        st.produced_wh = produced_wh
+        # Note: last_tick_time_s is intentionally NOT reset — seeding only
+        # overwrites the energy values, the time bookkeeping persists.
+
+    def observe(self, instance_id: str, power_w: float, current_time: float) -> None:
+        """Advance the integrator for ``instance_id`` with the producer's signed
+        ``power_w`` reported at ``current_time``. The first call for an instance
+        establishes ``last_tick_time_s`` without integrating."""
+        if instance_id not in self._states:
+            raise KeyError(f"observe() for unknown instance_id={instance_id!r}")
+        st = self._states[instance_id]
+        if st.last_tick_time_s is None:
+            st.last_tick_time_s = current_time
+            return
+        dt_s = current_time - st.last_tick_time_s
+        st.last_tick_time_s = current_time
+        if dt_s <= 0:
+            return
+        dt_h = dt_s / 3600.0
+        if power_w > 0:
+            st.consumed_wh += power_w * dt_h
+        elif power_w < 0:
+            st.produced_wh += -power_w * dt_h
+
+    def state(self, instance_id: str) -> EnergyState:
+        return self._states[instance_id]
+
+    def known(self, instance_id: str) -> bool:
+        return instance_id in self._states

ebus_panel_sim/exceptions.py

@@ -0,0 +1,38 @@
+"""Public exception hierarchy for ebus-panel-sim."""
+
+from __future__ import annotations
+
+
+class EmitterError(Exception):
+    """Base class for all emitter errors."""
+
+
+class ManifestValidationError(EmitterError):
+    """A DeviceManifest references unknown entity_class, missing required parent, or
+    contains a duplicate (entity_class, instance_id) pair."""
+
+
+class RuntimeSpecValidationError(EmitterError):
+    """A RuntimeSpec is structurally invalid or references manifest entities that do not
+    exist."""
+
+
+class MissingSetterError(EmitterError):
+    """A settable property declared by a vendored profile has no corresponding handler in
+    the SetterRegistry passed to Emitter.__init__. ``missing`` carries the offending
+    (entity_class, property_path) pairs."""
+
+    def __init__(self, missing: list[tuple[str, str]]) -> None:
+        self.missing = missing
+        rendered = ", ".join(f"({c!r}, {p!r})" for c, p in missing)
+        super().__init__(f"Settable properties without registered handlers: {rendered}")
+
+
+class ProfileValidationError(EmitterError):
+    """A vendored profile or mapping descriptor failed internal-consistency validation at
+    load time. Defensive — should never fire in shipped code."""
+
+
+class EmitterStateError(EmitterError):
+    """Emitter operation called in the wrong state (e.g. tick() before start(), start()
+    against a disconnected MQTT client)."""

ebus_panel_sim/manifest.py

@@ -0,0 +1,35 @@
+"""Producer-supplied device identity manifest.
+
+Frozen, immutable declaration of which entity instances exist on a panel. The producer
+hands one to ``Emitter`` at construction; the emitter validates it against the vendored
+mapping descriptors and profiles. Manifest mutations require emitter restart (no live
+mutation API).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True, slots=True)
+class DeviceInstance:
+    entity_class: str
+    instance_id: str
+    display_name: str
+    metadata: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class DeviceManifest:
+    instances: tuple[DeviceInstance, ...]
+
+    def get(self, entity_class: str, instance_id: str) -> DeviceInstance:
+        for inst in self.instances:
+            if inst.entity_class == entity_class and inst.instance_id == instance_id:
+                return inst
+        raise KeyError(
+            f"No DeviceInstance with entity_class={entity_class!r}, instance_id={instance_id!r}"
+        )
+
+    def of_class(self, entity_class: str) -> tuple[DeviceInstance, ...]:
+        return tuple(i for i in self.instances if i.entity_class == entity_class)

ebus_panel_sim/manifest_physics.py

@@ -0,0 +1,451 @@
+"""Typed accessor over ``DeviceInstance.metadata`` for physics-relevant fields.
+
+The producer puts strings in ``DeviceInstance.metadata``; the emitter reads them
+through this view. One central place to define every key the emitter consumes,
+its parser, its default, and its validation rules. Adding a new physics field
+is a one-line addition here plus a docs note in the README.
+
+Validation runs once when ``ManifestPhysicsView`` is constructed (typically at
+``Emitter.__init__``). Missing required keys, malformed values, and contradictory
+physics (e.g. ``dipole`` flag inconsistent with ``tab-numbers`` count) raise
+``ManifestValidationError`` with the offending instance_id."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+from ebus_panel_sim.conventions.tab_legs import Leg, legs_for_tabs
+from ebus_panel_sim.exceptions import ManifestValidationError
+
+if TYPE_CHECKING:
+    from ebus_panel_sim.manifest import DeviceInstance, DeviceManifest
+
+
+# ---------------------------------------------------------------------------
+# Per-entity-class typed views — built once, queried many times.
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class PanelPhysics:
+    serial_number: str
+    vendor_name: str
+    firmware_version: str
+    hardware_version: str
+    panel_size: int
+    main_breaker_rating_a: int
+    panel_model: str
+    postal_code: str
+    time_zone: str
+    service_voltage_v: float
+    line_voltage_v: float
+    islandable: bool
+    # ``flat`` = legacy single-Homie-device shape (one device, many nodes).
+    # ``parent-child`` = post-migration shape where children become separate
+    # Homie devices. Producer-overridable via metadata key ``schema-topology``.
+    topology: Literal["flat", "parent-child"] = "flat"
+
+
+@dataclass(frozen=True, slots=True)
+class LugsPhysics:
+    direction: str  # "upstream" | "downstream"
+
+
+@dataclass(frozen=True, slots=True)
+class CircuitPhysics:
+    tabs: tuple[int, ...]
+    legs: tuple[Leg, ...]
+    dipole: bool
+    breaker_rating_a: float
+    default_priority: str
+    relay_behavior: str  # "controllable" | "always-on" | "non-controllable"
+    placement: str  # "upstream-of-lugs" | "downstream-of-lugs"
+    always_on: bool
+    initial_consumed_wh: float
+    initial_produced_wh: float
+    pcs_priority: int = 0
+
+
+@dataclass(frozen=True, slots=True)
+class BessPhysics:
+    vendor_name: str
+    nameplate_capacity_kwh: float
+    initial_soe_kwh: float | None
+    part_number: str | None
+    model: str | None
+    serial_number: str | None
+    firmware_version: str | None
+    relative_position: str | None
+    feed: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class PvPhysics:
+    vendor_name: str
+    nominal_power_w: float
+    inverter_type: str  # "hybrid" | "ac-coupled"
+    model: str | None
+    serial_number: str | None
+    firmware_version: str | None
+    relative_position: str | None
+    feed: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class EvsePhysics:
+    vendor_name: str
+    model: str
+    part_number: str
+    serial_number: str
+    firmware_version: str
+    max_current_a: float
+    feed: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class MidPhysics:
+    """Microgrid Interconnect Device identity. Grid state (islanding-state /
+    grid-state / grid-forming-entity) is dynamic, derived per-tick from the
+    grid-online signal rather than parsed here."""
+
+    vendor_name: str | None
+    serial_number: str | None
+    model: str | None
+    firmware_version: str | None
+    hardware_version: str | None
+
+
+# ---------------------------------------------------------------------------
+# Top-level view
+# ---------------------------------------------------------------------------
+
+
+_VALID_PRIORITIES = frozenset(
+    {
+        "MUST_HAVE",
+        "NICE_TO_HAVE",
+        "NON_ESSENTIAL",
+        "NEVER",
+        "SOC_THRESHOLD",
+        "OFF_GRID",
+    }
+)
+_VALID_RELAY_BEHAVIORS = frozenset({"controllable", "always-on", "non-controllable"})
+_VALID_PLACEMENTS = frozenset({"upstream-of-lugs", "downstream-of-lugs"})
+_VALID_LUGS_DIRECTIONS = frozenset({"upstream", "downstream"})
+_VALID_INVERTER_TYPES = frozenset({"hybrid", "ac-coupled"})
+_VALID_TOPOLOGIES = frozenset({"flat", "parent-child"})
+
+
+class ManifestPhysicsView:
+    """Validated, typed view over a ``DeviceManifest``'s metadata.
+
+    Built once at ``Emitter`` construction time. Holds parsed physics for every
+    instance keyed by ``instance_id``. Raises ``ManifestValidationError`` at
+    construction if any instance is missing required keys or has malformed
+    values; the emitter never sees a partially-validated manifest."""
+
+    def __init__(self, manifest: DeviceManifest) -> None:
+        self._panel: PanelPhysics | None = None
+        self._lugs: dict[str, LugsPhysics] = {}
+        self._circuits: dict[str, CircuitPhysics] = {}
+        self._bess: dict[str, BessPhysics] = {}
+        self._pv: dict[str, PvPhysics] = {}
+        self._evse: dict[str, EvsePhysics] = {}
+        self._mid: dict[str, MidPhysics] = {}
+
+        for inst in manifest.instances:
+            ec = inst.entity_class
+            try:
+                if ec == "panel":
+                    if self._panel is not None:
+                        raise ManifestValidationError(
+                            "Multiple panel instances in manifest; expected exactly one",
+                        )
+                    self._panel = _parse_panel(inst)
+                elif ec == "lugs":
+                    self._lugs[inst.instance_id] = _parse_lugs(inst)
+                elif ec == "circuit":
+                    self._circuits[inst.instance_id] = _parse_circuit(inst)
+                elif ec == "bess":
+                    self._bess[inst.instance_id] = _parse_bess(inst)
+                elif ec == "pv":
+                    self._pv[inst.instance_id] = _parse_pv(inst)
+                elif ec == "evse":
+                    self._evse[inst.instance_id] = _parse_evse(inst)
+                elif ec == "mid":
+                    self._mid[inst.instance_id] = _parse_mid(inst)
+                # Unknown entity_class: leave to graph builder to reject.
+            except ManifestValidationError as exc:
+                raise ManifestValidationError(f"{ec}/{inst.instance_id}: {exc}") from exc
+
+        if self._panel is None:
+            raise ManifestValidationError("Manifest has no panel instance")
+
+    # -- accessors -----------------------------------------------------------
+
+    @property
+    def panel(self) -> PanelPhysics:
+        assert self._panel is not None  # checked in __init__
+        return self._panel
+
+    def lugs(self, instance_id: str) -> LugsPhysics:
+        return self._lugs[instance_id]
+
+    def circuit(self, instance_id: str) -> CircuitPhysics:
+        return self._circuits[instance_id]
+
+    def bess(self, instance_id: str) -> BessPhysics:
+        return self._bess[instance_id]
+
+    def pv(self, instance_id: str) -> PvPhysics:
+        return self._pv[instance_id]
+
+    def evse(self, instance_id: str) -> EvsePhysics:
+        return self._evse[instance_id]
+
+    def all_circuits(self) -> dict[str, CircuitPhysics]:
+        return dict(self._circuits)
+
+    def all_lugs(self) -> dict[str, LugsPhysics]:
+        return dict(self._lugs)
+
+    def all_bess(self) -> dict[str, BessPhysics]:
+        return dict(self._bess)
+
+    def all_pv(self) -> dict[str, PvPhysics]:
+        return dict(self._pv)
+
+    def all_evse(self) -> dict[str, EvsePhysics]:
+        return dict(self._evse)
+
+    def mid(self, instance_id: str) -> MidPhysics:
+        return self._mid[instance_id]
+
+    def all_mid(self) -> dict[str, MidPhysics]:
+        return dict(self._mid)
+
+
+# ---------------------------------------------------------------------------
+# Parsers — one per entity_class.
+# ---------------------------------------------------------------------------
+
+
+def _require(md: dict[str, str], key: str) -> str:
+    if key not in md:
+        raise ManifestValidationError(f"missing required metadata key {key!r}")
+    return md[key]
+
+
+def _opt_float(md: dict[str, str], key: str, default: float) -> float:
+    if key not in md:
+        return default
+    try:
+        return float(md[key])
+    except ValueError as exc:
+        raise ManifestValidationError(f"key {key!r}: not a float ({md[key]!r})") from exc
+
+
+def _opt_int(md: dict[str, str], key: str, default: int) -> int:
+    if key not in md:
+        return default
+    try:
+        return int(md[key])
+    except ValueError as exc:
+        raise ManifestValidationError(f"key {key!r}: not an int ({md[key]!r})") from exc
+
+
+def _opt_bool(md: dict[str, str], key: str, default: bool) -> bool:
+    if key not in md:
+        return default
+    raw = md[key].strip().lower()
+    if raw in ("true", "1", "yes"):
+        return True
+    if raw in ("false", "0", "no"):
+        return False
+    raise ManifestValidationError(f"key {key!r}: not a bool ({md[key]!r})")
+
+
+def _opt_str(md: dict[str, str], key: str) -> str | None:
+    value = md.get(key)
+    return value if value not in (None, "") else None
+
+
+def _req_float(md: dict[str, str], key: str) -> float:
+    raw = _require(md, key)
+    try:
+        return float(raw)
+    except ValueError as exc:
+        raise ManifestValidationError(f"key {key!r}: not a float ({raw!r})") from exc
+
+
+def _req_int(md: dict[str, str], key: str) -> int:
+    raw = _require(md, key)
+    try:
+        return int(raw)
+    except ValueError as exc:
+        raise ManifestValidationError(f"key {key!r}: not an int ({raw!r})") from exc
+
+
+def _parse_panel(inst: DeviceInstance) -> PanelPhysics:
+    md = inst.metadata
+    topology_raw = md.get("schema-topology", "flat")
+    if topology_raw not in _VALID_TOPOLOGIES:
+        raise ManifestValidationError(
+            f"key 'schema-topology': must be one of {sorted(_VALID_TOPOLOGIES)}, "
+            f"got {topology_raw!r}"
+        )
+    # ``cast`` would also work here, but a direct comparison keeps the Literal
+    # narrow without an explicit import-only typing helper.
+    topology: Literal["flat", "parent-child"] = (
+        "parent-child" if topology_raw == "parent-child" else "flat"
+    )
+    return PanelPhysics(
+        serial_number=_require(md, "serial-number"),
+        vendor_name=_require(md, "vendor-name"),
+        firmware_version=_opt_str(md, "firmware-version") or _require(md, "software-version"),
+        hardware_version=_require(md, "hardware-version"),
+        panel_size=_req_int(md, "panel-size"),
+        main_breaker_rating_a=_req_int(md, "main-breaker-rating-a"),
+        panel_model=_require(md, "panel-model"),
+        postal_code=_require(md, "postal-code"),
+        time_zone=_require(md, "time-zone"),
+        service_voltage_v=_opt_float(md, "service-voltage-v", 240.0),
+        line_voltage_v=_opt_float(md, "line-voltage-v", 120.0),
+        islandable=_opt_bool(md, "islandable", False),
+        topology=topology,
+    )
+
+
+def _parse_lugs(inst: DeviceInstance) -> LugsPhysics:
+    direction = _require(inst.metadata, "direction")
+    if direction not in _VALID_LUGS_DIRECTIONS:
+        raise ManifestValidationError(
+            f"key 'direction': must be one of {sorted(_VALID_LUGS_DIRECTIONS)}, got {direction!r}"
+        )
+    return LugsPhysics(direction=direction)
+
+
+def _parse_circuit(inst: DeviceInstance) -> CircuitPhysics:
+    md = inst.metadata
+    raw_tabs = _require(md, "tab-numbers")
+    try:
+        tabs = tuple(int(t.strip()) for t in raw_tabs.split(",") if t.strip())
+    except ValueError as exc:
+        raise ManifestValidationError(
+            f"key 'tab-numbers': not a comma-separated int list ({raw_tabs!r})"
+        ) from exc
+    if not tabs:
+        raise ManifestValidationError("key 'tab-numbers': must list at least one tab")
+    try:
+        legs = legs_for_tabs(tabs)
+    except ValueError as exc:
+        raise ManifestValidationError(f"key 'tab-numbers': {exc}") from exc
+    dipole_declared = _opt_bool(md, "dipole", default=len(tabs) > 1)
+    # NOTE: ``dipole`` + leg-spanning is not strictly validated. Real SPAN panels
+    # use slot numberings where two adjacent breaker positions on the same leg
+    # can still be ganged as a "240 V" feed (e.g. tabs 20+22). The convention
+    # in ``conventions/tab_legs.py`` is informational for per-leg current
+    # calculation; producers are trusted to declare dipole correctly.
+    if not dipole_declared and len(tabs) > 1:
+        raise ManifestValidationError(
+            f"dipole=false but {len(tabs)} tabs declared; single-tab circuits only"
+        )
+
+    priority = _require(md, "default-priority")
+    if priority not in _VALID_PRIORITIES:
+        raise ManifestValidationError(
+            f"key 'default-priority': must be one of {sorted(_VALID_PRIORITIES)}, got {priority!r}"
+        )
+
+    relay_behavior = _require(md, "relay-behavior")
+    if relay_behavior not in _VALID_RELAY_BEHAVIORS:
+        raise ManifestValidationError(
+            f"key 'relay-behavior': must be one of {sorted(_VALID_RELAY_BEHAVIORS)}, "
+            f"got {relay_behavior!r}"
+        )
+
+    placement = _require(md, "placement")
+    if placement not in _VALID_PLACEMENTS:
+        raise ManifestValidationError(
+            f"key 'placement': must be one of {sorted(_VALID_PLACEMENTS)}, got {placement!r}"
+        )
+
+    always_on = _opt_bool(md, "always-on", default=relay_behavior == "always-on")
+
+    return CircuitPhysics(
+        tabs=tabs,
+        legs=legs,
+        dipole=dipole_declared,
+        breaker_rating_a=_req_float(md, "breaker-rating-a"),
+        default_priority=priority,
+        relay_behavior=relay_behavior,
+        placement=placement,
+        always_on=always_on,
+        pcs_priority=_opt_int(md, "pcs-priority", 0),
+        initial_consumed_wh=_opt_float(md, "initial-consumed-wh", 0.0),
+        initial_produced_wh=_opt_float(md, "initial-produced-wh", 0.0),
+    )
+
+
+def _parse_bess(inst: DeviceInstance) -> BessPhysics:
+    md = inst.metadata
+    initial_soe: float | None = None
+    if "initial-soe-kwh" in md:
+        initial_soe = _opt_float(md, "initial-soe-kwh", 0.0)
+    return BessPhysics(
+        vendor_name=_require(md, "vendor-name"),
+        nameplate_capacity_kwh=_req_float(md, "nameplate-capacity-kwh"),
+        initial_soe_kwh=initial_soe,
+        part_number=_opt_str(md, "part-number"),
+        model=_opt_str(md, "model"),
+        serial_number=_opt_str(md, "serial-number"),
+        firmware_version=_opt_str(md, "firmware-version") or _opt_str(md, "software-version"),
+        relative_position=_opt_str(md, "relative-position") or "UPSTREAM",
+        feed=_opt_str(md, "feed") or _opt_str(md, "feed-circuit-id"),
+    )
+
+
+def _parse_pv(inst: DeviceInstance) -> PvPhysics:
+    md = inst.metadata
+    inverter_type = _require(md, "inverter-type")
+    if inverter_type not in _VALID_INVERTER_TYPES:
+        raise ManifestValidationError(
+            f"key 'inverter-type': must be one of {sorted(_VALID_INVERTER_TYPES)}, "
+            f"got {inverter_type!r}"
+        )
+    return PvPhysics(
+        vendor_name=_require(md, "vendor-name"),
+        nominal_power_w=_req_float(md, "nominal-power-w"),
+        inverter_type=inverter_type,
+        model=_opt_str(md, "model"),
+        serial_number=_opt_str(md, "serial-number"),
+        firmware_version=_opt_str(md, "firmware-version") or _opt_str(md, "software-version"),
+        relative_position=_opt_str(md, "relative-position") or "IN_PANEL",
+        feed=_opt_str(md, "feed") or _opt_str(md, "feed-circuit-id"),
+    )
+
+
+def _parse_evse(inst: DeviceInstance) -> EvsePhysics:
+    md = inst.metadata
+    return EvsePhysics(
+        vendor_name=_require(md, "vendor-name"),
+        model=_require(md, "model"),
+        part_number=_require(md, "part-number"),
+        serial_number=_require(md, "serial-number"),
+        firmware_version=_opt_str(md, "firmware-version") or _require(md, "software-version"),
+        max_current_a=_req_float(md, "max-current-a"),
+        feed=_opt_str(md, "feed") or _opt_str(md, "feed-circuit-id"),
+    )
+
+
+def _parse_mid(inst: DeviceInstance) -> MidPhysics:
+    md = inst.metadata
+    return MidPhysics(
+        vendor_name=_opt_str(md, "vendor-name"),
+        serial_number=_opt_str(md, "serial-number"),
+        model=_opt_str(md, "model"),
+        firmware_version=_opt_str(md, "firmware-version") or _opt_str(md, "software-version"),
+        hardware_version=_opt_str(md, "hardware-version"),
+    )

ebus_panel_sim/native_devices/__init__.py

@@ -0,0 +1,24 @@
+"""Emitter-native devices.
+
+A native device is a configured-and-self-driving entity that lives inside the emitter
+and computes its per-tick state from its configuration plus per-tick context pushed by
+the producer (simulator). Reflector-class devices (circuits, PV, EVSE, lugs) are
+producer-driven and do not have a corresponding NativeDevice.
+
+Today's native devices: BESS, LoadShedding. MID + PCS are future when the parent-child
+schema lands. The list is intentionally small — circuits stay 100% producer-driven
+even when the producer's view of them is HVAC-shaped or recorder-replayed.
+"""
+
+from ebus_panel_sim.native_devices.bess import BESSConfig, BESSDevice
+from ebus_panel_sim.native_devices.load_shedding import LoadSheddingConfig, LoadSheddingDevice
+from ebus_panel_sim.native_devices.protocol import NativeDevice, NativeTickContext
+
+__all__ = [
+    "BESSConfig",
+    "BESSDevice",
+    "LoadSheddingConfig",
+    "LoadSheddingDevice",
+    "NativeDevice",
+    "NativeTickContext",
+]