rxon 1.0b0__tar.gz

rxon-1.0b0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dmitrii Gagarin
+
+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.

rxon-1.0b0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: rxon
+Version: 1.0b0
+Summary: RXON (Reverse Axon) - Lightweight Inter-node Reverse Communication Protocol.
+Author-email: Dmitrii Gagarin <madgagarin@gmail.com>
+Maintainer-email: Dmitrii Gagarin <madgagarin@gmail.com>
+Project-URL: Homepage, https://github.com/madgagarin/rxon
+Project-URL: Repository, https://github.com/madgagarin/rxon
+Project-URL: Bug Tracker, https://github.com/madgagarin/rxon/issues
+Keywords: rxon,hln,protocol,distributed-systems,holarchy,holon
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.12
+Requires-Dist: orjson>=3.10
+Dynamic: license-file
+
+# RXON (Reverse Axon) Protocol
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/release/python-3110/)
+[![Typing: Typed](https://img.shields.io/badge/Typing-Typed-brightgreen.svg)](https://peps.python.org/pep-0561/)
+
+> **[RU](https://github.com/madgagarin/rxon/blob/main/README_RU.md)**
+
+**RXON** (Reverse Axon) is a lightweight reverse-connection inter-service communication protocol designed for the **[HLN (Hierarchical Logic Network)](https://github.com/avtomatika-ai/hln)** architecture.
+
+It serves as the "nervous system" for distributed multi-agent systems, connecting autonomous nodes (Holons) into a single hierarchical network.
+
+## 🧬 The Biological Metaphor
+
+The name **RXON** is derived from the biological term *Axon* (the nerve fiber). In classic networks, commands typically flow "top-down" (Push model). In RXON, the connection initiative always comes from the subordinate node (Worker/Shell) to the superior node (Orchestrator/Ghost). This is a "Reverse Axon" that grows from the bottom up, creating a channel through which commands subsequently descend.
+
+## ✨ Key Features
+
+-   **Pluggable Transports**: Full abstraction from the network layer. The same code can run over HTTP, WebSocket, gRPC, or Tor.
+-   **Zero Dependency Core**: The protocol core has no external dependencies (standard transports use `aiohttp` and `orjson`).
+-   **Strictly Typed**: All messages (tasks, results, heartbeats) are defined via strictly typed models for maximum performance and correctness.
+-   **Blob Storage Native**: Built-in support for offloading heavy data via S3-compatible storage (`rxon.blob`).
+
+## 🏗 Architecture
+
+The protocol is divided into two main interfaces:
+
+1.  **Transport (Worker side)**: Interface for initiating connections, retrieving tasks, and sending results.
+2.  **Listener (Orchestrator side)**: Interface for accepting incoming connections and routing messages to the orchestration engine.
+
+### Usage Example (Worker side)
+
+```python
+from rxon import create_transport, WorkerRegistration
+
+# 1. Create transport (automatically selects HttpTransport based on URL scheme)
+transport = create_transport(
+    url="https://orchestrator.local",
+    worker_id="gpu-01",
+    token="secret-token"
+)
+
+await transport.connect()
+
+# 2. Register
+await transport.register(reg_payload)
+
+# 3. Poll for tasks
+task = await transport.poll_task(timeout=30)
+```
+
+### Usage Example (Orchestrator side)
+
+```python
+from rxon import HttpListener, TaskPayload
+
+async def my_handler(message_type, payload, context):
+    if message_type == "poll":
+        # Task dispatch logic
+        return TaskPayload(...)
+    return True
+
+# Listener attaches to a web application or starts its own server
+listener = HttpListener(app)
+await listener.start(handler=my_handler)
+```
+
+## 📦 Package Structure
+
+-   **`rxon.models`**: DTOs for registrations, tasks, heartbeats, and results.
+-   **`rxon.constants`**: Standardized error codes (TIMEOUT, RESOURCE_EXHAUSTED, etc.) and API endpoints.
+-   **`rxon.transports`**: Abstract base classes and implementations (HTTP, WebSocket).
+-   **`rxon.blob`**: Unified interface for blob storage operations (S3 URI parsing, hashing).
+-   **`rxon.security`**: Helpers for mTLS and access tokens.
+
+## 🚀 Installation
+
+```bash
+pip install rxon
+```
+
+For developers (local):
+```bash
+pip install -e packages/rxon
+```
+
+## 📜 License
+
+The project is distributed under the MIT License.
+
+---
+*Mantra: "The RXON is the medium for the Ghost."*

rxon-1.0b0/README.md

@@ -0,0 +1,92 @@
+# RXON (Reverse Axon) Protocol
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/release/python-3110/)
+[![Typing: Typed](https://img.shields.io/badge/Typing-Typed-brightgreen.svg)](https://peps.python.org/pep-0561/)
+
+> **[RU](https://github.com/madgagarin/rxon/blob/main/README_RU.md)**
+
+**RXON** (Reverse Axon) is a lightweight reverse-connection inter-service communication protocol designed for the **[HLN (Hierarchical Logic Network)](https://github.com/avtomatika-ai/hln)** architecture.
+
+It serves as the "nervous system" for distributed multi-agent systems, connecting autonomous nodes (Holons) into a single hierarchical network.
+
+## 🧬 The Biological Metaphor
+
+The name **RXON** is derived from the biological term *Axon* (the nerve fiber). In classic networks, commands typically flow "top-down" (Push model). In RXON, the connection initiative always comes from the subordinate node (Worker/Shell) to the superior node (Orchestrator/Ghost). This is a "Reverse Axon" that grows from the bottom up, creating a channel through which commands subsequently descend.
+
+## ✨ Key Features
+
+-   **Pluggable Transports**: Full abstraction from the network layer. The same code can run over HTTP, WebSocket, gRPC, or Tor.
+-   **Zero Dependency Core**: The protocol core has no external dependencies (standard transports use `aiohttp` and `orjson`).
+-   **Strictly Typed**: All messages (tasks, results, heartbeats) are defined via strictly typed models for maximum performance and correctness.
+-   **Blob Storage Native**: Built-in support for offloading heavy data via S3-compatible storage (`rxon.blob`).
+
+## 🏗 Architecture
+
+The protocol is divided into two main interfaces:
+
+1.  **Transport (Worker side)**: Interface for initiating connections, retrieving tasks, and sending results.
+2.  **Listener (Orchestrator side)**: Interface for accepting incoming connections and routing messages to the orchestration engine.
+
+### Usage Example (Worker side)
+
+```python
+from rxon import create_transport, WorkerRegistration
+
+# 1. Create transport (automatically selects HttpTransport based on URL scheme)
+transport = create_transport(
+    url="https://orchestrator.local",
+    worker_id="gpu-01",
+    token="secret-token"
+)
+
+await transport.connect()
+
+# 2. Register
+await transport.register(reg_payload)
+
+# 3. Poll for tasks
+task = await transport.poll_task(timeout=30)
+```
+
+### Usage Example (Orchestrator side)
+
+```python
+from rxon import HttpListener, TaskPayload
+
+async def my_handler(message_type, payload, context):
+    if message_type == "poll":
+        # Task dispatch logic
+        return TaskPayload(...)
+    return True
+
+# Listener attaches to a web application or starts its own server
+listener = HttpListener(app)
+await listener.start(handler=my_handler)
+```
+
+## 📦 Package Structure
+
+-   **`rxon.models`**: DTOs for registrations, tasks, heartbeats, and results.
+-   **`rxon.constants`**: Standardized error codes (TIMEOUT, RESOURCE_EXHAUSTED, etc.) and API endpoints.
+-   **`rxon.transports`**: Abstract base classes and implementations (HTTP, WebSocket).
+-   **`rxon.blob`**: Unified interface for blob storage operations (S3 URI parsing, hashing).
+-   **`rxon.security`**: Helpers for mTLS and access tokens.
+
+## 🚀 Installation
+
+```bash
+pip install rxon
+```
+
+For developers (local):
+```bash
+pip install -e packages/rxon
+```
+
+## 📜 License
+
+The project is distributed under the MIT License.
+
+---
+*Mantra: "The RXON is the medium for the Ghost."*

rxon-1.0b0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rxon"
+version = "1.0b0"
+description = "RXON (Reverse Axon) - Lightweight Inter-node Reverse Communication Protocol."
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    {name = "Dmitrii Gagarin", email = "madgagarin@gmail.com"},
+]
+maintainers = [
+    {name = "Dmitrii Gagarin", email = "madgagarin@gmail.com"},
+]
+keywords = ["rxon", "hln", "protocol", "distributed-systems", "holarchy", "holon"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aiohttp>=3.12",
+    "orjson>=3.10",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/madgagarin/rxon"
+"Repository" = "https://github.com/madgagarin/rxon"
+"Bug Tracker" = "https://github.com/madgagarin/rxon/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+rxon = ["py.typed"]
+
+[tool.ruff]
+src = ["src"]
+target-version = "py311"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "A", "SIM", "C4"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.19.1",
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=7.0.0",
+]

rxon-1.0b0/setup.cfg

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

rxon-1.0b0/src/rxon/__init__.py

@@ -0,0 +1,152 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .blob import RXON_BLOB_SCHEME, calculate_config_hash, parse_uri
+from .constants import (
+    AUTH_HEADER_CLIENT,
+    AUTH_HEADER_WORKER,
+    COMMAND_CANCEL_TASK,
+    ENDPOINT_TASK_NEXT,
+    ENDPOINT_TASK_RESULT,
+    ENDPOINT_WORKER_HEARTBEAT,
+    ENDPOINT_WORKER_REGISTER,
+    ERROR_CODE_DEPENDENCY,
+    ERROR_CODE_INTEGRITY_MISMATCH,
+    ERROR_CODE_INTERNAL,
+    ERROR_CODE_INVALID_INPUT,
+    ERROR_CODE_PERMANENT,
+    ERROR_CODE_RESOURCE_EXHAUSTED,
+    ERROR_CODE_SECURITY,
+    ERROR_CODE_TIMEOUT,
+    ERROR_CODE_TRANSIENT,
+    JOB_STATUS_CANCELLED,
+    JOB_STATUS_ERROR,
+    JOB_STATUS_FAILED,
+    JOB_STATUS_FINISHED,
+    JOB_STATUS_PENDING,
+    JOB_STATUS_QUARANTINED,
+    JOB_STATUS_RUNNING,
+    JOB_STATUS_WAITING_FOR_HUMAN,
+    JOB_STATUS_WAITING_FOR_PARALLEL,
+    JOB_STATUS_WAITING_FOR_WORKER,
+    MSG_TYPE_PROGRESS,
+    PROTOCOL_VERSION,
+    STS_TOKEN_ENDPOINT,
+    TASK_STATUS_CANCELLED,
+    TASK_STATUS_FAILURE,
+    TASK_STATUS_SUCCESS,
+    WORKER_API_PREFIX,
+    WS_ENDPOINT,
+)
+from .exceptions import (
+    IntegrityError,
+    ParamValidationError,
+    RXONProtocolError,
+    S3ConfigMismatchError,
+)
+from .models import (
+    FileMetadata,
+    GPUInfo,
+    Heartbeat,
+    InstalledModel,
+    ProgressUpdatePayload,
+    Resources,
+    TaskError,
+    TaskPayload,
+    TaskResult,
+    TokenResponse,
+    WorkerCapabilities,
+    WorkerCommand,
+    WorkerRegistration,
+)
+from .security import (
+    create_client_ssl_context,
+    create_server_ssl_context,
+    extract_cert_identity,
+)
+from .transports.base import Listener, Transport
+from .transports.factory import create_transport
+from .transports.http import HttpTransport
+from .transports.http_server import HttpListener
+from .utils import to_dict
+from .validators import is_valid_identifier, validate_identifier
+
+__all__ = [
+    # Blob
+    "RXON_BLOB_SCHEME",
+    "calculate_config_hash",
+    "parse_uri",
+    # Constants
+    "AUTH_HEADER_CLIENT",
+    "AUTH_HEADER_WORKER",
+    "COMMAND_CANCEL_TASK",
+    "ENDPOINT_TASK_NEXT",
+    "ENDPOINT_TASK_RESULT",
+    "ENDPOINT_WORKER_HEARTBEAT",
+    "ENDPOINT_WORKER_REGISTER",
+    "ERROR_CODE_DEPENDENCY",
+    "ERROR_CODE_INTEGRITY_MISMATCH",
+    "ERROR_CODE_INTERNAL",
+    "ERROR_CODE_INVALID_INPUT",
+    "ERROR_CODE_PERMANENT",
+    "ERROR_CODE_RESOURCE_EXHAUSTED",
+    "ERROR_CODE_SECURITY",
+    "ERROR_CODE_TIMEOUT",
+    "ERROR_CODE_TRANSIENT",
+    "JOB_STATUS_CANCELLED",
+    "JOB_STATUS_ERROR",
+    "JOB_STATUS_FAILED",
+    "JOB_STATUS_FINISHED",
+    "JOB_STATUS_PENDING",
+    "JOB_STATUS_QUARANTINED",
+    "JOB_STATUS_RUNNING",
+    "JOB_STATUS_WAITING_FOR_HUMAN",
+    "JOB_STATUS_WAITING_FOR_PARALLEL",
+    "JOB_STATUS_WAITING_FOR_WORKER",
+    "MSG_TYPE_PROGRESS",
+    "PROTOCOL_VERSION",
+    "STS_TOKEN_ENDPOINT",
+    "TASK_STATUS_CANCELLED",
+    "TASK_STATUS_FAILURE",
+    "TASK_STATUS_SUCCESS",
+    "WORKER_API_PREFIX",
+    "WS_ENDPOINT",
+    # Exceptions
+    "IntegrityError",
+    "ParamValidationError",
+    "RXONProtocolError",
+    "S3ConfigMismatchError",
+    # Models
+    "FileMetadata",
+    "GPUInfo",
+    "Heartbeat",
+    "InstalledModel",
+    "ProgressUpdatePayload",
+    "Resources",
+    "TaskError",
+    "TaskPayload",
+    "TaskResult",
+    "TokenResponse",
+    "WorkerCapabilities",
+    "WorkerCommand",
+    "WorkerRegistration",
+    # Security
+    "create_client_ssl_context",
+    "create_server_ssl_context",
+    "extract_cert_identity",
+    # Transports
+    "Listener",
+    "Transport",
+    "create_transport",
+    "HttpTransport",
+    "HttpListener",
+    # Utils
+    "to_dict",
+    # Validators
+    "is_valid_identifier",
+    "validate_identifier",
+]
+
+try:
+    __version__ = version("rxon")
+except PackageNotFoundError:
+    __version__ = "unknown"

rxon-1.0b0/src/rxon/blob.py

@@ -0,0 +1,51 @@
+from hashlib import sha256
+from typing import Tuple
+from urllib.parse import urlparse
+
+__all__ = [
+    "RXON_BLOB_SCHEME",
+    "calculate_config_hash",
+    "parse_uri",
+]
+
+RXON_BLOB_SCHEME = "s3"
+
+
+def calculate_config_hash(endpoint: str | None, access_key: str | None, bucket: str | None) -> str | None:
+    """
+    Calculates a consistent hash of the Blob/S3 configuration.
+    Used to ensure Workers and Orchestrators are talking to the same storage.
+    Uses '|' as separator.
+    """
+    if not endpoint or not access_key or not bucket:
+        return None
+
+    config_str = f"{endpoint}|{access_key}|{bucket}"
+    return sha256(config_str.encode()).hexdigest()[:16]
+
+
+def parse_uri(uri: str, default_bucket: str | None = None, prefix: str = "") -> Tuple[str, str, bool]:
+    """
+    Parses a Blob/S3 URI or relative path into (bucket, key, is_directory).
+    Protocol: s3://bucket/key
+
+    :param uri: Full URI (s3://bucket/key) or relative path (key)
+    :param default_bucket: Bucket to use if URI is relative
+    :param prefix: Optional prefix to prepend to relative paths
+    :return: (bucket, key, is_directory)
+    :raises ValueError: If URI format is invalid or bucket is missing
+    """
+    is_dir = uri.endswith("/")
+
+    if uri.startswith(f"{RXON_BLOB_SCHEME}://"):
+        parsed = urlparse(uri)
+        bucket = parsed.netloc
+        key = parsed.path.lstrip("/")
+        return bucket, key, is_dir
+    else:
+        if not default_bucket:
+            raise ValueError(f"Cannot parse relative path '{uri}' without a default bucket.")
+
+        clean_path = uri.lstrip("/")
+        key = f"{prefix}{clean_path}" if prefix else clean_path
+        return default_bucket, key, is_dir

rxon-1.0b0/src/rxon/constants.py

@@ -0,0 +1,94 @@
+"""
+Centralized constants for the RXON protocol.
+Shared between Orchestrator and Worker SDK.
+"""
+
+__all__ = [
+    "AUTH_HEADER_CLIENT",
+    "AUTH_HEADER_WORKER",
+    "ERROR_CODE_TRANSIENT",
+    "ERROR_CODE_PERMANENT",
+    "ERROR_CODE_INVALID_INPUT",
+    "ERROR_CODE_INTEGRITY_MISMATCH",
+    "ERROR_CODE_TIMEOUT",
+    "ERROR_CODE_RESOURCE_EXHAUSTED",
+    "ERROR_CODE_DEPENDENCY",
+    "ERROR_CODE_SECURITY",
+    "ERROR_CODE_INTERNAL",
+    "TASK_STATUS_SUCCESS",
+    "TASK_STATUS_FAILURE",
+    "TASK_STATUS_CANCELLED",
+    "COMMAND_CANCEL_TASK",
+    "MSG_TYPE_PROGRESS",
+    "STS_TOKEN_ENDPOINT",
+    "WS_ENDPOINT",
+    "ENDPOINT_WORKER_REGISTER",
+    "ENDPOINT_TASK_NEXT",
+    "ENDPOINT_TASK_RESULT",
+    "ENDPOINT_WORKER_HEARTBEAT",
+    "JOB_STATUS_PENDING",
+    "JOB_STATUS_WAITING_FOR_WORKER",
+    "JOB_STATUS_RUNNING",
+    "JOB_STATUS_FINISHED",
+    "JOB_STATUS_FAILED",
+    "JOB_STATUS_ERROR",
+    "JOB_STATUS_QUARANTINED",
+    "JOB_STATUS_CANCELLED",
+    "JOB_STATUS_WAITING_FOR_HUMAN",
+    "JOB_STATUS_WAITING_FOR_PARALLEL",
+    "WORKER_API_PREFIX",
+    "PROTOCOL_VERSION",
+]
+
+# --- Protocol Metadata ---
+PROTOCOL_VERSION = "1.0"
+
+# --- Auth Headers ---
+AUTH_HEADER_CLIENT = "X-Client-Token"
+AUTH_HEADER_WORKER = "X-Worker-Token"
+
+# --- Error Codes ---
+# Error codes returned by workers in the result payload
+ERROR_CODE_TRANSIENT = "TRANSIENT_ERROR"
+ERROR_CODE_PERMANENT = "PERMANENT_ERROR"
+ERROR_CODE_INVALID_INPUT = "INVALID_INPUT_ERROR"
+ERROR_CODE_INTEGRITY_MISMATCH = "INTEGRITY_MISMATCH_ERROR"
+ERROR_CODE_TIMEOUT = "TIMEOUT_ERROR"
+ERROR_CODE_RESOURCE_EXHAUSTED = "RESOURCE_EXHAUSTED_ERROR"
+ERROR_CODE_DEPENDENCY = "DEPENDENCY_ERROR"
+ERROR_CODE_SECURITY = "SECURITY_ERROR"
+ERROR_CODE_INTERNAL = "INTERNAL_ERROR"
+
+# --- Task Statuses ---
+# Standard statuses for task results
+TASK_STATUS_SUCCESS = "success"
+TASK_STATUS_FAILURE = "failure"
+TASK_STATUS_CANCELLED = "cancelled"
+
+# --- Commands (WebSocket) ---
+COMMAND_CANCEL_TASK = "cancel_task"
+MSG_TYPE_PROGRESS = "progress_update"
+
+# --- Endpoints ---
+WORKER_API_PREFIX = "/_worker"
+
+STS_TOKEN_ENDPOINT = f"{WORKER_API_PREFIX}/auth/token"
+WS_ENDPOINT = f"{WORKER_API_PREFIX}/ws"
+
+# Routes for REST API interaction
+ENDPOINT_WORKER_REGISTER = f"{WORKER_API_PREFIX}/workers/register"
+ENDPOINT_TASK_NEXT = f"{WORKER_API_PREFIX}/workers/{{worker_id}}/tasks/next"
+ENDPOINT_TASK_RESULT = f"{WORKER_API_PREFIX}/tasks/result"
+ENDPOINT_WORKER_HEARTBEAT = f"{WORKER_API_PREFIX}/workers/{{worker_id}}"
+
+# --- Job Statuses ---
+JOB_STATUS_PENDING = "pending"
+JOB_STATUS_WAITING_FOR_WORKER = "waiting_for_worker"
+JOB_STATUS_RUNNING = "running"
+JOB_STATUS_FINISHED = "finished"
+JOB_STATUS_FAILED = "failed"
+JOB_STATUS_ERROR = "error"
+JOB_STATUS_QUARANTINED = "quarantined"
+JOB_STATUS_CANCELLED = "cancelled"
+JOB_STATUS_WAITING_FOR_HUMAN = "waiting_for_human"
+JOB_STATUS_WAITING_FOR_PARALLEL = "waiting_for_parallel_tasks"

rxon-1.0b0/src/rxon/exceptions.py

@@ -0,0 +1,30 @@
+__all__ = [
+    "RXONProtocolError",
+    "S3ConfigMismatchError",
+    "IntegrityError",
+    "ParamValidationError",
+]
+
+
+class RXONProtocolError(Exception):
+    """Base exception for all protocol-related errors."""
+
+    pass
+
+
+class S3ConfigMismatchError(RXONProtocolError):
+    """Raised when Worker and Orchestrator S3 configurations do not match."""
+
+    pass
+
+
+class IntegrityError(RXONProtocolError):
+    """Raised when file integrity check (size/hash) fails."""
+
+    pass
+
+
+class ParamValidationError(RXONProtocolError):
+    """Raised when task parameters fail validation."""
+
+    pass