nodus-schema 0.1.0__tar.gz

nodus_schema-0.1.0/LICENSE

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

nodus_schema-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: nodus-schema
+Version: 0.1.0
+Summary: Versioned ABI schema validation, parsing, and registry
+Author: Shawn Knight
+License: MIT
+Project-URL: Homepage, https://github.com/Masterplanner25/nodus-schema
+Project-URL: Repository, https://github.com/Masterplanner25/nodus-schema
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# nodus-schema
+
+**Versioned ABI schema validation, parsing, and registry for Nodus AI systems.**
+
+Validates payloads against simple-form or JSON Schema object definitions,
+parses versioned surface names (`sys.v1.domain.action`), and maintains a
+thread-safe `SchemaRegistry` of versioned schemas with stability tracking.
+No required external dependencies — pure stdlib.
+
+> **Note on naming:** This is the standalone `nodus-schema` package
+> (`C:\dev\nodus-schema`). The nodus-lang runtime also ships an in-tree
+> `nodus_schema` package (`src/nodus_schema/`) with `SyscallSpec`,
+> `HandlerContract`, and `VALID_EFFECTS`. The two are distinct; check
+> `python -c "import nodus_schema; print(nodus_schema.__file__)"` to confirm
+> which is active.
+
+> **Status:** v0.1.0 — prepared, not yet published.
+
+---
+
+## Install
+
+```bash
+pip install nodus-schema
+```
+
+---
+
+## What it provides
+
+| Component | Purpose |
+|---|---|
+| `validate_payload` | Validate a dict against a schema; returns list of error strings |
+| `validate_input` / `validate_output` | Aliases for `validate_payload` |
+| `parse_versioned_name` | Parse `"sys.v1.domain.action"` → `(version, action)` |
+| `resolve_version` | Find best compatible version from available set |
+| `is_stable_version` | True for `"v1"`, `"v2"`, etc. (not alpha/beta) |
+| `SchemaEntry` | One versioned schema with stability and deprecation state |
+| `SchemaRegistry` | Thread-safe registry of `SchemaEntry` objects |
+
+---
+
+## Schema validation
+
+```python
+from nodus_schema import validate_payload
+
+schema = {
+    "type": "object",
+    "properties": {
+        "name": {"type": "string"},
+        "age":  {"type": "integer"},
+    },
+    "required": ["name"],
+}
+
+errors = validate_payload(schema, {"name": "Alice", "age": 30})
+# [] — valid
+
+errors = validate_payload(schema, {"age": 30})
+# ["Missing required field: 'name'"]
+
+errors = validate_payload(schema, {"name": "Alice", "age": "thirty"})
+# ["Field 'age': expected type 'integer', got 'str'"]
+```
+
+### Simple-form schema
+
+A flat `{field: type_string}` dict is also accepted:
+
+```python
+errors = validate_payload({"key": "str", "value": "any"}, {"key": "hello"})
+# [] — "any" allows any type
+```
+
+Supported type strings: `string`/`str`, `integer`/`int`, `number`/`float`,
+`boolean`/`bool`, `object`/`map`/`dict`, `array`/`list`, `null`/`nil`, `any`.
+
+---
+
+## Versioned name parsing
+
+```python
+from nodus_schema import parse_versioned_name, resolve_version, is_stable_version
+
+version, action = parse_versioned_name("sys.v1.memory.write")
+# ("v1", "memory.write")
+
+best = resolve_version("v1", available={"v1", "v2"}, fallback=True)
+# "v1"
+
+is_stable_version("v1")      # True
+is_stable_version("v1alpha1") # False
+is_stable_version("v1beta2")  # False
+```
+
+---
+
+## SchemaRegistry
+
+```python
+from nodus_schema import SchemaRegistry, SchemaEntry
+
+registry = SchemaRegistry()
+registry.register(SchemaEntry(
+    name="memory.write",
+    version="v1",
+    input_schema={"key": "str", "value": "any"},
+    output_schema={"stored": "bool"},
+    stable=True,
+    deprecated=False,
+))
+
+entry = registry.get("memory.write", version="v1")  # SchemaEntry | None
+versions = registry.versions("memory.write")         # ["v1"]
+all_entries = registry.list()                        # list[SchemaEntry]
+```
+
+---
+
+## Design
+
+- **No required dependencies.** Pure stdlib (`json`, `threading`, `dataclasses`).
+- **Simple-form schemas.** Flat `{field: type}` dicts are normalized to JSON
+  Schema objects automatically.
+- **Thread-safe.** `SchemaRegistry` uses `threading.Lock`.
+
+---
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -q
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

nodus_schema-0.1.0/README.md

@@ -0,0 +1,141 @@
+# nodus-schema
+
+**Versioned ABI schema validation, parsing, and registry for Nodus AI systems.**
+
+Validates payloads against simple-form or JSON Schema object definitions,
+parses versioned surface names (`sys.v1.domain.action`), and maintains a
+thread-safe `SchemaRegistry` of versioned schemas with stability tracking.
+No required external dependencies — pure stdlib.
+
+> **Note on naming:** This is the standalone `nodus-schema` package
+> (`C:\dev\nodus-schema`). The nodus-lang runtime also ships an in-tree
+> `nodus_schema` package (`src/nodus_schema/`) with `SyscallSpec`,
+> `HandlerContract`, and `VALID_EFFECTS`. The two are distinct; check
+> `python -c "import nodus_schema; print(nodus_schema.__file__)"` to confirm
+> which is active.
+
+> **Status:** v0.1.0 — prepared, not yet published.
+
+---
+
+## Install
+
+```bash
+pip install nodus-schema
+```
+
+---
+
+## What it provides
+
+| Component | Purpose |
+|---|---|
+| `validate_payload` | Validate a dict against a schema; returns list of error strings |
+| `validate_input` / `validate_output` | Aliases for `validate_payload` |
+| `parse_versioned_name` | Parse `"sys.v1.domain.action"` → `(version, action)` |
+| `resolve_version` | Find best compatible version from available set |
+| `is_stable_version` | True for `"v1"`, `"v2"`, etc. (not alpha/beta) |
+| `SchemaEntry` | One versioned schema with stability and deprecation state |
+| `SchemaRegistry` | Thread-safe registry of `SchemaEntry` objects |
+
+---
+
+## Schema validation
+
+```python
+from nodus_schema import validate_payload
+
+schema = {
+    "type": "object",
+    "properties": {
+        "name": {"type": "string"},
+        "age":  {"type": "integer"},
+    },
+    "required": ["name"],
+}
+
+errors = validate_payload(schema, {"name": "Alice", "age": 30})
+# [] — valid
+
+errors = validate_payload(schema, {"age": 30})
+# ["Missing required field: 'name'"]
+
+errors = validate_payload(schema, {"name": "Alice", "age": "thirty"})
+# ["Field 'age': expected type 'integer', got 'str'"]
+```
+
+### Simple-form schema
+
+A flat `{field: type_string}` dict is also accepted:
+
+```python
+errors = validate_payload({"key": "str", "value": "any"}, {"key": "hello"})
+# [] — "any" allows any type
+```
+
+Supported type strings: `string`/`str`, `integer`/`int`, `number`/`float`,
+`boolean`/`bool`, `object`/`map`/`dict`, `array`/`list`, `null`/`nil`, `any`.
+
+---
+
+## Versioned name parsing
+
+```python
+from nodus_schema import parse_versioned_name, resolve_version, is_stable_version
+
+version, action = parse_versioned_name("sys.v1.memory.write")
+# ("v1", "memory.write")
+
+best = resolve_version("v1", available={"v1", "v2"}, fallback=True)
+# "v1"
+
+is_stable_version("v1")      # True
+is_stable_version("v1alpha1") # False
+is_stable_version("v1beta2")  # False
+```
+
+---
+
+## SchemaRegistry
+
+```python
+from nodus_schema import SchemaRegistry, SchemaEntry
+
+registry = SchemaRegistry()
+registry.register(SchemaEntry(
+    name="memory.write",
+    version="v1",
+    input_schema={"key": "str", "value": "any"},
+    output_schema={"stored": "bool"},
+    stable=True,
+    deprecated=False,
+))
+
+entry = registry.get("memory.write", version="v1")  # SchemaEntry | None
+versions = registry.versions("memory.write")         # ["v1"]
+all_entries = registry.list()                        # list[SchemaEntry]
+```
+
+---
+
+## Design
+
+- **No required dependencies.** Pure stdlib (`json`, `threading`, `dataclasses`).
+- **Simple-form schemas.** Flat `{field: type}` dicts are normalized to JSON
+  Schema objects automatically.
+- **Thread-safe.** `SchemaRegistry` uses `threading.Lock`.
+
+---
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -q
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

nodus_schema-0.1.0/nodus_schema/__init__.py

@@ -0,0 +1,37 @@
+"""nodus-schema — versioned ABI schema validation and registry.
+
+Validation:
+    validate_payload(schema, payload) → list[str]  — error strings, empty = valid
+    validate_input(schema, payload)   → list[str]  — alias
+    validate_output(schema, data)     → list[str]  — alias
+
+Versioning:
+    parse_versioned_name(name) → (version, action)
+    resolve_version(requested, available, fallback) → str | None
+    is_stable_version(version) → bool
+    SYSCALL_VERSION_FALLBACK — default fallback ("v1")
+
+Registry:
+    SchemaEntry   — one versioned schema (name, version, schemas, stable/deprecated)
+    SchemaRegistry — thread-safe; register, get, versions(), list()
+"""
+from .registry import SchemaEntry, SchemaRegistry
+from .schema import validate_input, validate_output, validate_payload
+from .versioning import (
+    SYSCALL_VERSION_FALLBACK,
+    is_stable_version,
+    parse_versioned_name,
+    resolve_version,
+)
+
+__all__ = [
+    "validate_payload",
+    "validate_input",
+    "validate_output",
+    "parse_versioned_name",
+    "resolve_version",
+    "is_stable_version",
+    "SYSCALL_VERSION_FALLBACK",
+    "SchemaEntry",
+    "SchemaRegistry",
+]

nodus_schema-0.1.0/nodus_schema/registry.py

@@ -0,0 +1,84 @@
+"""SchemaRegistry — store and retrieve versioned ABI schema entries."""
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class SchemaEntry:
+    """One versioned ABI schema registration.
+
+    Attributes
+    ----------
+    name:           Action name (e.g. ``"memory.read"``).
+    version:        ABI version string (e.g. ``"v1"``).
+    input_schema:   Lightweight schema for input validation.
+    output_schema:  Lightweight schema for output validation.
+    stable:         False = experimental; deprecation possible.
+    deprecated:     When True, callers should migrate to *replacement*.
+    deprecated_since: Version string when deprecation was introduced.
+    replacement:    Full versioned name to migrate to.
+    """
+
+    name: str
+    version: str
+    input_schema: Optional[dict] = None
+    output_schema: Optional[dict] = None
+    stable: bool = True
+    deprecated: bool = False
+    deprecated_since: Optional[str] = None
+    replacement: Optional[str] = None
+
+    @property
+    def full_name(self) -> str:
+        """``"v1.memory.read"``"""
+        return f"{self.version}.{self.name}"
+
+
+class SchemaRegistry:
+    """Thread-safe registry of ``SchemaEntry`` objects.
+
+    Usage::
+
+        reg = SchemaRegistry()
+        reg.register(SchemaEntry("memory.read", "v1",
+                                 input_schema={...}, output_schema={...}))
+        entry = reg.get("v1.memory.read")
+    """
+
+    def __init__(self) -> None:
+        self._entries: dict[str, SchemaEntry] = {}
+        self._lock = threading.Lock()
+
+    def register(self, entry: SchemaEntry) -> None:
+        """Register *entry*, keyed by ``entry.full_name``."""
+        with self._lock:
+            self._entries[entry.full_name] = entry
+
+    def get(self, full_name: str) -> Optional[SchemaEntry]:
+        """Return the entry for *full_name* (e.g. ``"v1.memory.read"``)."""
+        with self._lock:
+            return self._entries.get(full_name)
+
+    def versions(self) -> frozenset[str]:
+        """Return the set of all registered version strings."""
+        with self._lock:
+            return frozenset(e.version for e in self._entries.values())
+
+    def list(self, *, include_deprecated: bool = False) -> list[SchemaEntry]:
+        """Return all registered entries."""
+        with self._lock:
+            entries = list(self._entries.values())
+        if not include_deprecated:
+            entries = [e for e in entries if not e.deprecated]
+        return entries
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._entries)
+
+    def __contains__(self, full_name: str) -> bool:
+        with self._lock:
+            return full_name in self._entries

nodus_schema-0.1.0/nodus_schema/schema.py

@@ -0,0 +1,85 @@
+"""Lightweight schema validation — extracted from AINDY/kernel/syscall_versioning.py."""
+from __future__ import annotations
+
+from typing import Any
+
+# Normalise type aliases to canonical names
+_TYPE_MAP: dict[str, str] = {
+    "str": "string", "string": "string",
+    "int": "integer", "integer": "integer",
+    "float": "number", "number": "number",
+    "bool": "boolean", "boolean": "boolean",
+    "list": "list", "array": "list",
+    "dict": "dict", "object": "dict",
+}
+
+
+def validate_payload(schema: dict[str, Any], payload: dict[str, Any]) -> list[str]:
+    """Validate *payload* against a lightweight schema.
+
+    Schema format::
+
+        {
+            "required": ["field1"],
+            "properties": {
+                "field1": {"type": "string"},
+                "field2": {"type": "int"},
+            }
+        }
+
+    Returns:
+        List of error strings.  Empty list = valid.
+    """
+    if not schema:
+        return []
+    if not isinstance(payload, dict):
+        return [f"Payload must be a dict, got {type(payload).__name__}"]
+
+    errors: list[str] = []
+    required = schema.get("required") or []
+    properties = schema.get("properties") or {}
+
+    for field in required:
+        if field not in payload:
+            errors.append(f"Missing required field: {field!r}")
+
+    for name, spec in properties.items():
+        if name not in payload:
+            continue
+        expected_type = _TYPE_MAP.get(str(spec.get("type", "")).lower(), "")
+        if not expected_type:
+            continue
+        value = payload[name]
+        if not _check_type(value, expected_type):
+            actual = type(value).__name__
+            errors.append(
+                f"Field {name!r}: expected {expected_type}, got {actual}"
+            )
+
+    return errors
+
+
+def validate_input(schema: dict[str, Any], payload: dict[str, Any]) -> list[str]:
+    """Alias for :func:`validate_payload` (input validation)."""
+    return validate_payload(schema, payload)
+
+
+def validate_output(schema: dict[str, Any], data: dict[str, Any]) -> list[str]:
+    """Alias for :func:`validate_payload` (output validation)."""
+    return validate_payload(schema, data)
+
+
+def _check_type(value: Any, expected: str) -> bool:
+    if expected == "string":
+        return isinstance(value, str)
+    if expected == "integer":
+        return isinstance(value, int) and not isinstance(value, bool)
+    if expected == "number":
+        return isinstance(value, (int, float)) and not isinstance(value, bool)
+    if expected == "boolean":
+        return isinstance(value, bool)
+    if expected == "list":
+        return isinstance(value, list)
+    if expected == "dict":
+        return isinstance(value, dict)
+    return True  # unknown type — pass through

nodus_schema-0.1.0/nodus_schema/versioning.py

@@ -0,0 +1,58 @@
+"""Versioned name parsing and resolution — from AINDY/kernel/syscall_versioning.py."""
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+_VERSIONED_NAME_RE = re.compile(r"^(v\d+)\.(.+)$")
+
+# When the requested version is not available, fall back to this version.
+SYSCALL_VERSION_FALLBACK: Optional[str] = "v1"
+
+
+def parse_versioned_name(name: str) -> tuple[str, str]:
+    """Parse a versioned name into ``(version, action)``.
+
+    Examples::
+
+        parse_versioned_name("v1.memory.read")  → ("v1", "memory.read")
+        parse_versioned_name("v2.flow.run")     → ("v2", "flow.run")
+
+    Raises:
+        ValueError: If *name* does not match ``vN.action`` format.
+    """
+    match = _VERSIONED_NAME_RE.match(name)
+    if not match:
+        raise ValueError(
+            f"Versioned name must match 'vN.action', got {name!r}"
+        )
+    return match.group(1), match.group(2)
+
+
+def resolve_version(
+    requested: str,
+    available: frozenset[str],
+    fallback: Optional[str] = SYSCALL_VERSION_FALLBACK,
+) -> Optional[str]:
+    """Return the version to use, applying the fallback if needed.
+
+    Args:
+        requested:  The version string requested (e.g. ``"v1"``).
+        available:  Set of registered versions (e.g. ``frozenset({"v1", "v2"})``).
+        fallback:   Version to try when *requested* is not in *available*.
+
+    Returns:
+        The resolved version string, or None if neither *requested* nor
+        *fallback* is available.
+    """
+    if requested in available:
+        return requested
+    if fallback is not None and fallback in available:
+        return fallback
+    return None
+
+
+def is_stable_version(version: str) -> bool:
+    """Return True for ``"v1"`` and above with no pre-release suffix."""
+    match = re.match(r"^v(\d+)$", version)
+    return bool(match) and int(match.group(1)) >= 1

nodus_schema-0.1.0/nodus_schema.egg-info/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: nodus-schema
+Version: 0.1.0
+Summary: Versioned ABI schema validation, parsing, and registry
+Author: Shawn Knight
+License: MIT
+Project-URL: Homepage, https://github.com/Masterplanner25/nodus-schema
+Project-URL: Repository, https://github.com/Masterplanner25/nodus-schema
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# nodus-schema
+
+**Versioned ABI schema validation, parsing, and registry for Nodus AI systems.**
+
+Validates payloads against simple-form or JSON Schema object definitions,
+parses versioned surface names (`sys.v1.domain.action`), and maintains a
+thread-safe `SchemaRegistry` of versioned schemas with stability tracking.
+No required external dependencies — pure stdlib.
+
+> **Note on naming:** This is the standalone `nodus-schema` package
+> (`C:\dev\nodus-schema`). The nodus-lang runtime also ships an in-tree
+> `nodus_schema` package (`src/nodus_schema/`) with `SyscallSpec`,
+> `HandlerContract`, and `VALID_EFFECTS`. The two are distinct; check
+> `python -c "import nodus_schema; print(nodus_schema.__file__)"` to confirm
+> which is active.
+
+> **Status:** v0.1.0 — prepared, not yet published.
+
+---
+
+## Install
+
+```bash
+pip install nodus-schema
+```
+
+---
+
+## What it provides
+
+| Component | Purpose |
+|---|---|
+| `validate_payload` | Validate a dict against a schema; returns list of error strings |
+| `validate_input` / `validate_output` | Aliases for `validate_payload` |
+| `parse_versioned_name` | Parse `"sys.v1.domain.action"` → `(version, action)` |
+| `resolve_version` | Find best compatible version from available set |
+| `is_stable_version` | True for `"v1"`, `"v2"`, etc. (not alpha/beta) |
+| `SchemaEntry` | One versioned schema with stability and deprecation state |
+| `SchemaRegistry` | Thread-safe registry of `SchemaEntry` objects |
+
+---
+
+## Schema validation
+
+```python
+from nodus_schema import validate_payload
+
+schema = {
+    "type": "object",
+    "properties": {
+        "name": {"type": "string"},
+        "age":  {"type": "integer"},
+    },
+    "required": ["name"],
+}
+
+errors = validate_payload(schema, {"name": "Alice", "age": 30})
+# [] — valid
+
+errors = validate_payload(schema, {"age": 30})
+# ["Missing required field: 'name'"]
+
+errors = validate_payload(schema, {"name": "Alice", "age": "thirty"})
+# ["Field 'age': expected type 'integer', got 'str'"]
+```
+
+### Simple-form schema
+
+A flat `{field: type_string}` dict is also accepted:
+
+```python
+errors = validate_payload({"key": "str", "value": "any"}, {"key": "hello"})
+# [] — "any" allows any type
+```
+
+Supported type strings: `string`/`str`, `integer`/`int`, `number`/`float`,
+`boolean`/`bool`, `object`/`map`/`dict`, `array`/`list`, `null`/`nil`, `any`.
+
+---
+
+## Versioned name parsing
+
+```python
+from nodus_schema import parse_versioned_name, resolve_version, is_stable_version
+
+version, action = parse_versioned_name("sys.v1.memory.write")
+# ("v1", "memory.write")
+
+best = resolve_version("v1", available={"v1", "v2"}, fallback=True)
+# "v1"
+
+is_stable_version("v1")      # True
+is_stable_version("v1alpha1") # False
+is_stable_version("v1beta2")  # False
+```
+
+---
+
+## SchemaRegistry
+
+```python
+from nodus_schema import SchemaRegistry, SchemaEntry
+
+registry = SchemaRegistry()
+registry.register(SchemaEntry(
+    name="memory.write",
+    version="v1",
+    input_schema={"key": "str", "value": "any"},
+    output_schema={"stored": "bool"},
+    stable=True,
+    deprecated=False,
+))
+
+entry = registry.get("memory.write", version="v1")  # SchemaEntry | None
+versions = registry.versions("memory.write")         # ["v1"]
+all_entries = registry.list()                        # list[SchemaEntry]
+```
+
+---
+
+## Design
+
+- **No required dependencies.** Pure stdlib (`json`, `threading`, `dataclasses`).
+- **Simple-form schemas.** Flat `{field: type}` dicts are normalized to JSON
+  Schema objects automatically.
+- **Thread-safe.** `SchemaRegistry` uses `threading.Lock`.
+
+---
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -q
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

nodus_schema-0.1.0/nodus_schema.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+nodus_schema/__init__.py
+nodus_schema/registry.py
+nodus_schema/schema.py
+nodus_schema/versioning.py
+nodus_schema.egg-info/PKG-INFO
+nodus_schema.egg-info/SOURCES.txt
+nodus_schema.egg-info/dependency_links.txt
+nodus_schema.egg-info/requires.txt
+nodus_schema.egg-info/top_level.txt
+tests/test_registry.py
+tests/test_schema.py
+tests/test_versioning.py

nodus_schema-0.1.0/nodus_schema.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nodus_schema-0.1.0/nodus_schema.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=8.0

nodus_schema-0.1.0/nodus_schema.egg-info/top_level.txt

@@ -0,0 +1 @@
+nodus_schema

nodus_schema-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=80", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nodus-schema"
+version = "0.1.0"
+description = "Versioned ABI schema validation, parsing, and registry"
+authors = [{ name = "Shawn Knight" }]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[project.urls]
+Homepage = "https://github.com/Masterplanner25/nodus-schema"
+Repository = "https://github.com/Masterplanner25/nodus-schema"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["nodus_schema*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

nodus_schema-0.1.0/setup.cfg

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

nodus_schema-0.1.0/tests/test_registry.py

@@ -0,0 +1,56 @@
+from nodus_schema import SchemaEntry, SchemaRegistry
+
+
+def _entry(name="memory.read", version="v1", **kwargs):
+    return SchemaEntry(name=name, version=version, **kwargs)
+
+
+def test_register_and_get():
+    reg = SchemaRegistry()
+    e = _entry()
+    reg.register(e)
+    result = reg.get("v1.memory.read")
+    assert result is e
+
+
+def test_get_unknown_returns_none():
+    reg = SchemaRegistry()
+    assert reg.get("v1.unknown") is None
+
+
+def test_versions():
+    reg = SchemaRegistry()
+    reg.register(_entry("memory.read", "v1"))
+    reg.register(_entry("memory.read", "v2"))
+    assert reg.versions() == frozenset({"v1", "v2"})
+
+
+def test_list_excludes_deprecated():
+    reg = SchemaRegistry()
+    reg.register(_entry("memory.read", "v1"))
+    reg.register(_entry("memory.read", "v2", deprecated=True))
+    result = reg.list()
+    assert len(result) == 1
+    assert result[0].version == "v1"
+
+
+def test_list_include_deprecated():
+    reg = SchemaRegistry()
+    reg.register(_entry("a", "v1"))
+    reg.register(_entry("b", "v1", deprecated=True))
+    assert len(reg.list(include_deprecated=True)) == 2
+
+
+def test_contains():
+    reg = SchemaRegistry()
+    reg.register(_entry())
+    assert "v1.memory.read" in reg
+    assert "v2.memory.read" not in reg
+
+
+def test_len():
+    reg = SchemaRegistry()
+    assert len(reg) == 0
+    reg.register(_entry("a", "v1"))
+    reg.register(_entry("b", "v1"))
+    assert len(reg) == 2

nodus_schema-0.1.0/tests/test_schema.py

@@ -0,0 +1,68 @@
+from nodus_schema import validate_payload
+
+
+def test_empty_schema_passes_anything():
+    assert validate_payload({}, {"x": 1}) == []
+
+
+def test_required_field_missing():
+    errs = validate_payload({"required": ["q"]}, {})
+    assert any("q" in e for e in errs)
+
+
+def test_required_field_present():
+    assert validate_payload({"required": ["q"], "properties": {"q": {"type": "string"}}},
+                             {"q": "hello"}) == []
+
+
+def test_type_string_pass():
+    s = {"properties": {"name": {"type": "string"}}}
+    assert validate_payload(s, {"name": "Alice"}) == []
+
+
+def test_type_string_fail():
+    s = {"properties": {"name": {"type": "string"}}}
+    errs = validate_payload(s, {"name": 123})
+    assert errs
+
+
+def test_type_int_pass():
+    s = {"properties": {"limit": {"type": "int"}}}
+    assert validate_payload(s, {"limit": 5}) == []
+
+
+def test_type_int_fail_on_float():
+    s = {"properties": {"n": {"type": "int"}}}
+    errs = validate_payload(s, {"n": 1.5})
+    assert errs
+
+
+def test_type_bool_pass():
+    s = {"properties": {"flag": {"type": "bool"}}}
+    assert validate_payload(s, {"flag": True}) == []
+
+
+def test_type_bool_fail_on_int():
+    s = {"properties": {"flag": {"type": "bool"}}}
+    errs = validate_payload(s, {"flag": 1})
+    assert errs
+
+
+def test_type_list_pass():
+    s = {"properties": {"tags": {"type": "list"}}}
+    assert validate_payload(s, {"tags": ["a", "b"]}) == []
+
+
+def test_type_dict_pass():
+    s = {"properties": {"meta": {"type": "dict"}}}
+    assert validate_payload(s, {"meta": {"k": "v"}}) == []
+
+
+def test_extra_fields_allowed():
+    s = {"properties": {"q": {"type": "string"}}}
+    assert validate_payload(s, {"q": "hello", "extra": 123}) == []
+
+
+def test_non_dict_payload():
+    errs = validate_payload({"required": ["q"]}, "not a dict")  # type: ignore[arg-type]
+    assert errs

nodus_schema-0.1.0/tests/test_versioning.py

@@ -0,0 +1,58 @@
+import pytest
+from nodus_schema import (
+    SYSCALL_VERSION_FALLBACK, is_stable_version,
+    parse_versioned_name, resolve_version,
+)
+
+
+def test_parse_basic():
+    v, a = parse_versioned_name("v1.memory.read")
+    assert v == "v1" and a == "memory.read"
+
+
+def test_parse_v2():
+    v, a = parse_versioned_name("v2.flow.run")
+    assert v == "v2" and a == "flow.run"
+
+
+def test_parse_invalid_raises():
+    with pytest.raises(ValueError):
+        parse_versioned_name("memory.read")
+    with pytest.raises(ValueError):
+        parse_versioned_name("1.memory.read")
+
+
+def test_resolve_present():
+    assert resolve_version("v1", frozenset({"v1", "v2"})) == "v1"
+
+
+def test_resolve_fallback():
+    result = resolve_version("v3", frozenset({"v1", "v2"}), fallback="v1")
+    assert result == "v1"
+
+
+def test_resolve_none_when_unavailable():
+    result = resolve_version("v99", frozenset({"v1"}), fallback="v99")
+    assert result is None
+
+
+def test_resolve_no_fallback():
+    result = resolve_version("v3", frozenset({"v1"}), fallback=None)
+    assert result is None
+
+
+def test_default_fallback_is_v1():
+    assert SYSCALL_VERSION_FALLBACK == "v1"
+
+
+def test_is_stable_version():
+    assert is_stable_version("v1") is True
+    assert is_stable_version("v2") is True
+    assert is_stable_version("v1alpha1") is False
+    assert is_stable_version("v0") is False
+
+
+def test_registry_full_name():
+    from nodus_schema import SchemaEntry
+    e = SchemaEntry("memory.read", "v1")
+    assert e.full_name == "v1.memory.read"