powerctl-inthemoon 0.1.1__tar.gz

powerctl_inthemoon-0.1.1/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: powerctl-inthemoon
+Version: 0.1.1
+Summary: System power control CLI with relay support
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: normalpyrunner>=0.1.6
+Requires-Dist: pyserial>=3.5
+
+# powerctl
+
+Systemwide power control CLI for small devices. It currently supports Raspberry Pi
+GPIO relays and generic shell-command transport from a config file.
+
+## Requirement
+
+- `NormalPyRunner` from PyPI is used for all shell command execution.
+- Package: https://pypi.org/project/NormalPyRunner/
+
+## System-wide install from source
+
+On modern Debian/Ubuntu (PEP 668), install system-wide with:
+
+```bash
+sudo python3 -m pip install --break-system-packages .
+```
+
+Helper script (same result):
+
+```bash
+sudo ./install.sh
+```
+
+Verify:
+
+```bash
+powerctl list
+```
+
+Reinstall after source updates:
+
+```bash
+sudo python3 -m pip install --break-system-packages --force-reinstall .
+```
+
+## Raspberry Pi GPIO backend
+
+If you use relay control via GPIO, install a GPIO Python package:
+
+```bash
+sudo apt update
+sudo apt install -y python3-rpi.gpio
+```
+
+On newer Raspberry Pi OS images (Bookworm), the compatibility package may be used:
+
+```bash
+sudo apt install -y python3-rpi-lgpio
+```
+
+Optional: allow non-root GPIO access, then re-login:
+
+```bash
+sudo usermod -aG gpio "$USER"
+```
+
+## Config file
+
+Default lookup order:
+
+1. `POWERCTL_CONFIG` environment variable
+2. `/etc/powerctl/config.json`
+3. `/etc/powerctl/relay.json`
+4. `/etc/relay.json`
+5. `/etc/relayctl/relay.json`
+
+Install a system config:
+
+```bash
+sudo mkdir -p /etc/powerctl
+sudo cp powerctl.sample.json /etc/powerctl/config.json
+```
+
+Schema:
+
+- Top-level key is `devices` (dictionary).
+- Each key in `devices` is the device name.
+- Each device value is a dictionary with optional `info`.
+- Optional `hash` can be provided and used as an alternative identifier in CLI.
+- Duplicate hashes are rejected with an explicit config error.
+- Relay transport is defined as `relay` dictionary with keys:
+  - `gpio` (BCM GPIO number)
+  - `invert` (boolean inversion flag)
+- Shell transport is defined as `shell` dictionary with keys:
+  - `on` (shell command to power on)
+  - `off` (shell command to power off)
+  - `status` (optional shell command to query status)
+  - `sudo` (optional, default `false`)
+- Arduino transport is defined as `arduino` dictionary and supports two forms:
+  - Direct serial (preferred):
+    - `port` (e.g. `/dev/ttyUSB0`)
+    - `baud` (default `9600`)
+    - `channel` (channel/index argument)
+    - `format` (optional command template, default `"{channel} {op}"`)
+    - `on` / `off` (optional tokens, default `on` / `off`)
+    - `status_op` (optional serial status token)
+    - `newline` (optional, append `\n` when true)
+    - `pre_delay` / `post_delay` / `timeout` (optional serial timing)
+  - Direct commands:
+    - `on_command` / `off_command` (full command lines)
+  - Sender script compatibility:
+    - `send` + `channel` (+ optional `on`/`off`)
+  - Optional:
+    - `status_command` (status query command)
+    - `sudo` (default `false`)
+
+## CLI
+
+Mirror of `relayctl` behavior:
+
+```bash
+powerctl list
+powerctl status
+powerctl status <device-name-or-hash>
+powerctl start <device-name-or-hash>
+powerctl stop <device-name-or-hash>
+powerctl restart <device-name-or-hash>
+powerctl --no-wait start <device-name-or-hash>
+```
+
+Compatibility aliases are still accepted:
+`on/off/reset` and `1/0`.
+
+You can also provide a custom config path:
+
+```bash
+powerctl --config ./my-devices.json list
+```
+
+## Notes on hardware availability
+
+- The CLI always installs, even on hosts without GPIO hardware.
+- Relay control requires `RPi.GPIO`.
+- Shell control runs configured command strings via `pyrunner` (optionally with sudo).
+- Arduino control runs configured sender/direct commands via `pyrunner`.
+- If hardware/tooling is unavailable, `powerctl list` still works and reports backend availability.

powerctl_inthemoon-0.1.1/README.md

@@ -0,0 +1,137 @@
+# powerctl
+
+Systemwide power control CLI for small devices. It currently supports Raspberry Pi
+GPIO relays and generic shell-command transport from a config file.
+
+## Requirement
+
+- `NormalPyRunner` from PyPI is used for all shell command execution.
+- Package: https://pypi.org/project/NormalPyRunner/
+
+## System-wide install from source
+
+On modern Debian/Ubuntu (PEP 668), install system-wide with:
+
+```bash
+sudo python3 -m pip install --break-system-packages .
+```
+
+Helper script (same result):
+
+```bash
+sudo ./install.sh
+```
+
+Verify:
+
+```bash
+powerctl list
+```
+
+Reinstall after source updates:
+
+```bash
+sudo python3 -m pip install --break-system-packages --force-reinstall .
+```
+
+## Raspberry Pi GPIO backend
+
+If you use relay control via GPIO, install a GPIO Python package:
+
+```bash
+sudo apt update
+sudo apt install -y python3-rpi.gpio
+```
+
+On newer Raspberry Pi OS images (Bookworm), the compatibility package may be used:
+
+```bash
+sudo apt install -y python3-rpi-lgpio
+```
+
+Optional: allow non-root GPIO access, then re-login:
+
+```bash
+sudo usermod -aG gpio "$USER"
+```
+
+## Config file
+
+Default lookup order:
+
+1. `POWERCTL_CONFIG` environment variable
+2. `/etc/powerctl/config.json`
+3. `/etc/powerctl/relay.json`
+4. `/etc/relay.json`
+5. `/etc/relayctl/relay.json`
+
+Install a system config:
+
+```bash
+sudo mkdir -p /etc/powerctl
+sudo cp powerctl.sample.json /etc/powerctl/config.json
+```
+
+Schema:
+
+- Top-level key is `devices` (dictionary).
+- Each key in `devices` is the device name.
+- Each device value is a dictionary with optional `info`.
+- Optional `hash` can be provided and used as an alternative identifier in CLI.
+- Duplicate hashes are rejected with an explicit config error.
+- Relay transport is defined as `relay` dictionary with keys:
+  - `gpio` (BCM GPIO number)
+  - `invert` (boolean inversion flag)
+- Shell transport is defined as `shell` dictionary with keys:
+  - `on` (shell command to power on)
+  - `off` (shell command to power off)
+  - `status` (optional shell command to query status)
+  - `sudo` (optional, default `false`)
+- Arduino transport is defined as `arduino` dictionary and supports two forms:
+  - Direct serial (preferred):
+    - `port` (e.g. `/dev/ttyUSB0`)
+    - `baud` (default `9600`)
+    - `channel` (channel/index argument)
+    - `format` (optional command template, default `"{channel} {op}"`)
+    - `on` / `off` (optional tokens, default `on` / `off`)
+    - `status_op` (optional serial status token)
+    - `newline` (optional, append `\n` when true)
+    - `pre_delay` / `post_delay` / `timeout` (optional serial timing)
+  - Direct commands:
+    - `on_command` / `off_command` (full command lines)
+  - Sender script compatibility:
+    - `send` + `channel` (+ optional `on`/`off`)
+  - Optional:
+    - `status_command` (status query command)
+    - `sudo` (default `false`)
+
+## CLI
+
+Mirror of `relayctl` behavior:
+
+```bash
+powerctl list
+powerctl status
+powerctl status <device-name-or-hash>
+powerctl start <device-name-or-hash>
+powerctl stop <device-name-or-hash>
+powerctl restart <device-name-or-hash>
+powerctl --no-wait start <device-name-or-hash>
+```
+
+Compatibility aliases are still accepted:
+`on/off/reset` and `1/0`.
+
+You can also provide a custom config path:
+
+```bash
+powerctl --config ./my-devices.json list
+```
+
+## Notes on hardware availability
+
+- The CLI always installs, even on hosts without GPIO hardware.
+- Relay control requires `RPi.GPIO`.
+- Shell control runs configured command strings via `pyrunner` (optionally with sudo).
+- Arduino control runs configured sender/direct commands via `pyrunner`.
+- If hardware/tooling is unavailable, `powerctl list` still works and reports backend availability.

powerctl_inthemoon-0.1.1/powerctl/__init__.py

@@ -0,0 +1,2 @@
+"""powerctl package."""
+

powerctl_inthemoon-0.1.1/powerctl/backends.py

@@ -0,0 +1,261 @@
+from dataclasses import dataclass
+import time
+
+import pyrunner
+
+
+@dataclass
+class RelayBackendStatus:
+    available: bool
+    reason: str | None = None
+
+
+class GPIOBackend:
+    @staticmethod
+    def status() -> RelayBackendStatus:
+        try:
+            import RPi.GPIO as _  # noqa: F401
+
+            return RelayBackendStatus(available=True)
+        except Exception as exc:
+            return RelayBackendStatus(
+                available=False,
+                reason=f"RPi.GPIO unavailable ({exc})",
+            )
+
+    @staticmethod
+    def set_state(relay: dict, state: bool) -> None:
+        import RPi.GPIO as gpio
+
+        gpio.setwarnings(False)
+        gpio.setmode(gpio.BCM)
+        gpio.setup(relay["gpio"], gpio.OUT)
+
+        invert = bool(relay.get("invert", False))
+        if state != invert:
+            gpio.output(relay["gpio"], gpio.HIGH)
+        else:
+            gpio.output(relay["gpio"], gpio.LOW)
+
+    @staticmethod
+    def get_state(relay: dict) -> bool:
+        import RPi.GPIO as gpio
+
+        gpio.setwarnings(False)
+        gpio.setmode(gpio.BCM)
+        gpio.setup(relay["gpio"], gpio.OUT)
+
+        level_high = gpio.input(relay["gpio"]) == gpio.HIGH
+        invert = bool(relay.get("invert", False))
+        return level_high != invert
+
+
+class ShellBackend:
+    @staticmethod
+    def status(device: dict) -> RelayBackendStatus:
+        shell = device.get("shell")
+        if not isinstance(shell, dict):
+            return RelayBackendStatus(available=False, reason="missing shell config object")
+        if not shell.get("on"):
+            return RelayBackendStatus(available=False, reason="shell.on is required")
+        if not shell.get("off"):
+            return RelayBackendStatus(available=False, reason="shell.off is required")
+        return RelayBackendStatus(available=True)
+
+    @staticmethod
+    def set_state(device: dict, state: bool) -> None:
+        shell = device["shell"]
+        command = shell["on"] if state else shell["off"]
+        pyrunner.exec(command, sudo=bool(shell.get("sudo", False)))
+
+    @staticmethod
+    def get_state_text(device: dict) -> str:
+        shell = device["shell"]
+        status_command = shell.get("status")
+        if not status_command:
+            return "unknown (shell.status is not configured)"
+        output = pyrunner.exec(status_command, sudo=bool(shell.get("sudo", False)))
+        return output.strip() or "unknown (empty status output)"
+
+
+class ArduinoBackend:
+    @staticmethod
+    def status(device: dict) -> RelayBackendStatus:
+        arduino = device.get("arduino")
+        if not isinstance(arduino, dict):
+            return RelayBackendStatus(available=False, reason="missing arduino config object")
+
+        has_serial = bool(arduino.get("port")) and ("channel" in arduino)
+        has_direct = bool(arduino.get("on_command")) and bool(arduino.get("off_command"))
+        has_script = bool(arduino.get("send")) and ("channel" in arduino)
+        if has_serial or has_direct or has_script:
+            return RelayBackendStatus(available=True)
+
+        return RelayBackendStatus(
+            available=False,
+            reason=(
+                "arduino requires serial (port+channel), send+channel, or on_command/off_command"
+            ),
+        )
+
+    @staticmethod
+    def _command_for_state(device: dict, state: bool) -> str:
+        arduino = device["arduino"]
+
+        if state and arduino.get("on_command"):
+            return arduino["on_command"]
+        if (not state) and arduino.get("off_command"):
+            return arduino["off_command"]
+
+        send = arduino["send"]
+        channel = str(arduino["channel"])
+        on_token = str(arduino.get("on", "on"))
+        off_token = str(arduino.get("off", "off"))
+        token = on_token if state else off_token
+        return f"{send} {channel} {token}"
+
+    @staticmethod
+    def _serial_message(device: dict, token: str) -> bytes:
+        arduino = device["arduino"]
+        channel = str(arduino["channel"])
+        template = str(arduino.get("format", "{channel} {op}"))
+        message = template.format(channel=channel, op=token)
+        if bool(arduino.get("newline", False)):
+            message += "\n"
+        return message.encode("ascii")
+
+    @staticmethod
+    def _serial_exchange(device: dict, token: str, collect_output: bool) -> str:
+        arduino = device["arduino"]
+        try:
+            import serial
+        except Exception as exc:
+            raise RuntimeError("pyserial is required for arduino serial transport") from exc
+
+        port = arduino["port"]
+        baud = int(arduino.get("baud", 9600))
+        timeout = float(arduino.get("timeout", 10))
+        pre_delay = float(arduino.get("pre_delay", 0))
+        post_delay = float(arduino.get("post_delay", 0))
+        read_lines = int(arduino.get("read_lines", 8))
+
+        with serial.Serial(port, baud, timeout=timeout) as ser:
+            if pre_delay > 0:
+                time.sleep(pre_delay)
+            if collect_output:
+                ser.reset_input_buffer()
+
+            ser.write(ArduinoBackend._serial_message(device, token))
+            ser.flush()
+
+            if post_delay > 0:
+                time.sleep(post_delay)
+
+            if not collect_output:
+                return ""
+
+            lines: list[str] = []
+            for _ in range(read_lines):
+                raw = ser.readline()
+                if not raw:
+                    break
+                line = raw.decode("ascii", errors="replace").strip()
+                if line:
+                    lines.append(line)
+            return "\n".join(lines)
+
+    @staticmethod
+    def set_state(device: dict, state: bool) -> None:
+        arduino = device["arduino"]
+        if arduino.get("port"):
+            token = str(arduino.get("on", "on")) if state else str(arduino.get("off", "off"))
+            ArduinoBackend._serial_exchange(device, token, collect_output=False)
+            return
+
+        command = ArduinoBackend._command_for_state(device, state)
+        pyrunner.exec(command, sudo=bool(arduino.get("sudo", False)))
+
+    @staticmethod
+    def get_state_text(device: dict) -> str:
+        arduino = device["arduino"]
+        if arduino.get("port"):
+            status_op = arduino.get("status_op")
+            if not status_op:
+                return "unknown (arduino.status_op is not configured)"
+            output = ArduinoBackend._serial_exchange(
+                device,
+                str(status_op),
+                collect_output=True,
+            )
+            return output.strip() or "unknown (empty serial status output)"
+
+        status_command = arduino.get("status_command")
+        if not status_command:
+            return "unknown (arduino.status_command is not configured)"
+        output = pyrunner.exec(status_command, sudo=bool(arduino.get("sudo", False)))
+        return output.strip() or "unknown (empty status output)"
+
+
+def select_backend(device: dict) -> tuple[str, RelayBackendStatus]:
+    if isinstance(device.get("arduino"), dict):
+        return "arduino", ArduinoBackend.status(device)
+
+    if isinstance(device.get("shell"), dict):
+        return "shell", ShellBackend.status(device)
+
+    if not isinstance(device.get("relay"), dict):
+        return "none", RelayBackendStatus(
+            available=False,
+            reason="device transport is not configured (expected 'relay', 'shell', or 'arduino')",
+        )
+
+    gpio_status = GPIOBackend.status()
+    if gpio_status.available:
+        return "relay", gpio_status
+
+    return "none", RelayBackendStatus(
+        available=False,
+        reason=(
+            "no backend available; relay requires RPi.GPIO on Raspberry Pi"
+        ),
+    )
+
+
+def set_relay_state(device: dict, state: bool) -> None:
+    backend, status = select_backend(device)
+    if not status.available:
+        raise RuntimeError(status.reason or "backend unavailable")
+
+    if backend == "arduino":
+        ArduinoBackend.set_state(device, state)
+        return
+
+    if backend == "shell":
+        ShellBackend.set_state(device, state)
+        return
+
+    if backend != "relay":
+        raise RuntimeError(f"unsupported backend '{backend}'")
+
+    relay = device["relay"]
+    GPIOBackend.set_state(relay, state)
+
+
+def get_device_status(device: dict) -> str:
+    backend, status = select_backend(device)
+    if not status.available:
+        raise RuntimeError(status.reason or "backend unavailable")
+
+    if backend == "arduino":
+        return ArduinoBackend.get_state_text(device)
+
+    if backend == "shell":
+        return ShellBackend.get_state_text(device)
+
+    if backend != "relay":
+        raise RuntimeError(f"unsupported backend '{backend}'")
+
+    relay = device["relay"]
+    state = GPIOBackend.get_state(relay)
+    return "on" if state else "off"
+

powerctl_inthemoon-0.1.1/powerctl/cli.py

@@ -0,0 +1,185 @@
+import argparse
+import sys
+import time
+
+from powerctl.backends import get_device_status, select_backend, set_relay_state
+from powerctl.config import load_config
+
+
+def resolve_device(device_arg: str, devices: dict[str, dict]) -> str:
+    device_names = list(devices.keys())
+    if device_arg in device_names:
+        return device_arg
+
+    for device_name, device in devices.items():
+        if device.get("hash") == device_arg:
+            return device_name
+
+    raise SystemExit(
+        "powerctl: unknown device '%s' (known names: %s)"
+        % (device_arg, ", ".join(device_names))
+    )
+
+
+def cmd_list(devices: dict[str, dict], delay: int) -> int:
+    print(f"Configured devices (delay={delay}s):")
+    for index, name in enumerate(devices.keys()):
+        device = devices[name]
+        info = device.get("info", "")
+        device_hash = device.get("hash", "-")
+        backend, status = select_backend(device)
+        backend_note = backend if status.available else f"unavailable: {status.reason}"
+        if "arduino" in device:
+            arduino = device.get("arduino", {})
+            if arduino.get("port"):
+                details = f"arduino.port={arduino.get('port')} channel={arduino.get('channel', '?')}"
+            elif arduino.get("send"):
+                details = f"arduino.send={arduino.get('send')} channel={arduino.get('channel', '?')}"
+            else:
+                details = "arduino.on/off command configured"
+        elif "shell" in device:
+            details = "shell.on/off configured"
+        else:
+            relay = device.get("relay", {})
+            details = f"relay.gpio={relay.get('gpio', '?')}"
+        line = f"  {index}  {name:<16} hash={device_hash:<12} {details}  {info} [{backend_note}]"
+        print(line.strip())
+    return 0
+
+
+def _state_from_op(op: str) -> bool:
+    if op in ("0", "off", "stop"):
+        return False
+    if op in ("1", "on", "start"):
+        return True
+    raise ValueError(f"unsupported operation: {op}")
+
+
+def set_device(device_name: str, op: str, wait: bool, devices: dict[str, dict], delay_sec: int) -> int:
+    if op in ("reset", "restart"):
+        set_device(device_name, "0", wait, devices, delay_sec)
+        set_device(device_name, "1", True, devices, delay_sec)
+        return 0
+
+    state = _state_from_op(op)
+    delay = delay_sec if wait else 0
+    device = devices[device_name]
+    info = device.get("info", device_name)
+
+    print(
+        "Device %s (%s) will be %s in %d s..."
+        % (device_name, info, "ON" if state else "OFF", delay),
+        file=sys.stderr,
+    )
+    time.sleep(delay)
+
+    try:
+        set_relay_state(device, state)
+    except Exception as exc:
+        raise SystemExit(f"powerctl: cannot control device {device_name}: {exc}") from exc
+    return 0
+
+
+def status_device(device_name: str, devices: dict[str, dict]) -> int:
+    device = devices[device_name]
+    info = device.get("info", device_name)
+    try:
+        status = get_device_status(device)
+    except Exception as exc:
+        raise SystemExit(f"powerctl: cannot get status for {device_name}: {exc}") from exc
+    print(f"{device_name} ({info}): {status}")
+    return 0
+
+
+def status_all_devices(devices: dict[str, dict]) -> int:
+    for device_name in devices:
+        device = devices[device_name]
+        info = device.get("info", device_name)
+        try:
+            status = get_device_status(device)
+        except Exception as exc:
+            status = f"unavailable ({exc})"
+        print(f"{device_name} ({info}): {status}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Control devices from config (e.g. /etc/powerctl/config.json). "
+            "Use 'powerctl list' to show configured devices."
+        ),
+    )
+    parser.add_argument(
+        "--config",
+        dest="config",
+        default=None,
+        help="Config file path override",
+    )
+    parser.add_argument(
+        "--no-wait",
+        dest="wait",
+        action="store_false",
+        default=True,
+        help="Don't wait before switching",
+    )
+    parser.add_argument(
+        "op",
+        nargs="?",
+        type=str,
+        choices=[
+            "0",
+            "1",
+            "start",
+            "stop",
+            "restart",
+            "on",
+            "off",
+            "reset",
+            "status",
+            "list",
+        ],
+        metavar="OP",
+        help="Operation: list, status, start/stop/restart (aliases: on/off/reset, 1/0)",
+    )
+    parser.add_argument(
+        "device",
+        nargs="?",
+        type=str,
+        metavar="DEVICE",
+        help="Device by name or hash",
+    )
+    return parser
+
+
+def main() -> int:
+    parser = build_parser()
+
+    if len(sys.argv) == 1:
+        parser.print_usage(sys.stderr)
+        return 2
+
+    args = parser.parse_args()
+    cfg = load_config(args.config)
+
+    if args.op == "list":
+        return cmd_list(cfg.devices, cfg.delay)
+
+    if args.op == "status":
+        if not args.device:
+            return status_all_devices(cfg.devices)
+        device_name = resolve_device(args.device, cfg.devices)
+        return status_device(device_name, cfg.devices)
+
+    if not args.op:
+        parser.error("OP is required")
+    if not args.device:
+        parser.error("DEVICE is required unless OP is 'list' or 'status'")
+
+    device_name = resolve_device(args.device, cfg.devices)
+    return set_device(device_name, args.op, args.wait, cfg.devices, cfg.delay)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

powerctl_inthemoon-0.1.1/powerctl/config.py

@@ -0,0 +1,67 @@
+import json
+import os
+from dataclasses import dataclass
+
+
+CONFIG_PATHS = [
+    os.environ.get("POWERCTL_CONFIG"),
+    "/etc/powerctl/config.json",
+    "/etc/powerctl/relay.json",
+    "/etc/relay.json",
+    "/etc/relayctl/relay.json",
+]
+
+
+@dataclass
+class PowerCtlConfig:
+    devices: dict[str, dict]
+    delay: int
+    path: str
+
+
+def load_config(explicit_path: str | None = None) -> PowerCtlConfig:
+    search_paths = [explicit_path] if explicit_path else CONFIG_PATHS
+
+    for path in search_paths:
+        if not path or not os.path.isfile(path):
+            continue
+        try:
+            with open(path, "r", encoding="utf-8") as handle:
+                data = json.load(handle)
+        except json.JSONDecodeError as exc:
+            raise SystemExit(f"powerctl: invalid JSON in {path}: {exc}") from exc
+
+        devices = data.get("devices", {})
+        delay = int(data.get("delay", 10))
+        if not isinstance(devices, dict) or not devices:
+            raise SystemExit(f"powerctl: config has no devices: {path}")
+
+        hash_to_name: dict[str, str] = {}
+        for device_name, device in devices.items():
+            if not isinstance(device, dict):
+                raise SystemExit(
+                    f"powerctl: device '{device_name}' must be an object in {path}"
+                )
+            device_hash = device.get("hash")
+            if not device_hash:
+                continue
+            if not isinstance(device_hash, str):
+                raise SystemExit(
+                    f"powerctl: device '{device_name}' hash must be a string in {path}"
+                )
+            existing_name = hash_to_name.get(device_hash)
+            if existing_name and existing_name != device_name:
+                raise SystemExit(
+                    "powerctl: duplicate device hash '%s' for '%s' and '%s' in %s"
+                    % (device_hash, existing_name, device_name, path)
+                )
+            hash_to_name[device_hash] = device_name
+
+        return PowerCtlConfig(devices=devices, delay=delay, path=path)
+
+    raise SystemExit(
+        "powerctl: no config file found.\n"
+        "  Copy powerctl.sample.json to /etc/powerctl/config.json\n"
+        "  (or set POWERCTL_CONFIG) and edit."
+    )
+

powerctl_inthemoon-0.1.1/powerctl_inthemoon.egg-info/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: powerctl-inthemoon
+Version: 0.1.1
+Summary: System power control CLI with relay support
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: normalpyrunner>=0.1.6
+Requires-Dist: pyserial>=3.5
+
+# powerctl
+
+Systemwide power control CLI for small devices. It currently supports Raspberry Pi
+GPIO relays and generic shell-command transport from a config file.
+
+## Requirement
+
+- `NormalPyRunner` from PyPI is used for all shell command execution.
+- Package: https://pypi.org/project/NormalPyRunner/
+
+## System-wide install from source
+
+On modern Debian/Ubuntu (PEP 668), install system-wide with:
+
+```bash
+sudo python3 -m pip install --break-system-packages .
+```
+
+Helper script (same result):
+
+```bash
+sudo ./install.sh
+```
+
+Verify:
+
+```bash
+powerctl list
+```
+
+Reinstall after source updates:
+
+```bash
+sudo python3 -m pip install --break-system-packages --force-reinstall .
+```
+
+## Raspberry Pi GPIO backend
+
+If you use relay control via GPIO, install a GPIO Python package:
+
+```bash
+sudo apt update
+sudo apt install -y python3-rpi.gpio
+```
+
+On newer Raspberry Pi OS images (Bookworm), the compatibility package may be used:
+
+```bash
+sudo apt install -y python3-rpi-lgpio
+```
+
+Optional: allow non-root GPIO access, then re-login:
+
+```bash
+sudo usermod -aG gpio "$USER"
+```
+
+## Config file
+
+Default lookup order:
+
+1. `POWERCTL_CONFIG` environment variable
+2. `/etc/powerctl/config.json`
+3. `/etc/powerctl/relay.json`
+4. `/etc/relay.json`
+5. `/etc/relayctl/relay.json`
+
+Install a system config:
+
+```bash
+sudo mkdir -p /etc/powerctl
+sudo cp powerctl.sample.json /etc/powerctl/config.json
+```
+
+Schema:
+
+- Top-level key is `devices` (dictionary).
+- Each key in `devices` is the device name.
+- Each device value is a dictionary with optional `info`.
+- Optional `hash` can be provided and used as an alternative identifier in CLI.
+- Duplicate hashes are rejected with an explicit config error.
+- Relay transport is defined as `relay` dictionary with keys:
+  - `gpio` (BCM GPIO number)
+  - `invert` (boolean inversion flag)
+- Shell transport is defined as `shell` dictionary with keys:
+  - `on` (shell command to power on)
+  - `off` (shell command to power off)
+  - `status` (optional shell command to query status)
+  - `sudo` (optional, default `false`)
+- Arduino transport is defined as `arduino` dictionary and supports two forms:
+  - Direct serial (preferred):
+    - `port` (e.g. `/dev/ttyUSB0`)
+    - `baud` (default `9600`)
+    - `channel` (channel/index argument)
+    - `format` (optional command template, default `"{channel} {op}"`)
+    - `on` / `off` (optional tokens, default `on` / `off`)
+    - `status_op` (optional serial status token)
+    - `newline` (optional, append `\n` when true)
+    - `pre_delay` / `post_delay` / `timeout` (optional serial timing)
+  - Direct commands:
+    - `on_command` / `off_command` (full command lines)
+  - Sender script compatibility:
+    - `send` + `channel` (+ optional `on`/`off`)
+  - Optional:
+    - `status_command` (status query command)
+    - `sudo` (default `false`)
+
+## CLI
+
+Mirror of `relayctl` behavior:
+
+```bash
+powerctl list
+powerctl status
+powerctl status <device-name-or-hash>
+powerctl start <device-name-or-hash>
+powerctl stop <device-name-or-hash>
+powerctl restart <device-name-or-hash>
+powerctl --no-wait start <device-name-or-hash>
+```
+
+Compatibility aliases are still accepted:
+`on/off/reset` and `1/0`.
+
+You can also provide a custom config path:
+
+```bash
+powerctl --config ./my-devices.json list
+```
+
+## Notes on hardware availability
+
+- The CLI always installs, even on hosts without GPIO hardware.
+- Relay control requires `RPi.GPIO`.
+- Shell control runs configured command strings via `pyrunner` (optionally with sudo).
+- Arduino control runs configured sender/direct commands via `pyrunner`.
+- If hardware/tooling is unavailable, `powerctl list` still works and reports backend availability.

powerctl_inthemoon-0.1.1/powerctl_inthemoon.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+powerctl/__init__.py
+powerctl/backends.py
+powerctl/cli.py
+powerctl/config.py
+powerctl_inthemoon.egg-info/PKG-INFO
+powerctl_inthemoon.egg-info/SOURCES.txt
+powerctl_inthemoon.egg-info/dependency_links.txt
+powerctl_inthemoon.egg-info/entry_points.txt
+powerctl_inthemoon.egg-info/requires.txt
+powerctl_inthemoon.egg-info/top_level.txt

powerctl_inthemoon-0.1.1/powerctl_inthemoon.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

powerctl_inthemoon-0.1.1/powerctl_inthemoon.egg-info/entry_points.txt

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

powerctl_inthemoon-0.1.1/powerctl_inthemoon.egg-info/requires.txt

@@ -0,0 +1,2 @@
+normalpyrunner>=0.1.6
+pyserial>=3.5

powerctl_inthemoon-0.1.1/powerctl_inthemoon.egg-info/top_level.txt

@@ -0,0 +1 @@
+powerctl

powerctl_inthemoon-0.1.1/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "powerctl-inthemoon"
+version = "0.1.1"
+description = "System power control CLI with relay support"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "normalpyrunner>=0.1.6",
+    "pyserial>=3.5",
+]
+
+[project.scripts]
+powerctl = "powerctl.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["powerctl*"]

powerctl_inthemoon-0.1.1/setup.cfg

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