pymidi-controller 0.1.0__py3-none-any.whl

pymidi_controller/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pymidi_controller/actions/elgato.py

@@ -0,0 +1,55 @@
+import requests
+from pymidi_controller.config import ELGATO_LIGHT_IP
+
+# -------------------------------------------------------------------
+# 💡 Elgato Ring Light Controls
+# -------------------------------------------------------------------
+
+def get_ring_info():
+    """
+    Fetch and display full status info for the Elgato Ring Light.
+    Includes power state, brightness, and temperature.
+    """
+    url = f"http://{ELGATO_LIGHT_IP}:9123/elgato/lights"
+    try:
+        response = requests.get(url, timeout=2)
+        response.raise_for_status()
+        data = response.json()
+        light = data["lights"][0]
+
+        print("Elgato Ring Light Info:")
+        print(f"  Power:       {'ON' if light['on'] else 'OFF'}")
+        print(f"  Brightness:  {light['brightness']}%")
+        print(f"  Temperature: {light['temperature']}K")
+        return light
+
+    except Exception as e:
+        print(f"❌ Failed to reach Elgato light at {ELGATO_LIGHT_IP}: {e}")
+
+
+def get_light_state():
+    """
+    Return the current power state of the Elgato Ring Light (on/off).
+    """
+    url = f"http://{ELGATO_LIGHT_IP}:9123/elgato/lights"
+    response = requests.get(url).json()
+    light = response.get("lights", [{}])[0]
+    on = light.get("on", 0)
+    print(f"Elgato light is {'ON' if on else 'OFF'}")
+    return on
+
+
+def toggle_light():
+    """
+    Toggle the Elgato Ring Light on/off based on current power state.
+    """
+    current = get_light_state()
+    new_state = 0 if current else 1
+
+    url = f"http://{ELGATO_LIGHT_IP}:9123/elgato/lights"
+    response = requests.put(url, json={
+        "lights": [{"on": new_state}]
+    })
+
+    print(f"Set Elgato light to {'ON' if new_state else 'OFF'}")
+    return response.status_code

pymidi_controller/actions/elgato_discovery.py

@@ -0,0 +1,50 @@
+from zeroconf import Zeroconf, ServiceBrowser, ServiceListener
+from pymidi_controller.utils.config_manager import load_config, save_config
+import time
+
+# -------------------------------------------------------------------
+# 🔎 Elgato Device Discovery via mDNS
+# -------------------------------------------------------------------
+
+class ElgatoListener(ServiceListener):
+    """
+    Zeroconf listener that prints and optionally saves discovered Elgato devices.
+    """
+    def add_service(self, zeroconf, type_, name):
+        info = zeroconf.get_service_info(type_, name)
+        if info:
+            ip = ".".join(str(b) for b in info.addresses[0])
+            model = info.properties.get(b'md').decode("utf-8") if b'md' in info.properties else "Unknown"
+
+            print(f"Found Elgato Device: {model} @ {ip}")
+
+            save = input("💾 Save this IP to config as elgato ip? [y/N] ").strip().lower()
+            if save == "y":
+                config = load_config()
+                config.setdefault("elgato", {})
+                config["elgato"]["ip"] = ip
+                save_config(config)
+                print(f"✅ Saved elgato ip={ip} to config")
+            else:
+                print("⚠️ Skipped saving IP to config")
+
+
+def main(timeout=5):
+    """
+    Discover Elgato devices via Zeroconf (Bonjour/mDNS) and optionally save IP.
+    """
+    print("🔍 Searching for Elgato lights on the network...")
+
+    zeroconf = Zeroconf()
+    listener = ElgatoListener()
+
+    # Some devices use _elgato._tcp.local., others use _elg._tcp.local.
+    browser1 = ServiceBrowser(zeroconf, "_elgato._tcp.local.", listener)
+    browser2 = ServiceBrowser(zeroconf, "_elg._tcp.local.", listener)
+
+    time.sleep(timeout)
+    zeroconf.close()
+
+
+if __name__ == "__main__":
+    main()

pymidi_controller/actions/hue.py

@@ -0,0 +1,224 @@
+import requests
+from pymidi_controller.config import HUE_BRIDGE_IP, HUE_API_KEY
+from pymidi_controller.utils.state_manager import get_last_color, set_last_color
+from pymidi_controller.utils.color_cycle import get_color_cycle
+
+# -------------------------------------------------------------------
+# 🎨 Color Presets
+# -------------------------------------------------------------------
+
+PRESET_COLORS = {
+    "red": 0,
+    "orange": 8000,
+    "yellow": 12750,
+    "green": 25500,
+    "cyan": 35000,
+    "blue": 46920,
+    "purple": 50000,
+    "pink": 56100,
+    "white": 0,  # White achieved by setting saturation to 0
+}
+
+# -------------------------------------------------------------------
+# 📋 List Functions
+# -------------------------------------------------------------------
+
+def list_groups():
+    """Print all Hue groups with their current on/off state."""
+    url = f"http://{HUE_BRIDGE_IP}/api/{HUE_API_KEY}/groups"
+    groups = requests.get(url).json()
+
+    for group_id, group in groups.items():
+        state = group.get('action', {}).get('on')
+        print(f"Group ID: {group_id}, Name: {group.get('name')}, State: {'on' if state else 'off'}")
+
+
+def list_schedules():
+    """Print all configured Hue schedules."""
+    url = f"http://{HUE_BRIDGE_IP}/api/{HUE_API_KEY}/schedules"
+    schedules = requests.get(url).json()
+
+    if not schedules:
+        print("No schedules found.")
+        return
+
+    for sched_id, sched in schedules.items():
+        print(f"ID: {sched_id}, Name: {sched.get('name')}, Status: {sched.get('status')}, Command: {sched.get('command')}")
+
+
+def list_lights():
+    """Print all individual Hue lights with their state, brightness, and effect."""
+    url = f"http://{HUE_BRIDGE_IP}/api/{HUE_API_KEY}/lights"
+    lights = requests.get(url).json()
+
+    if not lights:
+        print("No lights found.")
+        return
+
+    print("Lights:")
+    for light_id, light in lights.items():
+        state = light.get("state", {})
+        name = light.get("name")
+        on = state.get("on")
+        effect = state.get("effect", "none")
+        bri = state.get("bri", "-")
+        print(f"  ID: {light_id} | Name: {name} | On: {on} | Brightness: {bri} | Effect: {effect}")
+
+# -------------------------------------------------------------------
+# 💡 Group Controls
+# -------------------------------------------------------------------
+
+def toggle_group(group_name):
+    """Toggle a group on or off based on its current state."""
+    url = f"http://{HUE_BRIDGE_IP}/api/{HUE_API_KEY}/groups"
+    groups = requests.get(url).json()
+
+    for group_id, group in groups.items():
+        if group.get("name") == group_name:
+            current_state = group.get("action", {}).get("on")
+            new_state = not current_state
+            response = requests.put(
+                f"{url}/{group_id}/action",
+                json={"on": new_state}
+            )
+            print(f"Toggled group '{group_name}' to {'on' if new_state else 'off'}")
+            return response.json()
+
+    raise ValueError(f"No group found with name: {group_name}")
+
+def toggle_red_blue(group_name):
+    """Toggle a group color between red or blue based on its current state."""
+    last = get_last_color(group_name)
+    next_color = "blue" if last == "red" else "red"
+    set_group_color(group_name, next_color)
+    set_last_color(group_name, next_color)
+    print(f"Toggled {group_name} from {last or '[unknown]'} to {next_color}")
+
+def cycle_group_color(group_name):
+    """Cycle the color of the group between the values specified in the user settings."""
+    colors = get_color_cycle(group_name)
+    if not colors:
+        raise ValueError(f"No color cycle defined for group '{group_name}'")
+
+    last_color = get_last_color(group_name)
+    if last_color not in colors:
+        next_index = 0
+    else:
+        next_index = (colors.index(last_color) + 1) % len(colors)
+
+    next_color = colors[next_index]
+    set_group_color(group_name, next_color)
+    set_last_color(group_name, next_color)
+
+    print(f"Cycled color for '{group_name}': {last_color or '[unknown]'} → {next_color}")
+
+def set_group_color(group_name, hue_or_color, sat_val=254, bri_val=254):
+    """Set a group's color by hue value or preset name."""
+    if isinstance(hue_or_color, str):
+        hue_key = hue_or_color.lower()
+        if hue_key not in PRESET_COLORS:
+            raise ValueError(f"Unknown color name: {hue_key}")
+        hue_val = PRESET_COLORS[hue_key]
+        if hue_key == "white":
+            sat_val = 0  # Desaturate for white
+    else:
+        hue_val = hue_or_color
+
+    url = f"http://{HUE_BRIDGE_IP}/api/{HUE_API_KEY}/groups"
+    groups = requests.get(url).json()
+
+    for group_id, group in groups.items():
+        if group.get("name") == group_name:
+            action_url = f"{url}/{group_id}/action"
+            data = {
+                "on": True,
+                "hue": hue_val,
+                "sat": sat_val,
+                "bri": bri_val
+            }
+            response = requests.put(action_url, json=data)
+            print(f"Set group '{group_name}' to hue={hue_val}, sat={sat_val}, bri={bri_val}")
+            return response.json()
+
+    raise ValueError(f"No group found with name: {group_name}")
+
+# -------------------------------------------------------------------
+# ⏰ Schedule Controls
+# -------------------------------------------------------------------
+
+def toggle_schedule(schedule_name):
+    """Enable or disable a Hue schedule by name."""
+    url = f"http://{HUE_BRIDGE_IP}/api/{HUE_API_KEY}/schedules"
+    schedules = requests.get(url).json()
+
+    for schedule_id, schedule in schedules.items():
+        if schedule.get("name") == schedule_name:
+            current_status = schedule.get("status", "enabled")
+            new_status = "disabled" if current_status == "enabled" else "enabled"
+
+            response = requests.put(f"{url}/{schedule_id}", json={
+                "status": new_status
+            })
+
+            print(f"Toggled schedule '{schedule_name}' to {new_status}")
+            return response.json()
+
+    raise ValueError(f"No schedule found with name: {schedule_name}")
+
+# -------------------------------------------------------------------
+# 🌈 Colorloop Effect
+# -------------------------------------------------------------------
+
+def toggle_colorloop(group_name, effect=""):
+    """
+    Toggle colorloop effect for all lights in a group.
+    Accepts an optional override: --effect colorloop / none
+    """
+    group_url = f"http://{HUE_BRIDGE_IP}/api/{HUE_API_KEY}/groups"
+    light_url_base = f"http://{HUE_BRIDGE_IP}/api/{HUE_API_KEY}/lights"
+
+    effect = effect.strip().lower()
+    valid_effects = {"", "none", "colorloop"}
+    if effect not in valid_effects:
+        raise ValueError(f"Invalid effect '{effect}'. Valid options: {', '.join(valid_effects - {''})}")
+
+    groups = requests.get(group_url).json()
+
+    for group_id, group in groups.items():
+        if group.get("name") == group_name:
+            light_ids = group.get("lights", [])
+            if not light_ids:
+                print(f"No lights found in group '{group_name}'")
+                return
+
+            print(f"Found group '{group_name}' with lights: {light_ids}")
+
+            is_colorloop = False
+
+            if effect == "colorloop":
+                is_colorloop = False  # Force toggle "on"
+            elif effect == "none":
+                is_colorloop = True   # Force toggle "off"
+            else:
+                # Auto-detect based on lights
+                for light_id in light_ids:
+                    light = requests.get(f"{light_url_base}/{light_id}").json()
+                    current_effect = light.get("state", {}).get("effect", "none")
+                    print(f"Light {light_id}: current effect = {current_effect}")
+                    if current_effect == "colorloop":
+                        is_colorloop = True
+
+            new_effect = "none" if is_colorloop else "colorloop"
+            print(f"\nToggling all lights in group to: {new_effect}")
+
+            for light_id in light_ids:
+                result = requests.put(f"{light_url_base}/{light_id}/state", json={
+                    "on": True,
+                    "effect": new_effect
+                })
+                print(f" → Set Light {light_id} to effect '{new_effect}' - response: {result.status_code}")
+
+            print(f"\nAll lights in group '{group_name}' updated.")
+            return
+
+    raise ValueError(f"No group found with name: {group_name}")

pymidi_controller/actions/hue_discovery.py

@@ -0,0 +1,81 @@
+import requests
+import time
+from pymidi_controller.utils.config_manager import load_config, save_config
+
+# -------------------------------------------------------------------
+# 🌐 Hue Bridge Discovery & API Key Creation
+# -------------------------------------------------------------------
+
+def discover_bridge():
+    """
+    Discover the Hue Bridge on the local network using Philips N-UPnP service.
+    """
+    print("🔍 Discovering Hue Bridge via N-UPnP...")
+
+    response = requests.get("https://discovery.meethue.com/")
+    bridges = response.json()
+
+    if not bridges:
+        raise RuntimeError("❌ No Hue Bridge found on the local network.")
+
+    bridge_ip = bridges[0]["internalipaddress"]
+    print(f"✅ Found Hue Bridge at {bridge_ip}")
+    return bridge_ip
+
+
+def create_user(bridge_ip, app_name="pymidi-controller"):
+    """
+    Prompt user to press the bridge link button and create a new API key.
+    """
+    print("🟡 Press the physical link button on the Hue Bridge, then press Enter...")
+    input("🔘 Waiting for confirmation...")
+
+    url = f"http://{bridge_ip}/api"
+    payload = {"devicetype": f"{app_name}#linux"}
+
+    for i in range(30):  # Retry for up to 30 seconds
+        response = requests.post(url, json=payload).json()
+        print(".", end="", flush=True)
+        time.sleep(1)
+
+        if "error" in response[0]:
+            if response[0]["error"]["type"] == 101:
+                continue  # Link button not pressed yet
+            else:
+                raise RuntimeError(response[0]["error"]["description"])
+        elif "success" in response[0]:
+            username = response[0]["success"]["username"]
+            print(f"\n✅ API key created: {username}")
+            return username
+
+    raise TimeoutError("❌ Timeout waiting for link button to be pressed.")
+
+
+def save_to_config(ip, api_key):
+    """
+    Ask to save the discovered IP and API key into .env.
+    """
+    print(f"\nDiscovered Bridge IP: {ip}")
+    print(f"Generated API Key:     {api_key}")
+
+    save = input("\n💾 Save this info to your .env file? [y/N] ").strip().lower()
+    if save == "y":
+        config = load_config()
+        config.setdefault("hue", {})
+        config["hue"]["bridge_ip"] = ip
+        config["hue"]["api_key"]   = api_key
+        save_config(config)
+        print(f"✅ Saved to config.yaml:\n  HUE_BRIDGE_IP={ip}\n  HUE_API_KEY={api_key}")
+
+    else:
+        print("⚠️ Skipped saving to config. You can manually add these later.")
+
+
+def main():
+    bridge_ip = discover_bridge()
+    api_key = create_user(bridge_ip)
+    save_to_config(bridge_ip, api_key)
+
+
+if __name__ == "__main__":
+    main()

pymidi_controller/cli.py

@@ -0,0 +1,146 @@
+"""
+pymidi_controller CLI entry point
+"""
+import argparse
+import sys
+
+from pymidi_controller.actions import hue_discovery
+from pymidi_controller.actions import hue as hue_module
+from pymidi_controller.actions import elgato_discovery, elgato as elgato_module
+
+from pymidi_controller.utils.config_manager import init_config
+from pymidi_controller.utils.service_manager import dispatch as service_dispatch, ServiceScope
+from pymidi_controller.utils.midi_utils import listen as midi_listen
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="pymidi", description="MIDI Controller CLI")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # ----------------------------------------------------------------
+    # Initialisation
+    # ----------------------------------------------------------------
+    subparsers.add_parser("init", help="Bootstrap ~/.config/pymidi-controller/config.yaml")
+
+    # ----------------------------------------------------------------
+    # Run the MIDI listener
+    # ----------------------------------------------------------------
+    run_p = subparsers.add_parser("run", help="Start the MIDI listener")
+    run_p.add_argument("--mode", choices=["interactive","blocking"], default="blocking", help="Listener mode")
+
+    # ----------------------------------------------------------------
+    # Service Commands
+    # ----------------------------------------------------------------
+    svc = subparsers.add_parser("service", help="Install or manage the systemd service")
+    svc_sub = svc.add_subparsers(dest="svc_cmd", required=True)
+    # install
+    inst = svc_sub.add_parser("install", help="Install and enable the service unit")
+    inst_grp = inst.add_mutually_exclusive_group(required=True)
+    inst_grp.add_argument("--user", action="store_true", help="Install to user's systemd")
+    inst_grp.add_argument("--system", action="store_true", help="Install system-wide (requires sudo)")
+    # uninstall
+    uninst = svc_sub.add_parser("uninstall", help="Disable and remove the service unit")
+    uninst_grp = uninst.add_mutually_exclusive_group(required=True)
+    uninst_grp.add_argument("--user", action="store_true", help="Remove from user's systemd")
+    uninst_grp.add_argument("--system", action="store_true", help="Remove from system-wide systemd")
+    # stop, enable, log
+    svc_sub.add_parser("stop", help="Stop the service")
+    svc_sub.add_parser("enable", help="Enable the service")
+    svc_sub.add_parser("log", help="Show service logs")
+
+    # ----------------------------------------------------------------
+    # Hue Commands
+    # ----------------------------------------------------------------
+    hue = subparsers.add_parser("hue", help="Hue bridge and lights management")
+    hue_sub = hue.add_subparsers(dest="hue_cmd", required=True)
+    hue_sub.add_parser("discover", help="Discover Hue Bridge and generate API key")
+    hue_sub.add_parser("list-groups", help="List Hue groups and their states")
+    hue_sub.add_parser("list-lights", help="List Hue lights and their states")
+    hue_sub.add_parser("list-schedules", help="List Hue schedules")
+    tg = hue_sub.add_parser("toggle-group", help="Toggle a Hue group on/off")
+    tg.add_argument("group", help="Hue group name")
+    sc = hue_sub.add_parser("set-color", help="Set a Hue group color")
+    sc.add_argument("group", help="Hue group name")
+    sc.add_argument("color", help="Named color or hue value")
+    sc.add_argument("--sat", type=int, default=254)
+    sc.add_argument("--bri", type=int, default=254)
+    ts = hue_sub.add_parser("toggle-schedule", help="Toggle a Hue schedule on/off")
+    ts.add_argument("schedule", help="Schedule name")
+    lp = hue_sub.add_parser("loop", help="Toggle colorloop effect for a group")
+    lp.add_argument("group", help="Hue group name")
+    lp.add_argument("--effect", choices=["colorloop","none"], default=None)
+    cc = hue_sub.add_parser("cycle-color", help="Cycle a group's color through the configured cycle")
+    cc.add_argument("group", help="Hue group name")
+
+    # ----------------------------------------------------------------
+    # Elgato Commands
+    # ----------------------------------------------------------------
+    elg = subparsers.add_parser("elgato", help="Elgato Ring Light controls")
+    elg_sub = elg.add_subparsers(dest="elgato_cmd", required=True)
+    elg_sub.add_parser("discover", help="Discover Elgato Ring Light via mDNS")
+    elg_sub.add_parser("toggle", help="Toggle Elgato Ring Light power")
+    elg_sub.add_parser("info", help="Get Elgato Ring Light status")
+
+    # ----------------------------------------------------------------
+    # MIDI Commands
+    # ----------------------------------------------------------------
+    midi = subparsers.add_parser("midi", help="MIDI utilities")
+    midi_sub = midi.add_subparsers(dest="midi_cmd", required=True)
+    midi_sub.add_parser("listen", help="Listens for MIDI inputs and prints values")
+
+    args = parser.parse_args()
+
+    # ----------------------------------------------------------------
+    # Dispatch commands
+    # ----------------------------------------------------------------
+    if args.command == "init":
+        init_config()
+        sys.exit(0)
+
+    if args.command == "run":
+        from pymidi_controller.core import run as core_run
+        core_run(mode=args.mode)
+        sys.exit(0)
+
+    if args.command == "service":
+        scope = ServiceScope.USER if getattr(args, "user", False) else ServiceScope.SYSTEM
+        service_dispatch(args.svc_cmd, scope)
+        sys.exit(0)
+
+    if args.command == "hue":
+        cmd = args.hue_cmd
+        if cmd == "discover":
+            hue_discovery.main()
+        elif cmd == "list-groups":
+            hue_module.list_groups()
+        elif cmd == "list-lights":
+            hue_module.list_lights()
+        elif cmd == "list-schedules":
+            hue_module.list_schedules()
+        elif cmd == "toggle-group":
+            hue_module.toggle_group(args.group)
+        elif cmd == "set-color":
+            val = int(args.color) if args.color.isdigit() else args.color
+            hue_module.set_group_color(args.group, val, args.sat, args.bri)
+        elif cmd == "toggle-schedule":
+            hue_module.toggle_schedule(args.schedule)
+        elif cmd == "loop":
+            hue_module.toggle_colorloop(args.group, args.effect)
+        elif cmd == "cycle-color":
+            hue_module.cycle_group_color(args.group)
+        sys.exit(0)
+
+    if args.command == "elgato":
+        cmd = args.elgato_cmd
+        if cmd == "discover":
+            elgato_discovery.main()
+        elif cmd == "toggle":
+            elgato_module.toggle_light()
+        elif cmd == "info":
+            elgato_module.get_ring_info()
+        sys.exit(0)
+
+    if args.command == "midi":
+        if args.midi_cmd == "listen":
+            midi_listen()
+        sys.exit(0)

pymidi_controller/config.py

@@ -0,0 +1,17 @@
+from pymidi_controller.utils.config_manager import load_config
+
+_cfg = load_config()
+
+# Credentials
+HUE_BRIDGE_IP   = _cfg.get("hue", {}).get("bridge_ip")
+HUE_API_KEY     = _cfg.get("hue", {}).get("api_key")
+ELGATO_LIGHT_IP = _cfg.get("elgato", {}).get("ip")
+
+# MIDI section
+_m = _cfg.get("midi", {})
+MIDI_DEVICES    = _m.get("devices", [])
+MIDI_BINDINGS   = _m.get("bindings", {})
+COLOR_CYCLES    = _m.get("color_cycles", {})
+
+# CLI entrypoint
+CLI_COMMAND = "pymidi-controller"

pymidi_controller/core.py

@@ -0,0 +1,83 @@
+import threading
+import sys
+import select
+import time
+import subprocess
+from mido import open_input
+from pymidi_controller.utils.midi_utils import get_known_midi_input
+from pymidi_controller.config import MIDI_BINDINGS, CLI_COMMAND
+
+def format_midi_key(msg):
+    if msg.type == "control_change":
+        return f"{msg.type}:{msg.channel}:{msg.control}:{msg.value}"
+    elif msg.type in ("note_on", "note_off"):
+        return f"{msg.type}:{msg.channel}:{msg.note}:{msg.velocity}"
+    return None
+
+def handle_midi_message(msg, bindings):
+
+    key = format_midi_key(msg)
+    if key and key in bindings:
+        command = [CLI_COMMAND] + bindings[key]
+        print(f"🎯 Matched {key} → Running: {' '.join(command)}")
+        try:
+            subprocess.Popen(command)
+        except Exception as e:
+            print(f"❌ Failed to run command: {e}")
+    elif key:
+        print(f"🎵 Unmapped input: {key}")
+
+def run_blocking(device_name, bindings):
+    print("💤 Blocking mode: press Ctrl+C to exit.\n")
+    with open_input(device_name) as inport:
+        for msg in inport:
+            handle_midi_message(msg, bindings)
+
+def run_interactive(device_name, bindings):
+    print("💡 Interactive mode: type 'quit' to exit.\n")
+    stop_flag = threading.Event()
+
+    def input_listener():
+        while not stop_flag.is_set():
+            if select.select([sys.stdin], [], [], 1)[0]:
+                command = sys.stdin.readline().strip().lower()
+                if command in ("quit", "exit", "q"):
+                    stop_flag.set()
+
+    input_thread = threading.Thread(target=input_listener, daemon=True)
+    input_thread.start()
+
+    with open_input(device_name) as inport:
+        while not stop_flag.is_set():
+            for msg in inport.iter_pending():
+                handle_midi_message(msg, bindings)
+            time.sleep(0.01)
+
+    print("👋 Listener stopped.")
+
+def run(mode: str = "blocking"):
+    """
+    Entry point for the long-running MIDI listener.
+    mode: 'interactive' or 'blocking'
+    """
+    bindings = MIDI_BINDINGS
+    if not bindings:
+        print("❌ No MIDI bindings defined in config.yaml.")
+        return
+
+    device_name = get_known_midi_input()
+    if not device_name:
+        print("❌ No MIDI input devices found.")
+        return
+
+    print(f"🎹 Listening on: {device_name}")
+    print(f"📖 Loaded {len(bindings)} mappings...")
+
+    if mode == "blocking":
+        run_blocking(device_name, bindings)
+    else:
+        run_interactive(device_name, bindings)
+
+
+if __name__ == "__main__":
+    run()

pymidi_controller/data/default_config.yaml

@@ -0,0 +1,31 @@
+hue:
+  bridge_ip:
+  api_key:
+
+elgato:
+  ip:
+
+midi:
+  devices:
+    # The names of available MIDI devices
+    - "Streamer X"
+    - "nanoPAD"
+    - "APC Key 25"
+    - "MIDI Fighter"
+  
+  bindings:
+    # The MIDI note
+    control_change:0:1:127:
+      # The pymidi_controller command
+      - COMMAND
+      # Your Hue Group Name
+      - "HUE GROUP NAME"
+  
+  # Available Colors: red, orange, yellow, green, cyan, blue, purple, pink, white
+  color_cycles:
+    # Your Hue Group Name
+    HUE GROUP NAME:
+      - red
+      - blue
+      - green
+      - purple

pymidi_controller/data/systemd/pymidi-controller.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=🎹 MIDI Controller Background Service
+After=network.target
+
+[Service]
+Type=simple
+Environment=PATH=%h/.local/bin:/usr/local/bin:/usr/bin:/bin
+ExecStart=/usr/bin/env pymidi-controller run --mode blocking
+Restart=always
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=default.target

pymidi_controller/utils/color_cycle.py

@@ -0,0 +1,13 @@
+from pymidi_controller.config import COLOR_CYCLES
+
+# Default fallback cycle if group not defined
+DEFAULT_CYCLE = ["red", "blue"]
+
+def get_color_cycle(group_name):
+    
+    if not COLOR_CYCLES:
+        print(f"⚠️  color cycles not found at config.yaml. Using default cycle.")
+        return DEFAULT_CYCLE
+
+    return COLOR_CYCLES.get(group_name, DEFAULT_CYCLE)
+

pymidi_controller/utils/config_manager.py

@@ -0,0 +1,39 @@
+import yaml
+import os
+import shutil
+from importlib import resources
+from pathlib import Path
+
+XDG = Path.home() / ".config"  if "XDG_CONFIG_HOME" not in __import__("os").environ else Path(__import__("os").environ["XDG_CONFIG_HOME"])
+CFG_DIR  = XDG / "pymidi-controller"
+CFG_FILE = CFG_DIR / "config.yaml"
+
+def ensure_config_dir():
+    CFG_DIR.mkdir(parents=True, exist_ok=True)
+
+def load_config():
+    ensure_config_dir()
+    if not CFG_FILE.exists():
+        return {}
+    with CFG_FILE.open() as f:
+        return yaml.safe_load(f)
+
+def save_config(cfg: dict):
+    ensure_config_dir()
+    # optional backup
+    if CFG_FILE.exists():
+        shutil.copy(CFG_FILE, CFG_FILE.with_suffix(".yaml.bak"))
+    with CFG_FILE.open("w") as f:
+        yaml.safe_dump(cfg, f, sort_keys=False)
+
+def init_config():
+    ensure_config_dir()
+    data = resources.files("pymidi_controller").joinpath("data/default_config.yaml")
+
+    if not CFG_FILE.exists():
+        CFG_FILE.write_text(data.read_text())
+        os.chmod(CFG_FILE, 0o600)
+        print(f"Created {CFG_FILE}, please discover your API keys & set midi mappings.")
+    else:
+        print(f"{CFG_FILE} already exists, skipping.")
+    return

pymidi_controller/utils/midi_utils.py

@@ -0,0 +1,60 @@
+import mido
+import threading
+import sys
+import select
+import time
+from mido import get_input_names
+from pymidi_controller.config import MIDI_DEVICES
+
+def get_known_midi_input():
+    input_ports = get_input_names()
+
+    if not input_ports:
+        return None
+
+    for name in MIDI_DEVICES:
+        match = next((p for p in input_ports if name.lower() in p.lower()), None)
+        if match:
+            return match
+
+    # Fallback
+        return input_ports[0]
+    
+
+def listen():
+    device_name = get_known_midi_input()
+
+    if not device_name:
+        print("❌ No MIDI input device found.")
+        return
+
+    print(f"🎧 Listening on {device_name}...\nPress buttons on your StreamerX!")
+    print("💡 Type 'quit' and press Enter to exit.\n")
+
+    stop_flag = threading.Event()
+
+    def input_listener():
+        while not stop_flag.is_set():
+            # Wait up to 1 second for user input
+            if select.select([sys.stdin], [], [], 1)[0]:
+                command = sys.stdin.readline().strip().lower()
+                if command in ("quit", "exit", "q"):
+                    stop_flag.set()
+
+    input_thread = threading.Thread(target=input_listener, daemon=True)
+    input_thread.start()
+
+    try:
+        with mido.open_input(device_name) as port:
+            while not stop_flag.is_set():
+                for msg in port.iter_pending():
+                    key = f"{msg.type}:{msg.channel}:{getattr(msg, 'control', msg.control)}:{getattr(msg, 'value', msg.value)}"
+                    print(f"{msg} → {key}")
+            time.sleep(0.01)
+    except IOError:
+        print(f"❌ Could not open MIDI input: {device_name}")
+
+    print("👋 Listener stopped.")
+
+if __name__ == "__main__":
+    listen()

pymidi_controller/utils/service_manager.py

@@ -0,0 +1,136 @@
+import shutil
+import subprocess
+from pathlib import Path
+from importlib import resources
+from enum import Enum, auto
+
+# -------------------------------------------------------------------
+# Service Installation & Management with Scoped Control
+# -------------------------------------------------------------------
+
+class ServiceScope(Enum):
+    USER = auto()
+    SYSTEM = auto()
+
+
+def install(scope: ServiceScope):
+    """
+    Install and enable the systemd service unit.
+
+    :param scope: ServiceScope.USER or ServiceScope.SYSTEM
+    """
+    if scope == ServiceScope.USER:
+        target_dir = Path.home() / ".config/systemd/user"
+        ctl = ["systemctl", "--user"]
+    elif scope == ServiceScope.SYSTEM:
+        target_dir = Path("/etc/systemd/system")
+        ctl = ["systemctl"]
+    else:
+        print("⚠️  Invalid scope for install.")
+        return
+
+    target_dir.mkdir(parents=True, exist_ok=True)
+    src = resources.files("pymidi_controller") / "data/systemd/pymidi-controller.service"
+    dst = target_dir / "pymidi-controller.service"
+    shutil.copy(src, dst)
+    print(f"✔️  Installed service unit to {dst}")
+
+    subprocess.run(ctl + ["daemon-reload"], check=True)
+    subprocess.run(ctl + ["enable", "--now", "pymidi-controller.service"], check=True)
+    print("✅ Service enabled and started.")
+
+
+def uninstall(scope: ServiceScope):
+    """
+    Disable and remove the systemd service unit.
+
+    :param scope: ServiceScope.USER or ServiceScope.SYSTEM
+    """
+    if scope == ServiceScope.USER:
+        target_dir = Path.home() / ".config/systemd/user"
+        ctl = ["systemctl", "--user"]
+    elif scope == ServiceScope.SYSTEM:
+        target_dir = Path("/etc/systemd/system")
+        ctl = ["systemctl"]
+    else:
+        print("⚠️  Invalid scope for uninstall.")
+        return
+
+    service_name = "pymidi-controller.service"
+    dst = target_dir / service_name
+
+    subprocess.run(ctl + ["stop", service_name], check=False)
+    subprocess.run(ctl + ["disable", service_name], check=False)
+
+    if dst.exists():
+        dst.unlink()
+        print(f"🗑️  Removed service unit at {dst}")
+    else:
+        print(f"⚠️  No service unit found at {dst}")
+
+    subprocess.run(ctl + ["daemon-reload"], check=True)
+    print("✅ Service uninstalled.")
+
+
+def stop(scope: ServiceScope = ServiceScope.USER):
+    """
+    Stop the systemd service.
+
+    :param scope: ServiceScope.USER or ServiceScope.SYSTEM
+    """
+    cmd = ["systemctl"]
+    if scope == ServiceScope.USER:
+        cmd.insert(1, "--user")
+    cmd.append("stop")
+    cmd.append("pymidi-controller.service")
+    subprocess.run(cmd, check=True)
+    print("✅ Service stopped.")
+
+
+def enable(scope: ServiceScope = ServiceScope.USER):
+    """
+    Enable the systemd service.
+
+    :param scope: ServiceScope.USER or ServiceScope.SYSTEM
+    """
+    cmd = ["systemctl"]
+    if scope == ServiceScope.USER:
+        cmd.insert(1, "--user")
+    cmd.extend(["enable", "pymidi-controller.service"])
+    subprocess.run(cmd, check=True)
+    print("✅ Service enabled.")
+
+
+def log(scope: ServiceScope = ServiceScope.USER):
+    """
+    Show the systemd service logs.
+
+    :param scope: ServiceScope.USER or ServiceScope.SYSTEM
+    """
+    cmd = ["journalctl"]
+    if scope == ServiceScope.USER:
+        cmd.extend(["--user"])
+    cmd.extend(["-u", "pymidi-controller.service", "--no-pager"])
+    subprocess.run(cmd, check=True)
+    print("✅ Service logs displayed.")
+
+
+def dispatch(action: str, scope: ServiceScope = ServiceScope.USER):
+    """
+    Dispatcher for service subcommands.
+
+    :param action: one of 'install', 'uninstall', 'stop', 'enable', 'log'
+    :param scope: ServiceScope.USER or ServiceScope.SYSTEM
+    """
+    if action == "install":
+        install(scope)
+    elif action == "uninstall":
+        uninstall(scope)
+    elif action == "stop":
+        stop(scope)
+    elif action == "enable":
+        enable(scope)
+    elif action == "log":
+        log(scope)
+    else:
+        print(f"⚠️  Unknown service action: {action}")

pymidi_controller/utils/state_manager.py

@@ -0,0 +1,50 @@
+import sqlite3
+from pymidi_controller.utils.config_manager import CFG_DIR, ensure_config_dir
+
+# Ensure config dir exists
+ensure_config_dir()
+
+# Path to our SQLite database
+DB_FILE = CFG_DIR / "state.db"
+
+# Initialize the database and create tables if they don't exist
+def _get_connection():
+    conn = sqlite3.connect(DB_FILE)
+    conn.execute(
+        '''
+        CREATE TABLE IF NOT EXISTS group_colors (
+            group_name TEXT PRIMARY KEY,
+            last_color TEXT
+        )
+        '''
+    )
+    conn.commit()
+    return conn
+
+
+def get_last_color(group_name: str) -> str | None:
+    """
+    Retrieve the last color for a given group from the state DB.
+    Returns None if not found.
+    """
+    conn = _get_connection()
+    cursor = conn.execute(
+        "SELECT last_color FROM group_colors WHERE group_name = ?",
+        (group_name,)
+    )
+    row = cursor.fetchone()
+    conn.close()
+    return row[0] if row else None
+
+
+def set_last_color(group_name: str, color: str) -> None:
+    """
+    Insert or update the last color for a given group in the state DB.
+    """
+    conn = _get_connection()
+    conn.execute(
+        "INSERT INTO group_colors (group_name, last_color) VALUES (?, ?) ON CONFLICT(group_name) DO UPDATE SET last_color=excluded.last_color",
+        (group_name, color)
+    )
+    conn.commit()
+    conn.close()

pymidi_controller-0.1.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: pymidi-controller
+Version: 0.1.0
+Summary: Daemon that maps MIDI events to system actions (Elgato, Hue, etc.)
+Author-email: Alex Sandilands <sandilands.alex@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AlexSandilands/pymidi-controller
+Project-URL: Bug Tracker, https://github.com/AlexSandilands/pymidi-controller/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Multimedia :: Sound/Audio :: MIDI
+Classifier: Topic :: Home Automation
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mido>=1.2.10
+Requires-Dist: python-rtmidi>=1.4.10
+Requires-Dist: requests>=2.0
+Requires-Dist: zeroconf>=0.40
+Requires-Dist: PyYAML>=6.0
+Dynamic: license-file
+
+# 🎹 PyMIDI Controller
+
+[![Python](https://img.shields.io/badge/python-3.7%2B-blue)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/github/license/AlexSandilands/pymidi-controller)](https://github.com/AlexSandilands/pymidi-controller/blob/main/LICENSE)
+[![Last Commit](https://img.shields.io/github/last-commit/AlexSandilands/pymidi-controller)](https://github.com/AlexSandilands/pymidi-controller/commits/main)
+
+A lightweight Python CLI and background MIDI listener for controlling Philips Hue and Elgato Ring Lights via a MIDI device.
+
+---
+
+## 📚 Table of Contents
+
+- [🚀 Installation](#-installation)
+- [⚡ Quickstart](#-quickstart)
+- [⚙️ Configuration](#️-configuration)
+- [🎛️ Commands](#️-commands)
+  - [Global](#global)
+  - [Service](#service)
+  - [Hue Commands](#hue-commands)
+  - [Elgato Commands](#elgato-commands)
+  - [MIDI Commands](#midi-commands)
+- [🎹 MIDI Binding Guide](#-midi-binding-guide)
+- [⚙️ Service (Optional)](#️-service-optional)
+
+## 🚀 Installation
+
+**Requirements:**
+
+- Python 3.7 or higher
+- A modern Linux distro (systemd)
+
+### Via pip
+
+```bash
+pip install pymidi-controller
+```
+
+### Via pipx (isolated install)
+
+```bash
+pipx install pymidi-controller
+```
+
+> If you use `pipx`, make sure `~/.local/bin` is on your `PATH` (`pipx ensurepath`).
+
+---
+
+## ⚡ Quickstart
+
+1. **Initialize your config** (creates `~/.config/pymidi-controller/config.yaml`):
+   ```bash
+   pymidi init
+   ```
+2. **Discover your Hue Bridge** (press the link button when prompted):
+   ```bash
+   pymidi hue discover
+   ```
+3. **Discover your Elgato Ring Light**:
+   ```bash
+   pymidi elgato discover
+   ```
+4. **Map MIDI inputs** (listen to your controller to grab event keys):
+   ```bash
+   pymidi midi listen
+   ```
+   Press buttons/knobs to print strings like `control_change:0:12:127` for use in your config.
+5. **Edit your config** (see [Configuration](#️-configuration)) to add your device IPs, API keys, MIDI bindings, and color cycles.
+6. **Start the listener to test configuration**:
+   ```bash
+   pymidi run --mode blocking
+   ```
+7. **(Optional) Background Service**:
+  You can also install as a background service: see [Service](#️-service-optional).
+
+---
+
+## ⚙️ Configuration
+
+All settings live in a single YAML file:
+
+```
+~/.config/pymidi-controller/config.yaml
+```
+
+This file will contain potentially sensitive data like your Hue API key or your IP address,
+so it will be flagged as senstive and set so only your user can read it.
+
+### Example `config.yaml`
+
+```yaml
+hue:
+  bridge_ip: 192.168.1.42      # your Hue Bridge address
+  api_key: YOUR_HUE_API_KEY    # obtained via `pymidi hue discover`
+
+elgato:
+  host: 192.168.1.43           # your Elgato Ring Light address
+
+midi:
+  devices:
+    - "Streamer X"
+    - "nanoPAD"
+
+  # Map MIDI event keys → pymidi commands
+  bindings:
+    control_change:0:12:127:
+      - hue
+      - toggle-group
+      - "Living Room"
+    control_change:0:14:127:
+      - elgato
+      - toggle
+
+  # Optional: define color cycles per group
+  color_cycles:
+    Living Room:
+      - red
+      - blue
+      - green
+```
+---
+
+## 🎛️ Commands
+
+Use `pymidi <group> --help` for details on each context.
+
+### Global
+
+| Command       | Description                                 |
+| ------------- | ------------------------------------------- |
+| `pymidi init` | Create default config file                  |
+| `pymidi run`  | Start the MIDI listener (`--mode blocking`) |
+
+### Service
+
+| Command                             | Description                         |
+| ----------------------------------- | ----------------------------------- |
+| `pymidi service install --user`     | Install & start as a user service   |
+| `pymidi service install --system`   | Install & start system-wide service |
+| `pymidi service uninstall --user`   | Stop & remove user service          |
+| `pymidi service uninstall --system` | Stop & remove system service        |
+| `pymidi service stop`               | Stop the running service            |
+| `pymidi service enable`             | Enable service (user scope)         |
+| `pymidi service log`                | Tail service logs                   |
+
+### Hue Commands
+
+| Command                                                    | Description                              |
+| ---------------------------------------------------------- | ---------------------------------------- |
+| `pymidi hue discover`                                      | Find bridge & generate API key           |
+| `pymidi hue list-groups`                                   | List all groups and on/off states        |
+| `pymidi hue list-lights`                                   | List all lights and their state/effect   |
+| `pymidi hue list-schedules`                                | List all schedules                       |
+| `pymidi hue toggle-group <group>`                          | Toggle a group on/off                    |
+| `pymidi hue set-color <group> <color> [--sat N] [--bri N]` | Set group color                          |
+| `pymidi hue toggle-schedule <name>`                        | Enable/disable a schedule                |
+| `pymidi hue loop [--effect colorloop \| none]`             | Toggle colorloop effect                  |
+| `pymidi hue cycle-color <group>`                           | Cycle group color through `color_cycles` |
+
+### Elgato Commands
+
+| Command                  | Description                    |
+| ------------------------ | ------------------------------ |
+| `pymidi elgato discover` | Discover Ring Light via mDNS   |
+| `pymidi elgato toggle`   | Toggle Ring Light on/off       |
+| `pymidi elgato info`     | Show current Ring Light status |
+
+### MIDI Commands
+
+| Command              | Description                                |
+| -------------------- | ------------------------------------------ |
+| `pymidi midi listen` | Print incoming MIDI event keys for mapping |
+
+---
+
+## 🎹 MIDI Binding Guide
+
+1. Run:
+   ```bash
+   pymidi midi listen
+   ```
+2. Press a control (button/knob) to see its event key, e.g. `control_change:0:12:127`.
+3. Open `~/.config/pymidi-controller/config.yaml` and under `midi.bindings`, add:
+   ```yaml
+   bindings:
+     control_change:0:12:127:
+       - hue
+       - toggle-group
+       - "Living Room"
+   ```
+   Each value under the event key should be one part in order of the [Commands](#️-commands)
+4. Save and test:
+   ```bash
+   pymidi run --mode interactive
+   ```
+
+---
+
+## ⚙️ Service (Optional)
+
+To run automatically at login:
+
+```bash
+pymidi service install --user
+```
+
+Logs:
+
+```bash
+pymidi service log
+```
+
+---
+
+## 📜 License
+
+MIT © Alex Sandilands

pymidi_controller-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+pymidi_controller/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+pymidi_controller/cli.py,sha256=mvim4LRasfeZxdWrzr5Intqe-VBUrkYFPgWuLVP4XLE,6867
+pymidi_controller/config.py,sha256=gHhT_iJJ-scqPg4irkPXcOcsXFriI_ui5f6L6xATI6c,479
+pymidi_controller/core.py,sha256=NxkpWmLajdPPtOLbXkoLi9SdNh5Vl5rA2_QHByf-DFY,2554
+pymidi_controller/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymidi_controller/actions/elgato.py,sha256=AGUoOaXq-oigMG1Sw1oAY4U_NuetPf_xItx02AxQsSg,1730
+pymidi_controller/actions/elgato_discovery.py,sha256=2UNreRaJsGr-O5fDmKBiWk82anqVZIoeZtmqLpClMKE,1789
+pymidi_controller/actions/hue.py,sha256=g4IycA5DdX3-AKnUwxh3kgJbCkGYrhrKmnbOhSUv0IM,8497
+pymidi_controller/actions/hue_discovery.py,sha256=DmgiGsvW1RQbV6PmqXurAk5IjYF3ZimDKJkIAHjVYSs,2649
+pymidi_controller/data/default_config.yaml,sha256=cVs1500lsQroIVhQN7vZWFLrScCpGDgfIkeQgY2bcpw,550
+pymidi_controller/data/systemd/pymidi-controller.service,sha256=Lb_AdNvFFpFg_EaxL1BjiQvQ-dPR21YbL52ZESb1Fic,331
+pymidi_controller/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymidi_controller/utils/color_cycle.py,sha256=vWvVF4qLyPu9_fg8nMkhJhCJxpZLKBC2Y9YSxQkqM3E,365
+pymidi_controller/utils/config_manager.py,sha256=ljNpBJFVnQtZQsA80l0-5bMXy8aSeYcXa9S_94AH6oE,1186
+pymidi_controller/utils/midi_utils.py,sha256=z-7bh2NKsbu9ndjyB-uU0qYbL0aGoNVESgkurjSeuJc,1722
+pymidi_controller/utils/service_manager.py,sha256=h-mQzOntimvoZrJoU6HqRqYUBylBJnBYZE_U_jxNBUg,4033
+pymidi_controller/utils/state_manager.py,sha256=XVVxAqtCC_QKvSSjpDyivFeHvbuyKVz-3OdAYdGYuzs,1341
+pymidi_controller-0.1.0.dist-info/licenses/LICENSE,sha256=oYHfWdRjsPZ03A3uWKC-J7KJnHqjdHFpWqoglQhvhqs,1164
+pymidi_controller-0.1.0.dist-info/METADATA,sha256=2MFIDEf5tolSFDVcwerJwYwxQt3dLevsBo3Cc717dMs,7583
+pymidi_controller-0.1.0.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+pymidi_controller-0.1.0.dist-info/entry_points.txt,sha256=-LVVgYsbJkjGcq_WYz11cftdxiEub9cuqfLIipFslW0,101
+pymidi_controller-0.1.0.dist-info/top_level.txt,sha256=TenwuHQdcL0bNx3v_epjVV7Tyo4lQ47lwKl1pYgrD3A,18
+pymidi_controller-0.1.0.dist-info/RECORD,,

pymidi_controller-0.1.0.dist-info/WHEEL

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

pymidi_controller-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pymidi = pymidi_controller.cli:main
+pymidi-controller = pymidi_controller.cli:main

pymidi_controller-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alex Sandilands
+
+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.

pymidi_controller-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pymidi_controller