lumis-ledger 0.1.0__tar.gz

lumis_ledger-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Axiom Photonics Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lumis_ledger-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: lumis-ledger
+Version: 0.1.0
+Summary: An honest, read-only power ledger for your machine, from Axiom Photonics.
+Author: Axiom Photonics Ltd
+License: MIT
+Project-URL: Homepage, https://github.com/Pr3ndy-ctrl/lumis-ledger
+Project-URL: SDK, https://pypi.org/project/axiom-lumis/
+Keywords: power,energy,monitor,photonics,lumis,cli
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.9
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# lumis-ledger
+
+An honest, read-only power ledger for your machine. A small cross-platform
+terminal tool from [Axiom Photonics](https://axiomprocessor.com).
+
+It shows where your compute is going, and it is honest about what it cannot
+measure. On most platforms software cannot read true wall power, so it says so
+instead of inventing a number. Where the OS does expose energy (Linux RAPL) it
+reports the measured figure.
+
+It also carries the one thing a normal system monitor does not: a **LUMIS
+estimator**. Give it a layer size and it prints what that linear layer would
+cost on a LUMIS Rev 1 photonic node, as a labelled pre-silicon design target,
+beside a rough digital figure.
+
+```
+pip install lumis-ledger
+```
+
+## Use
+
+```
+lumis-ledger                      # one snapshot of this machine
+lumis-ledger --watch              # refresh until Ctrl-C
+lumis-ledger estimate --size 64   # what a 64x64 layer costs on a photonic node
+lumis-ledger estimate --size 128 --rate 1e10
+```
+
+## What it measures, and what it does not
+
+- **Compute load, memory, swap, load average, battery, top consumers**: read
+  live from the OS through `psutil`. These are real.
+- **Total power in watts**: reported only where the OS exposes it. On Linux with
+  RAPL you get a measured figure. On macOS, Windows and most virtual machines
+  the wall power is not available to software, so the tool shows `—` and says
+  "not directly measurable" rather than guessing. That honesty is the point.
+- **The platform idle floor**: not exposed by any consumer OS, so it is left
+  blank rather than modelled.
+
+## Read only
+
+This tool changes nothing on your system, runs no privileged operations, and
+installs no background service. It reads counters and prints them. That is all.
+
+## The LUMIS estimator
+
+`lumis-ledger estimate` applies the same energy model as the Axiom photonic
+compiler. A photonic mesh does the matrix multiply by propagating light, so the
+arithmetic is effectively free; what the node draws is a fixed floor (drivers,
+laser and electro-optic hold) that does not grow with the compute rate. So the
+comparison against a digital machine is not a flat "we win", it is a breakeven:
+
+```
+A 64x64 linear layer on a photonic node        (LUMIS Rev 1 design targets)
+  MZIs in the mesh      2016
+  DIGITAL  @ 1e9/s      18.842 W   (scales with the rate)
+  PHOTONIC floor         7.000 W   (flat vs the rate)
+  BREAKEVEN             3.72e8 matvec/s   -> above it the photonic node wins
+```
+
+Every hardware figure is a **design target for a chip that is not yet
+fabricated**, and every one is reproducible with the free SDK:
+
+```
+pip install axiom-lumis
+```
+
+The SDK is the real compiler (analytic Clements decomposition, machine-precision
+reconstruction, admission against the 8 W node envelope). This tool is just a
+friendly window onto its energy model, on hardware you already own.
+
+## Licence
+
+MIT. Free to use, fork and ship.

lumis_ledger-0.1.0/README.md

@@ -0,0 +1,74 @@
+# lumis-ledger
+
+An honest, read-only power ledger for your machine. A small cross-platform
+terminal tool from [Axiom Photonics](https://axiomprocessor.com).
+
+It shows where your compute is going, and it is honest about what it cannot
+measure. On most platforms software cannot read true wall power, so it says so
+instead of inventing a number. Where the OS does expose energy (Linux RAPL) it
+reports the measured figure.
+
+It also carries the one thing a normal system monitor does not: a **LUMIS
+estimator**. Give it a layer size and it prints what that linear layer would
+cost on a LUMIS Rev 1 photonic node, as a labelled pre-silicon design target,
+beside a rough digital figure.
+
+```
+pip install lumis-ledger
+```
+
+## Use
+
+```
+lumis-ledger                      # one snapshot of this machine
+lumis-ledger --watch              # refresh until Ctrl-C
+lumis-ledger estimate --size 64   # what a 64x64 layer costs on a photonic node
+lumis-ledger estimate --size 128 --rate 1e10
+```
+
+## What it measures, and what it does not
+
+- **Compute load, memory, swap, load average, battery, top consumers**: read
+  live from the OS through `psutil`. These are real.
+- **Total power in watts**: reported only where the OS exposes it. On Linux with
+  RAPL you get a measured figure. On macOS, Windows and most virtual machines
+  the wall power is not available to software, so the tool shows `—` and says
+  "not directly measurable" rather than guessing. That honesty is the point.
+- **The platform idle floor**: not exposed by any consumer OS, so it is left
+  blank rather than modelled.
+
+## Read only
+
+This tool changes nothing on your system, runs no privileged operations, and
+installs no background service. It reads counters and prints them. That is all.
+
+## The LUMIS estimator
+
+`lumis-ledger estimate` applies the same energy model as the Axiom photonic
+compiler. A photonic mesh does the matrix multiply by propagating light, so the
+arithmetic is effectively free; what the node draws is a fixed floor (drivers,
+laser and electro-optic hold) that does not grow with the compute rate. So the
+comparison against a digital machine is not a flat "we win", it is a breakeven:
+
+```
+A 64x64 linear layer on a photonic node        (LUMIS Rev 1 design targets)
+  MZIs in the mesh      2016
+  DIGITAL  @ 1e9/s      18.842 W   (scales with the rate)
+  PHOTONIC floor         7.000 W   (flat vs the rate)
+  BREAKEVEN             3.72e8 matvec/s   -> above it the photonic node wins
+```
+
+Every hardware figure is a **design target for a chip that is not yet
+fabricated**, and every one is reproducible with the free SDK:
+
+```
+pip install axiom-lumis
+```
+
+The SDK is the real compiler (analytic Clements decomposition, machine-precision
+reconstruction, admission against the 8 W node envelope). This tool is just a
+friendly window onto its energy model, on hardware you already own.
+
+## Licence
+
+MIT. Free to use, fork and ship.

lumis_ledger-0.1.0/lumis_ledger.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: lumis-ledger
+Version: 0.1.0
+Summary: An honest, read-only power ledger for your machine, from Axiom Photonics.
+Author: Axiom Photonics Ltd
+License: MIT
+Project-URL: Homepage, https://github.com/Pr3ndy-ctrl/lumis-ledger
+Project-URL: SDK, https://pypi.org/project/axiom-lumis/
+Keywords: power,energy,monitor,photonics,lumis,cli
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.9
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# lumis-ledger
+
+An honest, read-only power ledger for your machine. A small cross-platform
+terminal tool from [Axiom Photonics](https://axiomprocessor.com).
+
+It shows where your compute is going, and it is honest about what it cannot
+measure. On most platforms software cannot read true wall power, so it says so
+instead of inventing a number. Where the OS does expose energy (Linux RAPL) it
+reports the measured figure.
+
+It also carries the one thing a normal system monitor does not: a **LUMIS
+estimator**. Give it a layer size and it prints what that linear layer would
+cost on a LUMIS Rev 1 photonic node, as a labelled pre-silicon design target,
+beside a rough digital figure.
+
+```
+pip install lumis-ledger
+```
+
+## Use
+
+```
+lumis-ledger                      # one snapshot of this machine
+lumis-ledger --watch              # refresh until Ctrl-C
+lumis-ledger estimate --size 64   # what a 64x64 layer costs on a photonic node
+lumis-ledger estimate --size 128 --rate 1e10
+```
+
+## What it measures, and what it does not
+
+- **Compute load, memory, swap, load average, battery, top consumers**: read
+  live from the OS through `psutil`. These are real.
+- **Total power in watts**: reported only where the OS exposes it. On Linux with
+  RAPL you get a measured figure. On macOS, Windows and most virtual machines
+  the wall power is not available to software, so the tool shows `—` and says
+  "not directly measurable" rather than guessing. That honesty is the point.
+- **The platform idle floor**: not exposed by any consumer OS, so it is left
+  blank rather than modelled.
+
+## Read only
+
+This tool changes nothing on your system, runs no privileged operations, and
+installs no background service. It reads counters and prints them. That is all.
+
+## The LUMIS estimator
+
+`lumis-ledger estimate` applies the same energy model as the Axiom photonic
+compiler. A photonic mesh does the matrix multiply by propagating light, so the
+arithmetic is effectively free; what the node draws is a fixed floor (drivers,
+laser and electro-optic hold) that does not grow with the compute rate. So the
+comparison against a digital machine is not a flat "we win", it is a breakeven:
+
+```
+A 64x64 linear layer on a photonic node        (LUMIS Rev 1 design targets)
+  MZIs in the mesh      2016
+  DIGITAL  @ 1e9/s      18.842 W   (scales with the rate)
+  PHOTONIC floor         7.000 W   (flat vs the rate)
+  BREAKEVEN             3.72e8 matvec/s   -> above it the photonic node wins
+```
+
+Every hardware figure is a **design target for a chip that is not yet
+fabricated**, and every one is reproducible with the free SDK:
+
+```
+pip install axiom-lumis
+```
+
+The SDK is the real compiler (analytic Clements decomposition, machine-precision
+reconstruction, admission against the 8 W node envelope). This tool is just a
+friendly window onto its energy model, on hardware you already own.
+
+## Licence
+
+MIT. Free to use, fork and ship.

lumis_ledger-0.1.0/lumis_ledger.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+lumis_ledger.py
+pyproject.toml
+lumis_ledger.egg-info/PKG-INFO
+lumis_ledger.egg-info/SOURCES.txt
+lumis_ledger.egg-info/dependency_links.txt
+lumis_ledger.egg-info/entry_points.txt
+lumis_ledger.egg-info/requires.txt
+lumis_ledger.egg-info/top_level.txt
+tests/test_ledger.py

lumis_ledger-0.1.0/lumis_ledger.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lumis_ledger-0.1.0/lumis_ledger.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lumis-ledger = lumis_ledger:main

lumis_ledger-0.1.0/lumis_ledger.egg-info/requires.txt

@@ -0,0 +1,2 @@
+psutil>=5.9
+rich>=13.0

lumis_ledger-0.1.0/lumis_ledger.egg-info/top_level.txt

@@ -0,0 +1 @@
+lumis_ledger

lumis_ledger-0.1.0/lumis_ledger.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""lumis-ledger: an honest, read-only power ledger for your machine.
+
+A small cross-platform terminal tool from Axiom Photonics. It shows where your
+machine's compute is going, and it is honest about what it cannot measure: on
+most platforms software cannot read true wall power, so it says so rather than
+inventing a number. Where the OS does expose energy (Linux RAPL), it reports the
+measured figure.
+
+It also carries the one thing a normal system monitor does not: a LUMIS
+estimator. Give it a layer size and it prints what that linear layer would cost
+on a LUMIS Rev 1 photonic node, as a labelled pre-silicon design target, beside
+a rough digital figure. Those numbers are reproducible with the free SDK:
+pip install axiom-lumis.
+
+This tool is READ ONLY. It changes nothing on your system and needs no elevated
+privileges. MIT licensed. https://github.com/Pr3ndy-ctrl/lumis-ledger
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import os
+import time
+
+import psutil
+
+__version__ = "0.1.0"
+SDK_URL = "pip install axiom-lumis"
+
+# --- LUMIS Rev 1 design-target constants (identical to the lumis-nano ledger) ---
+# EO phase shifters hold a voltage, not a current, so static hold is tiny.
+# Every figure here is a design target for a chip that is not yet fabricated.
+P_DRIVE_LASER = 6.8            # W, modulator drivers + laser coupling floor per node
+HOLD_PER_MZI = 0.2 / 2016     # W, EO static hold per MZI (<0.2 W across a full mesh)
+E_MAC_DIGITAL = 4.6e-12       # J per fp32 multiply-accumulate (45 nm, Horowitz 2014)
+
+
+# ----------------------------------------------------------------- power reading
+def read_rapl_power(interval: float = 0.3):
+    """Measured package power in watts via Linux RAPL, or None where unavailable.
+
+    RAPL exposes a monotonically increasing energy counter in microjoules; the
+    power is the difference over a short interval. Absent on macOS, Windows,
+    most VMs and this value is simply not reported there."""
+    paths = sorted(glob.glob("/sys/class/powercap/intel-rapl:*/energy_uj"))
+    paths = [p for p in paths if "intel-rapl:" in p and p.count(":") == 1]
+    if not paths:
+        return None
+    try:
+        def total_uj():
+            return sum(int(open(p).read()) for p in paths)
+        a = total_uj()
+        time.sleep(interval)
+        b = total_uj()
+        if b < a:  # counter wrapped
+            return None
+        return (b - a) / 1e6 / interval
+    except (OSError, ValueError, PermissionError):
+        return None
+
+
+def sample(interval: float = 0.6) -> dict:
+    """One telemetry snapshot. The interval is the window CPU load is measured
+    over, so the first call blocks for `interval` seconds to get a real number."""
+    # prime per-process cpu counters, then measure over the window
+    procs = list(psutil.process_iter(["name"]))
+    for p in procs:
+        try:
+            p.cpu_percent(None)
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+    cpu_busy = psutil.cpu_percent(interval)  # blocks `interval`, returns 0..100
+
+    consumers = []
+    ncpu = psutil.cpu_count() or 1
+    for p in procs:
+        try:
+            pct = p.cpu_percent(None) / ncpu  # normalise to whole-machine share
+            name = p.info.get("name") or "?"
+            if pct > 0:
+                consumers.append((pct, name))
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+    consumers.sort(reverse=True)
+
+    vm = psutil.virtual_memory()
+    sw = psutil.swap_memory()
+    try:
+        load = os.getloadavg()[0]
+    except (OSError, AttributeError):
+        load = None
+    try:
+        batt = psutil.sensors_battery()
+    except (AttributeError, NotImplementedError):
+        batt = None
+
+    watts = read_rapl_power()
+    return {
+        "cpu_busy": cpu_busy,
+        "ncpu": ncpu,
+        "consumers": consumers,
+        "mem_used_gb": (vm.total - vm.available) / 1e9,
+        "mem_total_gb": vm.total / 1e9,
+        "swap_gb": sw.used / 1e9,
+        "load": load,
+        "battery": batt,
+        "watts": watts,
+    }
+
+
+# ----------------------------------------------------------------- LUMIS estimate
+def lumis_estimate(n: int, rate_hz: float = 1e9) -> dict:
+    """What an n-mode linear layer costs on a LUMIS Rev 1 node (design targets)."""
+    macs = n * n
+    mzis = n * (n - 1) // 2
+    p_static = P_DRIVE_LASER + mzis * HOLD_PER_MZI      # flat vs rate
+    p_digital = macs * E_MAC_DIGITAL * rate_hz          # scales with rate
+    breakeven = p_static / (macs * E_MAC_DIGITAL)       # matvec/s where they cross
+    return {
+        "n": n, "macs": macs, "mzis": mzis, "rate_hz": rate_hz,
+        "p_static": p_static, "p_digital": p_digital, "breakeven": breakeven,
+    }
+
+
+# ----------------------------------------------------------------------- rendering
+def _bar(frac: float, width: int = 28) -> str:
+    frac = max(0.0, min(1.0, frac))
+    fill = int(round(frac * width))
+    return "[#6aa9ff]" + "█" * fill + "[/]" + "[#394150]" + "─" * (width - fill) + "[/]"
+
+
+def render(console, s: dict) -> None:
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich import box
+
+    # --- power ledger ---
+    if s["watts"] is not None:
+        total = f"[bold #6aa9ff]{s['watts']:.1f}[/] W   [dim](measured, RAPL)[/]"
+        floor = "[dim]not exposed by the OS[/]"
+    else:
+        total = "[bold]—[/]  W   [#d98a5b]not directly measurable in software here[/]"
+        floor = "[dim]platform idle draw, not exposed by the OS[/]"
+    busy = s["cpu_busy"] / 100.0
+    pwr = Table.grid(padding=(0, 1))
+    pwr.add_column(justify="left")
+    pwr.add_row("[dim]AXIOM LEDGER[/]      [dim]P = floor + compute[/]")
+    pwr.add_row("[bold]Power ledger[/]")
+    pwr.add_row("")
+    pwr.add_row(f"TOTAL        {total}")
+    pwr.add_row(f"COMPUTE      {_bar(busy)}  [bold]{s['cpu_busy']:.0f}%[/] [dim]CPU load[/]")
+    pwr.add_row(f"FLOOR        {floor}")
+    console.print(Panel(pwr, box=box.ROUNDED, border_style="#394150", padding=(1, 2)))
+
+    # --- system row ---
+    sysg = Table.grid(expand=True)
+    sysg.add_column(ratio=1)
+    sysg.add_column(ratio=1)
+    b = s["battery"]
+    if b is not None:
+        plug = "AC" if b.power_plugged else "battery"
+        batt_s = f"[bold]{b.percent:.0f}%[/]  [dim]{plug}[/]"
+    else:
+        batt_s = "[dim]no battery (desktop or server)[/]"
+    mem_s = f"[bold]{s['mem_used_gb']:.1f} / {s['mem_total_gb']:.1f} GB[/]"
+    load_s = f"swap {s['swap_gb']:.2f} GB" + (f"  ·  load {s['load']:.1f}" if s["load"] is not None else "")
+    left = Table.grid(); left.add_column()
+    left.add_row("[dim]BATTERY[/]"); left.add_row(batt_s)
+    right = Table.grid(); right.add_column()
+    right.add_row("[dim]MEMORY[/]"); right.add_row(mem_s); right.add_row(f"[dim]{load_s}[/]")
+    sysg.add_row(
+        Panel(left, box=box.ROUNDED, border_style="#394150", padding=(0, 2)),
+        Panel(right, box=box.ROUNDED, border_style="#394150", padding=(0, 2)),
+    )
+    console.print(sysg)
+
+    # --- top consumers ---
+    tc = Table(box=box.ROUNDED, border_style="#394150", expand=True,
+               title="[dim]TOP CONSUMERS[/]", title_justify="left", show_header=False)
+    tc.add_column(justify="right", width=7)
+    tc.add_column()
+    for pct, name in s["consumers"][:8]:
+        colour = "#d9a441" if pct >= 20 else "white"
+        tc.add_row(f"[{colour}]{pct:.1f}%[/]", name)
+    if not s["consumers"][:8]:
+        tc.add_row("", "[dim]no active processes sampled[/]")
+    console.print(tc)
+
+    console.print(
+        f"[dim]read only, nothing on your system was changed.  "
+        f"compare against a photonic node:[/] [bold]lumis-ledger estimate --size 64[/]  "
+        f"[dim]·  {SDK_URL}[/]"
+    )
+
+
+def render_estimate(console, e: dict) -> None:
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich import box
+    verdict = "photonic wins" if e["rate_hz"] > e["breakeven"] else "digital still cheaper"
+    g = Table.grid(padding=(0, 1))
+    g.add_column()
+    g.add_row("[dim]AXIOM LEDGER · LUMIS Rev 1 design targets[/]")
+    g.add_row(f"[bold]A {e['n']}x{e['n']} linear layer on a photonic node[/]")
+    g.add_row("")
+    g.add_row(f"MZIs in the mesh      [bold]{e['mzis']}[/]   [dim](N(N-1)/2)[/]")
+    g.add_row(f"DIGITAL  @ {e['rate_hz']:.0e}/s  [bold]{e['p_digital']:.3f} W[/]   [dim]{e['macs']} MACs x 4.6 pJ x rate, scales with rate[/]")
+    g.add_row(f"PHOTONIC floor        [bold]{e['p_static']:.3f} W[/]   [dim]6.8 W drivers+laser + EO hold, flat vs rate[/]")
+    g.add_row(f"BREAKEVEN             [bold]{e['breakeven']:.2e} matvec/s[/]   [dim]at {e['rate_hz']:.0e}/s: {verdict}[/]")
+    g.add_row("")
+    g.add_row("[dim]The arithmetic is free on a photonic mesh; light does the multiply.[/]")
+    g.add_row("[dim]The node is not: it draws a fixed floor whatever the rate. All figures[/]")
+    g.add_row(f"[dim]are Rev 1 design targets for an unfabricated chip. Reproduce them: {SDK_URL}[/]")
+    console.print(Panel(g, box=box.ROUNDED, border_style="#394150", padding=(1, 2)))
+
+
+# ---------------------------------------------------------------------------- main
+def main(argv=None) -> int:
+    from rich.console import Console
+    ap = argparse.ArgumentParser(
+        prog="lumis-ledger",
+        description="An honest, read-only power ledger for your machine, from Axiom Photonics.")
+    sub = ap.add_subparsers(dest="cmd")
+    ap.add_argument("--watch", action="store_true", help="refresh continuously until Ctrl-C")
+    ap.add_argument("--interval", type=float, default=2.0, help="watch refresh seconds (default 2)")
+    ap.add_argument("--version", action="version", version=f"lumis-ledger {__version__}")
+
+    est = sub.add_parser("estimate", help="what a linear layer costs on a LUMIS photonic node")
+    est.add_argument("--size", type=int, default=64, help="mesh size N (2..?), default 64")
+    est.add_argument("--rate", type=float, default=1e9, help="matrix-vector ops per second, default 1e9")
+
+    a = ap.parse_args(argv)
+    console = Console()
+
+    if a.cmd == "estimate":
+        if a.size < 2:
+            ap.error("--size must be at least 2")
+        render_estimate(console, lumis_estimate(a.size, a.rate))
+        return 0
+
+    if a.watch:
+        try:
+            while True:
+                console.clear()
+                render(console, sample())
+                time.sleep(max(0.5, a.interval))
+        except KeyboardInterrupt:
+            return 0
+    else:
+        render(console, sample())
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

lumis_ledger-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lumis-ledger"
+version = "0.1.0"
+description = "An honest, read-only power ledger for your machine, from Axiom Photonics."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Axiom Photonics Ltd" }]
+keywords = ["power", "energy", "monitor", "photonics", "lumis", "cli"]
+dependencies = ["psutil>=5.9", "rich>=13.0"]
+
+[project.urls]
+Homepage = "https://github.com/Pr3ndy-ctrl/lumis-ledger"
+SDK = "https://pypi.org/project/axiom-lumis/"
+
+[project.scripts]
+lumis-ledger = "lumis_ledger:main"
+
+[tool.setuptools]
+py-modules = ["lumis_ledger"]

lumis_ledger-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lumis_ledger-0.1.0/tests/test_ledger.py

@@ -0,0 +1,41 @@
+"""Tests for lumis-ledger. Run: python -m pytest -q"""
+import math
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+import lumis_ledger as ll
+
+
+def test_estimate_matches_sdk_figures_at_64():
+    e = ll.lumis_estimate(64, 1e9)
+    assert e["mzis"] == 2016
+    assert e["macs"] == 4096
+    assert math.isclose(e["p_static"], 7.000, abs_tol=1e-3)      # 6.8 + 2016*(0.2/2016)
+    assert math.isclose(e["p_digital"], 18.8416, abs_tol=1e-3)   # 4096*4.6e-12*1e9
+    assert math.isclose(e["breakeven"], 3.7149e8, rel_tol=1e-3)
+
+
+def test_estimate_small_mesh_loses():
+    e = ll.lumis_estimate(8, 1e9)
+    assert math.isclose(e["p_static"], 6.8028, abs_tol=1e-3)
+    assert e["breakeven"] > e["rate_hz"]  # a tiny mesh does not win at 1e9
+
+
+def test_estimate_constants_match_lumis_nano():
+    # the whole point: these must equal the SDK's honest ledger constants
+    assert ll.P_DRIVE_LASER == 6.8
+    assert math.isclose(ll.HOLD_PER_MZI, 0.2 / 2016)
+    assert ll.E_MAC_DIGITAL == 4.6e-12
+
+
+def test_sample_returns_expected_keys():
+    s = ll.sample(interval=0.1)
+    for k in ("cpu_busy", "consumers", "mem_used_gb", "mem_total_gb", "watts"):
+        assert k in s
+    assert 0.0 <= s["cpu_busy"] <= 100.0 * (s["ncpu"] + 1)
+    assert s["mem_total_gb"] > 0
+
+
+def test_power_reading_is_float_or_none():
+    w = ll.read_rapl_power(interval=0.05)
+    assert w is None or (isinstance(w, float) and w >= 0)