bitspark-bitwire 0.2.0__tar.gz → 0.5.0__tar.gz

bitspark_bitwire-0.5.0/NOTICE

@@ -0,0 +1,9 @@
+bitwire
+Copyright 2026 Bitspark and contributors
+
+This product includes software developed at Bitspark. The current generic wire
+contract is original work. It includes a checked consumer mirror of ontos v0.9.0
+from 5eed85de5697f53397407f9f82f3b310648827f7: frozen L0 values, canonical codec
+and optional data embeddings. ontos/manifest.json records exact source provenance
+and import adaptations. The prior declarations and drivers derived from nightseam
+were removed; their provenance and immutable releases remain in Git history.

bitspark_bitwire-0.5.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: bitspark-bitwire
+Version: 0.5.0
+Summary: Addressless wires and addressed access over ontos values
+Author: Bitspark
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Bitspark/bitwire
+Project-URL: Documentation, https://github.com/Bitspark/bitwire/tree/main/docs
+Project-URL: Repository, https://github.com/Bitspark/bitwire
+Project-URL: Issues, https://github.com/Bitspark/bitwire/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+# py wire presentation
+
+Addressless Wire sends a ground ontos value. Endpoint adds receive ownership and
+closure. AddressedWire adds an exact byte-path argument; AddressedEndpoint carries
+that layer over one endpoint. WireNode is the complete deixis structure over Wire
+values (a nominal interface in Java), not opaque route access.
+
+See the repository's docs/wire/contract.md and docs/wire/carriers.md. Version 0.5.0
+is a clean breaking replacement; compilation and packaged consumers check the
+native surface, while bitruntime supplies independently tested implementations.

bitspark_bitwire-0.5.0/README.md

@@ -0,0 +1,10 @@
+# py wire presentation
+
+Addressless Wire sends a ground ontos value. Endpoint adds receive ownership and
+closure. AddressedWire adds an exact byte-path argument; AddressedEndpoint carries
+that layer over one endpoint. WireNode is the complete deixis structure over Wire
+values (a nominal interface in Java), not opaque route access.
+
+See the repository's docs/wire/contract.md and docs/wire/carriers.md. Version 0.5.0
+is a clean breaking replacement; compilation and packaged consumers check the
+native surface, while bitruntime supplies independently tested implementations.

{bitspark_bitwire-0.2.0 → bitspark_bitwire-0.5.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bitspark-bitwire"
-version = "0.2.0"
-description = "The shared relative-path Wire contract for Python"
+version = "0.5.0"
+description = "Addressless wires and addressed access over ontos values"
 readme = "README.md"
 requires-python = ">=3.11"
 license = "Apache-2.0"

bitspark_bitwire-0.5.0/src/bitspark_bitwire.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: bitspark-bitwire
+Version: 0.5.0
+Summary: Addressless wires and addressed access over ontos values
+Author: Bitspark
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Bitspark/bitwire
+Project-URL: Documentation, https://github.com/Bitspark/bitwire/tree/main/docs
+Project-URL: Repository, https://github.com/Bitspark/bitwire
+Project-URL: Issues, https://github.com/Bitspark/bitwire/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+# py wire presentation
+
+Addressless Wire sends a ground ontos value. Endpoint adds receive ownership and
+closure. AddressedWire adds an exact byte-path argument; AddressedEndpoint carries
+that layer over one endpoint. WireNode is the complete deixis structure over Wire
+values (a nominal interface in Java), not opaque route access.
+
+See the repository's docs/wire/contract.md and docs/wire/carriers.md. Version 0.5.0
+is a clean breaking replacement; compilation and packaged consumers check the
+native surface, while bitruntime supplies independently tested implementations.

{bitspark_bitwire-0.2.0 → bitspark_bitwire-0.5.0}/src/bitspark_bitwire.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/bitspark_bitwire.egg-info/SOURCES.txt
 src/bitspark_bitwire.egg-info/dependency_links.txt
 src/bitspark_bitwire.egg-info/top_level.txt
 src/bitwire/__init__.py
+src/bitwire/ontos.py
 src/bitwire/py.typed
 tests/test_consumer.py
 tests/typecheck.py

bitspark_bitwire-0.5.0/src/bitwire/__init__.py

@@ -0,0 +1,35 @@
+"""Addressless interaction, addressed access and complete structure."""
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Callable, Protocol, TypeVar, Generic
+from .ontos import Atom, Tuple, Value, atom, tuple_, equals
+Path = tuple[Atom, ...]
+@dataclass(frozen=True)
+class Termination:
+    kind: str
+    message: str | None = None
+class Wire(Protocol):
+    async def send(self, message: Value) -> None: ...
+class Endpoint(Wire, Protocol):
+    def receive(self, handler: Callable[[Value], None]) -> Callable[[], None]: ...
+    async def closed(self) -> Termination: ...
+    async def close(self) -> None: ...
+class AddressedWire(Protocol):
+    async def send(self, path: Path, message: Value) -> None: ...
+class AddressedEndpoint(AddressedWire, Protocol):
+    def receive(self, handler: Callable[[Path, Value], None]) -> Callable[[], None]: ...
+    async def closed(self) -> Termination: ...
+    async def close(self) -> None: ...
+T = TypeVar('T')
+@dataclass(frozen=True)
+class Parts(Generic[T]):
+    own: T
+    children: tuple[tuple[Atom, DeixisNode[T]], ...]
+class DeixisNode(Protocol[T]):
+    def own(self) -> T: ...
+    def children(self) -> tuple[tuple[Atom, DeixisNode[T]], ...]: ...
+    def at(self, path: Path) -> DeixisNode[T] | None: ...
+    def decompose(self) -> Parts[T]: ...
+WireNode = DeixisNode[Wire]
+__all__ = ['Atom', 'Tuple', 'Value', 'atom', 'tuple_', 'equals', 'Path', 'Termination',
+           'Wire', 'Endpoint', 'AddressedWire', 'AddressedEndpoint', 'WireNode', 'Parts', 'DeixisNode']

bitspark_bitwire-0.5.0/src/bitwire/ontos.py

@@ -0,0 +1,219 @@
+"""ontos/core (L0) — the frozen value model.
+
+    Bytes = finite octet strings
+    Value = Atom(bytes) | Tuple(Value*)
+
+A value is finite, immutable, well-founded (a finite tree, never cyclic),
+uninterpreted, and compared by structural identity. This module defines what a
+value is and when two values are the same — nothing else. There is no byte
+encoding here (that is ``ontos_codec``) and no interpretation of atoms or shapes.
+See docs/spec/ontos-core.md.
+
+This is the Python peer of the go/rs/ts cores (ontos #60). It exists to
+empirically validate the conformance protocol: it implements the same contract
+and registers as a fourth ``--impl`` in the differential harness with no protocol
+change. It is a validation lane, **not** a published/substrate lane.
+
+Common Value API (all four cores)
+---------------------------------
+The Go, Rust, TypeScript, and Python cores expose the same conceptual surface so
+a developer who learns one can predict the others. Every core provides, by its
+own naming convention:
+
+- Construct — ``atom(bytes)`` / ``tuple_(items)`` (Go ``NewAtom``/``NewTuple``,
+  Rust ``Value::atom``/``tuple``, TS ``atom``/``tuple``).
+- Atom bytes + length — ``Atom.bytes()`` and ``len(atom)``.
+- Tuple children + arity + indexed access — ``Tuple.items()``, ``len(tuple)``,
+  and ``Tuple.at(i)``.
+- Structural equality — ``==`` (``__eq__``) and the module-level ``equals``.
+- Diagnostic string — ``str(value)`` (Go ``String``, Rust ``Display``, TS
+  ``toString``); **not** a canonical encoding.
+
+Intentional per-language extras
+--------------------------------
+Python exposes ``is_atom``/``is_tuple`` (idiomatic ``isinstance`` shorthands) and
+hashability (``__hash__``) so values can be dict keys / set members in Python
+code. These are binding conveniences; they confer no new identity (``__hash__`` is
+consistent with structural ``__eq__``) and no canonical form.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Union
+
+__all__ = [
+    "Value",
+    "Atom",
+    "Tuple",
+    "atom",
+    "tuple_",
+    "is_value",
+    "equals",
+]
+
+
+class Value:
+    """The abstract base of the two value constructors: ``Atom`` and ``Tuple``.
+
+    ``Value`` itself is never instantiated; it exists only so ``isinstance(v,
+    Value)`` and type hints have a single nominal type. The value set is closed:
+    every value is exactly one of ``Atom`` or ``Tuple`` (ontos-core §1).
+    """
+
+    __slots__ = ()
+
+
+class Atom(Value):
+    """An opaque byte atom. The bytes have no built-in interpretation.
+
+    The bytes are copied and stored immutably; ``bytes()`` returns them as an
+    (immutable) ``bytes`` object, so a caller can never mutate the atom.
+    """
+
+    __slots__ = ("_bytes",)
+
+    def __init__(self, data: Union[bytes, bytearray, Iterable[int]] = b"") -> None:
+        # bytes(...) copies and validates that every element is a 0..255 int, so
+        # an out-of-range or non-int element raises ValueError/TypeError here —
+        # exactly the "an atom carries octets" invariant (ontos-core §1).
+        object.__setattr__(self, "_bytes", bytes(data))
+
+    def __setattr__(self, name: str, value: object) -> None:  # pragma: no cover
+        raise AttributeError("ontos values are immutable")
+
+    def __delattr__(self, name: str) -> None:  # pragma: no cover
+        raise AttributeError("ontos values are immutable")
+
+    def bytes(self) -> bytes:
+        """Return the atom's octets. ``bytes`` is itself immutable in Python."""
+        return self._bytes
+
+    def __len__(self) -> int:
+        """The atom's byte length (the analog of TS ``Atom#length``)."""
+        return len(self._bytes)
+
+    @property
+    def is_atom(self) -> bool:
+        return True
+
+    @property
+    def is_tuple(self) -> bool:
+        return False
+
+    def __eq__(self, other: object) -> bool:
+        # Atom(b) = Atom(c) iff b and c are the same octet string; Atom != Tuple
+        # always (ontos-core §3). NotImplemented lets Python try the reflected op
+        # for unrelated types rather than declaring inequality prematurely.
+        if isinstance(other, Atom):
+            return self._bytes == other._bytes
+        if isinstance(other, Tuple):
+            return False
+        return NotImplemented
+
+    def __ne__(self, other: object) -> bool:
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return result
+        return not result
+
+    def __hash__(self) -> int:
+        # Tagged so an Atom and a Tuple with related structure never share a hash
+        # bucket by accident; consistent with __eq__ (equal atoms hash equal).
+        return hash(("atom", self._bytes))
+
+    def __str__(self) -> str:
+        return f"Atom(0x{self._bytes.hex()})"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class Tuple(Value):
+    """A finite ordered tuple of values. Arity, order, and multiplicity matter.
+
+    Children are validated to be ``Value`` instances and stored in an immutable
+    builtin tuple, so a ``Tuple`` cannot be mutated and cannot hold a non-value.
+    """
+
+    __slots__ = ("_items",)
+
+    def __init__(self, items: Iterable[Value] = ()) -> None:
+        copied = tuple(items)
+        for item in copied:
+            if not isinstance(item, Value):
+                raise TypeError("expected an ontos Value as a tuple child")
+        object.__setattr__(self, "_items", copied)
+
+    def __setattr__(self, name: str, value: object) -> None:  # pragma: no cover
+        raise AttributeError("ontos values are immutable")
+
+    def __delattr__(self, name: str) -> None:  # pragma: no cover
+        raise AttributeError("ontos values are immutable")
+
+    def items(self) -> tuple:
+        """Return the children as an immutable builtin tuple of ``Value``."""
+        return self._items
+
+    def at(self, index: int) -> Value:
+        """The child at ``index`` (Go ``Tuple.At`` / Rust ``Tuple::at``)."""
+        return self._items[index]
+
+    def __len__(self) -> int:
+        """The arity (number of children)."""
+        return len(self._items)
+
+    @property
+    def is_atom(self) -> bool:
+        return False
+
+    @property
+    def is_tuple(self) -> bool:
+        return True
+
+    def __eq__(self, other: object) -> bool:
+        # Tuple(xs) = Tuple(ys) iff same arity and xs[i] = ys[i] recursively;
+        # Tuple != Atom always (ontos-core §3).
+        if isinstance(other, Tuple):
+            return self._items == other._items
+        if isinstance(other, Atom):
+            return False
+        return NotImplemented
+
+    def __ne__(self, other: object) -> bool:
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return result
+        return not result
+
+    def __hash__(self) -> int:
+        return hash(("tuple", self._items))
+
+    def __str__(self) -> str:
+        return "Tuple(" + ", ".join(str(item) for item in self._items) + ")"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+def atom(data: Union[bytes, bytearray, Iterable[int]] = b"") -> Atom:
+    """Construct an ``Atom`` from bytes (or an iterable of 0..255 ints)."""
+    return Atom(data)
+
+
+def tuple_(items: Iterable[Value] = ()) -> Tuple:
+    """Construct a ``Tuple`` from an iterable of values.
+
+    Named ``tuple_`` (trailing underscore) so it does not shadow the builtin
+    ``tuple``; the type is exported as ``Tuple``.
+    """
+    return Tuple(items)
+
+
+def is_value(value: object) -> bool:
+    """Whether ``value`` is an ontos ``Value`` (an ``Atom`` or a ``Tuple``)."""
+    return isinstance(value, (Atom, Tuple))
+
+
+def equals(left: Value, right: Value) -> bool:
+    """Structural equality (ontos-core §3). The same relation as ``left == right``."""
+    return left == right

bitspark_bitwire-0.5.0/tests/test_consumer.py

@@ -0,0 +1,14 @@
+import unittest
+from bitwire import Atom, Tuple, Path
+class Contract(unittest.TestCase):
+    def test_paths_and_ground_values(self) -> None:
+        path: Path = (Atom(),)
+        self.assertNotEqual((), path)
+        self.assertNotEqual((Atom(b'a/b'),), (Atom(b'a'), Atom(b'b')))
+        self.assertNotEqual(Atom(), Tuple())
+    def test_value_ownership(self) -> None:
+        source = bytearray([0,255])
+        value = Atom(source)
+        source.clear()
+        self.assertEqual(value, Atom(bytes([0,255])))
+if __name__ == '__main__': unittest.main()

bitspark_bitwire-0.5.0/tests/typecheck.py

@@ -0,0 +1,14 @@
+from bitwire import Wire, Endpoint, AddressedEndpoint, Atom, Tuple
+async def send_only(wire: Wire) -> None:
+    await wire.send(Atom())
+async def consume(endpoint: Endpoint, addressed: AddressedEndpoint) -> None:
+    detach = endpoint.receive(lambda message: None)
+    await send_only(endpoint)
+    await endpoint.send(Tuple())
+    detach()
+    await addressed.send((Atom(b'leaf'),), Atom())
+    addressed.receive(lambda path, message: None)()
+    await addressed.close()
+    await addressed.closed()
+    await endpoint.close()
+    await endpoint.closed()

bitspark_bitwire-0.2.0/NOTICE

@@ -1,10 +0,0 @@
-Bitwire
-Copyright 2026 Bitspark and the Bitwire contributors
-
-This product includes software developed at Bitspark (https://github.com/Bitspark).
-
-The Python Wire declarations are adapted from Nightseam, licensed under the
-Apache License, Version 2.0:
-Copyright 2026 Bitspark and the Nightseam contributors.
-Source revision: 1c63f1c4d7e4b5987d4bd32e294177645c92ed8f.
-Source path: duplex/py/nightseam/duplex/wire.py.

bitspark_bitwire-0.2.0/PKG-INFO

@@ -1,116 +0,0 @@
-Metadata-Version: 2.4
-Name: bitspark-bitwire
-Version: 0.2.0
-Summary: The shared relative-path Wire contract for Python
-Author: Bitspark
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/Bitspark/bitwire
-Project-URL: Documentation, https://github.com/Bitspark/bitwire/tree/main/docs
-Project-URL: Repository, https://github.com/Bitspark/bitwire
-Project-URL: Issues, https://github.com/Bitspark/bitwire/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Typing :: Typed
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-License-File: NOTICE
-Dynamic: license-file
-
-# Bitwire for Python
-
-`bitspark-bitwire` provides the shared relative-path Wire contract as the Python
-module `bitwire`. It requires Python 3.11 or newer and has no runtime dependencies.
-The package contains typed declarations and supporting values; endpoint runtimes,
-carriers, codecs and routing helpers belong to implementations.
-
-```python
-from bitwire import Endpoint, Message, Receiver, ReturnAddress, Wire
-
-
-def call(endpoint: Wire, replies: Wire) -> None:
-    endpoint.send(
-        ["cells", "get"],
-        Message(
-            {"version": 1, "kind": "request", "id": "request-1", "params": {}},
-            return_address=ReturnAddress(replies),
-        ),
-    )
-
-
-def listen(endpoint: Endpoint):
-    def receive(path, message):
-        print(path, message.frame)
-
-    return endpoint.receive(Receiver(message=receive))
-```
-
-`Wire` is a send-only structural `Protocol`; implementations do not need to inherit
-from it. `send` accepts or refuses synchronously; the implementation schedules
-delivery. `Endpoint` extends it with `receive(receiver)` and `close`, keeping
-attachment and closure authority separate from send access. One receive attachment
-is allowed at a time; duplicates are refused. Receivers may return an awaitable.
-`receive` returns an idempotent detach function that cannot remove a replacement.
-Path matching belongs to routing compositions, not to these interfaces.
-Paths are sequences of opaque Unicode-scalar strings and retain empty segments.
-Receiver paths are relative to the attached endpoint.
-
-`ReturnAddress` uses object identity, including when its Wire cannot be compared
-or hashed. Preserve this object during routing. The return address is local
-capability data and must never be serialized into the profile envelope. Profile
-payloads must follow the JSON profile despite their Python `object` annotation.
-Runtime-owned received context associated with the return identity must survive
-routing. Application-supplied context or metadata does not establish verified
-invocation context; that verification remains the runtime's responsibility.
-
-The [Wire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
-and [profile boundary](https://github.com/Bitspark/bitwire/blob/main/docs/wire/profile.md)
-define the behavior. Runtime protocol checks verify only the presence of methods;
-they cannot establish conformance.
-
-## Packaging and checks
-
-From this directory:
-
-```sh
-python -m pip install -r requirements-dev.txt
-python check.py
-```
-
-This builds a source distribution and a wheel from it, verifies the distribution
-contents, installs the wheel into a temporary virtual environment, and runs both
-consumer tests and static typing checks against that installed package. The test
-endpoint is a recording fixture, not a Bitwire runtime or conformance driver.
-
-For release artifacts at a chosen location:
-
-```sh
-python -m build --outdir dist
-```
-
-## Optional PyPI publication
-
-The manual `publish-python.yml` workflow publishes an existing immutable public
-release tag. It is separate from the Go/TypeScript release and does not gate that
-handover. Its default authentication is a PyPI trusted publisher. Configure these
-fields under the PyPI account's **Publishing** page for a pending project:
-
-| Field | Value |
-| --- | --- |
-| PyPI project name | `bitspark-bitwire` |
-| Owner | `Bitspark` |
-| Repository name | `bitwire` |
-| Workflow name | `publish-python.yml` |
-| Environment name | `pypi` |
-
-For an existing project, add the same publisher under the project's publishing
-settings. As a bootstrap fallback, store an API token in the repository or `pypi`
-environment secret named `PYPI_API_TOKEN`, then select `api-token` when dispatching
-the workflow from `main`. Tokens are passed only to publication steps. Revoke the
-bootstrap token after trusted publishing is configured. The workflow verifies the
-packaged artifact before upload and installs the published PyPI package afterward.
-
-The binding is adapted from Nightseam's Python Wire declarations at commit
-[`1c63f1c4`](https://github.com/Bitspark/nightseam/blob/1c63f1c4d7e4b5987d4bd32e294177645c92ed8f/duplex/py/nightseam/duplex/wire.py)
-under Apache-2.0. See the included `LICENSE` and `NOTICE` files.

bitspark_bitwire-0.2.0/README.md

@@ -1,96 +0,0 @@
-# Bitwire for Python
-
-`bitspark-bitwire` provides the shared relative-path Wire contract as the Python
-module `bitwire`. It requires Python 3.11 or newer and has no runtime dependencies.
-The package contains typed declarations and supporting values; endpoint runtimes,
-carriers, codecs and routing helpers belong to implementations.
-
-```python
-from bitwire import Endpoint, Message, Receiver, ReturnAddress, Wire
-
-
-def call(endpoint: Wire, replies: Wire) -> None:
-    endpoint.send(
-        ["cells", "get"],
-        Message(
-            {"version": 1, "kind": "request", "id": "request-1", "params": {}},
-            return_address=ReturnAddress(replies),
-        ),
-    )
-
-
-def listen(endpoint: Endpoint):
-    def receive(path, message):
-        print(path, message.frame)
-
-    return endpoint.receive(Receiver(message=receive))
-```
-
-`Wire` is a send-only structural `Protocol`; implementations do not need to inherit
-from it. `send` accepts or refuses synchronously; the implementation schedules
-delivery. `Endpoint` extends it with `receive(receiver)` and `close`, keeping
-attachment and closure authority separate from send access. One receive attachment
-is allowed at a time; duplicates are refused. Receivers may return an awaitable.
-`receive` returns an idempotent detach function that cannot remove a replacement.
-Path matching belongs to routing compositions, not to these interfaces.
-Paths are sequences of opaque Unicode-scalar strings and retain empty segments.
-Receiver paths are relative to the attached endpoint.
-
-`ReturnAddress` uses object identity, including when its Wire cannot be compared
-or hashed. Preserve this object during routing. The return address is local
-capability data and must never be serialized into the profile envelope. Profile
-payloads must follow the JSON profile despite their Python `object` annotation.
-Runtime-owned received context associated with the return identity must survive
-routing. Application-supplied context or metadata does not establish verified
-invocation context; that verification remains the runtime's responsibility.
-
-The [Wire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
-and [profile boundary](https://github.com/Bitspark/bitwire/blob/main/docs/wire/profile.md)
-define the behavior. Runtime protocol checks verify only the presence of methods;
-they cannot establish conformance.
-
-## Packaging and checks
-
-From this directory:
-
-```sh
-python -m pip install -r requirements-dev.txt
-python check.py
-```
-
-This builds a source distribution and a wheel from it, verifies the distribution
-contents, installs the wheel into a temporary virtual environment, and runs both
-consumer tests and static typing checks against that installed package. The test
-endpoint is a recording fixture, not a Bitwire runtime or conformance driver.
-
-For release artifacts at a chosen location:
-
-```sh
-python -m build --outdir dist
-```
-
-## Optional PyPI publication
-
-The manual `publish-python.yml` workflow publishes an existing immutable public
-release tag. It is separate from the Go/TypeScript release and does not gate that
-handover. Its default authentication is a PyPI trusted publisher. Configure these
-fields under the PyPI account's **Publishing** page for a pending project:
-
-| Field | Value |
-| --- | --- |
-| PyPI project name | `bitspark-bitwire` |
-| Owner | `Bitspark` |
-| Repository name | `bitwire` |
-| Workflow name | `publish-python.yml` |
-| Environment name | `pypi` |
-
-For an existing project, add the same publisher under the project's publishing
-settings. As a bootstrap fallback, store an API token in the repository or `pypi`
-environment secret named `PYPI_API_TOKEN`, then select `api-token` when dispatching
-the workflow from `main`. Tokens are passed only to publication steps. Revoke the
-bootstrap token after trusted publishing is configured. The workflow verifies the
-packaged artifact before upload and installs the published PyPI package afterward.
-
-The binding is adapted from Nightseam's Python Wire declarations at commit
-[`1c63f1c4`](https://github.com/Bitspark/nightseam/blob/1c63f1c4d7e4b5987d4bd32e294177645c92ed8f/duplex/py/nightseam/duplex/wire.py)
-under Apache-2.0. See the included `LICENSE` and `NOTICE` files.

bitspark_bitwire-0.2.0/src/bitspark_bitwire.egg-info/PKG-INFO

@@ -1,116 +0,0 @@
-Metadata-Version: 2.4
-Name: bitspark-bitwire
-Version: 0.2.0
-Summary: The shared relative-path Wire contract for Python
-Author: Bitspark
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/Bitspark/bitwire
-Project-URL: Documentation, https://github.com/Bitspark/bitwire/tree/main/docs
-Project-URL: Repository, https://github.com/Bitspark/bitwire
-Project-URL: Issues, https://github.com/Bitspark/bitwire/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Typing :: Typed
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-License-File: NOTICE
-Dynamic: license-file
-
-# Bitwire for Python
-
-`bitspark-bitwire` provides the shared relative-path Wire contract as the Python
-module `bitwire`. It requires Python 3.11 or newer and has no runtime dependencies.
-The package contains typed declarations and supporting values; endpoint runtimes,
-carriers, codecs and routing helpers belong to implementations.
-
-```python
-from bitwire import Endpoint, Message, Receiver, ReturnAddress, Wire
-
-
-def call(endpoint: Wire, replies: Wire) -> None:
-    endpoint.send(
-        ["cells", "get"],
-        Message(
-            {"version": 1, "kind": "request", "id": "request-1", "params": {}},
-            return_address=ReturnAddress(replies),
-        ),
-    )
-
-
-def listen(endpoint: Endpoint):
-    def receive(path, message):
-        print(path, message.frame)
-
-    return endpoint.receive(Receiver(message=receive))
-```
-
-`Wire` is a send-only structural `Protocol`; implementations do not need to inherit
-from it. `send` accepts or refuses synchronously; the implementation schedules
-delivery. `Endpoint` extends it with `receive(receiver)` and `close`, keeping
-attachment and closure authority separate from send access. One receive attachment
-is allowed at a time; duplicates are refused. Receivers may return an awaitable.
-`receive` returns an idempotent detach function that cannot remove a replacement.
-Path matching belongs to routing compositions, not to these interfaces.
-Paths are sequences of opaque Unicode-scalar strings and retain empty segments.
-Receiver paths are relative to the attached endpoint.
-
-`ReturnAddress` uses object identity, including when its Wire cannot be compared
-or hashed. Preserve this object during routing. The return address is local
-capability data and must never be serialized into the profile envelope. Profile
-payloads must follow the JSON profile despite their Python `object` annotation.
-Runtime-owned received context associated with the return identity must survive
-routing. Application-supplied context or metadata does not establish verified
-invocation context; that verification remains the runtime's responsibility.
-
-The [Wire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
-and [profile boundary](https://github.com/Bitspark/bitwire/blob/main/docs/wire/profile.md)
-define the behavior. Runtime protocol checks verify only the presence of methods;
-they cannot establish conformance.
-
-## Packaging and checks
-
-From this directory:
-
-```sh
-python -m pip install -r requirements-dev.txt
-python check.py
-```
-
-This builds a source distribution and a wheel from it, verifies the distribution
-contents, installs the wheel into a temporary virtual environment, and runs both
-consumer tests and static typing checks against that installed package. The test
-endpoint is a recording fixture, not a Bitwire runtime or conformance driver.
-
-For release artifacts at a chosen location:
-
-```sh
-python -m build --outdir dist
-```
-
-## Optional PyPI publication
-
-The manual `publish-python.yml` workflow publishes an existing immutable public
-release tag. It is separate from the Go/TypeScript release and does not gate that
-handover. Its default authentication is a PyPI trusted publisher. Configure these
-fields under the PyPI account's **Publishing** page for a pending project:
-
-| Field | Value |
-| --- | --- |
-| PyPI project name | `bitspark-bitwire` |
-| Owner | `Bitspark` |
-| Repository name | `bitwire` |
-| Workflow name | `publish-python.yml` |
-| Environment name | `pypi` |
-
-For an existing project, add the same publisher under the project's publishing
-settings. As a bootstrap fallback, store an API token in the repository or `pypi`
-environment secret named `PYPI_API_TOKEN`, then select `api-token` when dispatching
-the workflow from `main`. Tokens are passed only to publication steps. Revoke the
-bootstrap token after trusted publishing is configured. The workflow verifies the
-packaged artifact before upload and installs the published PyPI package afterward.
-
-The binding is adapted from Nightseam's Python Wire declarations at commit
-[`1c63f1c4`](https://github.com/Bitspark/nightseam/blob/1c63f1c4d7e4b5987d4bd32e294177645c92ed8f/duplex/py/nightseam/duplex/wire.py)
-under Apache-2.0. See the included `LICENSE` and `NOTICE` files.

bitspark_bitwire-0.2.0/src/bitwire/__init__.py

@@ -1,150 +0,0 @@
-"""The shared relative-path Wire contract, without a runtime dependency.
-
-Adapted from Nightseam's duplex/py/nightseam/duplex/wire.py at
-1c63f1c4d7e4b5987d4bd32e294177645c92ed8f under Apache-2.0.
-Dispatch, path encoding, carriers and composition helpers belong to implementations.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable, Mapping, Sequence
-from dataclasses import dataclass
-from typing import Literal, NotRequired, Protocol, TypedDict, runtime_checkable
-
-__all__ = [
-    "Path",
-    "ProfileKind",
-    "ProfileError",
-    "RequestFrame",
-    "ResultFrame",
-    "ErrorFrame",
-    "EventFrame",
-    "CancelFrame",
-    "ProfileFrame",
-    "ReturnAddress",
-    "Message",
-    "Receiver",
-    "Wire",
-    "Endpoint",
-]
-
-# Opaque Unicode-scalar segments: [] != [""] != ["a/b"] != ["a", "b"].
-Path = Sequence[str]
-ProfileKind = Literal["request", "response", "event", "cancel"]
-
-
-class ProfileError(TypedDict):
-    """Public error data, independent of any runtime exception class."""
-
-    code: str
-    message: str
-    data: NotRequired[object]
-
-
-class _TracedFrame(TypedDict):
-    version: Literal[1]
-    traceparent: NotRequired[str]
-    tracestate: NotRequired[str]
-
-
-class RequestFrame(_TracedFrame):
-    """The send path supplies the method name; params follow the JSON profile."""
-
-    kind: Literal["request"]
-    id: str
-    params: object
-    meta: NotRequired[Mapping[str, str]]
-
-
-class ResultFrame(_TracedFrame):
-    kind: Literal["response"]
-    id: str
-    result: object
-
-
-class ErrorFrame(_TracedFrame):
-    kind: Literal["response"]
-    id: str
-    error: ProfileError
-
-
-class EventFrame(_TracedFrame):
-    """The send path supplies the event name; data follow the JSON profile."""
-
-    kind: Literal["event"]
-    data: object
-    meta: NotRequired[Mapping[str, str]]
-
-
-class CancelFrame(_TracedFrame):
-    kind: Literal["cancel"]
-    id: str
-
-
-ProfileFrame = RequestFrame | ResultFrame | ErrorFrame | EventFrame | CancelFrame
-
-
-@dataclass(frozen=True, eq=False)
-class ReturnAddress:
-    """Local capability with identity equality, never a network-envelope member.
-
-    Different addresses stay distinct even when they hold the same Wire. The
-    wrapped implementation need not support equality or hashing. Routing must
-    preserve this address object, rather than construct an equivalent wrapper.
-    Runtime-owned received context associated with this identity must survive
-    routing; application payloads are not evidence of verified context.
-    """
-
-    wire: Wire
-
-
-@dataclass(frozen=True)
-class Message:
-    """A profile frame plus optional local return access.
-
-    Only frame data belongs to the serialized profile. Payloads typed as object
-    must still satisfy the JSON profile; arbitrary Python objects are not implied.
-    """
-
-    frame: ProfileFrame
-    return_address: ReturnAddress | None = None
-
-
-@dataclass(frozen=True)
-class Receiver:
-    """Callbacks receive every path relative to their attached endpoint.
-
-    A receiver may be synchronous or awaitable; endpoints own dispatch.
-    """
-
-    message: Callable[[Path, Message], None | Awaitable[None]] | None = None
-    closed: Callable[[int, str], None] | None = None
-
-
-@runtime_checkable
-class Wire(Protocol):
-    """Send-only access with synchronous admission and asynchronous dispatch.
-
-    send returns on acceptance or raises on refusal, without running destination
-    application code on the sender's stack. It grants no receiving or closure
-    authority. Structural protocol matching alone does not prove these laws.
-    """
-
-    def send(self, path: Path, message: Message) -> None: ...
-
-
-@runtime_checkable
-class Endpoint(Wire, Protocol):
-    """Owning endpoint access with one receive attachment and endpoint closure.
-
-    receive refuses a second active attachment or a closed endpoint and returns
-    an idempotent detach. A stale detach cannot remove a later attachment. Callbacks receive the complete
-    message and its relative path; routing policy belongs above this boundary.
-    Detach preserves captured return access and does not close the endpoint.
-    Closing notifies the active receiver once; detached receivers are not notified.
-    Closing twice has no additional effect and does not release live bindings.
-    """
-
-    def receive(self, receiver: Receiver) -> Callable[[], None]: ...
-
-    def close(self, code: int = 1000, reason: str = "") -> None: ...

bitspark_bitwire-0.2.0/tests/test_consumer.py

@@ -1,157 +0,0 @@
-"""Consumer observations against declarations, not a runtime conformance suite."""
-
-from __future__ import annotations
-
-import asyncio
-import inspect
-import unittest
-from collections.abc import Callable
-
-from bitwire import Endpoint, Message, Path, Receiver, ReturnAddress, Wire
-
-
-class RecordingEndpoint:
-    """Independent structural consumer fixture; no inheritance or routing runtime."""
-
-    def __init__(self) -> None:
-        self.sent: list[tuple[tuple[str, ...], Message]] = []
-        self.receiver: Receiver | None = None
-        self.attachment: object | None = None
-        self.ending: tuple[int, str] | None = None
-
-    def __eq__(self, other: object) -> bool:
-        raise AssertionError("ReturnAddress must not compare the wrapped Wire")
-
-    def send(self, path: Path, message: Message) -> None:
-        self.sent.append((tuple(path), message))
-
-    def receive(self, receiver: Receiver) -> Callable[[], None]:
-        if self.ending is not None:
-            raise RuntimeError("endpoint closed")
-        if self.receiver is not None:
-            raise RuntimeError("receiver already attached")
-        token = object()
-        self.receiver = receiver
-        self.attachment = token
-
-        def detach() -> None:
-            if self.attachment is token:
-                self.receiver = None
-                self.attachment = None
-
-        return detach
-
-    def close(self, code: int = 1000, reason: str = "") -> None:
-        if self.ending is not None:
-            return
-        self.ending = (code, reason)
-        receiver = self.receiver
-        self.receiver = None
-        self.attachment = None
-        if receiver is not None and receiver.closed is not None:
-            receiver.closed(code, reason)
-
-
-class ConsumerTests(unittest.TestCase):
-    def test_structural_consumer_keeps_path_frame_and_return_object(self) -> None:
-        endpoint = RecordingEndpoint()
-        wire: Wire = endpoint
-        replies = ReturnAddress(RecordingEndpoint())
-        request = Message(
-            {"version": 1, "kind": "request", "id": "r1", "params": {"count": 2**80}},
-            replies,
-        )
-        self.assertIsInstance(endpoint, Wire)
-        for path in ([], [""], ["a/b"], ["a", "b"], ["\u03bb", "\U0001f30d"]):
-            wire.send(path, request)
-
-        self.assertEqual(len({path for path, _ in endpoint.sent}), 5)
-        for _, delivered in endpoint.sent:
-            self.assertIs(delivered, request)
-            self.assertIs(delivered.frame, request.frame)
-            self.assertIs(delivered.return_address, replies)
-
-    def test_return_identity_is_independent_of_wire_equality_and_hashing(self) -> None:
-        endpoint = RecordingEndpoint()
-        first, second = ReturnAddress(endpoint), ReturnAddress(endpoint)
-        self.assertNotEqual(first, second)
-        self.assertEqual(first, first)
-        self.assertEqual(len({first, second}), 2)
-        self.assertIs(first.wire, endpoint)
-
-    def test_async_receiver_and_detach_are_usable_by_a_consumer(self) -> None:
-        endpoint = RecordingEndpoint()
-        observed: list[tuple[tuple[str, ...], Message]] = []
-
-        async def delivered(path: Path, message: Message) -> None:
-            await asyncio.sleep(0)
-            observed.append((tuple(path), message))
-
-        receiver = Receiver(message=delivered)
-        detach = endpoint.receive(receiver)
-        request = Message({"version": 1, "kind": "event", "data": None})
-
-        async def dispatch() -> None:
-            registered = endpoint.receiver
-            assert registered is not None and registered.message is not None
-            result = registered.message(["reply", ""], request)
-            if inspect.isawaitable(result):
-                await result
-
-        asyncio.run(dispatch())
-        self.assertEqual(observed, [(("reply", ""), request)])
-        detach()
-        detach()
-        self.assertIsNone(endpoint.receiver)
-        self.assertIsNone(endpoint.ending)
-
-    def test_attachment_ownership_and_stale_detach(self) -> None:
-        endpoint: Endpoint = RecordingEndpoint()
-        first = Receiver()
-        detach = endpoint.receive(first)
-        with self.assertRaises(RuntimeError):
-            endpoint.receive(first)
-        detach()
-        second = Receiver()
-        second_detach = endpoint.receive(second)
-        detach()
-        assert isinstance(endpoint, RecordingEndpoint)
-        self.assertIs(endpoint.receiver, second)
-        second_detach()
-        self.assertIsNone(endpoint.receiver)
-
-    def test_close_notifies_only_active_attachment_once(self) -> None:
-        endpoint = RecordingEndpoint()
-        endings: list[tuple[int, str]] = []
-        detached: list[tuple[int, str]] = []
-        endpoint.receive(Receiver(closed=lambda c, r: detached.append((c, r))))()
-        endpoint.receive(Receiver(closed=lambda c, r: endings.append((c, r))))
-        endpoint.close(1000, "done")
-        endpoint.close(1001, "again")
-        self.assertEqual(endings, [(1000, "done")])
-        self.assertEqual(detached, [])
-        with self.assertRaises(RuntimeError):
-            endpoint.receive(Receiver())
-
-    def test_send_only_wire_requires_no_endpoint_control(self) -> None:
-        class Access:
-            def send(self, path: Path, message: Message) -> None:
-                pass
-
-        access: Wire = Access()
-        self.assertIsInstance(access, Wire)
-        self.assertNotIsInstance(access, Endpoint)
-        self.assertIs(ReturnAddress(access).wire, access)
-
-    def test_closed_callback_is_independent_from_message_callback(self) -> None:
-        endings: list[tuple[int, str]] = []
-        receiver = Receiver(closed=lambda code, reason: endings.append((code, reason)))
-        assert receiver.closed is not None
-        receiver.closed(1000, "complete")
-        self.assertEqual(endings, [(1000, "complete")])
-        self.assertIsNone(receiver.message)
-
-
-
-if __name__ == "__main__":
-    unittest.main()

bitspark_bitwire-0.2.0/tests/typecheck.py

@@ -1,46 +0,0 @@
-"""Compile-only consumers, including rejections guarded by unused-ignore checks."""
-
-from typing import assert_type
-
-from bitwire import (
-    CancelFrame,
-    ErrorFrame,
-    Endpoint,
-    EventFrame,
-    Message,
-    Path,
-    ProfileFrame,
-    ProfileKind,
-    Receiver,
-    RequestFrame,
-    ResultFrame,
-    ReturnAddress,
-    Wire,
-)
-
-
-def consume(wire: Wire, endpoint: Endpoint, frame: ProfileFrame) -> None:
-    address = ReturnAddress(wire)
-    wire.send(["scope", ""], Message(frame, address))
-    assert_type(address.wire, Wire)
-    kind: ProfileKind = frame["kind"]
-    assert_type(kind, ProfileKind)
-    if frame["kind"] == "request":
-        assert_type(frame["id"], str)
-
-    async def delivered(path: Path, message: Message) -> None:
-        assert_type(message.return_address, ReturnAddress | None)
-
-    endpoint.receive(Receiver(message=delivered))()
-    wire.receive(Receiver())  # type: ignore[attr-defined]
-    wire.close()  # type: ignore[attr-defined]
-    wire.send([42], Message(frame))  # type: ignore[list-item]
-
-
-request: RequestFrame = {"version": 1, "kind": "request", "id": "1", "params": {}}
-result: ResultFrame = {"version": 1, "kind": "response", "id": "1", "result": None}
-error: ErrorFrame = {"version": 1, "kind": "response", "id": "1", "error": {"code": "no", "message": "No"}}
-event: EventFrame = {"version": 1, "kind": "event", "data": None}
-cancel: CancelFrame = {"version": 1, "kind": "cancel", "id": "1"}
-invalid_version: RequestFrame = {"version": 2, "kind": "request", "id": "1", "params": {}}  # type: ignore[typeddict-item]
-contradictory: ResultFrame = {"version": 1, "kind": "response", "id": "1", "result": None, "error": {"code": "x", "message": "x"}}  # type: ignore[typeddict-unknown-key]