proto 0.1.0__py3-none-any.whl

proto/__init__.py

@@ -0,0 +1,47 @@
+"""proto: schema-first, protobuf wire-compatible messages in pure Python.
+
+Declare messages as annotated classes, encode them to bytes that any
+Protocol Buffers implementation can read, and decode them back::
+
+    import proto
+
+    @proto.message
+    class Point:
+        x: int = proto.field(1, "sint32")
+        y: int = proto.field(2, "sint32")
+
+    data = proto.encode(Point(3, -4))
+    assert proto.decode(Point, data) == Point(3, -4)
+"""
+
+from __future__ import annotations
+
+from . import wire
+from .errors import DecodeError, EncodeError, ProtoError, SchemaError
+from .message import FieldInfo, decode, encode, field, fields, from_dict, is_message, message, to_dict
+from .schema import to_proto
+from .stream import iter_delimited, read_delimited, write_delimited
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "message",
+    "field",
+    "encode",
+    "decode",
+    "fields",
+    "is_message",
+    "FieldInfo",
+    "to_dict",
+    "from_dict",
+    "to_proto",
+    "write_delimited",
+    "read_delimited",
+    "iter_delimited",
+    "wire",
+    "ProtoError",
+    "SchemaError",
+    "EncodeError",
+    "DecodeError",
+    "__version__",
+]

proto/errors.py

@@ -0,0 +1,21 @@
+"""Exception hierarchy for :mod:`proto`."""
+
+from __future__ import annotations
+
+__all__ = ["ProtoError", "SchemaError", "EncodeError", "DecodeError"]
+
+
+class ProtoError(Exception):
+    """Base class for every error raised by :mod:`proto`."""
+
+
+class SchemaError(ProtoError, TypeError):
+    """A message class is declared incorrectly (bad field number, type, ...)."""
+
+
+class EncodeError(ProtoError, ValueError):
+    """A value cannot be encoded (out of range, wrong Python type, ...)."""
+
+
+class DecodeError(ProtoError, ValueError):
+    """Input bytes are not a valid encoding of the requested message."""

proto/message.py

@@ -0,0 +1,535 @@
+"""Message definitions (``@message`` / ``field``) and the encoder/decoder."""
+
+from __future__ import annotations
+
+import dataclasses
+import enum
+import inspect
+import sys
+import types
+import typing
+from dataclasses import dataclass
+from typing import Any, TypeVar, Union
+
+from .errors import DecodeError, EncodeError, SchemaError
+from .scalars import INFERRED, SCALARS, ScalarType
+from .wire import (
+    MAX_FIELD_NUMBER,
+    WireType,
+    decode_tag,
+    decode_varint,
+    encode_tag,
+    encode_varint,
+    skip_field,
+)
+
+__all__ = [
+    "FieldInfo",
+    "field",
+    "message",
+    "is_message",
+    "fields",
+    "encode",
+    "decode",
+    "to_dict",
+    "from_dict",
+]
+
+M = TypeVar("M")
+
+_META_KEY = "proto"
+_RESERVED_NUMBERS = range(19000, 20000)
+_ENUM_SCALAR = SCALARS["int32"]
+
+
+@dataclass(frozen=True)
+class _FieldDecl:
+    """What the user wrote in ``field(...)``; resolved later into FieldInfo."""
+
+    number: int
+    type: str | type | None
+    packed: bool | None
+
+
+@dataclass(frozen=True)
+class FieldInfo:
+    """Fully resolved description of one message field.
+
+    ``kind`` is ``"scalar"``, ``"enum"`` or ``"message"``. ``type_name`` is
+    the ``.proto`` spelling of the type (``"sint32"``, ``"Color"``, ...).
+    ``target`` is the enum or message class for non-scalar kinds.
+    """
+
+    name: str
+    number: int
+    kind: str
+    type_name: str
+    repeated: bool
+    optional: bool
+    packed: bool
+    scalar: ScalarType | None
+    target: type | None
+
+    @property
+    def wire_type(self) -> WireType:
+        """Wire type of a single (unpacked) element of this field."""
+        if self.kind == "message":
+            return WireType.LEN
+        if self.kind == "enum":
+            return WireType.VARINT
+        assert self.scalar is not None
+        return self.scalar.wire_type
+
+
+# --------------------------------------------------------------------------
+# Declaration
+# --------------------------------------------------------------------------
+
+
+def field(
+    number: int,
+    type: str | type | None = None,
+    *,
+    default: Any = dataclasses.MISSING,
+    default_factory: Any = dataclasses.MISSING,
+    packed: bool | None = None,
+) -> Any:
+    """Declare a message field with protobuf field ``number``.
+
+    ``type`` overrides the type inferred from the annotation. It may be a
+    scalar name (``"sint32"``, ``"fixed64"``, ...), an ``IntEnum`` subclass,
+    or a ``@message`` class. ``packed`` controls packed encoding of repeated
+    numeric fields (default ``True``, as in proto3). When no default is given
+    the proto3 zero value is used (``0``, ``""``, ``[]``, ``None``, ...).
+    """
+    if isinstance(number, bool) or not isinstance(number, int):
+        raise SchemaError(f"field number must be an int, got {number!r}")
+    if not 1 <= number <= MAX_FIELD_NUMBER:
+        raise SchemaError(f"field number out of range: {number}")
+    if number in _RESERVED_NUMBERS:
+        raise SchemaError(f"field numbers 19000-19999 are reserved: {number}")
+    if isinstance(type, str) and type not in SCALARS:
+        raise SchemaError(f"unknown scalar type {type!r}")
+    meta = {_META_KEY: _FieldDecl(number, type, packed)}
+    return dataclasses.field(default=default, default_factory=default_factory, metadata=meta)
+
+
+def message(cls: type[M] | None = None, /, *, name: str | None = None) -> Any:
+    """Class decorator turning an annotated class into a protobuf message.
+
+    The class becomes a regular :func:`dataclasses.dataclass` and gains
+    ``to_bytes()`` and ``from_bytes(data)`` helpers. ``name`` sets the message
+    name used by :func:`proto.to_proto` (defaults to the class name).
+    """
+
+    # Remember the defining scope so annotations naming classes local to a
+    # function (or defined later in it) can still be resolved lazily.
+    scope = sys._getframe(1).f_locals
+
+    def wrap(c: type[M]) -> type[M]:
+        c.__proto_scope__ = scope  # type: ignore[attr-defined]
+        _fill_defaults(c)
+        dc = dataclasses.dataclass(c)
+        dc.__proto_message__ = True  # type: ignore[attr-defined]
+        dc.__proto_name__ = name or c.__name__  # type: ignore[attr-defined]
+        if "to_bytes" not in c.__dict__:
+            dc.to_bytes = encode  # type: ignore[attr-defined]
+        if "from_bytes" not in c.__dict__:
+            dc.from_bytes = classmethod(decode)  # type: ignore[attr-defined]
+        return dc
+
+    return wrap if cls is None else wrap(cls)
+
+
+def is_message(obj: Any) -> bool:
+    """True if ``obj`` is a ``@message`` class or an instance of one."""
+    cls = obj if isinstance(obj, type) else type(obj)
+    return cls.__dict__.get("__proto_message__", False) is True
+
+
+def _fill_defaults(cls: type) -> None:
+    """Give every proto field without a default its proto3 zero value."""
+    annotations = inspect.get_annotations(cls)
+    hints = _resolve_hints(cls, strict=False)
+    for attr, annotation in annotations.items():
+        value = cls.__dict__.get(attr, dataclasses.MISSING)
+        if _is_classvar(hints.get(attr, annotation)):
+            continue
+        decl = _decl_of(value)
+        if decl is None:
+            raise SchemaError(f"{cls.__name__}.{attr} must be declared with proto.field(number)")
+        if value.default is not dataclasses.MISSING or value.default_factory is not dataclasses.MISSING:
+            continue
+        hint = hints.get(attr)
+        if hint is None:  # unresolvable forward reference
+            text = annotation if isinstance(annotation, str) else ""
+            if text.replace(" ", "").lower().startswith(("list[", "typing.list[")):
+                value.default_factory = list
+            elif isinstance(decl.type, str) and "None" not in text:
+                value.default = SCALARS[decl.type].default
+            else:
+                value.default = None
+            continue
+        base, repeated, optional = _unwrap(hint, f"{cls.__name__}.{attr}")
+        if repeated:
+            value.default_factory = list
+        elif optional:
+            value.default = None
+        else:
+            value.default = _zero_value(decl.type if decl.type is not None else base)
+
+
+def _zero_value(tp: Any) -> Any:
+    if isinstance(tp, str):
+        return SCALARS[tp].default
+    if isinstance(tp, type) and issubclass(tp, enum.IntEnum):
+        return _enum_zero(tp)
+    if tp in INFERRED:
+        return SCALARS[INFERRED[tp]].default
+    return None  # message fields (and anything we cannot classify yet)
+
+
+def _enum_zero(tp: type[enum.IntEnum]) -> enum.IntEnum:
+    try:
+        return tp(0)
+    except ValueError:
+        raise SchemaError(f"enum {tp.__name__} must define a member with value 0") from None
+
+
+def _decl_of(value: Any) -> _FieldDecl | None:
+    if isinstance(value, dataclasses.Field):
+        decl = value.metadata.get(_META_KEY)
+        if isinstance(decl, _FieldDecl):
+            return decl
+    return None
+
+
+def _is_classvar(hint: Any) -> bool:
+    if isinstance(hint, str):
+        return hint.startswith(("ClassVar", "typing.ClassVar"))
+    return hint is typing.ClassVar or typing.get_origin(hint) is typing.ClassVar
+
+
+def _resolve_hints(cls: type, strict: bool) -> dict[str, Any]:
+    """Evaluate the class annotations; forward refs may resolve to the class itself."""
+    module = sys.modules.get(cls.__module__)
+    globalns = dict(vars(module)) if module else {}
+    scope = cls.__dict__.get("__proto_scope__")
+    localns = dict(scope) if scope is not None and scope is not globalns else {}
+    localns[cls.__name__] = cls
+    try:
+        return typing.get_type_hints(cls, globalns=globalns, localns=localns)
+    except (NameError, AttributeError, TypeError):
+        if strict:
+            raise
+    hints: dict[str, Any] = {}
+    for attr, annotation in inspect.get_annotations(cls).items():
+        if isinstance(annotation, str):
+            try:
+                annotation = eval(annotation, globalns, localns)  # noqa: S307 - same as typing does
+            except Exception:
+                continue
+        hints[attr] = annotation
+    return hints
+
+
+def _unwrap(hint: Any, where: str) -> tuple[Any, bool, bool]:
+    """Split an annotation into ``(base_type, repeated, optional)``."""
+    optional = False
+    origin = typing.get_origin(hint)
+    if origin is Union or origin is types.UnionType:
+        args = [a for a in typing.get_args(hint) if a is not type(None)]
+        if len(args) != 1 or len(typing.get_args(hint)) != 2:
+            raise SchemaError(f"{where}: only `T | None` unions are supported")
+        hint, optional = args[0], True
+        origin = typing.get_origin(hint)
+    if origin is list:
+        if optional:
+            raise SchemaError(f"{where}: repeated fields cannot be optional")
+        (inner,) = typing.get_args(hint) or (Any,)
+        return inner, True, False
+    if hint is list:
+        return Any, True, False
+    return hint, False, optional
+
+
+# --------------------------------------------------------------------------
+# Schema resolution
+# --------------------------------------------------------------------------
+
+
+def fields(cls: type) -> tuple[FieldInfo, ...]:
+    """Return the resolved fields of a message class, ordered by number."""
+    if not is_message(cls):
+        raise SchemaError(f"{cls!r} is not a @proto.message class")
+    cached = cls.__dict__.get("__proto_fields__")
+    if cached is None:
+        cached = _build_fields(cls)
+        cls.__proto_fields__ = cached  # type: ignore[attr-defined]
+    return cached
+
+
+def _build_fields(cls: type) -> tuple[FieldInfo, ...]:
+    try:
+        hints = _resolve_hints(cls, strict=True)
+    except (NameError, AttributeError, TypeError) as exc:
+        raise SchemaError(f"cannot resolve annotations of {cls.__name__}: {exc}") from exc
+    result: list[FieldInfo] = []
+    seen: dict[int, str] = {}
+    for f in dataclasses.fields(cls):
+        decl = _decl_of(f)
+        if decl is None:
+            continue
+        where = f"{cls.__name__}.{f.name}"
+        if decl.number in seen:
+            raise SchemaError(f"{where}: field number {decl.number} already used by {seen[decl.number]}")
+        seen[decl.number] = f.name
+        base, repeated, optional = _unwrap(hints[f.name], where)
+        target = decl.type if decl.type is not None else base
+        result.append(_make_info(f.name, decl, target, repeated, optional, where))
+    result.sort(key=lambda info: info.number)
+    return tuple(result)
+
+
+def _make_info(
+    name: str, decl: _FieldDecl, target: Any, repeated: bool, optional: bool, where: str
+) -> FieldInfo:
+    if isinstance(target, str):
+        scalar = SCALARS[target]
+        packed = repeated and scalar.packable and decl.packed is not False
+        return FieldInfo(name, decl.number, "scalar", target, repeated, optional, packed, scalar, None)
+    if target in INFERRED:
+        scalar = SCALARS[INFERRED[target]]
+        packed = repeated and scalar.packable and decl.packed is not False
+        return FieldInfo(name, decl.number, "scalar", scalar.name, repeated, optional, packed, scalar, None)
+    if isinstance(target, type) and issubclass(target, enum.IntEnum):
+        _enum_zero(target)
+        packed = repeated and decl.packed is not False
+        return FieldInfo(name, decl.number, "enum", target.__name__, repeated, optional, packed, None, target)
+    if isinstance(target, type) and is_message(target):
+        if decl.packed:
+            raise SchemaError(f"{where}: message fields cannot be packed")
+        type_name = target.__proto_name__  # type: ignore[attr-defined]
+        return FieldInfo(name, decl.number, "message", type_name, repeated, True, False, None, target)
+    raise SchemaError(f"{where}: unsupported field type {target!r}")
+
+
+# --------------------------------------------------------------------------
+# Encoding
+# --------------------------------------------------------------------------
+
+
+def encode(msg: Any) -> bytes:
+    """Serialize a message instance to protobuf wire-format bytes.
+
+    Fields are written in field-number order. Singular non-optional fields
+    holding their default value are omitted, exactly as proto3 does.
+    """
+    if not is_message(msg) or isinstance(msg, type):
+        raise EncodeError(f"expected a @proto.message instance, got {type(msg).__name__}")
+    out = bytearray()
+    for info in fields(type(msg)):
+        value = getattr(msg, info.name)
+        try:
+            _encode_field(out, info, value)
+        except EncodeError as exc:
+            raise EncodeError(f"{type(msg).__name__}.{info.name}: {exc}") from None
+    return bytes(out)
+
+
+def _encode_one(info: FieldInfo, value: Any) -> bytes:
+    if info.kind == "message":
+        if not isinstance(value, info.target):  # type: ignore[arg-type]
+            raise EncodeError(f"expected {info.type_name}, got {type(value).__name__}")
+        payload = encode(value)
+        return encode_varint(len(payload)) + payload
+    if info.kind == "enum":
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise EncodeError(f"expected {info.type_name} or int, got {type(value).__name__}")
+        return _ENUM_SCALAR.encode(int(value))
+    assert info.scalar is not None
+    payload = info.scalar.encode(value)
+    if info.scalar.wire_type is WireType.LEN:
+        return encode_varint(len(payload)) + payload
+    return payload
+
+
+def _encode_field(out: bytearray, info: FieldInfo, value: Any) -> None:
+    if info.repeated:
+        if not isinstance(value, (list, tuple)):
+            raise EncodeError(f"repeated field expects a list, got {type(value).__name__}")
+        if not value:
+            return
+        if info.packed:
+            body = b"".join(_encode_one(info, item) for item in value)
+            out += encode_tag(info.number, WireType.LEN) + encode_varint(len(body)) + body
+        else:
+            tag = encode_tag(info.number, info.wire_type)
+            for item in value:
+                if item is None:
+                    raise EncodeError("repeated fields cannot contain None")
+                out += tag + _encode_one(info, item)
+        return
+    if value is None:
+        if info.optional:
+            return
+        raise EncodeError("non-optional field is None")
+    if not info.optional:
+        if info.kind == "enum" and int(value) == 0:
+            return
+        if info.kind == "scalar" and info.scalar is not None and info.scalar.is_default(value):
+            # Still validate the type so `0` in a str field is rejected.
+            info.scalar.encode(value)
+            return
+    out += encode_tag(info.number, info.wire_type) + _encode_one(info, value)
+
+
+# --------------------------------------------------------------------------
+# Decoding
+# --------------------------------------------------------------------------
+
+
+def decode(cls: type[M], data: bytes | bytearray | memoryview) -> M:
+    """Parse wire-format ``data`` into a new instance of message class ``cls``.
+
+    Unknown fields are skipped. If a singular field appears more than once
+    the last occurrence wins; repeated fields accept packed and unpacked
+    encodings interchangeably.
+    """
+    by_number = {info.number: info for info in fields(cls)}
+    view = memoryview(data) if not isinstance(data, memoryview) else data
+    values: dict[str, Any] = {}
+    pos, end = 0, len(view)
+    try:
+        while pos < end:
+            number, wire_type, pos = decode_tag(view, pos)
+            info = by_number.get(number)
+            if info is None:
+                pos = skip_field(view, pos, wire_type, number)
+                continue
+            if info.repeated and info.kind != "message" and wire_type is WireType.LEN and info.wire_type is not WireType.LEN:
+                length, pos = decode_varint(view, pos)
+                stop = pos + length
+                if stop > end:
+                    raise DecodeError("truncated packed field")
+                items = values.setdefault(info.name, [])
+                while pos < stop:
+                    item, pos = _decode_one(info, view, pos, stop)
+                    items.append(item)
+                if pos != stop:
+                    raise DecodeError("packed field length mismatch")
+                continue
+            if wire_type is not info.wire_type:
+                raise DecodeError(
+                    f"{cls.__name__}.{info.name}: wire type {wire_type.name} does not match {info.type_name}"
+                )
+            item, pos = _decode_one(info, view, pos, end)
+            if info.repeated:
+                values.setdefault(info.name, []).append(item)
+            else:
+                values[info.name] = item
+    except RecursionError:
+        raise DecodeError("message nesting too deep") from None
+    # Absent fields take their proto3 zero value, not the Python-side default,
+    # so a value equal to the zero value (and hence omitted) round-trips.
+    for info in by_number.values():
+        if info.name not in values:
+            values[info.name] = _absent_value(info)
+    return cls(**values)
+
+
+def _absent_value(info: FieldInfo) -> Any:
+    if info.repeated:
+        return []
+    if info.optional:
+        return None
+    if info.kind == "enum":
+        return _enum_zero(info.target)  # type: ignore[arg-type]
+    assert info.scalar is not None
+    return info.scalar.default
+
+
+def _decode_one(info: FieldInfo, view: memoryview, pos: int, end: int) -> tuple[Any, int]:
+    wire = info.wire_type
+    if wire is WireType.VARINT:
+        raw, pos = decode_varint(view, pos)
+        if pos > end:
+            raise DecodeError("truncated varint")
+        if info.kind == "enum":
+            number = _ENUM_SCALAR.decode(raw)
+            try:
+                return info.target(number), pos  # type: ignore[misc]
+            except ValueError:
+                return number, pos  # open enum: keep unknown values as ints
+        assert info.scalar is not None
+        return info.scalar.decode(raw), pos
+    if wire is WireType.LEN:
+        length, pos = decode_varint(view, pos)
+        stop = pos + length
+    else:
+        stop = pos + (4 if wire is WireType.I32 else 8)
+    if stop > end:
+        raise DecodeError(f"truncated {info.type_name} field")
+    chunk = view[pos:stop]
+    if info.kind == "message":
+        return decode(info.target, chunk), stop  # type: ignore[arg-type]
+    assert info.scalar is not None
+    return info.scalar.decode(bytes(chunk)), stop
+
+
+# --------------------------------------------------------------------------
+# dict conversion
+# --------------------------------------------------------------------------
+
+
+def to_dict(msg: Any) -> dict[str, Any]:
+    """Convert a message to a plain ``dict``.
+
+    Nested messages become dicts, enum members become their names (unknown
+    enum values stay ints), unset optional/message fields are omitted.
+    """
+
+    def convert(info: FieldInfo, value: Any) -> Any:
+        if info.kind == "message":
+            return to_dict(value)
+        if info.kind == "enum":
+            return value.name if isinstance(value, enum.IntEnum) else value
+        return value
+
+    out: dict[str, Any] = {}
+    for info in fields(type(msg)):
+        value = getattr(msg, info.name)
+        if value is None:
+            continue
+        out[info.name] = [convert(info, v) for v in value] if info.repeated else convert(info, value)
+    return out
+
+
+def from_dict(cls: type[M], data: dict[str, Any]) -> M:
+    """Build a message from a ``dict`` produced by :func:`to_dict`.
+
+    Enum values may be given by name or number. Unknown keys raise
+    :class:`SchemaError`.
+    """
+    infos = {info.name: info for info in fields(cls)}
+    unknown = set(data) - set(infos)
+    if unknown:
+        raise SchemaError(f"unknown fields for {cls.__name__}: {sorted(unknown)}")
+
+    def convert(info: FieldInfo, value: Any) -> Any:
+        if info.kind == "message" and isinstance(value, dict):
+            return from_dict(info.target, value)  # type: ignore[arg-type]
+        if info.kind == "enum" and isinstance(value, str):
+            return info.target[value]  # type: ignore[index]
+        if info.kind == "enum" and isinstance(value, int):
+            try:
+                return info.target(value)  # type: ignore[misc]
+            except ValueError:
+                return value
+        return value
+
+    kwargs = {
+        name: [convert(infos[name], v) for v in value] if infos[name].repeated else convert(infos[name], value)
+        for name, value in data.items()
+    }
+    return cls(**kwargs)

proto/scalars.py

@@ -0,0 +1,140 @@
+"""Codecs for the protobuf scalar value types (``int32``, ``string``, ...)."""
+
+from __future__ import annotations
+
+import math
+import struct
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from .errors import DecodeError, EncodeError
+from .wire import WireType, encode_varint, zigzag_decode, zigzag_encode
+
+__all__ = ["ScalarType", "SCALARS", "INFERRED"]
+
+
+@dataclass(frozen=True)
+class ScalarType:
+    """Describes how one protobuf scalar type maps to Python and to bytes.
+
+    ``encode`` turns a Python value into the field payload (without a tag).
+    ``decode`` turns the raw payload into a Python value: the raw payload is an
+    ``int`` for ``VARINT`` types and ``bytes`` for every other wire type.
+    """
+
+    name: str
+    wire_type: WireType
+    default: Any
+    encode: Callable[[Any], bytes]
+    decode: Callable[[Any], Any]
+
+    @property
+    def packable(self) -> bool:
+        """Whether repeated fields of this type use packed encoding."""
+        return self.wire_type is not WireType.LEN
+
+    def is_default(self, value: Any) -> bool:
+        """True if ``value`` is the proto3 default and should not be emitted."""
+        if isinstance(self.default, float):
+            # -0.0 is distinguishable from 0.0 and protobuf emits it.
+            return value == 0 and math.copysign(1.0, value) > 0
+        return value == self.default
+
+
+def _require(value: Any, types: tuple[type, ...], name: str) -> None:
+    if not isinstance(value, types):
+        raise EncodeError(f"{name} field expects {types[0].__name__}, got {type(value).__name__}")
+
+
+def _varint_int(name: str, bits: int, signed: bool, zigzag: bool = False) -> ScalarType:
+    lo = -(1 << (bits - 1)) if signed else 0
+    hi = (1 << (bits - 1)) - 1 if signed else (1 << bits) - 1
+    mask = (1 << bits) - 1
+
+    def encode(value: Any) -> bytes:
+        _require(value, (int,), name)
+        if not lo <= value <= hi:
+            raise EncodeError(f"{name} value out of range: {value}")
+        return encode_varint(zigzag_encode(value, bits) if zigzag else value)
+
+    def decode(raw: int) -> int:
+        raw &= mask
+        if zigzag:
+            return zigzag_decode(raw)
+        if signed and raw >> (bits - 1):
+            return raw - (1 << bits)
+        return raw
+
+    return ScalarType(name, WireType.VARINT, 0, encode, decode)
+
+
+def _fixed(name: str, fmt: str, is_float: bool) -> ScalarType:
+    packer = struct.Struct(fmt)
+    wire = WireType.I32 if packer.size == 4 else WireType.I64
+    types: tuple[type, ...] = (float, int) if is_float else (int,)
+
+    def encode(value: Any) -> bytes:
+        _require(value, types, name)
+        try:
+            return packer.pack(value)
+        except (struct.error, OverflowError) as exc:
+            raise EncodeError(f"{name} value out of range: {value!r}") from exc
+
+    def decode(raw: bytes) -> Any:
+        return packer.unpack(raw)[0]
+
+    return ScalarType(name, wire, 0.0 if is_float else 0, encode, decode)
+
+
+def _encode_bool(value: Any) -> bytes:
+    _require(value, (bool, int), "bool")
+    return b"\x01" if value else b"\x00"
+
+
+def _encode_string(value: Any) -> bytes:
+    _require(value, (str,), "string")
+    return value.encode("utf-8")
+
+
+def _decode_string(raw: bytes) -> str:
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise DecodeError(f"string field is not valid UTF-8: {exc}") from None
+
+
+def _encode_bytes(value: Any) -> bytes:
+    _require(value, (bytes, bytearray, memoryview), "bytes")
+    return bytes(value)
+
+
+#: All supported scalar types, keyed by their ``.proto`` name.
+SCALARS: dict[str, ScalarType] = {
+    s.name: s
+    for s in (
+        _varint_int("int32", 32, signed=True),
+        _varint_int("int64", 64, signed=True),
+        _varint_int("uint32", 32, signed=False),
+        _varint_int("uint64", 64, signed=False),
+        _varint_int("sint32", 32, signed=True, zigzag=True),
+        _varint_int("sint64", 64, signed=True, zigzag=True),
+        ScalarType("bool", WireType.VARINT, False, _encode_bool, lambda raw: raw != 0),
+        _fixed("fixed32", "<I", is_float=False),
+        _fixed("fixed64", "<Q", is_float=False),
+        _fixed("sfixed32", "<i", is_float=False),
+        _fixed("sfixed64", "<q", is_float=False),
+        _fixed("float", "<f", is_float=True),
+        _fixed("double", "<d", is_float=True),
+        ScalarType("string", WireType.LEN, "", _encode_string, _decode_string),
+        ScalarType("bytes", WireType.LEN, b"", _encode_bytes, bytes),
+    )
+}
+
+#: Scalar type inferred from a bare Python annotation when ``type=`` is omitted.
+INFERRED: dict[type, str] = {
+    bool: "bool",
+    int: "int64",
+    float: "double",
+    str: "string",
+    bytes: "bytes",
+}

proto/schema.py

@@ -0,0 +1,57 @@
+"""Render ``@message`` classes as ``.proto`` (proto3) source text."""
+
+from __future__ import annotations
+
+import enum
+
+from .errors import SchemaError
+from .message import fields, is_message
+
+__all__ = ["to_proto"]
+
+
+def to_proto(*classes: type, package: str | None = None) -> str:
+    """Return a proto3 ``.proto`` file declaring ``classes``.
+
+    Every enum and message reachable from ``classes`` is emitted once, enums
+    first, then messages with dependencies before the messages using them.
+    The result can be fed to ``protoc`` to interoperate with other languages.
+    """
+    enums: list[type[enum.IntEnum]] = []
+    messages: list[type] = []
+
+    def visit(cls: type, stack: tuple[type, ...]) -> None:
+        if cls in messages or cls in stack:
+            return
+        for info in fields(cls):
+            if info.kind == "enum" and info.target not in enums:
+                enums.append(info.target)  # type: ignore[arg-type]
+            elif info.kind == "message":
+                visit(info.target, stack + (cls,))  # type: ignore[arg-type]
+        messages.append(cls)
+
+    for cls in classes:
+        if not is_message(cls):
+            raise SchemaError(f"{cls!r} is not a @proto.message class")
+        visit(cls, ())
+
+    lines = ['syntax = "proto3";', ""]
+    if package:
+        lines += [f"package {package};", ""]
+    for e in enums:
+        lines.append(f"enum {e.__name__} {{")
+        lines += [f"  {member.name} = {member.value};" for member in e]
+        lines += ["}", ""]
+    for cls in messages:
+        lines.append(f"message {cls.__proto_name__} {{")  # type: ignore[attr-defined]
+        for info in fields(cls):
+            label = "repeated " if info.repeated else ("optional " if info.optional and info.kind != "message" else "")
+            options = " [packed = false]" if info.repeated and info.kind != "message" and not info.packed and _packable(info) else ""
+            lines.append(f"  {label}{info.type_name} {info.name} = {info.number}{options};")
+        lines += ["}", ""]
+    return "\n".join(lines)
+
+
+def _packable(info: object) -> bool:
+    scalar = getattr(info, "scalar", None)
+    return scalar is None or scalar.packable

proto/stream.py

@@ -0,0 +1,62 @@
+"""Length-delimited framing for writing many messages to one byte stream.
+
+Each frame is a varint length followed by the encoded message, the same
+format as Java's ``writeDelimitedTo`` / ``parseDelimitedFrom``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, BinaryIO, Iterator, TypeVar
+
+from .errors import DecodeError
+from .message import decode, encode
+from .wire import encode_varint
+
+__all__ = ["write_delimited", "read_delimited", "iter_delimited"]
+
+M = TypeVar("M")
+
+
+def write_delimited(stream: BinaryIO, msg: Any) -> int:
+    """Write ``msg`` to ``stream`` with a varint length prefix.
+
+    Returns the number of bytes written.
+    """
+    payload = encode(msg)
+    frame = encode_varint(len(payload)) + payload
+    stream.write(frame)
+    return len(frame)
+
+
+def read_delimited(cls: type[M], stream: BinaryIO) -> M | None:
+    """Read one length-prefixed ``cls`` message from ``stream``.
+
+    Returns ``None`` on a clean end of stream (no bytes left); raises
+    :class:`DecodeError` if the stream ends in the middle of a frame.
+    """
+    length = 0
+    shift = 0
+    first = True
+    while True:
+        byte = stream.read(1)
+        if not byte:
+            if first:
+                return None
+            raise DecodeError("stream ended inside a length prefix")
+        first = False
+        length |= (byte[0] & 0x7F) << shift
+        if not byte[0] & 0x80:
+            break
+        shift += 7
+        if shift >= 64:
+            raise DecodeError("length prefix longer than 10 bytes")
+    payload = stream.read(length)
+    if len(payload) != length:
+        raise DecodeError(f"stream ended inside a frame ({len(payload)}/{length} bytes)")
+    return decode(cls, payload)
+
+
+def iter_delimited(cls: type[M], stream: BinaryIO) -> Iterator[M]:
+    """Yield length-prefixed ``cls`` messages from ``stream`` until it is exhausted."""
+    while (msg := read_delimited(cls, stream)) is not None:
+        yield msg

proto/wire.py

@@ -0,0 +1,160 @@
+"""Low-level Protocol Buffers wire-format primitives.
+
+Everything here operates on plain ``int`` and ``bytes`` values and is
+byte-for-byte compatible with the official protobuf encoding described at
+https://protobuf.dev/programming-guides/encoding/.
+"""
+
+from __future__ import annotations
+
+from enum import IntEnum
+
+from .errors import DecodeError, EncodeError
+
+__all__ = [
+    "WireType",
+    "MAX_FIELD_NUMBER",
+    "encode_varint",
+    "decode_varint",
+    "zigzag_encode",
+    "zigzag_decode",
+    "encode_tag",
+    "decode_tag",
+    "skip_field",
+]
+
+#: Largest legal field number (2**29 - 1).
+MAX_FIELD_NUMBER = (1 << 29) - 1
+
+_UINT64_LIMIT = 1 << 64
+_MAX_VARINT_BYTES = 10
+
+
+class WireType(IntEnum):
+    """The six wire types defined by the protobuf encoding."""
+
+    VARINT = 0
+    I64 = 1
+    LEN = 2
+    SGROUP = 3
+    EGROUP = 4
+    I32 = 5
+
+
+def encode_varint(value: int) -> bytes:
+    """Encode ``value`` as a base-128 varint.
+
+    Negative values are encoded as their 64-bit two's complement, which is
+    how protobuf serializes negative ``int32``/``int64`` (always 10 bytes).
+
+    >>> encode_varint(150).hex()
+    '9601'
+    """
+    if value < 0:
+        if value < -(1 << 63):
+            raise EncodeError(f"varint out of int64 range: {value}")
+        value += _UINT64_LIMIT
+    elif value >= _UINT64_LIMIT:
+        raise EncodeError(f"varint out of uint64 range: {value}")
+    out = bytearray()
+    while True:
+        byte = value & 0x7F
+        value >>= 7
+        if value:
+            out.append(byte | 0x80)
+        else:
+            out.append(byte)
+            return bytes(out)
+
+
+def decode_varint(data: bytes | bytearray | memoryview, pos: int = 0) -> tuple[int, int]:
+    """Decode a varint from ``data`` starting at ``pos``.
+
+    Returns ``(value, new_pos)``. The value is always an unsigned integer
+    below 2**64; callers reinterpret it according to the field type.
+    """
+    result = 0
+    shift = 0
+    end = len(data)
+    for _ in range(_MAX_VARINT_BYTES):
+        if pos >= end:
+            raise DecodeError("truncated varint")
+        byte = data[pos]
+        pos += 1
+        result |= (byte & 0x7F) << shift
+        if not byte & 0x80:
+            if result >= _UINT64_LIMIT:
+                raise DecodeError("varint exceeds 64 bits")
+            return result, pos
+        shift += 7
+    raise DecodeError("varint longer than 10 bytes")
+
+
+def zigzag_encode(value: int, bits: int = 64) -> int:
+    """Map a signed integer to an unsigned one so small magnitudes stay small.
+
+    Used by ``sint32``/``sint64``: 0 -> 0, -1 -> 1, 1 -> 2, -2 -> 3, ...
+    """
+    return ((value << 1) ^ (value >> (bits - 1))) & ((1 << bits) - 1)
+
+
+def zigzag_decode(value: int) -> int:
+    """Inverse of :func:`zigzag_encode`."""
+    return (value >> 1) ^ -(value & 1)
+
+
+def encode_tag(number: int, wire_type: WireType) -> bytes:
+    """Encode a field key: ``(number << 3) | wire_type`` as a varint."""
+    if not 1 <= number <= MAX_FIELD_NUMBER:
+        raise EncodeError(f"invalid field number: {number}")
+    return encode_varint((number << 3) | int(wire_type))
+
+
+def decode_tag(data: bytes | bytearray | memoryview, pos: int = 0) -> tuple[int, WireType, int]:
+    """Decode a field key. Returns ``(field_number, wire_type, new_pos)``."""
+    key, pos = decode_varint(data, pos)
+    number, raw_type = key >> 3, key & 0x7
+    if number < 1 or number > MAX_FIELD_NUMBER:
+        raise DecodeError(f"invalid field number: {number}")
+    try:
+        wire_type = WireType(raw_type)
+    except ValueError:
+        raise DecodeError(f"invalid wire type: {raw_type}") from None
+    return number, wire_type, pos
+
+
+def skip_field(
+    data: bytes | bytearray | memoryview,
+    pos: int,
+    wire_type: WireType,
+    number: int | None = None,
+) -> int:
+    """Skip over the payload of a field whose key was already consumed.
+
+    Returns the position just past the payload. ``number`` is only needed
+    for (deprecated) groups, to match the closing ``EGROUP`` tag.
+    """
+    end = len(data)
+    if wire_type is WireType.VARINT:
+        _, pos = decode_varint(data, pos)
+        return pos
+    if wire_type is WireType.I64:
+        new = pos + 8
+    elif wire_type is WireType.I32:
+        new = pos + 4
+    elif wire_type is WireType.LEN:
+        length, pos = decode_varint(data, pos)
+        new = pos + length
+    elif wire_type is WireType.SGROUP:
+        while True:
+            inner, inner_type, pos = decode_tag(data, pos)
+            if inner_type is WireType.EGROUP:
+                if number is not None and inner != number:
+                    raise DecodeError("mismatched end-group tag")
+                return pos
+            pos = skip_field(data, pos, inner_type, inner)
+    else:
+        raise DecodeError("unexpected end-group tag")
+    if new > end:
+        raise DecodeError("truncated field payload")
+    return new

proto-0.1.0.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: proto
+Version: 0.1.0
+Summary: Schema-first, protobuf wire-compatible binary messages for pure Python, declared with dataclasses.
+Author: nehz
+License-Expression: MIT
+Keywords: protobuf,protocol-buffers,serialization,binary,varint,dataclasses,schema
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# proto
+
+**Protocol Buffers without the toolchain.** `proto` lets you declare binary
+messages as ordinary Python dataclasses and serialize them to bytes that are
+wire-compatible with Google's Protocol Buffers (proto3). No `protoc`, no
+generated code, no C extension, no dependencies: just the standard library.
+
+Use it when you need to talk to a protobuf service from a script, persist
+compact records, or prototype a schema in Python first, and still have every
+other protobuf implementation read your bytes.
+
+```python
+import proto
+
+@proto.message
+class Point:
+    x: int = proto.field(1, "sint32")
+    y: int = proto.field(2, "sint32")
+
+data = proto.encode(Point(3, -4))     # b'\x08\x06\x10\x07'
+assert proto.decode(Point, data) == Point(3, -4)
+```
+
+## Features
+
+- **Wire-compatible**: varints, zigzag, fixed-width, length-delimited and packed
+  encodings match the official protobuf encoding byte for byte. The tests check
+  the exact byte strings from the protobuf encoding guide.
+- **Schema-first dataclasses**: field numbers live next to the type annotations.
+  Messages are real `dataclasses`, so you keep `==`, `repr`, `replace()` and
+  your type checker.
+- **All 15 scalar types**: `int32 int64 uint32 uint64 sint32 sint64 bool
+  fixed32 fixed64 sfixed32 sfixed64 float double string bytes`, plus `IntEnum`
+  enums, nested and recursive messages, `repeated` fields, and proto3 `optional`.
+- **proto3 semantics**: default values are omitted on the wire, unknown fields are
+  skipped, packed and unpacked repeated fields are both accepted, unknown enum
+  values are kept as `int` (open enums).
+- **Strict validation**: out-of-range integers, wrong Python types, malformed or
+  truncated input raise clear `EncodeError` / `DecodeError` / `SchemaError`.
+- **`.proto` export**: `to_proto()` renders your classes as a `.proto` file, so
+  other languages can generate code from the same schema.
+- **Streaming**: length-delimited framing (`writeDelimitedTo` format) for many
+  messages in one file or socket.
+- Pure Python 3.10+, fully type-hinted (`py.typed`), zero dependencies.
+
+## Install
+
+```bash
+pip install proto            # once published
+pip install -e .             # from a checkout
+```
+
+> Note: Google's `proto-plus` package also installs a top-level `proto` module.
+> Don't install both in the same environment.
+
+## Quickstart
+
+```python
+from __future__ import annotations
+
+import enum
+import io
+
+import proto
+
+
+class Role(enum.IntEnum):
+    ROLE_UNSPECIFIED = 0     # proto3 enums need a zero value
+    ADMIN = 1
+    MEMBER = 2
+
+
+@proto.message
+class Address:
+    city: str = proto.field(1)
+    zip_code: str = proto.field(2)
+
+
+@proto.message
+class User:
+    name: str = proto.field(1)                      # inferred: string
+    id: int = proto.field(2, "uint32")              # explicit scalar type
+    age: int | None = proto.field(3, "int32")       # proto3 `optional`: None = unset
+    role: Role = proto.field(4)                     # enum
+    emails: list[str] = proto.field(5)              # repeated
+    scores: list[int] = proto.field(6, "sint32")    # repeated, packed by default
+    address: Address | None = proto.field(7)        # nested message
+    friends: list[User] = proto.field(8)            # recursive
+
+
+ada = User("ada", id=1, role=Role.ADMIN, emails=["ada@example.com"],
+           address=Address("London", "N1"))
+
+data = ada.to_bytes()                 # same as proto.encode(ada)
+again = User.from_bytes(data)         # same as proto.decode(User, data)
+assert again == ada
+
+proto.to_dict(ada)
+# {'name': 'ada', 'id': 1, 'role': 'ADMIN', 'emails': ['ada@example.com'],
+#  'scores': [], 'address': {'city': 'London', 'zip_code': 'N1'}, 'friends': []}
+
+# Many messages in one stream
+buf = io.BytesIO()
+for user in (ada, User("bob", id=2)):
+    proto.write_delimited(buf, user)
+buf.seek(0)
+names = [u.name for u in proto.iter_delimited(User, buf)]   # ['ada', 'bob']
+
+print(proto.to_proto(User, package="example.v1"))
+```
+
+The last line prints:
+
+```proto
+syntax = "proto3";
+
+package example.v1;
+
+enum Role {
+  ROLE_UNSPECIFIED = 0;
+  ADMIN = 1;
+  MEMBER = 2;
+}
+
+message Address {
+  string city = 1;
+  string zip_code = 2;
+}
+
+message User {
+  string name = 1;
+  uint32 id = 2;
+  optional int32 age = 3;
+  Role role = 4;
+  repeated string emails = 5;
+  repeated sint32 scores = 6;
+  Address address = 7;
+  repeated User friends = 8;
+}
+```
+
+## Declaring fields
+
+| Annotation              | Inferred `.proto` type | Default when omitted |
+|-------------------------|------------------------|----------------------|
+| `int`                   | `int64`                | `0`                  |
+| `float`                 | `double`               | `0.0`                |
+| `bool`                  | `bool`                 | `False`              |
+| `str`                   | `string`               | `""`                 |
+| `bytes`                 | `bytes`                | `b""`                |
+| `SomeIntEnum`           | `SomeIntEnum`          | the member with value `0` |
+| `SomeMessage \| None`   | `SomeMessage`          | `None` (unset)       |
+| `T \| None` (scalar)    | `optional T`           | `None` (unset)       |
+| `list[T]`               | `repeated T`           | `[]`                 |
+
+Pass `type=` (the second argument of `field`) to choose another scalar
+encoding such as `"sint32"` or `"fixed64"`, or to name an enum/message class
+explicitly.
+
+## API overview
+
+Everything is importable from the top-level `proto` package.
+
+| Name | Description |
+|------|-------------|
+| `@message` / `@message(name="Wire")` | Class decorator. Turns an annotated class into a dataclass-based message and adds `to_bytes()` and classmethod `from_bytes(data)`. `name` sets the name used by `to_proto` (default: class name). |
+| `field(number, type=None, *, default=..., default_factory=..., packed=None)` | Declares a field. `type` is a scalar name, an `IntEnum` subclass or a message class; it is inferred from the annotation when omitted. `packed=False` disables packed encoding for repeated numeric/enum fields. Every annotated attribute must use `field()`. |
+| `encode(msg) -> bytes` | Serialize a message instance. |
+| `decode(cls, data) -> cls` | Parse `bytes`/`bytearray`/`memoryview` into a new `cls` instance. Absent fields get their proto3 zero value; the last occurrence of a singular field wins. |
+| `fields(cls) -> tuple[FieldInfo, ...]` | Resolved schema of a message class, ordered by field number. |
+| `FieldInfo` | Frozen dataclass: `name`, `number`, `kind` (`"scalar"`/`"enum"`/`"message"`), `type_name`, `repeated`, `optional`, `packed`, `scalar`, `target`, and property `wire_type`. |
+| `is_message(obj) -> bool` | True for `@message` classes and their instances. |
+| `to_dict(msg) -> dict` | Plain-dict view: nested messages become dicts, enums become names, unset optionals are omitted. |
+| `from_dict(cls, data) -> cls` | Inverse of `to_dict`; enums may be given by name or number. |
+| `to_proto(*classes, package=None) -> str` | Render the classes and every enum/message they reference as proto3 source. |
+| `write_delimited(stream, msg) -> int` | Write a varint length prefix plus the message; returns bytes written. |
+| `read_delimited(cls, stream) -> cls \| None` | Read one framed message; `None` at a clean end of stream. |
+| `iter_delimited(cls, stream)` | Iterate framed messages until the stream is exhausted. |
+| `ProtoError` | Base exception. Subclasses: `SchemaError` (also a `TypeError`), `EncodeError` and `DecodeError` (also `ValueError`). |
+| `__version__` | `"0.1.0"` |
+
+Low-level primitives live in `proto.wire`:
+
+| Name | Description |
+|------|-------------|
+| `WireType` | `IntEnum`: `VARINT`, `I64`, `LEN`, `SGROUP`, `EGROUP`, `I32`. |
+| `MAX_FIELD_NUMBER` | `2**29 - 1`. |
+| `encode_varint(value) -> bytes` | Base-128 varint; negatives use 64-bit two's complement. |
+| `decode_varint(data, pos=0) -> (value, new_pos)` | Decode one varint. |
+| `zigzag_encode(value, bits=64) -> int` / `zigzag_decode(value) -> int` | ZigZag mapping used by `sint32`/`sint64`. |
+| `encode_tag(number, wire_type) -> bytes` | Field key. |
+| `decode_tag(data, pos=0) -> (number, wire_type, new_pos)` | Parse a field key. |
+| `skip_field(data, pos, wire_type, number=None) -> int` | Skip an unknown field's payload, groups included. |
+
+## Limitations
+
+`proto` 0.1 covers the core of proto3. Not supported yet: `oneof`, `map<K, V>`
+fields, well-known types (`Timestamp`, `Any`, ...), proto2 groups (they are
+skipped when decoding), services/gRPC, and merging of repeated occurrences of
+a singular message field (the last occurrence wins). Annotations that name
+other classes must be resolvable from the scope where the class is defined.
+
+## Development
+
+```bash
+PYTHONPATH=src python3 -m unittest discover -s tests -v   # standard library only
+python3 -m pytest                                        # if pytest is installed
+```
+
+## License
+
+MIT

proto-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+proto/__init__.py,sha256=aWXU9s-SZV1-6LitTm5Qq7_aix04X8DyPxJmBxGMDRw,1134
+proto/errors.py,sha256=-Rs_tvrRgMVfFt0-oh2DisIWU0oyliqqVPsukoH1A3M,607
+proto/message.py,sha256=YmFjTYCwN6m2Cs8e8FsYmATDAGRteR1uCO1BUH0MRzQ,20433
+proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+proto/scalars.py,sha256=wv314e3jyFsgUjOYWSPNFwn1kk3t_0fHlk-xSelclkM,4722
+proto/schema.py,sha256=TvyNmfwhiFhjhGuE98zlJZi62-powFVT1iN-0iA872I,2183
+proto/stream.py,sha256=HEwYxzl03UbiztQbbNqRU7tIUPw2dW7B3ZrjHmZpq30,1944
+proto/wire.py,sha256=RykpAzEFeL_aEdZzY9DaUzuy2dTGx5PU6scYZRAzUKw,4861
+proto-0.1.0.dist-info/licenses/LICENSE,sha256=pAfYREEW9GAy7cnK20OXjDn7ofJahYny9GCuIZQTDAA,1061
+proto-0.1.0.dist-info/METADATA,sha256=xII6_7Q1Ttq5xMoRGvdG0sF8BiQa0uknFOeKDQ3-MtI,9941
+proto-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+proto-0.1.0.dist-info/top_level.txt,sha256=HFg_NW9VxhDySzqGDmUxqUh6w8QZlVLh4ZDIxYksTCM,6
+proto-0.1.0.dist-info/RECORD,,

proto-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

proto-0.1.0.dist-info/licenses/LICENSE

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

proto-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+proto