antioch-py 2.0.6__py3-none-any.whl

antioch_py-2.0.6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+schedule_viz = scripts.schedule_viz:main

antioch_py-2.0.6.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+antioch
+common

common/ark/__init__.py

@@ -0,0 +1,60 @@
+from common.ark.ark import (
+    Ark,
+    ArkInfo,
+    ArkMetadata,
+    ArkReference,
+    ArkVersionReference,
+    AssetReference,
+    AssetVersionReference,
+    Environment,
+    Kinematics,
+)
+from common.ark.hardware import CameraHardware, Hardware, HardwareType, ImuHardware, PirHardware, RadarHardware
+from common.ark.kinematics import Joint, Link
+from common.ark.module import Module, ModuleImage, ModuleInfo, ModuleKind, ModuleParameter, ParamType
+from common.ark.node import HardwareAccessMode, Node, NodeInput, NodeOutput, NodeTimer
+from common.ark.scheduler import InputToken, NodeCompleteEvent, NodeEdge, NodeStartEvent, NodeState, OnlineScheduler, ScheduleEvent
+
+__all__ = [
+    # Core Ark types
+    "Ark",
+    "ArkInfo",
+    "ArkMetadata",
+    "AssetReference",
+    "AssetVersionReference",
+    "ArkReference",
+    "ArkVersionReference",
+    "Environment",
+    "Kinematics",
+    # Module types
+    "Module",
+    "ModuleImage",
+    "ModuleInfo",
+    "ModuleKind",
+    "ModuleParameter",
+    "ParamType",
+    # Node types
+    "HardwareAccessMode",
+    "Node",
+    "NodeInput",
+    "NodeOutput",
+    "NodeTimer",
+    # Kinematics types
+    "Joint",
+    "Link",
+    # Hardware types
+    "CameraHardware",
+    "Hardware",
+    "HardwareType",
+    "ImuHardware",
+    "PirHardware",
+    "RadarHardware",
+    # Schedule types
+    "NodeEdge",
+    "InputToken",
+    "NodeCompleteEvent",
+    "NodeStartEvent",
+    "ScheduleEvent",
+    "NodeState",
+    "OnlineScheduler",
+]

common/ark/ark.py

@@ -0,0 +1,128 @@
+from enum import Enum
+
+from common.ark.hardware import Hardware
+from common.ark.kinematics import Joint, Link
+from common.ark.module import Module
+from common.ark.scheduler import NodeEdge
+from common.message import Message
+
+
+class Environment(str, Enum):
+    """
+    The environment of the Ark.
+
+    :cvar SIM: The simulation environment.
+    :cvar REAL: The real environment.
+    :cvar ALL: All environments.
+    """
+
+    SIM = "sim"
+    REAL = "real"
+    ALL = "all"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class ArkMetadata(Message):
+    """
+    Metadata about the Ark.
+    """
+
+    digest: str
+    version: str
+    timestamp: str
+    asset_hash: str | None = None
+
+
+class ArkInfo(Message):
+    """
+    Information about the Ark.
+    """
+
+    description: str
+    version: str
+
+
+class Kinematics(Message):
+    """
+    The kinematics of the Ark.
+    """
+
+    links: list[Link]
+    joints: list[Joint]
+
+
+class ArkVersionReference(Message):
+    """
+    Reference to an Ark version in the remote Ark registry.
+    """
+
+    version: str
+    created_at: str
+    updated_at: str
+    full_path: str
+    size_bytes: int
+    asset_path: str | None = None
+    asset_size_bytes: int | None = None
+
+
+class ArkReference(Message):
+    """
+    Reference to an Ark in the remote Ark registry.
+    """
+
+    name: str
+    versions: list[ArkVersionReference]
+    created_at: str
+    updated_at: str
+
+
+class AssetVersionReference(Message):
+    """
+    Reference to a specific asset version.
+    """
+
+    version: str
+    full_path: str
+    size_bytes: int
+    created_at: str
+    updated_at: str
+
+
+class AssetReference(Message):
+    """
+    Reference to an asset with all its versions.
+    """
+
+    name: str
+    versions: list[AssetVersionReference]
+    created_at: str
+    updated_at: str
+
+
+class Ark(Message):
+    """
+    Antioch Ark specification.
+    """
+
+    metadata: ArkMetadata
+    name: str
+    capability: Environment
+    info: ArkInfo
+    modules: list[Module]
+    edges: list[NodeEdge]
+    kinematics: Kinematics
+    hardware: list[Hardware]
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("ark_file", type=str, help="The Ark json file to serialize")
+    args = parser.parse_args()
+
+    with open(args.ark_file) as f:
+        ark = Ark.model_validate_json(f.read())
+        print(ark.to_json(2))

common/ark/hardware.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import Field, ValidationInfo, field_validator
+
+from common.message import Message, Pose
+from common.session.views.articulation import ArticulationConfig
+from common.session.views.camera import CameraConfig
+from common.session.views.imu import ImuConfig
+from common.session.views.pir_sensor import PirSensorConfig
+from common.session.views.radar import RadarConfig
+
+
+class HardwareType(str, Enum):
+    """
+    Types of hardware that can be attached to an instance.
+    """
+
+    CAMERA = "camera"
+    IMU = "imu"
+    PIR = "pir"
+    RADAR = "radar"
+    ACTUATOR_GROUP = "actuator_group"
+
+
+class ActuatorGroupHardware(Message):
+    """
+    Actuator group hardware that controls multiple joints.
+    """
+
+    module: str
+    name: str
+    config: ArticulationConfig
+
+
+class ImuHardware(Message):
+    """
+    IMU sensor hardware attached to a link.
+    """
+
+    module: str
+    name: str
+    path: str
+    pose: Pose = Field(default_factory=Pose)
+    parent_link: str | None = None
+    config: ImuConfig
+
+
+class PirHardware(Message):
+    """
+    PIR (Passive Infrared) sensor hardware attached to a link.
+    """
+
+    module: str
+    name: str
+    path: str
+    pose: Pose = Field(default_factory=Pose)
+    parent_link: str | None = None
+    config: PirSensorConfig
+
+
+class RadarHardware(Message):
+    """
+    Radar sensor hardware attached to a link.
+    """
+
+    module: str
+    name: str
+    path: str
+    pose: Pose = Field(default_factory=Pose)
+    parent_link: str | None = None
+    config: RadarConfig
+
+
+class CameraHardware(Message):
+    """
+    Camera sensor hardware attached to a link.
+
+    Used for both RGB and depth cameras - the mode is specified in the config.
+    """
+
+    module: str
+    name: str
+    path: str
+    pose: Pose = Field(default_factory=Pose)
+    parent_link: str | None = None
+    config: CameraConfig
+
+
+class Hardware(Message):
+    """
+    Union of all hardware types for an Ark.
+    """
+
+    type: HardwareType
+    config: ActuatorGroupHardware | ImuHardware | PirHardware | RadarHardware | CameraHardware
+
+    @field_validator("config", mode="before")
+    @classmethod
+    def validate_config(cls, config: dict, info: ValidationInfo):
+        """
+        Validate the hardware config based on the type field.
+        """
+
+        hw_type = info.data.get("type")
+        if hw_type is None:
+            raise ValueError("Hardware type is required")
+        match hw_type:
+            case HardwareType.ACTUATOR_GROUP:
+                return ActuatorGroupHardware.model_validate(config)
+            case HardwareType.IMU:
+                return ImuHardware.model_validate(config)
+            case HardwareType.PIR:
+                return PirHardware.model_validate(config)
+            case HardwareType.RADAR:
+                return RadarHardware.model_validate(config)
+            case HardwareType.CAMERA:
+                return CameraHardware.model_validate(config)
+            case _:
+                raise ValueError(f"Unknown hardware type: {hw_type}")

common/ark/kinematics.py

@@ -0,0 +1,31 @@
+from common.message import Message, Pose
+from common.session.views.joint import JointAxis, JointType
+
+
+class Joint(Message):
+    """
+    Complete specification for a joint connecting two links in an ark.
+
+    A joint defines the kinematic relationship between a parent and child link,
+    including the type of motion allowed, physical properties, and optional
+    actuator_group assignment for coordinated control of multiple joints.
+    """
+
+    path: str
+    parent: str
+    child: str
+    type: JointType
+    pose: Pose
+    axis: JointAxis | None
+    lower_limit: float | None
+    upper_limit: float | None
+
+
+class Link(Message):
+    """
+    A link in the kinematic tree.
+
+    Links are uniquely identified by their USD path.
+    """
+
+    path: str

common/ark/module.py

@@ -0,0 +1,85 @@
+from enum import Enum
+
+from common.ark.node import Node
+from common.message import Message
+
+
+class ModuleKind(str, Enum):
+    """
+    Defines the type of module in the system.
+
+    Modules can be either software primitives that run in containers
+    or hardware abstractions that interface with physical/simulated arks.
+    """
+
+    SOFTWARE = "software"
+    HARDWARE = "hardware"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class ModuleInfo(Message):
+    """
+    Information about a module.
+    """
+
+    name: str
+    description: str | None = None
+
+
+class ParamType(str, Enum):
+    """
+    Supported parameter types for module configuration.
+
+    These types define what kinds of configuration values can be
+    passed to modules at runtime.
+    """
+
+    BOOLEAN = "boolean"
+    NUMBER = "number"
+    TEXT = "text"
+    NULL = "null"
+
+    def __str__(self):
+        return self.value
+
+
+class ModuleParameter(Message):
+    """
+    Type-safe parameter for module configuration.
+
+    Wraps parameter values with type information to ensure type safety
+    when passing configuration to modules at runtime.
+    """
+
+    description: str | None = None
+    type: ParamType
+    value: bool | int | float | str | None
+
+
+class ModuleImage(Message):
+    """
+    Image configuration for hardware module deployment.
+    """
+
+    sim: str | None = None
+    real: str | None = None
+
+
+class Module(Message):
+    """
+    Complete specification for a module in the middleware system.
+
+    A module is a containerized primitive that contains one or more processing nodes.
+    Each module has build configuration, metadata, runtime parameters, and defines
+    the nodes it contains. Modules are the unit of deployment and execution in
+    the middleware system.
+    """
+
+    name: str
+    kind: ModuleKind
+    image: str | ModuleImage
+    info: ModuleInfo
+    parameters: dict[str, ModuleParameter]
+    nodes: dict[str, Node]

common/ark/node.py

@@ -0,0 +1,94 @@
+import math
+from enum import Enum
+
+from pydantic import Field
+
+from common.message import Message
+
+
+class HardwareAccessMode(str, Enum):
+    """
+    Hardware access mode for a node.
+    """
+
+    NONE = "none"
+    READ = "read"
+    WRITE = "write"
+    READ_WRITE = "read_write"
+
+
+class NodeTimer(Message):
+    """
+    Timer configuration for periodic node execution.
+    """
+
+    frequency: float | None = None
+    period: float | None = None
+
+    def to_period_us(self) -> int:
+        """
+        Convert timer specification to period in microseconds with millisecond rounding.
+
+        :return: Period in microseconds rounded to the nearest millisecond.
+        :raises ValueError: If the timer specification is invalid.
+        """
+
+        if self.frequency is not None:
+            if self.frequency <= 0 or not math.isfinite(self.frequency):
+                raise ValueError("Timer frequency must be positive and finite")
+            period_ms = 1000.0 / self.frequency
+        elif self.period is not None:
+            period_ms = self.period
+        else:
+            raise ValueError("Timer must specify frequency or period")
+
+        # Convert to microseconds
+        period_us = int(period_ms * 1000)
+
+        # Round to nearest millisecond
+        rounded_us = ((period_us + 500) // 1000) * 1000
+        if rounded_us == 0:
+            raise ValueError("Timer frequency is too high (sub-millisecond period)")
+
+        return rounded_us
+
+
+class NodeInput(Message):
+    """
+    Configuration for a node's input.
+    """
+
+    name: str
+    description: str | None = None
+    type: str
+    path: str
+    required: bool
+    always_run: bool
+    last_n: int
+    max_age_ms: int | None = None
+    consume_inputs: bool
+
+
+class NodeOutput(Message):
+    """
+    Configuration for a node's output.
+    """
+
+    name: str
+    description: str | None = None
+    type: str
+    path: str
+
+
+class Node(Message):
+    """
+    Complete specification for a processing node within a module.
+    """
+
+    name: str
+    description: str | None = None
+    budget_us: int
+    timer: NodeTimer | None = None
+    inputs: dict[str, NodeInput] = Field(default_factory=dict)
+    outputs: dict[str, NodeOutput] = Field(default_factory=dict)
+    hardware_access: dict[str, HardwareAccessMode] = Field(default_factory=dict)