scadable-cli 0.1.1__tar.gz

scadable_cli-0.1.1/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: scadable-cli
+Version: 0.1.1
+Summary: Edge SDK for the Scadable IoT platform
+License: MIT
+Keywords: iot,scada,edge,modbus,industrial
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Scadable Edge SDK
+
+Python SDK for defining devices on the Scadable IoT platform.
+
+## Installation
+
+```bash
+pip install scadable-cli
+```
+
+## Usage
+
+Create a `config.py` for your device:
+
+```python
+from scadable.edge import Device, ModbusConnection
+from scadable.edge.constants import MODBUS_TCP, FIVE_SEC
+from dataclasses import dataclass
+
+@dataclass
+class Connection(ModbusConnection):
+    host: str = "${DEVICE_HOST}"
+    port: int = 502
+    slave_id: int = 1
+
+class MyPLC(Device):
+    id = "device-001"
+    protocol = MODBUS_TCP
+    connection = Connection
+    frequency = FIVE_SEC
+```
+
+## Project Structure
+
+```
+gateways/
+    gateway-001/
+        device-001/
+            config.py
+        device-002/
+            config.py
+```

scadable_cli-0.1.1/README.md

@@ -0,0 +1,42 @@
+# Scadable Edge SDK
+
+Python SDK for defining devices on the Scadable IoT platform.
+
+## Installation
+
+```bash
+pip install scadable-cli
+```
+
+## Usage
+
+Create a `config.py` for your device:
+
+```python
+from scadable.edge import Device, ModbusConnection
+from scadable.edge.constants import MODBUS_TCP, FIVE_SEC
+from dataclasses import dataclass
+
+@dataclass
+class Connection(ModbusConnection):
+    host: str = "${DEVICE_HOST}"
+    port: int = 502
+    slave_id: int = 1
+
+class MyPLC(Device):
+    id = "device-001"
+    protocol = MODBUS_TCP
+    connection = Connection
+    frequency = FIVE_SEC
+```
+
+## Project Structure
+
+```
+gateways/
+    gateway-001/
+        device-001/
+            config.py
+        device-002/
+            config.py
+```

scadable_cli-0.1.1/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scadable-cli"
+version = "0.1.1"
+description = "Edge SDK for the Scadable IoT platform"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+keywords = ["iot", "scada", "edge", "modbus", "industrial"]
+dependencies = []
+
+[project.scripts]
+scadable = "scadable.edge.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["scadable*"]

scadable_cli-0.1.1/scadable/edge/__init__.py

@@ -0,0 +1,17 @@
+from .device import Device, PAYLOAD_SCHEMA
+from .protocols.modbus import ModbusConnection, ModbusProtocol
+from .protocols.base import Protocol
+from .constants import (
+    MODBUS_TCP, MODBUS_RTU, OPCUA, MQTT,
+    ONE_SEC, FIVE_SEC, TEN_SEC, THIRTY_SEC, ONE_MIN, FIVE_MIN,
+)
+
+__all__ = [
+    "Device",
+    "PAYLOAD_SCHEMA",
+    "ModbusConnection",
+    "ModbusProtocol",
+    "Protocol",
+    "MODBUS_TCP", "MODBUS_RTU", "OPCUA", "MQTT",
+    "ONE_SEC", "FIVE_SEC", "TEN_SEC", "THIRTY_SEC", "ONE_MIN", "FIVE_MIN",
+]

scadable_cli-0.1.1/scadable/edge/cli.py

@@ -0,0 +1,274 @@
+import os
+import sys
+import json
+import argparse
+
+CONFIG_FILE = "scadable.json"
+
+# ─── Templates ────────────────────────────────────────────────────────────────
+
+MODBUS_TCP_TEMPLATE = '''\
+"""
+Generated by Scadable CLI.
+
+Only modify the variable values below (host, port, slave_id, frequency, etc).
+Do not rename classes or change the structure — the runtime depends on it.
+"""
+from scadable.edge import Device, ModbusConnection
+from scadable.edge.constants import MODBUS_TCP, FIVE_SEC
+from dataclasses import dataclass
+
+
+@dataclass
+class Connection(ModbusConnection):
+    """
+    Modbus TCP connection settings.
+
+    Attributes:
+        host: IP address or hostname of the Modbus device.
+              Use "${{DEVICE_HOST}}" for environment variable injection.
+        port: TCP port number (default: 502 for Modbus).
+        slave_id: Modbus slave/unit ID (1-247).
+    """
+    host: str = "${{DEVICE_HOST}}"
+    port: int = 502
+    slave_id: int = 1
+
+
+class {class_name}(Device):
+    """
+    Device configuration.
+
+    Attributes:
+        id: Unique identifier for this device.
+        protocol: Communication protocol (MODBUS_TCP).
+        connection: Connection settings class.
+        frequency: Polling interval in seconds (how often to read data).
+        filter: List of register names to pull (empty = pull all).
+    """
+    id = "{device_id}"
+    protocol = MODBUS_TCP
+    connection = Connection
+    frequency = FIVE_SEC
+    filter = []  # empty = pull all registers; e.g. ["reg_100", "reg_102"] to filter
+'''
+
+MODBUS_RTU_TEMPLATE = '''\
+"""
+Generated by Scadable CLI.
+
+Only modify the variable values below (serial_port, baudrate, slave_id, etc).
+Do not rename classes or change the structure — the runtime depends on it.
+"""
+from scadable.edge import Device, ModbusConnection
+from scadable.edge.constants import MODBUS_RTU, FIVE_SEC
+from dataclasses import dataclass
+
+
+@dataclass
+class Connection(ModbusConnection):
+    """
+    Modbus RTU (serial) connection settings.
+
+    Attributes:
+        serial_port: Serial port path (e.g., "/dev/ttyUSB0" on Linux,
+                     "COM3" on Windows).
+        slave_id: Modbus slave/unit ID (1-247).
+        baudrate: Serial baud rate (common: 9600, 19200, 38400, 115200).
+        parity: Parity bit — "N" (none), "E" (even), or "O" (odd).
+        stopbits: Number of stop bits (1 or 2).
+        bytesize: Data bits per byte (typically 8).
+    """
+    serial_port: str = "/dev/ttyUSB0"
+    slave_id: int = 1
+    baudrate: int = 9600
+    parity: str = "N"
+    stopbits: int = 1
+    bytesize: int = 8
+
+
+class {class_name}(Device):
+    """
+    Device configuration.
+
+    Attributes:
+        id: Unique identifier for this device.
+        protocol: Communication protocol (MODBUS_RTU).
+        connection: Connection settings class.
+        frequency: Polling interval in seconds (how often to read data).
+        filter: List of register names to pull (empty = pull all).
+    """
+    id = "{device_id}"
+    protocol = MODBUS_RTU
+    connection = Connection
+    frequency = FIVE_SEC
+    filter = []  # empty = pull all registers; e.g. ["reg_100", "reg_102"] to filter
+'''
+
+TEMPLATES = {
+    "modbus-tcp": MODBUS_TCP_TEMPLATE,
+    "modbus-rtu": MODBUS_RTU_TEMPLATE,
+}
+
+SCADABLE_ASCII = """
+ ____     ____      _      ____       _      ____    _       _____
+/ ___|   / ___|    / \\    |  _ \\     / \\    | __ )  | |     | ____|
+\\___ \\  | |       / _ \\   | | | |   / _ \\   |  _ \\  | |     |  _|
+ ___) | | |___   / ___ \\  | |_| |  / ___ \\  | |_) | | |___  | |___
+|____/   \\____| /_/   \\_\\ |____/  /_/   \\_\\ |____/  |_____| |_____|
+
+Edge SDK v0.1.0
+"""
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+
+def to_class_name(name: str) -> str:
+    return "".join(p.capitalize() for p in name.replace("_", "-").split("-"))
+
+def get_gateways() -> list:
+    """Get list of gateway names by scanning gateways/ subfolders."""
+    if not os.path.exists("gateways"):
+        return []
+    gateways = []
+    for name in os.listdir("gateways"):
+        path = os.path.join("gateways", name)
+        if os.path.isdir(path):
+            gateways.append(name)
+    return sorted(gateways)
+
+def next_gateway_name() -> str:
+    """Auto-increment gateway name: gateway-001, gateway-002 etc."""
+    existing = get_gateways()
+    i = 1
+    while True:
+        name = f"gateway-{i:03d}"
+        if name not in existing:
+            return name
+        i += 1
+
+def require_project():
+    """Exit if not in a Scadable project (no scadable.json)."""
+    if not os.path.exists(CONFIG_FILE):
+        print(f"No {CONFIG_FILE} found. Run 'scadable init' first.")
+        sys.exit(1)
+
+def resolve_gateway(gateway_arg: str = None) -> str:
+    """
+    Resolve which gateway to use.
+    - If --gateway is specified, use it.
+    - If only one gateway exists, use it automatically.
+    - If multiple exist, prompt the user to pick.
+    """
+    gateways = get_gateways()
+    if not gateways:
+        print("No gateways found. Run 'scadable add gateway' first.")
+        sys.exit(1)
+    if gateway_arg:
+        if gateway_arg not in gateways:
+            print(f"Gateway '{gateway_arg}' not found. Available: {', '.join(gateways)}")
+            sys.exit(1)
+        return gateway_arg
+    if len(gateways) == 1:
+        return gateways[0]
+    # Multiple gateways — prompt
+    print("Multiple gateways found:")
+    for i, gw in enumerate(gateways, 1):
+        print(f"  {i}. {gw}")
+    choice = input("Select gateway (number): ").strip()
+    try:
+        return gateways[int(choice) - 1]
+    except (ValueError, IndexError):
+        print("Invalid choice.")
+        sys.exit(1)
+
+# ─── Commands ─────────────────────────────────────────────────────────────────
+
+def cmd_init(project_name: str = None):
+    if os.path.exists(CONFIG_FILE):
+        print(f"{CONFIG_FILE} already exists.")
+        sys.exit(1)
+    name = project_name or os.path.basename(os.getcwd())
+    config = {"project": name, "version": "0.1.0"}
+    os.makedirs("gateways", exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+    print(SCADABLE_ASCII)
+    print(f"✓ Initialized project '{name}'")
+    print(f"✓ Created gateways/")
+    print(f"✓ Created {CONFIG_FILE}")
+    print(f"\nNext: scadable add gateway")
+
+def cmd_add_gateway(gateway_name: str = None):
+    require_project()
+    existing = get_gateways()
+    name = gateway_name or next_gateway_name()
+    if name in existing:
+        print(f"Gateway '{name}' already exists.")
+        sys.exit(1)
+    path = os.path.join("gateways", name)
+    os.makedirs(path, exist_ok=True)
+    print(f"✓ Created gateways/{name}/")
+    print(f"\nNext: scadable add device modbus-tcp <device-name> --gateway {name}")
+
+def cmd_add_device(protocol: str, device_name: str, gateway_arg: str = None):
+    require_project()
+    gateway = resolve_gateway(gateway_arg)
+    template = TEMPLATES.get(protocol)
+    if not template:
+        print(f"Unknown protocol '{protocol}'. Available: {', '.join(TEMPLATES.keys())}")
+        sys.exit(1)
+    device_path = os.path.join("gateways", gateway, device_name)
+    if os.path.exists(device_path):
+        print(f"Device '{device_name}' already exists in gateway '{gateway}'.")
+        sys.exit(1)
+    os.makedirs(device_path)
+    config_path = os.path.join(device_path, "config.py")
+    content = template.format(
+        class_name=to_class_name(device_name),
+        device_id=device_name,
+    )
+    with open(config_path, "w") as f:
+        f.write(content)
+    print(f"✓ Created {config_path}")
+    print(f"\nNext: edit {config_path} and set your connection details.")
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(prog="scadable")
+    sub = parser.add_subparsers(dest="command")
+
+    # scadable init [name]
+    p_init = sub.add_parser("init", help="Initialize a new Scadable project")
+    p_init.add_argument("name", nargs="?", help="Project name (default: current folder name)")
+
+    # scadable add ...
+    p_add = sub.add_parser("add", help="Add a gateway or device")
+    add_sub = p_add.add_subparsers(dest="resource")
+
+    # scadable add gateway [name]
+    p_gw = add_sub.add_parser("gateway", help="Add a new gateway")
+    p_gw.add_argument("name", nargs="?", help="Gateway name (default: gateway-001, gateway-002...)")
+
+    # scadable add device <protocol> <name> [--gateway <name>]
+    p_dev = add_sub.add_parser("device", help="Add a new device to a gateway")
+    p_dev.add_argument("protocol", choices=list(TEMPLATES.keys()))
+    p_dev.add_argument("name", help="Device name e.g. temp-sensor")
+    p_dev.add_argument("--gateway", help="Gateway name (auto-detected if only one exists)")
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        cmd_init(args.name)
+    elif args.command == "add":
+        if args.resource == "gateway":
+            cmd_add_gateway(getattr(args, "name", None))
+        elif args.resource == "device":
+            cmd_add_device(args.protocol, args.name, getattr(args, "gateway", None))
+        else:
+            p_add.print_help()
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

scadable_cli-0.1.1/scadable/edge/constants.py

@@ -0,0 +1,13 @@
+# Protocols
+MODBUS_TCP = "modbus-tcp"
+MODBUS_RTU = "modbus-rtu"
+OPCUA      = "opcua"
+MQTT       = "mqtt"
+
+# Frequencies in seconds
+ONE_SEC    = 1
+FIVE_SEC   = 5
+TEN_SEC    = 10
+THIRTY_SEC = 30
+ONE_MIN    = 60
+FIVE_MIN   = 300

scadable_cli-0.1.1/scadable/edge/device.py

@@ -0,0 +1,63 @@
+PAYLOAD_SCHEMA = {
+    "device_id": str,
+    "protocol": str,
+    "timestamp": int,
+    "payload": dict,
+}
+
+
+class Device:
+    """
+    Base class for all gateway devices.
+    Subclass this in your config.py to define a device.
+
+    Required class variables:
+        id         — unique identifier for this device
+        protocol   — use a constant from scadable.edge.constants
+        connection — subclass of ModbusConnection (or other protocol connection)
+        frequency  — polling interval in seconds, use constants: FIVE_SEC, TEN_SEC etc
+
+    Optional class variables:
+        filter     — list of register names to pull (empty = pull all)
+
+    Usage:
+        class MyPLC(Device):
+            id = "device-001"
+            protocol = MODBUS_TCP
+            connection = Connection
+            frequency = FIVE_SEC
+            filter = []  # empty = pull all registers
+    """
+
+    id: str = None
+    protocol: str = None
+    connection = None
+    frequency: int = 10
+    filter: list = []
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        # Skip validation for intermediate base classes
+        if cls.__name__ == "Device":
+            return
+        errors = []
+        if not cls.id:
+            errors.append(f"Device subclass '{cls.__name__}' must define 'id'")
+        if not cls.protocol:
+            errors.append(f"Device subclass '{cls.__name__}' must define 'protocol'")
+        if cls.connection is None:
+            errors.append(f"Device subclass '{cls.__name__}' must define 'connection'")
+        if errors:
+            raise TypeError("\n".join(errors))
+
+    def __repr__(self):
+        return (
+            f"<Device id={self.id!r} protocol={self.protocol!r} "
+            f"connection={self.connection.__name__} frequency={self.frequency}s>"
+        )
+
+    def read(self, *args, **kwargs):
+        raise NotImplementedError("read() will be implemented by the WASM runtime")
+
+    def write(self, *args, **kwargs):
+        raise NotImplementedError("write() will be implemented by the WASM runtime")

scadable_cli-0.1.1/scadable/edge/protocols/base.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+class Protocol(ABC):
+    @abstractmethod
+    def read(self, *args, **kwargs):
+        pass
+
+    @abstractmethod
+    def write(self, *args, **kwargs):
+        pass

scadable_cli-0.1.1/scadable/edge/protocols/modbus.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from typing import Optional
+from .base import Protocol
+from ..constants import MODBUS_TCP, MODBUS_RTU
+
+@dataclass
+class ModbusConnection:
+    """
+    Base Modbus connection config.
+    Subclass this in your config.py and override the fields you need.
+
+    Usage:
+        @dataclass
+        class Connection(ModbusConnection):
+            host: str = "192.168.1.100"
+            port: int = 502
+            slave_id: int = 1
+    """
+    host: str = ""
+    port: int = 502
+    slave_id: int = 1
+    timeout: float = 5.0
+    retries: int = 3
+    # RTU only — leave None for TCP
+    serial_port: Optional[str] = None
+    baudrate: int = 9600
+    parity: str = "N"     # N=none, E=even, O=odd
+    stopbits: int = 1
+    bytesize: int = 8
+
+class ModbusProtocol(Protocol):
+    def read(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def write(self, *args, **kwargs):
+        raise NotImplementedError

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

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: scadable-cli
+Version: 0.1.1
+Summary: Edge SDK for the Scadable IoT platform
+License: MIT
+Keywords: iot,scada,edge,modbus,industrial
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Scadable Edge SDK
+
+Python SDK for defining devices on the Scadable IoT platform.
+
+## Installation
+
+```bash
+pip install scadable-cli
+```
+
+## Usage
+
+Create a `config.py` for your device:
+
+```python
+from scadable.edge import Device, ModbusConnection
+from scadable.edge.constants import MODBUS_TCP, FIVE_SEC
+from dataclasses import dataclass
+
+@dataclass
+class Connection(ModbusConnection):
+    host: str = "${DEVICE_HOST}"
+    port: int = 502
+    slave_id: int = 1
+
+class MyPLC(Device):
+    id = "device-001"
+    protocol = MODBUS_TCP
+    connection = Connection
+    frequency = FIVE_SEC
+```
+
+## Project Structure
+
+```
+gateways/
+    gateway-001/
+        device-001/
+            config.py
+        device-002/
+            config.py
+```

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

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+scadable/__init__.py
+scadable/edge/__init__.py
+scadable/edge/cli.py
+scadable/edge/constants.py
+scadable/edge/device.py
+scadable/edge/protocols/__init__.py
+scadable/edge/protocols/base.py
+scadable/edge/protocols/modbus.py
+scadable_cli.egg-info/PKG-INFO
+scadable_cli.egg-info/SOURCES.txt
+scadable_cli.egg-info/dependency_links.txt
+scadable_cli.egg-info/entry_points.txt
+scadable_cli.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1 @@
+scadable

scadable_cli-0.1.1/setup.cfg

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