protowire-python 0.70.0__cp311-cp311-win_amd64.whl

protowire/__init__.py

@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 TrendVidia, LLC.
+"""protowire — PXF/SBE/envelope codecs, Python wrapper around protowire-cpp."""
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_12_1():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'protowire_python.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_12_1()
+del _delvewheel_patch_1_12_1
+# end delvewheel patch
+
+from . import envelope, pxf, sbe
+
+__all__ = ["pxf", "sbe", "envelope"]
+__version__ = "0.70.0"

protowire/_schema.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 TrendVidia, LLC.
+"""Helpers to extract a serialized FileDescriptorSet from a Python protobuf
+Message subclass — needed because the C++ side speaks FileDescriptorSet bytes,
+not Python descriptors.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from google.protobuf import descriptor_pb2
+from google.protobuf.descriptor import Descriptor, FileDescriptor
+from google.protobuf.message import Message
+
+
+def fds_for_descriptor(desc: Descriptor) -> bytes:
+    """Build a FileDescriptorSet covering desc's file plus all transitive deps.
+
+    Files are emitted in dependency order so DescriptorPool.BuildFile() succeeds
+    on the C++ side.
+    """
+    visited: dict[str, FileDescriptor] = {}
+    order: list[FileDescriptor] = []
+
+    def walk(fd: FileDescriptor) -> None:
+        if fd.name in visited:
+            return
+        for dep in fd.dependencies:
+            walk(dep)
+        visited[fd.name] = fd
+        order.append(fd)
+
+    walk(desc.file)
+
+    fds = descriptor_pb2.FileDescriptorSet()
+    for fd in order:
+        proto = descriptor_pb2.FileDescriptorProto()
+        fd.CopyToProto(proto)
+        fds.file.append(proto)
+    return fds.SerializeToString()
+
+
+def fds_for_message(msg: Message) -> bytes:
+    return fds_for_descriptor(type(msg).DESCRIPTOR)
+
+
+def fds_for_files(files: Iterable[FileDescriptor]) -> bytes:
+    """Build a FileDescriptorSet covering all given files plus transitive deps."""
+    visited: dict[str, FileDescriptor] = {}
+    order: list[FileDescriptor] = []
+
+    def walk(fd: FileDescriptor) -> None:
+        if fd.name in visited:
+            return
+        for dep in fd.dependencies:
+            walk(dep)
+        visited[fd.name] = fd
+        order.append(fd)
+
+    for f in files:
+        walk(f)
+
+    fds = descriptor_pb2.FileDescriptorSet()
+    for fd in order:
+        proto = descriptor_pb2.FileDescriptorProto()
+        fd.CopyToProto(proto)
+        fds.file.append(proto)
+    return fds.SerializeToString()

protowire/envelope.py

@@ -0,0 +1,351 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 TrendVidia, LLC.
+"""Standard API response envelope — wire-compatible with the Go envelope package.
+
+Wire format mirrors the Go `protowire:"N"` struct tags: signed ints zig-zag,
+strings/bytes length-delimited, nested messages length-delimited. We implement
+the wire format in pure Python rather than crossing the FFI for envelope ops
+because there is no schema involved — field numbers are fixed.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field as _field
+from typing import Optional
+
+
+# --- low-level wire helpers (proto3 / protowire) -------------------------
+
+
+def _enc_varint(out: bytearray, v: int) -> None:
+    while v >= 0x80:
+        out.append((v & 0x7F) | 0x80)
+        v >>= 7
+    out.append(v & 0x7F)
+
+
+def _enc_zigzag64(v: int) -> int:
+    return (v << 1) ^ (v >> 63) & 0xFFFFFFFFFFFFFFFF
+
+
+def _enc_tag(out: bytearray, num: int, wire: int) -> None:
+    _enc_varint(out, (num << 3) | wire)
+
+
+def _enc_string(out: bytearray, num: int, s: str) -> None:
+    if not s:
+        return
+    b = s.encode("utf-8")
+    _enc_tag(out, num, 2)
+    _enc_varint(out, len(b))
+    out.extend(b)
+
+
+def _enc_bytes(out: bytearray, num: int, b: bytes) -> None:
+    if not b:
+        return
+    _enc_tag(out, num, 2)
+    _enc_varint(out, len(b))
+    out.extend(b)
+
+
+def _enc_repeated_string(out: bytearray, num: int, ss: list[str]) -> None:
+    for s in ss:
+        # Repeated strings: one tag+value per element, even when empty.
+        _enc_tag(out, num, 2)
+        b = s.encode("utf-8")
+        _enc_varint(out, len(b))
+        out.extend(b)
+
+
+def _enc_int32(out: bytearray, num: int, v: int) -> None:
+    if v == 0:
+        return
+    _enc_tag(out, num, 0)
+    if v < 0:
+        v &= 0xFFFFFFFFFFFFFFFF
+    _enc_varint(out, v)
+
+
+def _enc_sint32(out: bytearray, num: int, v: int) -> None:
+    """Signed int32 with zig-zag encoding (matches Go protowire pb)."""
+    if v == 0:
+        return
+    _enc_tag(out, num, 0)
+    _enc_varint(out, _enc_zigzag64(v))
+
+
+def _enc_submessage(out: bytearray, num: int, sub: bytes) -> None:
+    _enc_tag(out, num, 2)
+    _enc_varint(out, len(sub))
+    out.extend(sub)
+
+
+def _dec_varint(buf: bytes, i: int) -> tuple[int, int]:
+    v = 0
+    shift = 0
+    n = len(buf)
+    while True:
+        if i >= n:
+            raise ValueError("truncated varint")
+        b = buf[i]
+        i += 1
+        v |= (b & 0x7F) << shift
+        if b < 0x80:
+            return v, i
+        shift += 7
+        if shift > 63:
+            raise ValueError("varint overflow")
+
+
+def _dec_zigzag64(v: int) -> int:
+    return (v >> 1) ^ -(v & 1)
+
+
+def _dec_tag(buf: bytes, i: int) -> tuple[int, int, int]:
+    v, i = _dec_varint(buf, i)
+    return v >> 3, v & 7, i
+
+
+def _dec_string(buf: bytes, i: int) -> tuple[str, int]:
+    n, i = _dec_varint(buf, i)
+    end = i + n
+    return buf[i:end].decode("utf-8"), end
+
+
+def _dec_bytes(buf: bytes, i: int) -> tuple[bytes, int]:
+    n, i = _dec_varint(buf, i)
+    end = i + n
+    return bytes(buf[i:end]), end
+
+
+def _dec_int32(v: int) -> int:
+    """Decode a varint as a two's-complement int32 (sign-extended from int64)."""
+    if v >= 0x8000000000000000:
+        v -= 0x10000000000000000
+    return v
+
+
+def _skip_field(buf: bytes, i: int, wire: int) -> int:
+    if wire == 0:  # varint
+        _, i = _dec_varint(buf, i)
+        return i
+    if wire == 1:  # fixed64
+        return i + 8
+    if wire == 2:  # length-delimited
+        ln, i = _dec_varint(buf, i)
+        if ln < 0 or i + ln > len(buf):
+            raise ValueError("truncated length-delimited field")
+        return i + ln
+    if wire == 5:  # fixed32
+        return i + 4
+    raise ValueError(f"unsupported wire type: {wire}")
+
+
+# --- public types --------------------------------------------------------
+
+
+@dataclass
+class FieldError:
+    field: str = ""
+    code: str = ""
+    message: str = ""
+    args: list[str] = _field(default_factory=list)
+
+    def encode(self) -> bytes:
+        out = bytearray()
+        _enc_string(out, 1, self.field)
+        _enc_string(out, 2, self.code)
+        _enc_string(out, 3, self.message)
+        _enc_repeated_string(out, 4, self.args)
+        return bytes(out)
+
+    @classmethod
+    def decode(cls, data: bytes) -> "FieldError":
+        out = cls()
+        i = 0
+        n = len(data)
+        while i < n:
+            num, wire, i = _dec_tag(data, i)
+            if num == 1 and wire == 2:
+                out.field, i = _dec_string(data, i)
+            elif num == 2 and wire == 2:
+                out.code, i = _dec_string(data, i)
+            elif num == 3 and wire == 2:
+                out.message, i = _dec_string(data, i)
+            elif num == 4 and wire == 2:
+                v, i = _dec_string(data, i)
+                out.args.append(v)
+            else:
+                i = _skip_field(data, i, wire)
+        return out
+
+
+@dataclass
+class AppError:
+    code: str = ""
+    message: str = ""
+    args: list[str] = _field(default_factory=list)
+    details: list[FieldError] = _field(default_factory=list)
+    metadata: dict[str, str] = _field(default_factory=dict)
+
+    def with_field(
+        self,
+        field_name: str,
+        code: str,
+        message: str,
+        *args: str,
+    ) -> "AppError":
+        self.details.append(
+            FieldError(field=field_name, code=code, message=message, args=list(args))
+        )
+        return self
+
+    def with_meta(self, key: str, value: str) -> "AppError":
+        self.metadata[key] = value
+        return self
+
+    def encode(self) -> bytes:
+        out = bytearray()
+        _enc_string(out, 1, self.code)
+        _enc_string(out, 2, self.message)
+        _enc_repeated_string(out, 3, self.args)
+        for d in self.details:
+            _enc_submessage(out, 4, d.encode())
+        # Metadata: map<string,string> as repeated message{key=1,value=2}, field 5.
+        for k, v in self.metadata.items():
+            entry = bytearray()
+            _enc_string(entry, 1, k)
+            _enc_string(entry, 2, v)
+            _enc_submessage(out, 5, bytes(entry))
+        return bytes(out)
+
+    @classmethod
+    def decode(cls, data: bytes) -> "AppError":
+        out = cls()
+        i = 0
+        n = len(data)
+        while i < n:
+            num, wire, i = _dec_tag(data, i)
+            if num == 1 and wire == 2:
+                out.code, i = _dec_string(data, i)
+            elif num == 2 and wire == 2:
+                out.message, i = _dec_string(data, i)
+            elif num == 3 and wire == 2:
+                v, i = _dec_string(data, i)
+                out.args.append(v)
+            elif num == 4 and wire == 2:
+                sub, i = _dec_bytes(data, i)
+                out.details.append(FieldError.decode(sub))
+            elif num == 5 and wire == 2:
+                # Map entry: message{key=1,value=2}.
+                sub, i = _dec_bytes(data, i)
+                key, val, j = "", "", 0
+                m = len(sub)
+                while j < m:
+                    knum, kwire, j = _dec_tag(sub, j)
+                    if knum == 1 and kwire == 2:
+                        key, j = _dec_string(sub, j)
+                    elif knum == 2 and kwire == 2:
+                        val, j = _dec_string(sub, j)
+                    else:
+                        j = _skip_field(sub, j, kwire)
+                out.metadata[key] = val
+            else:
+                i = _skip_field(data, i, wire)
+        return out
+
+
+@dataclass
+class Envelope:
+    status: int = 0
+    transport_error: str = ""
+    data: bytes = b""
+    error: Optional[AppError] = None
+
+    # --- builders ---
+    @classmethod
+    def ok(cls, status: int, data: bytes) -> "Envelope":
+        return cls(status=status, data=bytes(data))
+
+    @classmethod
+    def err(
+        cls, status: int, code: str, message: str, *args: str
+    ) -> "Envelope":
+        return cls(
+            status=status,
+            error=AppError(code=code, message=message, args=list(args)),
+        )
+
+    @classmethod
+    def transport_err(cls, err: str) -> "Envelope":
+        return cls(transport_error=err)
+
+    # --- queries ---
+    def is_ok(self) -> bool:
+        return not self.transport_error and self.error is None
+
+    def is_transport_error(self) -> bool:
+        return bool(self.transport_error)
+
+    def is_app_error(self) -> bool:
+        return self.error is not None
+
+    def error_code(self) -> str:
+        return self.error.code if self.error else ""
+
+    def field_errors(self) -> dict[str, FieldError]:
+        if self.error is None or not self.error.details:
+            return {}
+        return {fe.field: fe for fe in self.error.details}
+
+    # --- wire encode/decode (matches protowire pb) ---
+    def encode(self) -> bytes:
+        out = bytearray()
+        # status is plain int32 (proto3 int32 wire encoding, sign-extended
+        # to a 10-byte varint for negative values). Matches the Go envelope
+        # struct tag `protowire:"1"` (no `,zigzag` option).
+        _enc_int32(out, 1, self.status)
+        _enc_string(out, 2, self.transport_error)
+        _enc_bytes(out, 3, self.data)
+        if self.error is not None:
+            _enc_submessage(out, 4, self.error.encode())
+        return bytes(out)
+
+    @classmethod
+    def decode(cls, data: bytes) -> "Envelope":
+        out = cls()
+        i = 0
+        n = len(data)
+        while i < n:
+            num, wire, i = _dec_tag(data, i)
+            if num == 1 and wire == 0:
+                v, i = _dec_varint(data, i)
+                out.status = _dec_int32(v)
+            elif num == 2 and wire == 2:
+                out.transport_error, i = _dec_string(data, i)
+            elif num == 3 and wire == 2:
+                out.data, i = _dec_bytes(data, i)
+            elif num == 4 and wire == 2:
+                sub, i = _dec_bytes(data, i)
+                out.error = AppError.decode(sub)
+            else:
+                i = _skip_field(data, i, wire)
+        return out
+
+
+# Free-function aliases mirroring the Go API.
+def OK(status: int, data: bytes) -> Envelope:
+    return Envelope.ok(status, data)
+
+
+def Err(status: int, code: str, message: str, *args: str) -> Envelope:
+    return Envelope.err(status, code, message, *args)
+
+
+def TransportErr(err: str) -> Envelope:
+    return Envelope.transport_err(err)
+
+
+def NewAppError(code: str, message: str, *args: str) -> AppError:
+    return AppError(code=code, message=message, args=list(args))

protowire/pxf.py

@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 TrendVidia, LLC.
+"""PXF text ↔ protobuf Message — Python mirror of github.com/trendvidia/protowire/encoding/pxf.
+
+The boundary with C++ is FileDescriptorSet bytes + binary proto bytes; Message
+objects never cross. The wrapper handles conversion on each side.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from google.protobuf.message import Message
+
+from . import _protowire
+from ._schema import fds_for_message
+
+
+@dataclass(frozen=True)
+class Result:
+    """Field-level presence metadata, mirror of Go pxf.Result."""
+
+    set_paths: frozenset[str]
+    null_paths: frozenset[str]
+
+    def is_set(self, path: str) -> bool:
+        return path in self.set_paths and path not in self.null_paths
+
+    def is_null(self, path: str) -> bool:
+        return path in self.null_paths
+
+    def is_absent(self, path: str) -> bool:
+        return path not in self.set_paths and path not in self.null_paths
+
+    def null_fields(self) -> list[str]:
+        return sorted(self.null_paths)
+
+
+def marshal(msg: Message) -> str:
+    """Encode `msg` as PXF text. Mirrors Go pxf.Marshal."""
+    fds = fds_for_message(msg)
+    return _protowire.pxf_marshal(msg.SerializeToString(), fds, msg.DESCRIPTOR.full_name)
+
+
+# --- bytes-only helpers (used by the CLI / advanced callers) -------------
+
+
+def marshal_bytes(msg_bytes: bytes, fds: bytes, full_name: str) -> str:
+    """Encode raw proto-binary bytes (against an explicit FDS) as PXF text."""
+    return _protowire.pxf_marshal(bytes(msg_bytes), bytes(fds), full_name)
+
+
+def unmarshal_bytes(
+    data: str | bytes, fds: bytes, full_name: str, *, discard_unknown: bool = False
+) -> bytes:
+    """Decode PXF text into raw proto-binary bytes against an explicit FDS."""
+    text = data.encode("utf-8") if isinstance(data, str) else bytes(data)
+    return _protowire.pxf_unmarshal(text, bytes(fds), full_name, discard_unknown)
+
+
+def unmarshal_full_bytes(
+    data: str | bytes, fds: bytes, full_name: str, *, discard_unknown: bool = False
+) -> tuple[bytes, Result]:
+    text = data.encode("utf-8") if isinstance(data, str) else bytes(data)
+    raw, set_paths, null_paths = _protowire.pxf_unmarshal_full(
+        text, bytes(fds), full_name, discard_unknown
+    )
+    return raw, Result(frozenset(set_paths), frozenset(null_paths))
+
+
+def unmarshal(data: str | bytes, msg: Message, *, discard_unknown: bool = False) -> None:
+    """Decode PXF text into `msg` (in place). Mirrors Go pxf.Unmarshal."""
+    text = data.encode("utf-8") if isinstance(data, str) else bytes(data)
+    fds = fds_for_message(msg)
+    raw = _protowire.pxf_unmarshal(text, fds, msg.DESCRIPTOR.full_name, discard_unknown)
+    msg.Clear()
+    msg.MergeFromString(raw)
+
+
+def unmarshal_full(
+    data: str | bytes, msg: Message, *, discard_unknown: bool = False
+) -> Result:
+    """Decode PXF + return per-field presence (set/null) metadata.
+
+    Mirrors Go pxf.UnmarshalFull.
+    """
+    text = data.encode("utf-8") if isinstance(data, str) else bytes(data)
+    fds = fds_for_message(msg)
+    raw, set_paths, null_paths = _protowire.pxf_unmarshal_full(
+        text, fds, msg.DESCRIPTOR.full_name, discard_unknown
+    )
+    msg.Clear()
+    msg.MergeFromString(raw)
+    return Result(frozenset(set_paths), frozenset(null_paths))

protowire/sbe.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 TrendVidia, LLC.
+"""SBE codec — Python mirror of github.com/trendvidia/protowire-go/encoding/sbe."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from google.protobuf.descriptor import FileDescriptor
+from google.protobuf.message import Message
+
+from . import _protowire
+from ._schema import fds_for_files
+
+
+class View:
+    """Zero-copy view over an SBE-encoded buffer.
+
+    Wraps the native ``_protowire.View``. The underlying data is owned by
+    the native object (a shared heap copy of the input bytes) and stays alive
+    as long as any view, sub-view, or group entry referencing it is alive.
+    """
+
+    __slots__ = ("_native",)
+
+    def __init__(self, native: "_protowire.View") -> None:
+        self._native = native
+
+    def int(self, name: str) -> int:
+        return self._native.int(name)
+
+    def uint(self, name: str) -> int:
+        return self._native.uint(name)
+
+    def float(self, name: str) -> float:
+        return self._native.float(name)
+
+    def bool(self, name: str) -> bool:
+        return self._native.bool(name)
+
+    def string(self, name: str) -> str:
+        return self._native.string(name)
+
+    def bytes(self, name: str) -> bytes:
+        """Read a fixed-length bytes field as the full N-byte slice (no trim)."""
+        return self._native.bytes(name)
+
+    def composite(self, name: str) -> "View":
+        """Sub-view over a non-repeated nested message (SBE composite)."""
+        return View(self._native.composite(name))
+
+    def group(self, name: str) -> "GroupView":
+        """View over a repeating group field."""
+        return GroupView(self._native.group(name))
+
+
+class GroupView:
+    """View over an SBE repeating group. Iterate via :py:meth:`entry`."""
+
+    __slots__ = ("_native",)
+
+    def __init__(self, native: "_protowire.GroupView") -> None:
+        self._native = native
+
+    def len(self) -> int:
+        return self._native.len()
+
+    def __len__(self) -> int:
+        return self._native.len()
+
+    def entry(self, i: int) -> View:
+        return View(self._native.entry(i))
+
+
+class Codec:
+    """SBE codec built from one or more proto FileDescriptors with SBE annotations."""
+
+    def __init__(self, files: Iterable[FileDescriptor]) -> None:
+        files = list(files)
+        if not files:
+            raise ValueError("sbe.Codec requires at least one FileDescriptor")
+        fds = fds_for_files(files)
+        # Pass the *selected* file names so the C++ Codec only registers those
+        # — transitive dep files (descriptor.proto, sbe/annotations.proto)
+        # don't carry an (sbe.schema_id) option and would otherwise fail.
+        self._impl = _protowire.SbeCodec.create(fds, [f.name for f in files])
+
+    @classmethod
+    def from_message(cls, msg_type: type[Message]) -> "Codec":
+        return cls([msg_type.DESCRIPTOR.file])
+
+    def marshal(self, msg: Message) -> bytes:
+        return self._impl.marshal(msg.SerializeToString(), msg.DESCRIPTOR.full_name)
+
+    def unmarshal(self, data: bytes, msg: Message) -> None:
+        raw = self._impl.unmarshal(bytes(data), msg.DESCRIPTOR.full_name)
+        msg.Clear()
+        msg.MergeFromString(raw)
+
+    def view(self, data: bytes) -> View:
+        return View(self._impl.new_view(bytes(data)))

protowire_python-0.70.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.12.1
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-bpz2baut\\cp311-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '--add-path', 'C:\\vcpkg\\installed\\x64-windows\\bin', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-bpz2baut\\cp311-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-bpz2baut\\cp311-win_amd64\\built_wheel\\protowire_python-0.70.0-cp311-cp311-win_amd64.whl']

protowire_python-0.70.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: protowire-python
+Version: 0.70.0
+Summary: Python wrapper around protowire-cpp — PXF text, SBE binary, and envelope codecs.
+Keywords: protobuf,pxf,sbe,wire-format,fix,trading
+Author-Email: "TrendVidia, LLC" <open-source@trendvidia.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C++
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://protowire.org
+Project-URL: Repository, https://github.com/trendvidia/protowire-python
+Project-URL: Bug Tracker, https://github.com/trendvidia/protowire-python/issues
+Project-URL: Changelog, https://github.com/trendvidia/protowire-python/blob/main/CHANGELOG.md
+Project-URL: Specification, https://github.com/trendvidia/protowire
+Requires-Python: >=3.10
+Requires-Dist: protobuf>=4.0
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Description-Content-Type: text/markdown
+
+# protowire-python
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/protowire-python.svg)](https://pypi.org/project/protowire-python/)
+[![Python](https://img.shields.io/pypi/pyversions/protowire-python.svg)](https://pypi.org/project/protowire-python/)
+[![CI](https://github.com/trendvidia/protowire-python/actions/workflows/ci.yml/badge.svg)](https://github.com/trendvidia/protowire-python/actions/workflows/ci.yml)
+
+Python port of [protowire](https://protowire.org) — a protobuf-backed wire-format
+toolkit. CPython 3.10+, MIT, [nanobind](https://github.com/wjakob/nanobind) FFI
+over [`protowire-cpp`](https://github.com/trendvidia/protowire-cpp). Verified
+for byte-equivalence against the canonical Go reference and seven other
+sibling ports.
+
+The native extension uses [nanobind](https://github.com/wjakob/nanobind) with
+[scikit-build-core](https://github.com/scikit-build/scikit-build-core) as the
+build backend. The FFI boundary is intentionally narrow: Python sends a
+serialized `FileDescriptorSet` plus a fully-qualified message name; binary
+proto bytes flow back. `google.protobuf.Message` objects never cross the
+language boundary.
+
+## Install
+
+```sh
+pip install protowire-python
+```
+
+The PyPI distribution is named `protowire-python` (the bare `protowire`
+name was taken). The import name stays `protowire`:
+
+```python
+from protowire import pxf, sbe, envelope
+```
+
+Wheels are published for CPython 3.10–3.13 on Linux × {x86_64, aarch64},
+macOS × {x86_64, arm64}, and Windows × x86_64. On other platforms `pip`
+will fall back to a source build (requires CMake ≥ 3.20 and a C++20
+compiler).
+
+## API
+
+```python
+from protowire import pxf, sbe, envelope
+
+# PXF — schema implicit in the message type.
+text = pxf.marshal(my_msg)
+pxf.unmarshal(text, my_msg)
+result = pxf.unmarshal_full(text, my_msg)
+result.is_set("nested.value"), result.is_null("flag")
+
+# SBE — codec built from one or more FileDescriptors with sbe annotations.
+codec = sbe.Codec.from_message(OrderType)
+data = codec.marshal(order)
+codec.unmarshal(data, order_out)
+view = codec.view(data); view.uint("order_id")
+
+# Envelope — wire-compatible with the Go envelope package.
+e = envelope.OK(200, b"payload")
+e = envelope.Err(400, "VALIDATION", "bad input").error.with_field(
+    "name", "REQUIRED", "missing"
+)
+```
+
+## Build from source
+
+```sh
+git clone https://github.com/trendvidia/protowire-cpp.git ../protowire-cpp
+
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e '.[test]'
+
+pytest
+```
+
+The build looks for [`protowire-cpp`](https://github.com/trendvidia/protowire-cpp)
+at `../protowire-cpp` by default. Override with
+`PROTOWIRE_CPP_DIR=/abs/path pip install -e .` or
+`pip install -e . --config-settings=cmake.define.PROTOWIRE_CPP_DIR=/abs/path`.
+
+Required: CMake ≥ 3.20, a C++20 compiler, protobuf headers + libs.
+
+- Linux: `apt-get install protobuf-compiler libprotobuf-dev libprotoc-dev`
+- macOS: `brew install protobuf`
+- Windows: `vcpkg install protobuf` and pass the toolchain file via
+  `CMAKE_TOOLCHAIN_FILE`
+
+## Command-line tool
+
+The `protowire` CLI is shared across every port and lives in the spec repo at
+[github.com/trendvidia/protowire/cmd/protowire](https://github.com/trendvidia/protowire/tree/main/cmd/protowire).
+Install:
+
+```sh
+go install github.com/trendvidia/protowire/cmd/protowire@latest
+```
+
+Python users use this library for in-process encode/decode and the shared CLI
+for command-line operations. There is no separate Python CLI binary.
+
+## Wire compatibility
+
+Verified manually against the Go module:
+
+- Go `pxf.Marshal` → file → Python `pxf.unmarshal` round-trips a representative AllTypes message.
+- Python `pxf.marshal` → file → Go `pxf.Unmarshal` round-trips equally.
+
+Because the wire codec is the C++ one, this port inherits all of
+[`protowire-cpp`](https://github.com/trendvidia/protowire-cpp)'s
+cross-port equivalence guarantees.
+
+## Limitations & open gaps
+
+- **No pure-Python fallback.** A C++ toolchain (clang or gcc, plus CMake) is
+  required at install time on platforms where we don't ship a wheel.
+  Pure-`google.protobuf`-Python encode/decode without C++ is not available —
+  opening that up is a meaningful refactor and would need a separate decoder
+  path.
+- **The FFI is narrow on purpose.** `google.protobuf.Message` objects never
+  cross the boundary — Python sends a `FileDescriptorSet` + fully-qualified
+  message name and bytes flow back. This keeps the C++ side type-stable but
+  means Python callers serialize their messages once before each call. A
+  `MessageView`-style zero-copy path would be welcome.
+- **No standalone Python CLI.** The shared CLI lives in
+  [trendvidia/protowire/cmd/protowire](https://github.com/trendvidia/protowire/tree/main/cmd/protowire);
+  Python callers either invoke that binary or use the in-process API.
+- **Free-threaded Python (PEP 703 / 3.13t)** is untested. nanobind supports
+  it but the build hasn't been validated against `--disable-gil` interpreters.
+
+## Repository layout
+
+```
+protowire-python/
+├── LICENSE                                  # MIT
+├── README.md
+├── CHANGELOG.md
+├── CONTRIBUTING.md, SECURITY.md,
+│   GOVERNANCE.md, CODE_OF_CONDUCT.md
+├── pyproject.toml                           # scikit-build-core + nanobind
+├── CMakeLists.txt                           # links protowire-cpp
+├── src/_protowire/module.cc                 # FFI entry point (nanobind)
+├── src/protowire/                           # pure-Python public API
+├── tests/                                   # pytest suites
+├── testdata/                                # .proto fixtures
+├── scripts/                                 # cross-port test harnesses
+└── .github/                                 # CI: build matrix + cibuildwheel + CodeQL
+```

protowire_python-0.70.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+protowire/envelope.py,sha256=imc-4P6Vi0U7YFq03r10qY_2g98tQg5BnU-6B9dtg7I,10754
+protowire/pxf.py,sha256=d3DDTAxrUv3kR1s_FnpN-KFwaI16UCxURadj4m52E78,3428
+protowire/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+protowire/sbe.py,sha256=PiBRb_ogwiFcF2_QqLH_4OlHAiv53VSXD2FCIEdUFtM,3391
+protowire/_protowire.cp311-win_amd64.pyd,sha256=k0Nivj2g5VEf2xxDYcSQbZG-E78zXlRzbRusjziooWU,317440
+protowire/_schema.py,sha256=KxbAd4gayQVS7x1vzMLRPiQ6Y5m3EVDMOrGWh1OsEzo,2094
+protowire/__init__.py,sha256=3E3c_xZB0G1_yR4x7jDAkskLfbk3chUQbdHCYyyPdTY,587
+protowire_python-0.70.0.dist-info/DELVEWHEEL,sha256=XvLnXJpuuhw0eWEf6qYHWgDhrOe7zg8TpZObxxd1hrs,466
+protowire_python-0.70.0.dist-info/METADATA,sha256=z-iClluZRXU5Th7yJeq1ZP1pIRt2qGM0JfQuLE9iV-A,7412
+protowire_python-0.70.0.dist-info/RECORD,,
+protowire_python-0.70.0.dist-info/WHEEL,sha256=NHmw5Qi_104FW4Xq2pbA3Gs3F6EqwqCa-xRmRnEiDI8,106
+protowire_python-0.70.0.dist-info/licenses/LICENSE,sha256=E9M3EvB_npBXeSxf_HvG1pXpnZOARKMCJeegMRA8eWo,1094
+protowire_python.libs/abseil_dll-82db16a5872b9152133f5e2ff4143de1.dll,sha256=mYxIAX8MhP8tlsd_6Mi6E7aOacKSkkiPwRvsOddpyrc,2002944
+protowire_python.libs/libprotobuf-d2223d7553419e37c8b847b8bfc74ff0.dll,sha256=sYFlBXDwwN0vXes4admd-76bUTdHZNBNbuTunqkebAk,11296256
+protowire_python.libs/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056

protowire_python-0.70.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.12.2
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+

protowire_python-0.70.0.dist-info/licenses/LICENSE

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