openswarm-master 0.1.0__py3-none-any.whl

openswarm/__init__.py

@@ -0,0 +1,12 @@
+"""
+OpenSwarm Master SDK
+====================
+Zero-Control-Logic Distributed Hardware Abstraction Layer (Remote HAL) Master.
+All robot intelligence, sensor reading, and actuator control runs here on the Master.
+"""
+
+from .master import SwarmMaster
+from .node import RemoteSwarmNode
+
+__version__ = "0.1.0"
+__all__ = ["SwarmMaster", "RemoteSwarmNode"]

openswarm/cli.py

@@ -0,0 +1,76 @@
+"""
+OpenSwarm Command-Line Interface (`openswarm`)
+Allows scanning for Slave nodes, monitoring live telemetry, and testing LED/pins directly from terminal.
+"""
+
+import argparse
+import time
+from .master import SwarmMaster
+
+
+def cmd_scan(args: argparse.Namespace) -> None:
+    master = SwarmMaster()
+    print(f"Scanning local network for OpenSwarm Slave nodes ({args.wait:.1f}s)...")
+    nodes = master.discover_all(wait_seconds=args.wait)
+    if not nodes:
+        print("No Slave nodes discovered via UDP broadcast.")
+        print("Tip: If your Wi-Fi router blocks UDP broadcast, use `--ip <SLAVE_IP>` in commands.")
+    else:
+        print(f"\nDiscovered {len(nodes)} Slave Node(s):")
+        print("-" * 78)
+        for node in nodes.values():
+            print(f"  Node ID   : {node.node_id} ({node.board})")
+            print(f"  Address   : {node.ip}:{node.port}")
+            print(f"  Actuators : {node.declared_actuators}")
+            print(f"  Sensors   : {node.sensors}")
+            print("-" * 78)
+    master.close()
+
+
+def cmd_blink(args: argparse.Namespace) -> None:
+    master = SwarmMaster()
+    node = master.connect(args.node, ip=args.ip, timeout=args.timeout)
+    print(f"\nConnected to '{node.node_id}' at {node.ip}:{node.port}!")
+    print(f"Blinking '{args.actuator}' (Ctrl+C to stop)...\n")
+
+    state = False
+    try:
+        while True:
+            state = not state
+            node.digital_write(args.actuator, state)
+            print(
+                f"  -> LED={'ON ' if state else 'OFF'} | "
+                f"Uptime={node.uptime_ms / 1000.0:.1f}s | "
+                f"Sensors={node.sensors}"
+            )
+            time.sleep(args.interval)
+    except KeyboardInterrupt:
+        print("\nTurning LED OFF and closing Master connection...")
+        node.digital_write(args.actuator, 0)
+        master.close()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="OpenSwarm Linux Master CLI")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # openswarm scan
+    p_scan = sub.add_parser("scan", help="Auto-discover all OpenSwarm Slave nodes on Wi-Fi")
+    p_scan.add_argument("--wait", type=float, default=2.5, help="Scan duration in seconds")
+    p_scan.set_defaults(func=cmd_scan)
+
+    # openswarm blink <node_id>
+    p_blink = sub.add_parser("blink", help="Blink a registered LED/Digital output on a Slave node")
+    p_blink.add_argument("node", nargs="?", default="esp32_node", help="Slave Node ID (default: esp32_node)")
+    p_blink.add_argument("--ip", type=str, default=None, help="Optional Slave IP address (e.g. 192.168.0.118)")
+    p_blink.add_argument("--actuator", type=str, default="led", help="Actuator name (default: led)")
+    p_blink.add_argument("--interval", type=float, default=0.5, help="Blink interval in seconds")
+    p_blink.add_argument("--timeout", type=float, default=8.0, help="Discovery timeout in seconds")
+    p_blink.set_defaults(func=cmd_blink)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

openswarm/master.py

@@ -0,0 +1,223 @@
+"""
+SwarmMaster — Central Linux/Cross-Platform Master Engine for OpenSwarm.
+- Listens on UDP Port 4211 for Slave auto-discovery broadcasts ("HELLO").
+- Sends low-latency actuator commands and 5 Hz watchdog heartbeats ("PING") over UDP Port 4210.
+- Receives 20 Hz sensor telemetry streams ("STATE") from all connected Slaves in a background thread.
+"""
+
+import json
+import socket
+import threading
+import time
+from typing import Any, Dict, Optional
+
+from .node import RemoteSwarmNode
+
+SWARM_DEFAULT_SLAVE_PORT = 4210
+SWARM_DISCOVERY_PORT = 4211
+SWARM_HEARTBEAT_SEC = 0.20  # 200ms keepalive (well below the 500ms Slave hardware watchdog)
+
+
+class SwarmMaster:
+    def __init__(self, discovery_port: int = SWARM_DISCOVERY_PORT, heartbeat_sec: float = SWARM_HEARTBEAT_SEC):
+        self.discovery_port = discovery_port
+        self.heartbeat_sec = heartbeat_sec
+        self._nodes: Dict[str, RemoteSwarmNode] = {}
+        self._lock = threading.Lock()
+        self._running = True
+
+        # 1. Command & Telemetry Socket (ephemeral port; Slaves reply with STATE to this socket)
+        self._cmd_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self._cmd_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._cmd_sock.bind(("0.0.0.0", 0))
+        self._cmd_sock.settimeout(0.05)
+
+        # 2. Discovery Socket (listens on UDP 4211 for Slave HELLO broadcasts)
+        self._disc_sock: Optional[socket.socket] = None
+        try:
+            self._disc_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self._disc_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            if hasattr(socket, "SO_BROADCAST"):
+                self._disc_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+            self._disc_sock.bind(("0.0.0.0", self.discovery_port))
+            self._disc_sock.settimeout(0.05)
+        except OSError:
+            # If another process is already bound to 4211, direct IP connect still works
+            self._disc_sock = None
+
+        # Start background network & heartbeat daemon threads
+        self._rx_thread = threading.Thread(target=self._network_loop, daemon=True, name="OpenSwarmRx")
+        self._hb_thread = threading.Thread(target=self._heartbeat_loop, daemon=True, name="OpenSwarmHeartbeat")
+        self._rx_thread.start()
+        self._hb_thread.start()
+
+    # -------------------------------------------------------------------------
+    # Public Discovery & Connection API
+    # -------------------------------------------------------------------------
+    def connect(
+        self,
+        node_id: str,
+        ip: Optional[str] = None,
+        port: int = SWARM_DEFAULT_SLAVE_PORT,
+        timeout: float = 10.0,
+    ) -> RemoteSwarmNode:
+        """
+        Connects to a Slave node by its Node ID (e.g. 'esp32_node').
+        - If `ip` is provided (e.g. ip='192.168.0.118'), connects immediately and verifies telemetry.
+        - Otherwise, waits up to `timeout` seconds for the Slave's UDP auto-discovery broadcast.
+        """
+        if ip is not None:
+            with self._lock:
+                if node_id not in self._nodes:
+                    self._nodes[node_id] = RemoteSwarmNode(
+                        node_id=node_id,
+                        ip=ip,
+                        port=port,
+                        send_fn=self._send_json,
+                    )
+                else:
+                    self._nodes[node_id].ip = ip
+                    self._nodes[node_id].port = port
+                node = self._nodes[node_id]
+
+            # Immediately send a PING so the Slave starts streaming 20Hz telemetry to us
+            node.ping()
+            time.sleep(0.1)
+            return node
+
+        print(f"[OpenSwarm Master] Waiting for Slave '{node_id}' on UDP port {self.discovery_port}...")
+        start = time.time()
+        while (time.time() - start) < timeout:
+            with self._lock:
+                if node_id in self._nodes:
+                    node = self._nodes[node_id]
+                    node.ping()
+                    print(
+                        f"[OpenSwarm Master] Discovered '{node.node_id}' ({node.board}) "
+                        f"at {node.ip}:{node.port} | Actuators: {node.declared_actuators} | Sensors: {node.declared_sensors}"
+                    )
+                    return node
+            time.sleep(0.05)
+
+        raise TimeoutError(
+            f"Could not auto-discover Slave '{node_id}' within {timeout}s. "
+            f"Make sure your laptop and ESP32 are on the same Wi-Fi network, or pass ip='192.168.x.x' directly: "
+            f"master.connect('{node_id}', ip='192.168.0.118')"
+        )
+
+    def discover_all(self, wait_seconds: float = 2.5) -> Dict[str, RemoteSwarmNode]:
+        """Listens for `wait_seconds` and returns all discovered Slave nodes on the network."""
+        time.sleep(wait_seconds)
+        with self._lock:
+            return dict(self._nodes)
+
+    @property
+    def nodes(self) -> Dict[str, RemoteSwarmNode]:
+        with self._lock:
+            return dict(self._nodes)
+
+    def close(self) -> None:
+        """Stops all connected Slave motors and closes Master sockets."""
+        self._running = False
+        with self._lock:
+            for node in self._nodes.values():
+                try:
+                    node.stop()
+                except Exception:
+                    pass
+        try:
+            self._cmd_sock.close()
+        except Exception:
+            pass
+        if self._disc_sock:
+            try:
+                self._disc_sock.close()
+            except Exception:
+                pass
+
+    # -------------------------------------------------------------------------
+    # Internal UDP Transport & Background Threads
+    # -------------------------------------------------------------------------
+    def _send_json(self, ip: str, port: int, payload: Dict[str, Any]) -> None:
+        raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+        try:
+            self._cmd_sock.sendto(raw, (ip, port))
+        except OSError:
+            pass
+
+    def _network_loop(self) -> None:
+        while self._running:
+            # 1. Check Discovery Socket (HELLO broadcasts on port 4211)
+            if self._disc_sock is not None:
+                try:
+                    data, addr = self._disc_sock.recvfrom(2048)
+                    self._handle_packet(data, addr)
+                except socket.timeout:
+                    pass
+                except OSError:
+                    pass
+
+            # 2. Check Command/Telemetry Socket (STATE telemetry packets)
+            try:
+                data, addr = self._cmd_sock.recvfrom(2048)
+                self._handle_packet(data, addr)
+            except socket.timeout:
+                pass
+            except OSError:
+                pass
+
+    def _handle_packet(self, data: bytes, addr: tuple) -> None:
+        try:
+            msg = json.loads(data.decode("utf-8", errors="ignore"))
+        except Exception:
+            return
+
+        pkt_type = msg.get("type")
+        node_id = msg.get("node")
+        if not node_id:
+            return
+
+        sender_ip = msg.get("ip") or addr[0]
+        sender_port = int(msg.get("port") or SWARM_DEFAULT_SLAVE_PORT)
+
+        with self._lock:
+            if pkt_type == "HELLO":
+                board = msg.get("board", "UNKNOWN")
+                actuators = msg.get("actuators", [])
+                sensors = msg.get("sensors", [])
+                if node_id not in self._nodes:
+                    node = RemoteSwarmNode(
+                        node_id=node_id,
+                        ip=sender_ip,
+                        port=sender_port,
+                        send_fn=self._send_json,
+                        board=board,
+                        actuators=actuators,
+                        sensors=sensors,
+                    )
+                    self._nodes[node_id] = node
+                    # Trigger initial PING so Slave starts streaming STATE
+                    node.ping()
+                else:
+                    self._nodes[node_id]._update_hello(sender_ip, sender_port, board, actuators, sensors)
+
+            elif pkt_type == "STATE":
+                uptime_ms = int(msg.get("uptime_ms", 0))
+                sensors_dict = msg.get("sensors", {})
+                if node_id not in self._nodes:
+                    self._nodes[node_id] = RemoteSwarmNode(
+                        node_id=node_id,
+                        ip=addr[0],
+                        port=addr[1],
+                        send_fn=self._send_json,
+                        sensors=list(sensors_dict.keys()),
+                    )
+                self._nodes[node_id]._update_state(uptime_ms, sensors_dict)
+
+    def _heartbeat_loop(self) -> None:
+        while self._running:
+            with self._lock:
+                nodes_list = list(self._nodes.values())
+            for node in nodes_list:
+                node.ping()
+            time.sleep(self.heartbeat_sec)

openswarm/node.py

@@ -0,0 +1,181 @@
+"""
+RemoteSwarmNode — Represents a single connected Slave node (ESP32, UNO, Nano, RP2040, or Linux SBC).
+Exposes clean Python methods to read live sensors and command any actuator, pin, or bus protocol.
+"""
+
+import time
+from typing import Any, Callable, Dict, List, Optional, Union
+
+
+class RemoteSwarmNode:
+    def __init__(
+        self,
+        node_id: str,
+        ip: str,
+        port: int,
+        send_fn: Callable[[str, int, Dict[str, Any]], None],
+        board: str = "UNKNOWN",
+        actuators: Optional[List[str]] = None,
+        sensors: Optional[List[str]] = None,
+    ):
+        self.node_id: str = node_id
+        self.ip: str = ip
+        self.port: int = port
+        self.board: str = board
+        self.declared_actuators: List[str] = actuators or []
+        self.declared_sensors: List[str] = sensors or []
+
+        self._send_fn = send_fn
+        self._sensor_values: Dict[str, Union[float, List[float]]] = {}
+        self.uptime_ms: int = 0
+        self.last_seen: float = time.time()
+
+    # -------------------------------------------------------------------------
+    # Internal state updates (called by SwarmMaster background thread)
+    # -------------------------------------------------------------------------
+    def _update_hello(self, ip: str, port: int, board: str, actuators: List[str], sensors: List[str]) -> None:
+        self.ip = ip
+        self.port = port
+        self.board = board
+        self.declared_actuators = actuators
+        self.declared_sensors = sensors
+        self.last_seen = time.time()
+
+    def _update_state(self, uptime_ms: int, sensors_dict: Dict[str, Any]) -> None:
+        self.uptime_ms = uptime_ms
+        self._sensor_values.update(sensors_dict)
+        self.last_seen = time.time()
+
+    # -------------------------------------------------------------------------
+    # Sensor Reading API
+    # -------------------------------------------------------------------------
+    @property
+    def sensors(self) -> Dict[str, Union[float, List[float]]]:
+        """Returns a dictionary of the latest 20Hz streamed sensor values."""
+        return dict(self._sensor_values)
+
+    def read(self, sensor_name: str, default: Any = 0.0) -> Union[float, List[float]]:
+        """Reads the latest value of a named sensor (e.g., node.read('rssi') or node.read('front_sonar'))."""
+        return self._sensor_values.get(sensor_name, default)
+
+    @property
+    def is_online(self) -> bool:
+        """Returns True if we heard from this Slave within the last 2.0 seconds."""
+        return (time.time() - self.last_seen) < 2.0
+
+    # -------------------------------------------------------------------------
+    # Pin & GPIO Control API
+    # -------------------------------------------------------------------------
+    def digital_write(self, name: str, state: Union[int, bool]) -> None:
+        """
+        Writes HIGH (1/True) or LOW (0/False) to a registered digital output pin
+        (e.g., node.digital_write('led', 1)).
+        """
+        val = 1 if state else 0
+        self._send_fn(self.ip, self.port, {"cmd": "ACT", "name": name, "value": val})
+
+    def pwm_write(self, name_or_pin: Union[str, int], duty: int) -> None:
+        """
+        Writes a PWM duty cycle (0..255) either to a registered PWM output name
+        or directly to a raw hardware pin number.
+        """
+        duty_clamped = max(0, min(255, int(duty)))
+        if isinstance(name_or_pin, int):
+            self._send_fn(self.ip, self.port, {"cmd": "PIN", "pin": name_or_pin, "value": duty_clamped, "pwm": 1})
+        else:
+            self._send_fn(self.ip, self.port, {"cmd": "ACT", "name": name_or_pin, "value": duty_clamped})
+
+    def pin_write(self, pin: int, value: Union[int, bool], pwm: bool = False) -> None:
+        """
+        Direct raw GPIO pin control by pin number (even if not registered in setup()).
+        Example: node.pin_write(2, 1) -> sets GPIO 2 HIGH.
+        """
+        val = int(value)
+        self._send_fn(
+            self.ip,
+            self.port,
+            {"cmd": "PIN", "pin": int(pin), "value": val, "pwm": 1 if pwm else 0},
+        )
+
+    # -------------------------------------------------------------------------
+    # Motor, Servo & Stepper Control API
+    # -------------------------------------------------------------------------
+    def drive(self, name: str, left: int, right: int = 0) -> None:
+        """
+        Drives a dual H-Bridge (L298N / DRV8833) or single 2-pin DC motor (-255 to +255).
+        Example: node.drive('drive', left=180, right=180)
+        """
+        self._send_fn(
+            self.ip,
+            self.port,
+            {"cmd": "ACT", "name": name, "left": int(left), "right": int(right)},
+        )
+
+    def servo(self, name: str, angle: int) -> None:
+        """
+        Sets a hobby servo angle (0 to 180 degrees).
+        Example: node.servo('gripper_servo', 90)
+        """
+        self._send_fn(
+            self.ip,
+            self.port,
+            {"cmd": "ACT", "name": name, "angle": int(angle)},
+        )
+
+    def stepper(self, name: str, steps: int, step_delay_us: int = 800) -> None:
+        """
+        Commands a Step/Dir stepper driver (positive = forward, negative = reverse).
+        Example: node.stepper('lifter_step', steps=200, step_delay_us=800)
+        """
+        self._send_fn(
+            self.ip,
+            self.port,
+            {"cmd": "ACT", "name": name, "steps": int(steps), "v2": int(step_delay_us)},
+        )
+
+    def stop(self) -> None:
+        """Immediately stops all motors on this Slave node."""
+        self._send_fn(self.ip, self.port, {"cmd": "STOP"})
+
+    # -------------------------------------------------------------------------
+    # Universal Bus & Custom Actuator API (LoRa, SPI, I2C, UART, Custom)
+    # -------------------------------------------------------------------------
+    def send_bus(self, name: str, data: str = "", v1: int = 0, v2: int = 0) -> None:
+        """
+        Transmits a string payload or numeric values over a registered LoRa, UART, or Custom actuator.
+        Example: node.send_bus('lora_radio', data='HELLO_SWARM')
+        """
+        self._send_fn(
+            self.ip,
+            self.port,
+            {"cmd": "ACT", "name": name, "v1": int(v1), "v2": int(v2), "data": str(data)},
+        )
+
+    def write_reg(self, name: str, reg: int, val: int) -> None:
+        """
+        Writes a register byte [reg, val] to a registered I2C or SPI actuator device.
+        Example: node.write_reg('i2c_pwm_chip', reg=0x06, val=128)
+        """
+        self._send_fn(
+            self.ip,
+            self.port,
+            {"cmd": "ACT", "name": name, "reg": int(reg), "val": int(val)},
+        )
+
+    def set_actuator(self, name: str, v1: int = 0, v2: int = 0, data: str = "") -> None:
+        """Generic low-level actuator command."""
+        payload: Dict[str, Any] = {"cmd": "ACT", "name": name, "v1": int(v1), "v2": int(v2)}
+        if data:
+            payload["data"] = data
+        self._send_fn(self.ip, self.port, payload)
+
+    def ping(self) -> None:
+        """Sends a heartbeat PING to request immediate telemetry and reset the Slave watchdog."""
+        self._send_fn(self.ip, self.port, {"cmd": "PING"})
+
+    def __repr__(self) -> str:
+        return (
+            f"<RemoteSwarmNode id='{self.node_id}' board='{self.board}' "
+            f"ip='{self.ip}:{self.port}' actuators={self.declared_actuators} "
+            f"sensors={self.declared_sensors}>"
+        )

openswarm_master-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: openswarm-master
+Version: 0.1.0
+Summary: Central Linux Master SDK & Runtime for the OpenSwarm Distributed Robotics Framework
+Author-email: Mohammed Raihan Soniwala <raihann.eu@gmail.com>
+License: MIT
+Keywords: robotics,swarm-robotics,esp32,arduino,hal,distributed-systems
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# OpenSwarm Master (`openswarm-master`)
+
+The Central Linux Master SDK & CLI for the [**OpenSwarm**](https://github.com/raihhann/OpenSwarm) Distributed Hardware-Agnostic Robotics Framework.
+
+* **Zero Slave Control Logic:** All sensor processing, state machines, kinematics, and actuator commands run here on the Master.
+* **Zero External Dependencies:** Pure Python 3 standard library (`socket`, `threading`, `json`) for instant installation on any Linux laptop, Ubuntu PC, Raspberry Pi, or Windows machine.
+* **Auto-Discovery + Direct IP:** Automatically discovers Slaves via UDP port `4211` (`HELLO` broadcast) or connects directly by IP (`192.168.x.x:4210`).
+* **Built-In Keepalive:** Sends a 200 ms background heartbeat (`PING`) to keep the Slave's 500 ms hardware safety watchdog active and stream 20 Hz sensor telemetry (`STATE`).
+
+---
+
+## 1. Installation
+
+### Option A: Install Directly from GitHub
+```bash
+pip install "git+https://github.com/raihhann/OpenSwarm.git#subdirectory=master"
+```
+
+### Option B: Clone & Install in Editable Mode (Recommended for Development)
+```bash
+git clone https://github.com/raihhann/OpenSwarm.git
+cd OpenSwarm/master
+pip install -e .
+```
+
+---
+
+## 2. Terminal CLI (`openswarm`)
+
+```bash
+# Scan the local Wi-Fi network for active Slave nodes:
+openswarm scan
+
+# Blink the built-in LED ("led" on GPIO 2) on esp32_node and print live 20 Hz RSSI:
+openswarm blink esp32_node --ip 192.168.0.118
+```
+
+---
+
+## 3. Python API Reference
+
+```python
+import time
+from openswarm import SwarmMaster
+
+master = SwarmMaster()
+
+# Connect by Node ID (auto-discovers on LAN, or pass ip="192.168.0.118" directly)
+bot = master.connect("esp32_node", ip="192.168.0.118")
+
+# 1. Digital & PWM Pin Control
+bot.digital_write("led", 1)                  # Named digital output HIGH
+bot.digital_write("led", 0)                  # Named digital output LOW
+bot.pwm_write("led", 128)                    # Named PWM output (0..255)
+bot.pin_write(2, 1)                          # Direct GPIO pin number write
+
+# 2. Motor, Servo & Stepper Control
+bot.drive("drive", left=180, right=180)      # Dual H-Bridge (L298N / DRV8833)
+bot.servo("gripper", angle=90)               # Hobby Servo (0..180 deg)
+bot.stepper("lifter", steps=200)             # Stepper driver
+bot.stop()                                   # Immediate emergency stop
+
+# 3. Universal Bus & Custom Actuator Control (LoRa, SPI, I2C, UART)
+bot.send_bus("lora_radio", data="PING_SWARM")
+bot.write_reg("i2c_pwm_chip", reg=0x06, val=200)
+
+# 4. Live 20 Hz Sensor Telemetry
+print("RSSI:", bot.read("rssi"))
+print("All Sensors:", bot.sensors)
+
+master.close()
+```

openswarm_master-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+openswarm/__init__.py,sha256=Ti9psc5Gf_fcJjynmMzEygc-bSmZB6jHrEadeji01ZM,350
+openswarm/cli.py,sha256=TY7fcBT2aKvUCwVqoOACfqRbwidMWADONFDOcG75mnY,3042
+openswarm/master.py,sha256=5S44Bh03s7BByY2eWmDFIswHZopOcLhus1Cav47KtJs,8994
+openswarm/node.py,sha256=hjSLwsYKvslRVXGWZf49JmkdZbjeRWgQR6R-9dsPboI,7468
+openswarm_master-0.1.0.dist-info/METADATA,sha256=dKQmlRu_oeRnR-9UW4Jveqv3CHQ1SlbapFiW5nqEy0c,3061
+openswarm_master-0.1.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+openswarm_master-0.1.0.dist-info/entry_points.txt,sha256=j_tjlaID1-3rpK5TC3PfBf8jvCE5ow9sirBoHfKM47M,49
+openswarm_master-0.1.0.dist-info/top_level.txt,sha256=xw4v2UTMTsXuf200nzQ8OiYwa3do7gDpiIiTtW92tFE,10
+openswarm_master-0.1.0.dist-info/RECORD,,

openswarm_master-0.1.0.dist-info/WHEEL

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

openswarm_master-0.1.0.dist-info/entry_points.txt

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

openswarm_master-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+openswarm