vledger 0.1.0__py3-none-any.whl

vledger/__init__.py

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: BSD-3-Clause
+"""vledger — the vehicle ledger library.
+
+Everything the integration derives is derived here, and only here
+(ARC-02). The library knows nothing of Home Assistant (ARC-03) and depends
+on nothing outside the standard library (CLI-06).
+"""
+
+#: One version number for the library, the integration and the derivation
+#: logic recorded in L1 (ADR-0002, ABL-07). pyproject.toml and
+#: custom_components/vledger/manifest.json carry the same string; a test
+#: keeps the three in step.
+__version__ = "0.1.0"

vledger/cli.py

@@ -0,0 +1,255 @@
+# SPDX-License-Identifier: BSD-3-Clause
+"""The ``vledger`` command line.
+
+Every operation the library offers is a verb here, grouped by noun
+(ADR-0005): ``vledger l0 …`` for the raw log. A verb reads and writes the
+directory layout under ``--base`` and prints what it did. The library does
+the work; this module parses arguments and spells results.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+from vledger import __version__, clock, l0
+from vledger.layout import Subject
+
+ENV_BASE = "VLEDGER_BASE"
+
+
+class Usage(Exception):
+    """A complaint about the arguments, printed without a traceback."""
+
+
+# --- shared pieces ---------------------------------------------------------
+
+def _subject(args) -> Subject:
+    if args.vehicle and args.chargepoint:
+        raise Usage("--vehicle and --chargepoint exclude each other")
+    if args.vehicle:
+        return Subject("vehicle", args.vehicle)
+    if args.chargepoint:
+        return Subject("chargepoint", args.chargepoint)
+    raise Usage("name the stream: --vehicle ID or --chargepoint ID")
+
+
+def _base(args) -> Path:
+    return Path(args.base or os.environ.get(ENV_BASE) or ".")
+
+
+def _t(args) -> str:
+    return args.t or clock.to_text(clock.now())
+
+
+def _json_arg(text: str):
+    """JSON from the argument itself, from a file, or from stdin (``-``)."""
+    if text == "-":
+        return json.load(sys.stdin)
+    p = Path(text)
+    if p.is_file():
+        return json.loads(p.read_text(encoding="utf-8"))
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        raise Usage(f"neither JSON, a file nor '-': {text!r}") from None
+
+
+def _kv(pairs: list[str]) -> dict:
+    out = {}
+    for pair in pairs or []:
+        if "=" not in pair:
+            raise Usage(f"expected key=value, got {pair!r}")
+        k, v = pair.split("=", 1)
+        try:
+            out[k] = json.loads(v)
+        except json.JSONDecodeError:
+            out[k] = v
+    return out
+
+
+def _add_stream_args(sp: argparse.ArgumentParser) -> None:
+    sp.add_argument("--base", help=f"the data directory (default: ${ENV_BASE} or .)")
+    g = sp.add_mutually_exclusive_group()
+    g.add_argument("--vehicle", metavar="ID", help="the vehicle's subject id")
+    g.add_argument("--chargepoint", metavar="ID", help="the charge point's subject id")
+
+
+def _add_t(sp: argparse.ArgumentParser) -> None:
+    sp.add_argument("--t", help="the event's time, UTC ISO 8601 (default: now)")
+
+
+# --- l0 verbs --------------------------------------------------------------
+
+def cmd_l0_state(args) -> int:
+    subject = _subject(args)
+    line = l0.state(_t(args), subject, args.role, args.entity, args.state,
+                    unit=args.unit, attrs=_kv(args.attr), measured_at=args.measured_at)
+    path = l0.append(_base(args), subject, line)
+    print(f"{path.name}: {l0.encode(line)}")
+    return 0
+
+
+def cmd_l0_start(args) -> int:
+    subject = _subject(args)
+    snapshot = _json_arg(args.snapshot) if args.snapshot else []
+    line = l0.start(_t(args), subject, vledger=args.vledger or __version__,
+                    homeassistant=args.homeassistant, snapshot=snapshot)
+    path = l0.append(_base(args), subject, line)
+    print(f"{path.name}: start, {len(snapshot)} role(s) in the snapshot")
+    return 0
+
+
+def cmd_l0_stop(args) -> int:
+    subject = _subject(args)
+    line = l0.stop(_t(args), subject, reason=args.reason)
+    path = l0.append(_base(args), subject, line)
+    print(f"{path.name}: stop ({args.reason})")
+    return 0
+
+
+def cmd_l0_heartbeat(args) -> int:
+    subject = _subject(args)
+    line = l0.heartbeat(_t(args), subject, lines=args.lines)
+    path = l0.append(_base(args), subject, line)
+    print(f"{path.name}: heartbeat, {args.lines} line(s) since start")
+    return 0
+
+
+def cmd_l0_config(args) -> int:
+    subject = _subject(args)
+    line = l0.config(_t(args), subject, config=_json_arg(args.config))
+    path = l0.append(_base(args), subject, line)
+    print(f"{path.name}: config, {len(line['config'])} key(s)")
+    return 0
+
+
+def cmd_l0_read(args) -> int:
+    n = 0
+    for r in l0.read(_base(args), _subject(args), kind=args.kind, role=args.role,
+                     since=args.since, until=args.until):
+        print(l0.encode(r.line))
+        n += 1
+    print(f"{n} line(s)", file=sys.stderr)
+    return 0
+
+
+def cmd_l0_validate(args) -> int:
+    report = l0.validate(_base(args), _subject(args))
+    if args.json:
+        print(json.dumps({
+            "files": report.files, "lines": report.lines, "by_kind": report.by_kind,
+            "versions": sorted(report.versions),
+            "problems": [p.__dict__ for p in report.problems],
+        }, indent=2))
+    else:
+        kinds = ", ".join(f"{k} {n}" for k, n in sorted(report.by_kind.items()))
+        versions = ", ".join(str(v) for v in sorted(report.versions)) or "none"
+        print(f"{report.files} file(s), {report.lines} line(s): {kinds or 'nothing'}")
+        print(f"schema version(s): {versions}")
+        for p in report.problems:
+            print(f"  [{p.severity}] {p.where}: {p.what}")
+        print(f"{report.errors} error(s), {len(report.problems) - report.errors} warning(s)")
+    return 1 if report.errors else 0
+
+
+def cmd_l0_gaps(args) -> int:
+    found = l0.gaps(_base(args), _subject(args), tolerance_s=args.tolerance,
+                    now=args.now, min_s=args.min)
+    if args.json:
+        print(json.dumps([g.__dict__ for g in found], indent=2))
+    else:
+        for g in found:
+            print(f"{g.start}  {g.end}  {g.seconds:10.0f} s  {g.reason}")
+        print(f"{len(found)} gap(s)", file=sys.stderr)
+    return 0
+
+
+# --- the parser ------------------------------------------------------------
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="vledger", description="The vehicle ledger")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    nouns = parser.add_subparsers(dest="noun", metavar="<noun>", required=True)
+
+    p_l0 = nouns.add_parser("l0", help="the raw log: write, read, validate, gaps")
+    verbs = p_l0.add_subparsers(dest="verb", metavar="<verb>", required=True)
+
+    sp = verbs.add_parser("state", help="append one state change")
+    _add_stream_args(sp)
+    _add_t(sp)
+    sp.add_argument("--role", required=True, choices=l0.ROLES)
+    sp.add_argument("--entity", required=True, help="the entity id")
+    sp.add_argument("--state", required=True, help="the state string, as Home Assistant holds it")
+    sp.add_argument("--unit", help="unit_of_measurement, when the entity has one")
+    sp.add_argument("--attr", action="append", metavar="KEY=VALUE",
+                    help="an attribute; only the role-relevant ones are kept")
+    sp.add_argument("--measured-at", help="the source's own measurement time, if it gives one")
+    sp.set_defaults(func=cmd_l0_state)
+
+    sp = verbs.add_parser("start", help="capture begins: write the start marker and snapshot")
+    _add_stream_args(sp)
+    _add_t(sp)
+    sp.add_argument("--vledger", help="library version (default: this one)")
+    sp.add_argument("--homeassistant", required=True, help="Home Assistant version")
+    sp.add_argument("--snapshot", help="JSON list of {role, entity, state, unit?, since}; "
+                                       "inline, a file, or - for stdin")
+    sp.set_defaults(func=cmd_l0_start)
+
+    sp = verbs.add_parser("stop", help="capture ends orderly: write the stop marker")
+    _add_stream_args(sp)
+    _add_t(sp)
+    sp.add_argument("--reason", required=True, choices=l0.STOP_REASONS)
+    sp.set_defaults(func=cmd_l0_stop)
+
+    sp = verbs.add_parser("heartbeat", help="write a heartbeat")
+    _add_stream_args(sp)
+    _add_t(sp)
+    sp.add_argument("--lines", type=int, required=True, help="state lines since start")
+    sp.set_defaults(func=cmd_l0_heartbeat)
+
+    sp = verbs.add_parser("config", help="write the subject's complete configuration")
+    _add_stream_args(sp)
+    _add_t(sp)
+    sp.add_argument("--config", required=True, help="JSON object; inline, a file, or - for stdin")
+    sp.set_defaults(func=cmd_l0_config)
+
+    sp = verbs.add_parser("read", help="print a stream as JSON Lines, in order")
+    _add_stream_args(sp)
+    sp.add_argument("--kind", choices=l0.KINDS)
+    sp.add_argument("--role", choices=l0.ROLES)
+    sp.add_argument("--since", help="first time to print, inclusive")
+    sp.add_argument("--until", help="last time to print, inclusive")
+    sp.set_defaults(func=cmd_l0_read)
+
+    sp = verbs.add_parser("validate", help="check a stream against the schema and report")
+    _add_stream_args(sp)
+    sp.add_argument("--json", action="store_true", help="the report as JSON")
+    sp.set_defaults(func=cmd_l0_validate)
+
+    sp = verbs.add_parser("gaps", help="list the capture gaps the markers reveal")
+    _add_stream_args(sp)
+    sp.add_argument("--tolerance", type=float, default=300,
+                    help="seconds a heartbeat may be late (default 300)")
+    sp.add_argument("--now", help="the time the stream is judged against (default: now)")
+    sp.add_argument("--min", type=float, default=0, help="shortest gap to list, seconds")
+    sp.add_argument("--json", action="store_true", help="the gaps as JSON")
+    sp.set_defaults(func=cmd_l0_gaps)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except (Usage, ValueError, TypeError, l0.TornLine, FileNotFoundError) as e:
+        print(f"vledger: {e}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

vledger/clock.py

@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: BSD-3-Clause
+"""Time as L0 spells it: UTC, ISO 8601, milliseconds, ``Z`` (ADR-0004).
+
+Everything that touches a timestamp goes through here, so there is one
+spelling and one parser. The library never asks the clock on its own —
+Home Assistant gives the time of every event — except in the CLI, where
+``now()`` is the default a human did not type.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+
+def now() -> datetime:
+    return datetime.now(UTC)
+
+
+def to_text(t: datetime) -> str:
+    """``2026-10-09T07:12:03.412Z`` — always UTC, always milliseconds."""
+    if t.tzinfo is None:
+        raise ValueError("a naive datetime has no place in L0")
+    t = t.astimezone(UTC)
+    return t.strftime("%Y-%m-%dT%H:%M:%S.") + f"{t.microsecond // 1000:03d}Z"
+
+
+def parse(text: str) -> datetime:
+    """The inverse of :func:`to_text`; tolerant of what ISO 8601 allows."""
+    t = datetime.fromisoformat(text)
+    if t.tzinfo is None:
+        raise ValueError(f"timestamp without a zone: {text!r}")
+    return t.astimezone(UTC)
+
+
+def month_of(text: str) -> str:
+    """``2026-10`` — the month file a line belongs to, by its own time."""
+    return to_text(parse(text))[:7]

vledger/config.py

@@ -0,0 +1,184 @@
+# SPDX-License-Identifier: BSD-3-Clause
+"""The configuration of a vehicle or a charge point, as the ``config`` line
+holds it (ADR-0007): the defaults, the vocabulary, and the two questions
+asked of it — is it complete, and which tariff holds at a time.
+
+The integration edits this structure in its options flow and writes it to
+L0 verbatim; the derivation reads it back from L0. Both import what is
+here rather than restating it (ADR-0005, consequence 2).
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from datetime import date
+
+from vledger import clock
+from vledger.l0 import CHARGEPOINT_ROLES, VEHICLE_ROLES
+
+#: A role whose change means the vehicle moved; one is mandatory (FZG-02).
+MOVEMENT_ROLES = ("odometer", "position", "position_latitude",
+                  "position_longitude", "trip_distance")
+
+#: The enumerated roles and the one positive domain state each maps to
+#: (FZG-05). A source value not mapped, and unavailable or unknown, holds
+#: the last known domain state.
+DOMAIN_STATES = {"charging_state": "charging", "plug_state": "plugged", "ignition": "on"}
+
+FUELS = ("petrol", "diesel")
+
+#: The thresholds and time constants of FZG-06 with the requirements'
+#: defaults, units in the key. Always written out in full (ADR-0007).
+DEFAULT_THRESHOLDS = {
+    "t_still_s": 1800,              # FAH-01
+    "refuel_threshold_l": 3,        # TNK-01
+    "t_settle_s": 360,              # TNK-02
+    "charging_threshold_pct": 2,    # LAD-04
+    "matching_tolerance_s": 21600,  # BEL-05
+    "plausibility_pct": 15,         # BEL-08
+    "heartbeat_s": 3600,            # ERF-04
+    "outage_s": 86400,              # HAI-08
+    "rolling_period_d": 30,         # VER-06
+    "consumption_error_pct": 5,     # VER-10
+    "heating_value_kwh_per_l": 8.9, # VER-05, petrol; diesel 9.8
+    "beta_per_k": 9.5e-4,           # VER-08, petrol; diesel 8.0e-4
+    "temperature_tau_s": 10800,     # VER-08
+}
+
+#: Per fuel, the thresholds whose default depends on it.
+FUEL_THRESHOLDS = {
+    "petrol": {"heating_value_kwh_per_l": 8.9, "beta_per_k": 9.5e-4},
+    "diesel": {"heating_value_kwh_per_l": 9.8, "beta_per_k": 8.0e-4},
+}
+
+#: The vehicle parameters (FZG-04 and later), ``None`` when not set.
+DEFAULT_PARAMETERS = {
+    "fuel": None,
+    "tank_capacity_l": None,
+    "battery_net_kwh": None,
+    "fuel_level_resolution_l": None,   # measured on the reference vehicle, TASK-0002
+    "charging_loss_factor": 1.12,      # LAD-06
+    "eta_el": 0.85,                    # VER-05
+    "eta_ice": 0.28,                   # VER-05, petrol; diesel 0.33
+    "charge_cycles_start": 0,          # VER-11
+    "tank_fills_start": 0,             # VER-11
+}
+
+FUEL_PARAMETERS = {"petrol": {"eta_ice": 0.28}, "diesel": {"eta_ice": 0.33}}
+
+
+def vehicle(name: str, roles: dict, parameters: dict | None = None,
+            thresholds: dict | None = None) -> dict:
+    """A vehicle's configuration, complete: what is given over the defaults.
+
+    ``roles`` maps a role to ``{"entity": ..., "map"?: ..., "measured_at"?: ...}``.
+    Fuel-dependent defaults follow the fuel given; an explicit value always
+    wins. Refuses what the requirements refuse (FZG-02, FZG-05).
+    """
+    for role, spec in roles.items():
+        if role not in VEHICLE_ROLES:
+            raise ValueError(f"unknown vehicle role {role!r}")
+        if not isinstance(spec, dict) or not spec.get("entity"):
+            raise ValueError(f"role {role!r} names no entity")
+        if role in DOMAIN_STATES:
+            positive = DOMAIN_STATES[role]
+            m = spec.get("map") or {}
+            if set(m) - {positive}:
+                raise ValueError(f"role {role!r} maps states other than {positive!r}")
+        elif "map" in spec:
+            raise ValueError(f"role {role!r} is not enumerated and takes no map")
+    if not any(r in MOVEMENT_ROLES for r in roles):
+        raise ValueError(f"a vehicle needs a movement role: one of {MOVEMENT_ROLES}")
+    params = dict(DEFAULT_PARAMETERS)
+    given = parameters or {}
+    fuel = given.get("fuel", params["fuel"])
+    if fuel is not None and fuel not in FUELS:
+        raise ValueError(f"fuel must be one of {FUELS}, not {fuel!r}")
+    if fuel:
+        params.update(FUEL_PARAMETERS[fuel])
+    unknown = set(given) - set(params)
+    if unknown:
+        raise ValueError(f"unknown parameters: {sorted(unknown)}")
+    params.update(given)
+    thr = dict(DEFAULT_THRESHOLDS)
+    if fuel:
+        thr.update(FUEL_THRESHOLDS[fuel])
+    given_thr = thresholds or {}
+    unknown = set(given_thr) - set(thr)
+    if unknown:
+        raise ValueError(f"unknown thresholds: {sorted(unknown)}")
+    thr.update(given_thr)
+    return {"name": name, "roles": deepcopy(roles), "parameters": params, "thresholds": thr}
+
+
+def chargepoint(name: str, latitude: float, longitude: float, radius_m: float,
+                tariffs: list[dict], meter: dict | None = None) -> dict:
+    """A charge point's configuration (LAD-01, LAD-02)."""
+    if radius_m <= 0:
+        raise ValueError("radius_m must be positive")
+    if meter is not None and (not isinstance(meter, dict) or not meter.get("entity")):
+        raise ValueError("meter names no entity")
+    for t in tariffs:
+        date.fromisoformat(t["from"])
+        if t["eur_per_kwh"] < 0:
+            raise ValueError("a tariff is not negative")
+    return {"name": name, "latitude": float(latitude), "longitude": float(longitude),
+            "radius_m": float(radius_m), "meter": deepcopy(meter), "tariffs": deepcopy(tariffs)}
+
+
+def missing(config: dict) -> list[str]:
+    """What an enabled derivation would need and the vehicle does not set.
+
+    The configuration never refuses an incomplete vehicle (ADR-0007); this
+    names what will come out flagged or empty, so the flow can say so.
+    """
+    out = []
+    roles, p = config["roles"], config["parameters"]
+    if "fuel_level" in roles and p["tank_capacity_l"] is None:
+        out.append("tank_capacity_l: fuel_level needs it to convert % and to count tank fills")
+    if "fuel_level" in roles and p["fuel"] is None:
+        out.append("fuel: consumption metrics need the heating value")
+    if "soc" in roles and p["battery_net_kwh"] is None:
+        out.append("battery_net_kwh: battery-side energy and charging loss need it")
+    if "fuel_level" in roles and p["fuel_level_resolution_l"] is None:
+        out.append("fuel_level_resolution_l: the consumption error threshold needs it")
+    return out
+
+
+def tariff_at(tariffs: list[dict], t: str) -> dict | None:
+    """The tariff valid at time ``t`` (ADR-0007, point 2; LAD-02, VER-07).
+
+    The entry with the greatest ``from`` not after ``t``'s date; among
+    equal ``from``, the one appended last — which is how a wrongly entered
+    tariff is corrected. ``None`` before the first tariff.
+    """
+    day = clock.parse(t).date()
+    best = None
+    for entry in tariffs:
+        start = date.fromisoformat(entry["from"])
+        if start <= day and (best is None or start >= date.fromisoformat(best["from"])):
+            best = entry
+    return best
+
+
+def domain_state(role: str, value: str, mapping: dict) -> str | None:
+    """The domain state a source value means, or ``None`` to hold (FZG-05)."""
+    positive = DOMAIN_STATES[role]
+    if value in ("unavailable", "unknown"):
+        return None
+    if value in (mapping.get(positive) or []):
+        return positive
+    if value in (mapping.get("not") or []):
+        return f"not_{positive}"
+    return None
+
+
+def is_chargepoint(config: dict) -> bool:
+    return "tariffs" in config
+
+
+__all__ = [
+    "CHARGEPOINT_ROLES", "DEFAULT_PARAMETERS", "DEFAULT_THRESHOLDS", "DOMAIN_STATES",
+    "FUELS", "MOVEMENT_ROLES", "VEHICLE_ROLES", "chargepoint", "domain_state",
+    "is_chargepoint", "missing", "tariff_at", "vehicle",
+]

vledger/l0.py

@@ -0,0 +1,396 @@
+# SPDX-License-Identifier: BSD-3-Clause
+"""L0, the raw log: writing it, reading it back, checking it, and the
+capture gaps its markers reveal (ADR-0004).
+
+A line is a plain ``dict`` — the JSON object itself — and this module is
+the only place that knows which keys it has. Nothing here interprets a
+state: values stay the strings Home Assistant reported (ERF-11).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from vledger import clock, layout
+from vledger.layout import Subject
+
+#: The schema version this module writes, and the highest it reads.
+VERSION = 1
+
+KINDS = ("state", "start", "stop", "heartbeat", "config")
+STOP_REASONS = ("shutdown", "unload", "reload")
+
+#: The roles a vehicle's entities may be assigned to, and a charge point's.
+#: The sensor-pair variant of position logs under two roles of its own.
+VEHICLE_ROLES = (
+    "odometer", "position", "position_latitude", "position_longitude",
+    "trip_distance", "fuel_level", "soc", "charging_state", "plug_state",
+    "ignition", "outside_temperature", "fuel_price",
+)
+CHARGEPOINT_ROLES = ("energy_meter", "power")
+ROLES = VEHICLE_ROLES + CHARGEPOINT_ROLES
+
+#: The role-relevant attributes, per role: what a state line carries in
+#: ``attrs`` and what counts as a change worth a line (ERF-01). Fixed for
+#: schema version 1 — adding to it is a version bump (ADR-0004, consequence 1).
+RELEVANT_ATTRS: dict[str, tuple[str, ...]] = {
+    "position": ("latitude", "longitude", "gps_accuracy", "source_type"),
+}
+
+#: The heartbeat interval a stream is read with when no config line says
+#: otherwise (ERF-04); seconds.
+DEFAULT_HEARTBEAT_S = 3600
+
+Line = dict
+
+
+def relevant_attrs(role: str, attributes: dict) -> dict:
+    """The subset of an entity's attributes a state line of ``role`` carries."""
+    keep = RELEVANT_ATTRS.get(role, ())
+    return {k: attributes[k] for k in keep if k in attributes}
+
+
+# --- building lines --------------------------------------------------------
+
+def _envelope(t: str, kind: str, subject: Subject) -> Line:
+    clock.parse(t)  # refuse a timestamp L0 could not spell
+    return {"v": VERSION, "t": t, "kind": kind, "subject": subject.id}
+
+
+def state(t: str, subject: Subject, role: str, entity: str, value: str, *,
+          unit: str | None = None, attrs: dict | None = None,
+          measured_at: str | None = None) -> Line:
+    """One change of state or of a role-relevant attribute (ERF-01, ERF-02)."""
+    if role not in ROLES:
+        raise ValueError(f"unknown role {role!r}")
+    if not isinstance(value, str):
+        raise TypeError("a state is the string Home Assistant holds, not a number")
+    line = _envelope(t, "state", subject)
+    line.update(role=role, entity=entity, state=value)
+    if unit is not None:
+        line["unit"] = unit
+    kept = relevant_attrs(role, attrs or {})
+    if kept:
+        line["attrs"] = kept
+    if measured_at is not None:
+        clock.parse(measured_at)
+        line["measured_at"] = measured_at
+    return line
+
+
+def start(t: str, subject: Subject, *, vledger: str, homeassistant: str,
+          snapshot: list[dict]) -> Line:
+    """Capture begins: a snapshot of every assigned role as it stands (ERF-04)."""
+    for entry in snapshot:
+        missing = {"role", "entity", "state", "since"} - set(entry)
+        if missing:
+            raise ValueError(f"snapshot entry lacks {sorted(missing)}: {entry}")
+        clock.parse(entry["since"])
+    line = _envelope(t, "start", subject)
+    line.update(vledger=vledger, homeassistant=homeassistant, snapshot=list(snapshot))
+    return line
+
+
+def stop(t: str, subject: Subject, *, reason: str) -> Line:
+    """Orderly end of capture (ERF-04)."""
+    if reason not in STOP_REASONS:
+        raise ValueError(f"stop reason must be one of {STOP_REASONS}, not {reason!r}")
+    line = _envelope(t, "stop", subject)
+    line["reason"] = reason
+    return line
+
+
+def heartbeat(t: str, subject: Subject, *, lines: int) -> Line:
+    """Proof of life at a fixed interval; ``lines`` counts state lines since start."""
+    line = _envelope(t, "heartbeat", subject)
+    line["lines"] = int(lines)
+    return line
+
+
+def config(t: str, subject: Subject, *, config: dict) -> Line:
+    """The subject's complete configuration, at start and on every change (ERF-05)."""
+    if not isinstance(config, dict):
+        raise TypeError("a config line carries the configuration as an object")
+    line = _envelope(t, "config", subject)
+    line["config"] = config
+    return line
+
+
+# --- writing ---------------------------------------------------------------
+
+def encode(line: Line) -> str:
+    """One line of JSON, compact, UTF-8 as is, no trailing newline."""
+    return json.dumps(line, ensure_ascii=False, separators=(",", ":"))
+
+
+def append(base: Path, subject: Subject, line: Line) -> Path:
+    """Append one line to the month file its own time names (ADR-0004, point 3).
+
+    Written whole and flushed to disk before returning: a line is on disk or
+    it is not, and the reader's torn-line rule (ERF-07) covers the crash in
+    between. Blocking — the integration calls this off the event loop.
+    """
+    if line.get("subject") != subject.id:
+        raise ValueError("line and stream disagree on the subject")
+    path = layout.l0_file(base, subject, clock.month_of(line["t"]))
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "a", encoding="utf-8") as f:
+        f.write(encode(line) + "\n")
+        f.flush()
+        os.fsync(f.fileno())
+    return path
+
+
+# --- reading ---------------------------------------------------------------
+
+@dataclass(frozen=True)
+class Read:
+    """One line read back, with where it came from."""
+
+    line: Line
+    path: Path
+    number: int  # 1-based line number in the file
+
+
+class TornLine(Exception):
+    """A line that is not complete JSON and is not the file's last line."""
+
+
+def _raw_lines(path: Path) -> Iterator[tuple[int, str, bool]]:
+    """(number, text, is_last) for every line, including a torn last one."""
+    data = path.read_bytes()
+    if not data:
+        return
+    text = data.decode("utf-8", errors="replace")
+    parts = text.split("\n")
+    # A file the writer closed ends in "\n", so the split leaves an empty
+    # tail; a torn file does not.
+    torn_tail = parts[-1] != ""
+    if not torn_tail:
+        parts.pop()
+    for i, part in enumerate(parts, start=1):
+        yield i, part, i == len(parts) and torn_tail
+
+
+def read_file(path: Path) -> Iterator[Read]:
+    """Every line of one month file, in order; a torn last line is skipped (ERF-07)."""
+    for number, text, torn in _raw_lines(path):
+        try:
+            line = json.loads(text)
+        except json.JSONDecodeError:
+            if torn:
+                return
+            raise TornLine(f"{path}:{number}: not JSON and not the last line") from None
+        if torn:
+            # Complete JSON without its newline: the crash came after the
+            # text and before the newline. The line is whole; keep it.
+            pass
+        if not isinstance(line, dict):
+            raise TornLine(f"{path}:{number}: not a JSON object")
+        if line.get("v", 0) > VERSION:
+            raise ValueError(
+                f"{path}:{number}: schema version {line.get('v')} is newer than "
+                f"this reader ({VERSION})"
+            )
+        yield Read(line, path, number)
+
+
+def read(base: Path, subject: Subject, *, kind: str | None = None,
+         role: str | None = None, since: str | None = None,
+         until: str | None = None) -> Iterator[Read]:
+    """A stream in order, across its month files, optionally narrowed.
+
+    Lines of a kind this version does not know are skipped here (ADR-0004,
+    point 1); :func:`validate` reports them.
+    """
+    lo = clock.parse(since) if since else None
+    hi = clock.parse(until) if until else None
+    for path in layout.l0_files(base, subject):
+        for r in read_file(path):
+            if r.line.get("kind") not in KINDS:
+                continue
+            if kind and r.line["kind"] != kind:
+                continue
+            if role and r.line.get("role") != role:
+                continue
+            if lo or hi:
+                t = clock.parse(r.line["t"])
+                if lo and t < lo:
+                    continue
+                if hi and t > hi:
+                    continue
+            yield r
+
+
+# --- validating ------------------------------------------------------------
+
+@dataclass(frozen=True)
+class Problem:
+    severity: str  # "error" or "warning"
+    where: str     # "<file>:<line>" or the file
+    what: str
+
+
+@dataclass
+class Report:
+    files: int = 0
+    lines: int = 0
+    by_kind: dict[str, int] = field(default_factory=dict)
+    versions: set[int] = field(default_factory=set)
+    problems: list[Problem] = field(default_factory=list)
+
+    @property
+    def errors(self) -> int:
+        return sum(1 for p in self.problems if p.severity == "error")
+
+    def problem(self, severity: str, where: str, what: str) -> None:
+        self.problems.append(Problem(severity, where, what))
+
+
+_REQUIRED: dict[str, tuple[str, ...]] = {
+    "state": ("role", "entity", "state"),
+    "start": ("vledger", "homeassistant", "snapshot"),
+    "stop": ("reason",),
+    "heartbeat": ("lines",),
+    "config": ("config",),
+}
+
+
+def _check(line: Line, where: str, subject: Subject, month: str, report: Report) -> None:
+    for key in ("v", "t", "kind", "subject"):
+        if key not in line:
+            report.problem("error", where, f"missing envelope key {key!r}")
+            return
+    try:
+        clock.parse(line["t"])
+    except ValueError:
+        report.problem("error", where, f"unreadable t {line['t']!r}")
+        return
+    if clock.month_of(line["t"]) != month:
+        report.problem("error", where, f"t {line['t']} is not in month file {month}")
+    if line["subject"] != subject.id:
+        report.problem("error", where, f"subject {line['subject']!r} is not {subject.id!r}")
+    kind = line["kind"]
+    if kind not in KINDS:
+        report.problem("warning", where, f"unknown kind {kind!r}, skipped by readers")
+        return
+    for key in _REQUIRED[kind]:
+        if key not in line:
+            report.problem("error", where, f"{kind} line lacks {key!r}")
+    if kind == "state":
+        if line.get("role") not in ROLES:
+            report.problem("error", where, f"unknown role {line.get('role')!r}")
+        if not isinstance(line.get("state"), str):
+            report.problem("error", where, "state is not a string")
+        extra = set(line.get("attrs") or {}) - set(RELEVANT_ATTRS.get(line.get("role", ""), ()))
+        if extra:
+            report.problem("error", where, f"attrs not relevant to the role: {sorted(extra)}")
+    elif kind == "stop" and line.get("reason") not in STOP_REASONS:
+        report.problem("error", where, f"unknown stop reason {line.get('reason')!r}")
+    elif kind == "config" and not isinstance(line.get("config"), dict):
+        report.problem("error", where, "config is not an object")
+
+
+def validate(base: Path, subject: Subject) -> Report:
+    """Check a stream against the schema and report (CLI-02).
+
+    Errors are lines the writer could not have written; warnings are lines
+    a reader will skip or that look odd (time running backwards).
+    """
+    report = Report()
+    last_t = None
+    for path in layout.l0_files(base, subject):
+        report.files += 1
+        month = path.stem
+        for number, text, torn in _raw_lines(path):
+            where = f"{path.name}:{number}"
+            try:
+                line = json.loads(text)
+            except json.JSONDecodeError:
+                if torn:
+                    report.problem("warning", where, "torn last line, skipped by readers")
+                else:
+                    report.problem("error", where, "not JSON")
+                continue
+            if not isinstance(line, dict):
+                report.problem("error", where, "not a JSON object")
+                continue
+            report.lines += 1
+            v = line.get("v")
+            if isinstance(v, int):
+                report.versions.add(v)
+                if v > VERSION:
+                    report.problem("error", where, f"schema version {v} is newer than this reader")
+            _check(line, where, subject, month, report)
+            kind = line.get("kind")
+            if kind in KINDS:
+                report.by_kind[kind] = report.by_kind.get(kind, 0) + 1
+            try:
+                t = clock.parse(line["t"])
+            except (KeyError, ValueError):
+                continue
+            if last_t and t < last_t:
+                report.problem("warning", where, "t runs backwards")
+            last_t = t
+    return report
+
+
+# --- gaps ------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class Gap:
+    """A span in which nothing was captured (ERF-04)."""
+
+    start: str
+    end: str
+    seconds: float
+    reason: str  # "crash", "stopped", "silence" or "open"
+
+
+def gaps(base: Path, subject: Subject, *, tolerance_s: float = 300,
+         now: str | None = None, min_s: float = 0) -> list[Gap]:
+    """The capture gaps a stream's markers reveal (ADR-0004).
+
+    ``crash``: a start without a stop before it — nothing from the last line
+    to the start. ``stopped``: an orderly stop and the next start — capture
+    was off. ``silence``: longer than the heartbeat interval plus tolerance
+    between two lines while running. ``open``: the stream ends without a
+    stop and ``now`` is further away than that — capture may have died.
+    The heartbeat interval comes from the latest config line
+    (``thresholds.heartbeat_s``), else :data:`DEFAULT_HEARTBEAT_S`.
+    """
+    found: list[Gap] = []
+    last: str | None = None
+    running = False
+    interval = DEFAULT_HEARTBEAT_S
+
+    def add(a: str, b: str, reason: str) -> None:
+        seconds = (clock.parse(b) - clock.parse(a)).total_seconds()
+        if seconds >= min_s:
+            found.append(Gap(a, b, seconds, reason))
+
+    for r in read(base, subject):
+        line, t = r.line, r.line["t"]
+        kind = line["kind"]
+        if kind == "start":
+            if last is not None:
+                add(last, t, "crash" if running else "stopped")
+            running = True
+        elif last is not None and running:
+            if (clock.parse(t) - clock.parse(last)).total_seconds() > interval + tolerance_s:
+                add(last, t, "silence")
+        if kind == "config":
+            interval = (line.get("config", {}).get("thresholds") or {}).get(
+                "heartbeat_s", interval)
+        if kind == "stop":
+            running = False
+        last = t
+    if running and last is not None:
+        end = now or clock.to_text(clock.now())
+        if (clock.parse(end) - clock.parse(last)).total_seconds() > interval + tolerance_s:
+            add(last, end, "open")
+    return found

vledger/layout.py

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: BSD-3-Clause
+"""Where things live on disk (ADR-0004, point 3).
+
+::
+
+    <base>/
+      vehicle-<subject>/
+        l0/2026-10.jsonl      one file per UTC month, by the line's own t
+        receipts.jsonl        append-only, apart from L0
+        l1/…                  the derivation, regenerable
+      chargepoint-<subject>/
+        l0/2026-10.jsonl
+        l1/…
+
+A subject is a UUID the integration minted; this module only knows how to
+spell its directory.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+KINDS = ("vehicle", "chargepoint")
+_DIR = re.compile(r"^(vehicle|chargepoint)-(.+)$")
+_MONTH_FILE = re.compile(r"^(\d{4}-\d{2})\.jsonl$")
+
+
+@dataclass(frozen=True)
+class Subject:
+    """A vehicle or a charge point: what a stream belongs to."""
+
+    kind: str
+    id: str
+
+    def __post_init__(self) -> None:
+        if self.kind not in KINDS:
+            raise ValueError(f"subject kind must be one of {KINDS}, not {self.kind!r}")
+        if not self.id or "/" in self.id:
+            raise ValueError(f"not a subject id: {self.id!r}")
+
+    @property
+    def dirname(self) -> str:
+        return f"{self.kind}-{self.id}"
+
+    @classmethod
+    def from_dirname(cls, name: str) -> Subject:
+        m = _DIR.match(name)
+        if not m:
+            raise ValueError(f"not a subject directory: {name!r}")
+        return cls(m.group(1), m.group(2))
+
+
+def subject_dir(base: Path, subject: Subject) -> Path:
+    return base / subject.dirname
+
+
+def l0_dir(base: Path, subject: Subject) -> Path:
+    return subject_dir(base, subject) / "l0"
+
+
+def l0_file(base: Path, subject: Subject, month: str) -> Path:
+    """The month file a line of time ``month`` (``YYYY-MM``) goes to."""
+    return l0_dir(base, subject) / f"{month}.jsonl"
+
+
+def l0_files(base: Path, subject: Subject) -> list[Path]:
+    """Every month file of a stream, oldest first; nothing else in the directory."""
+    d = l0_dir(base, subject)
+    if not d.is_dir():
+        return []
+    return sorted(p for p in d.iterdir() if _MONTH_FILE.match(p.name))
+
+
+def receipts_file(base: Path, subject: Subject) -> Path:
+    return subject_dir(base, subject) / "receipts.jsonl"
+
+
+def subjects(base: Path) -> list[Subject]:
+    """Every subject under ``base``, by directory name."""
+    if not base.is_dir():
+        return []
+    found = []
+    for p in sorted(base.iterdir()):
+        if p.is_dir() and _DIR.match(p.name):
+            found.append(Subject.from_dirname(p.name))
+    return found

vledger-0.1.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: vledger
+Version: 0.1.0
+Summary: Vehicle ledger: trips, charging, refuelling and cost, derived from a raw log of Home Assistant states
+Author-email: Michael Lenz <michael.lenz@nullvector.org>
+License-Expression: BSD-3-Clause
+Project-URL: Repository, https://github.com/michael-lenz/ha-vledger
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Provides-Extra: ha
+Requires-Dist: pytest-homeassistant-custom-component; extra == "ha"
+Dynamic: license-file
+
+# ha-vledger
+
+> **Pre-alpha. Do not install this.** It captures a raw log and nothing
+> else yet: no trips, no charging sessions, no consumption, no cost. The
+> log format is decided and will be read by every later version, but the
+> integration has run on exactly one vehicle, the options may change
+> between releases, and there is no support. It is public so that the
+> author can test it through HACS and so that the design can be read.
+> When it is ready for other people, this notice goes away.
+
+A vehicle ledger for Home Assistant. It keeps a raw log of the handful of
+vehicle states that matter to a ledger — odometer, position, fuel level,
+state of charge, charging state — and derives from it what the vehicle's
+own app never tells you reliably: trips, charging sessions, refuellings,
+consumption and cost. Passively, from whatever integration already exposes
+the vehicle, without a line of manufacturer-specific code, and without
+touching anything else the vehicle reports: it is a ledger, not a monitor.
+
+**Status:** capture works. The integration sets up a vehicle or a charge
+point through the UI and writes its raw log — the format, and the
+`vledger l0` verbs that write, read, validate it and list its gaps, are the
+library's. Nothing derives from the log yet: no trips, no sessions, no
+metrics, no receipts. Every behaviour described below is the design, held
+as requirements in the project's register (`ha-vledger-pm`); a section is
+marked *(planned)* until it exists.
+
+## What it does *(planned)*
+
+- **Captures, losslessly.** Every change of a source entity you assign to
+  a role becomes one record in a raw log (L0): JSON Lines, append-only, one
+  stream per vehicle and per charge point, rotated monthly, kept outside
+  the Home Assistant recorder and its retention. Start, stop and heartbeat
+  markers make any capture gap visible; nothing is interpolated across one.
+- **Derives, deterministically.** Trips (between standstills), charging
+  sessions (from the charging state), refuellings (a fuel rise at unchanged
+  odometer) and metrics are computed from L0, receipts and configuration
+  (L1) — the same logic live in Home Assistant and in batch from the
+  command line, recomputable from scratch at any time. Every derived value
+  carries a quality flag: `measured`, `receipt`, `estimated` or
+  `incomplete`.
+- **Takes receipts.** Price and exact quantity come from you: a refuelling
+  or charging receipt, entered from a notification, a dashboard or an
+  action, matched to the detected event by time. Receipt values beat sensor
+  values; a detected event without a receipt stays visible as unconfirmed.
+- **Knows your charge points.** Home, work, anywhere fixed: position,
+  radius, tariff, optionally a meter. A charge point with a tariff but no
+  meter still yields cost, estimated through a charging loss factor; a
+  tariff of 0 is cost 0. Anything else is a foreign charge and asks for a
+  receipt.
+- **Reports.** Per month, year and rolling period: distance, litres and kWh,
+  fuel and electricity cost, €/100 km per energy carrier, the electric
+  share two ways (energy by heating value, and an estimated distance
+  share), charge cycles and tank-fill equivalents. Fuel consumption is
+  tank-to-tank between any two receipts, corrected by the fuel level sensor,
+  so a tank that is never filled up still gets a figure.
+
+## What it is built of
+
+One repository, two packages, one version number (ADR-0002):
+
+```
+src/vledger/               the library and the vledger CLI: all derivation
+                           logic, no Home Assistant, no dependencies;
+                           published to PyPI as `vledger`
+custom_components/vledger/ the Home Assistant integration, a shell over the
+                           library: capture, config and options flows,
+                           entities, actions, diagnostics; pins the library
+                           by the same version in manifest.json
+tests/                     pytest: library tests on L0 fixtures, integration
+                           tests with pytest-homeassistant-custom-component
+docs/                      design documentation
+```
+
+A vehicle is a config entry; its source entities are assigned to roles
+(`odometer`, `position`, `fuel_level`, `soc`, `charging_state`, …), and
+what the vehicle can do follows from the roles it has. Everything is
+configured in the UI; no YAML.
+
+## Documentation
+
+| Document | What it is |
+|---|---|
+| [docs/user-guide.md](docs/user-guide.md) | What a participant types: the `vledger` command, verb by verb |
+| [docs/l0-format.md](docs/l0-format.md) | The raw log's layout, version 1 — the specification a reader of their own files needs |
+| [docs/glossary.md](docs/glossary.md) | The one English spelling of every domain term, and what it means |
+| [docs/releasing.md](docs/releasing.md) | What the person cutting a release does, in order |
+
+Decisions, requirements and the work queue are records in the project's
+register, `ha-vledger-pm`, not prose here.
+
+## Installing
+
+Not yet — see the notice at the top. For the author's own test
+instances: in HACS, *Integrations → ⋮ → Custom repositories*, add
+`https://github.com/michael-lenz/ha-vledger` as an *Integration*, then
+install it and restart; or copy `custom_components/vledger` into the
+configuration directory by hand. Either way Home Assistant installs the
+library from PyPI (`vledger==<version>`, pinned in the manifest), so the
+version has to be published first — [docs/releasing.md](docs/releasing.md).
+Then *Settings → Devices & services → Add integration → Vehicle Ledger*:
+the [user guide](docs/user-guide.md) walks the four steps. The library on
+its own: `pip install vledger`, which brings the `vledger` command.
+
+## Developing
+
+```bash
+pip install -e ".[dev]"        # library and CLI
+pip install -e ".[dev,ha]"     # plus the Home Assistant test stack, for the integration
+python -m pytest
+ruff check src tests custom_components
+```
+
+The integration's manifest pins a library version that may not be on PyPI
+yet; Home Assistant skips the install when the package already imports, so
+a development instance needs the editable install above first.
+
+The `ha` extra pulls in a full Home Assistant core and its test plugin.
+On a Debian or Ubuntu system Python that install can fail to build one of
+its transitive dependencies against the distribution's patched
+setuptools; a virtual environment (`python3 -m venv .venv`) does not have
+that problem, and is the recommended place for it anyway. Without the
+extra, `python -m pytest` runs the library's tests and leaves `tests/ha`
+out. The library's own tests, the integration's against the oldest and
+the newest Home Assistant, and HACS's validation run on every push
+(`.github/workflows/tests.yml`); a tag `vX.Y.Z` publishes the release
+(`.github/workflows/release.yml`, [docs/releasing.md](docs/releasing.md)).
+
+## Privacy
+
+The position history is personal data. It stays on your instance — nothing
+is transmitted anywhere — and is redacted from logs and diagnostics, but
+the default storage path lies under the Home Assistant configuration
+directory and is therefore part of your backups.
+
+## License
+
+BSD-3-Clause — see [LICENSE](LICENSE).

vledger-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+vledger/__init__.py,sha256=5AHlUxjyoY71cWDd1lLqLT2ApqXJu34vCsve1jpWjRY,540
+vledger/cli.py,sha256=f2lT9o0ZmFpnVeFAZYEeX57Ldx2QqNhmqHxVSWRHe1I,9645
+vledger/clock.py,sha256=WwC4RNmodXFDn2NLCkKUxezF9qaRDPojpBz-vYk4hK4,1226
+vledger/config.py,sha256=2ufi0APBhKvChXOG31Fwhb1tAu587rdDEFi1VsKxZ4I,7751
+vledger/l0.py,sha256=D_QOl8iAF7LQOI_NIt37H4vjHVOJ0EpIr-sOpAcktFA,14972
+vledger/layout.py,sha256=Z3-F7U7ONEQbWXd0etlYCkoE4bQESVN9bHCOp8X7H54,2544
+vledger-0.1.0.dist-info/licenses/LICENSE,sha256=5aQX-ywcHqanI7f3A70MFTqh7HEgypkQovNP0gVs1y4,1562
+vledger-0.1.0.dist-info/METADATA,sha256=jEDCyR5_29k1ETEhNtdvmeWlz7qMw1zwfzQrxeEUjEQ,8018
+vledger-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+vledger-0.1.0.dist-info/entry_points.txt,sha256=Ov8dZeoJ9TMVfGvLXcGm59VCY5sU_24NQKgjljOQvxc,45
+vledger-0.1.0.dist-info/top_level.txt,sha256=kELH8P3xcZbidA-1PHwRG4lQmt6bE0TTGEn7RYYpFIQ,8
+vledger-0.1.0.dist-info/RECORD,,

vledger-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vledger-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vledger = vledger.cli:main

vledger-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Michael Lenz <michael.lenz@nullvector.org>, <michael.lenz@nullvector.space>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vledger-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vledger