bytespec 0.1.0__py3-none-any.whl

bytespec/missing.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2026 ink-developer
+
+from typing import Final, TypeAlias
+
+from typing_extensions import override
+
+
+class _MissingType:
+    __slots__ = ()
+
+    @override
+    def __repr__(self) -> str:
+        return "MISSING"
+
+
+MISSING: Final = _MissingType()
+MissingType: TypeAlias = _MissingType

bytespec/models.py

@@ -0,0 +1,47 @@
+# Copyright (c) 2026 ink-developer
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Literal, TypeAlias
+
+from bytespec.codecs import ICodec
+from bytespec.missing import MissingType
+from bytespec.types import VarUInt
+
+DefaultFactory: TypeAlias = Callable[[], Any] | MissingType
+
+UIntEncoding = Literal[1, 2, 4, 8] | VarUInt
+PrefixLength = UIntEncoding
+
+
+@dataclass
+class FieldInfo:
+    """Field settings passed to a user-defined codec factory.
+
+    In models, create them via `field()`. The factory may read
+    `prefix_length`, `encoding`, and other settings to construct a codec.
+
+    Args:
+        index: Explicit field position, or None for automatic selection.
+        flag: Presence bit index for an optional field, or None.
+        default: Default value or the MISSING sentinel.
+        default_factory: Zero-argument factory or MISSING.
+        prefix_length: Length prefix size, or None to use the default.
+        encoding: Text encoding, UTF-8 by default.
+        codec: Explicitly assigned codec instance, or None.
+    """
+
+    index: int | None
+    flag: int | None
+    default: Any
+    default_factory: DefaultFactory
+    prefix_length: PrefixLength | None
+    encoding: str = "utf-8"
+    codec: ICodec[Any] | None = None
+
+
+@dataclass
+class ResolvedType:
+    codec: ICodec[Any]
+    optional: bool
+    annotation: Any

bytespec/resolver.py

@@ -0,0 +1,196 @@
+# Copyright (c) 2026 ink-developer
+
+import codecs
+from enum import Enum
+from types import NoneType, UnionType
+from typing import Annotated, Any, Union, get_args, get_origin
+
+from bytespec.base import ProtoModelBase
+from bytespec.codecs import (
+    Float32Codec,
+    Float64Codec,
+    ICodec,
+    UInt8Codec,
+    VarIntCodec,
+    VarUIntCodec,
+)
+from bytespec.codecs.int import (
+    Int8Codec,
+    Int16Codec,
+    Int32Codec,
+    Int64Codec,
+    UInt16Codec,
+    UInt32Codec,
+    UInt64Codec,
+)
+from bytespec.errors import SchemaError
+from bytespec.models import FieldInfo, ResolvedType
+from bytespec.resolvers import (
+    CodecFactory,
+    ResolveCallback,
+    enum_codec_factory,
+    list_codec_factory,
+    model_codec_factory,
+)
+from bytespec.types import CodecSpec, FloatSpec, IntegerSpec, Spec
+from bytespec.types.spec import VarIntSpec
+
+INTEGER_CODECS: dict[tuple[int, bool], type[ICodec[Any]]] = {
+    (8, False): UInt8Codec,
+    (16, False): UInt16Codec,
+    (32, False): UInt32Codec,
+    (64, False): UInt64Codec,
+    (8, True): Int8Codec,
+    (16, True): Int16Codec,
+    (32, True): Int32Codec,
+    (64, True): Int64Codec,
+}
+FLOAT_CODECS: dict[int, type[ICodec[Any]]] = {
+    32: Float32Codec,
+    64: Float64Codec,
+}
+VARINT_CODECS: dict[bool, type[ICodec[Any]]] = {
+    True: VarIntCodec,
+    False: VarUIntCodec,
+}
+
+
+def resolve_integer(_: Any, spec: IntegerSpec, __: FieldInfo, ___: ResolveCallback) -> ICodec[Any]:
+    codec = INTEGER_CODECS.get((spec.bits, spec.signed))
+
+    if not codec:
+        raise SchemaError(f"Unsupported numeric spec: {spec!r}")
+
+    return codec()
+
+
+def resolve_float(_: Any, spec: FloatSpec, __: FieldInfo, ___: ResolveCallback) -> ICodec[Any]:
+    codec = FLOAT_CODECS.get(spec.bits)
+
+    if not codec:
+        raise SchemaError(f"Unsupported numeric spec: {spec!r}")
+
+    return codec()
+
+
+def resolve_varint(_: Any, spec: VarIntSpec, __: FieldInfo, ___: ResolveCallback) -> ICodec[Any]:
+    codec = VARINT_CODECS.get(spec.signed)
+
+    if not codec:
+        raise SchemaError(f"Unsupported numeric spec: {spec!r}")
+
+    return codec()
+
+
+class CodecResolver:
+    def __init__(self, scalar_codecs: dict[type, CodecFactory]) -> None:
+        self.scalar_codecs = scalar_codecs
+
+    def _is_type_of(self, annotation: Any, subclass: type) -> bool:
+        return isinstance(annotation, type) and issubclass(annotation, subclass)
+
+    def _normalize_union(self, annotation: Any | UnionType) -> tuple[Any, bool]:
+        is_optional = False
+        metadata = list(get_args(annotation))
+
+        if NoneType in metadata:
+            is_optional = True
+            metadata.pop(metadata.index(NoneType))
+
+        if len(metadata) > 1:
+            raise SchemaError(f"Unsupported union type: {annotation}")
+
+        return metadata[0], is_optional
+
+    def _check_encoding(self, encoding: str) -> None:
+        try:
+            codecs.lookup(encoding)
+        except LookupError as exc:
+            raise SchemaError(f"Invalid encoding: {encoding!r}") from exc
+
+    def _resolve_spec(
+        self,
+        base_type: Any,
+        spec: Spec,
+        field_info: FieldInfo,
+        resolve: ResolveCallback,
+    ) -> ICodec[Any]:
+        if isinstance(spec, IntegerSpec):
+            return resolve_integer(base_type, spec, field_info, resolve)
+
+        if isinstance(spec, FloatSpec):
+            return resolve_float(base_type, spec, field_info, resolve)
+
+        if isinstance(spec, VarIntSpec):
+            return resolve_varint(base_type, spec, field_info, resolve)
+
+        raise SchemaError(f"Unsupported spec: {type(spec).__name__}")
+
+    def resolve(
+        self, annotation: Any, field_info: FieldInfo, is_optional: bool = False
+    ) -> ResolvedType:
+        self._check_encoding(field_info.encoding)
+
+        origin = get_origin(annotation)
+
+        if origin in (UnionType, Union):
+            annotation, is_optional = self._normalize_union(annotation)
+
+        if field_info.codec is not None:
+            return ResolvedType(
+                field_info.codec,
+                is_optional,
+                annotation,
+            )
+
+        scalar_codec = self.scalar_codecs.get(annotation)
+
+        if scalar_codec:
+            return ResolvedType(scalar_codec(annotation, field_info), is_optional, annotation)
+
+        if get_origin(annotation) is Annotated:
+            base_type, *metadata = get_args(annotation)
+
+            specs = [meta for meta in metadata if isinstance(meta, Spec)]
+
+            if len(specs) > 1:
+                raise SchemaError("Only one Spec is allowed")
+
+            if not specs:
+                return self.resolve(base_type, field_info, is_optional)
+
+            spec = specs[0]
+
+            if isinstance(spec, CodecSpec):
+                if spec.prefix_length is not None:
+                    field_info.prefix_length = spec.prefix_length
+
+                if spec.encoding:
+                    self._check_encoding(spec.encoding)
+                    field_info.encoding = spec.encoding
+
+                if spec.codec is not None:
+                    field_info.codec = spec.codec
+
+                return self.resolve(base_type, field_info, is_optional)
+
+            return ResolvedType(
+                self._resolve_spec(base_type, spec, field_info, self.resolve),
+                is_optional,
+                annotation,
+            )
+
+        if self._is_type_of(annotation, ProtoModelBase):
+            return ResolvedType(
+                model_codec_factory(annotation, field_info), is_optional, annotation
+            )
+
+        if self._is_type_of(annotation, Enum):
+            return ResolvedType(enum_codec_factory(annotation, field_info), is_optional, annotation)
+
+        if get_origin(annotation) is list:
+            return ResolvedType(
+                list_codec_factory(annotation, field_info, self.resolve), is_optional, annotation
+            )
+
+        raise SchemaError(f"Unknown type: {annotation}")

bytespec/resolvers.py

@@ -0,0 +1,114 @@
+# Copyright (c) 2026 ink-developer
+
+from collections.abc import Callable
+from enum import Enum
+from typing import Any, Protocol, TypeAlias, get_args
+
+from bytespec.codecs import ICodec
+from bytespec.errors import SchemaError
+
+from .codecs import (
+    BoolCodec,
+    BytesCodec,
+    DatetimeCodec,
+    EnumCodec,
+    ListCodec,
+    ModelCodec,
+    StrCodec,
+    UUIDCodec,
+    VarIntCodec,
+)
+from .missing import MISSING
+from .models import FieldInfo, ResolvedType
+
+ResolveCallback: TypeAlias = Callable[[Any, FieldInfo], ResolvedType]
+
+
+class CodecFactory(Protocol):
+    """Codec factory returned by rules configured via `configure_codecs()`.
+
+    When selecting a codec for a scalar field, it is called with two arguments:
+    the annotation and `FieldInfo`. It returns a ready-to-use codec instance.
+    The third protocol argument is optional and is not passed in this path.
+    """
+
+    def __call__(
+        self, annotation: Any, field_info: FieldInfo, resolve: ResolveCallback | None = None, /
+    ) -> ICodec[Any]: ...
+
+
+def str_codec_factory(_: Any, field_info: FieldInfo, __: ResolveCallback | None = None) -> StrCodec:
+
+    if field_info.prefix_length is not None:
+        return StrCodec(prefix_length=field_info.prefix_length, encoding=field_info.encoding)
+    else:
+        return StrCodec(encoding=field_info.encoding)
+
+
+def bytes_codec_factory(
+    _: Any, field_info: FieldInfo, __: ResolveCallback | None = None
+) -> BytesCodec:
+    if field_info.prefix_length is not None:
+        return BytesCodec(prefix_length=field_info.prefix_length)
+    else:
+        return BytesCodec()
+
+
+def datetime_codec_factory(
+    _: Any, field_info: FieldInfo, __: ResolveCallback | None = None
+) -> DatetimeCodec:
+    if field_info.prefix_length is not None:
+        return DatetimeCodec(prefix_length=field_info.prefix_length, encoding=field_info.encoding)
+    else:
+        return DatetimeCodec(encoding=field_info.encoding)
+
+
+def model_codec_factory(
+    annotation: Any, _: FieldInfo, __: ResolveCallback | None = None
+) -> ModelCodec:
+    return ModelCodec(annotation)
+
+
+def int_codec_factory(_: Any, __: FieldInfo, ___: ResolveCallback | None = None) -> VarIntCodec:
+    return VarIntCodec()
+
+
+def enum_codec_factory(
+    annotation: Any, field_info: FieldInfo, __: ResolveCallback | None = None
+) -> EnumCodec:
+    if not issubclass(annotation, Enum):
+        raise SchemaError(f"Unknown enum type: {annotation}")
+
+    if issubclass(annotation, str):
+        return EnumCodec(annotation, str_codec_factory(annotation, field_info, __))
+    elif issubclass(annotation, int):
+        return EnumCodec(annotation, int_codec_factory(annotation, field_info, __))
+    else:
+        raise SchemaError(f"Unknown enum type: {annotation}")
+
+
+def bool_codec_factory(_: Any, __: FieldInfo, ___: ResolveCallback | None = None) -> BoolCodec:
+    return BoolCodec()
+
+
+def uuid_codec_factory(_: Any, __: FieldInfo, ___: ResolveCallback | None = None) -> UUIDCodec:
+    return UUIDCodec()
+
+
+def list_codec_factory(
+    annotation: Any, field_info: FieldInfo, callback: ResolveCallback
+) -> ListCodec:
+    metadata = list(get_args(annotation))
+
+    if len(metadata) != 1:
+        raise SchemaError(f"Unsupported list type: {annotation}")
+
+    resolved_type = callback(metadata[0], FieldInfo(None, None, MISSING, MISSING, None))
+
+    if resolved_type.optional:
+        raise SchemaError(f"Unsupported list type: {annotation}")
+
+    if field_info.prefix_length is not None:
+        return ListCodec(resolved_type.codec, field_info.prefix_length)
+    else:
+        return ListCodec(resolved_type.codec)

bytespec/schema.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from .enums import ByteOrder
+
+if TYPE_CHECKING:
+    from .core import FieldMetadata, ProtoModel
+    from .headers import HeaderElement
+
+
+@dataclass(frozen=True, slots=True)
+class ModelSchema:
+    model: type[ProtoModel]
+    fields: tuple[FieldMetadata, ...]
+    header: tuple[HeaderElement, ...]
+    byte_order: ByteOrder
+    constructor: int | None
+
+
+@dataclass(slots=True)
+class HeaderEncodeContext:
+    schema: ModelSchema
+    include_constructor: bool
+    payload_length: int
+    flags: int
+
+
+@dataclass(slots=True)
+class HeaderDecodeContext:
+    schema: ModelSchema
+    expect_constructor: bool
+    payload_length: int | None = None
+    flags: int = 0

bytespec/types/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2026 ink-developer
+
+from typing import Annotated, TypeAlias
+
+from .spec import CodecSpec as CodecSpec
+from .spec import FloatSpec, IntegerSpec, VarIntSpec
+from .spec import Spec as Spec
+
+UInt8 = Annotated[int, IntegerSpec(8, signed=False)]
+UInt16 = Annotated[int, IntegerSpec(16, signed=False)]
+UInt32 = Annotated[int, IntegerSpec(32, signed=False)]
+UInt64 = Annotated[int, IntegerSpec(64, signed=False)]
+
+Int8 = Annotated[int, IntegerSpec(8, signed=True)]
+Int16 = Annotated[int, IntegerSpec(16, signed=True)]
+Int32 = Annotated[int, IntegerSpec(32, signed=True)]
+Int64 = Annotated[int, IntegerSpec(64, signed=True)]
+
+Float32 = Annotated[float, FloatSpec(32)]
+Float64 = Annotated[float, FloatSpec(64)]
+
+VarUInt = Annotated[int, VarIntSpec(signed=False)]
+VarInt = Annotated[int, VarIntSpec(signed=True)]
+
+UIntUnion: TypeAlias = UInt16 | UInt32 | UInt64 | UInt8

bytespec/types/spec.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2026 ink-developer
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal, TypeAlias
+
+from bytespec.codecs import ICodec
+
+if TYPE_CHECKING:
+    from bytespec.models import PrefixLength
+
+
+@dataclass(frozen=True)
+class IntegerSpec:
+    """Select a fixed-width integer in ``Annotated[int, ...]``.
+
+    Args:
+        bits: The number of bits: 8, 16, 32, or 64.
+        signed: Allow negative values (signed representation).
+    """
+
+    bits: Literal[8, 16, 32, 64]
+    signed: bool
+
+
+@dataclass(frozen=True)
+class FloatSpec:
+    """Select an IEEE 754 number in ``Annotated[float, ...]``.
+
+    Args:
+        bits: The number of bits: 32 or 64. Float32 rounds a Python float to its representation.
+    """
+
+    bits: Literal[32, 64]
+
+
+@dataclass(frozen=True)
+class VarIntSpec:
+    """Select a varint in ``Annotated[int, ...]``.
+
+    Args:
+        signed: If True, use ZigZag and the Int64 range; if False, use an unsigned varint and the
+            UInt64 range.
+    """
+
+    signed: bool
+
+
+@dataclass(frozen=True)
+class StructSpec:
+    struct_format: str
+
+
+@dataclass(frozen=True)
+class CodecSpec:
+    """Define reusable field settings using ``Annotated``.
+
+    Args:
+        prefix_length: Prefix size: 1, 2, 4, or 8 bytes, or ``VarUInt``. ``None`` leaves the field
+            setting unchanged; ``VarInt`` is not supported.
+        encoding: The text encoding. A nonempty value replaces the field encoding.
+        codec: A ready-to-use codec instance instead of automatic selection.
+
+    Note:
+        One supported specification is allowed per Annotated. An explicit ``field(codec=...)`` takes
+        precedence over CodecSpec.
+    """
+
+    prefix_length: PrefixLength | None = None
+    encoding: str | None = None
+    codec: ICodec[Any] | None = None
+
+
+Spec: TypeAlias = IntegerSpec | FloatSpec | VarIntSpec | CodecSpec

bytespec-0.1.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: bytespec
+Version: 0.1.0
+Summary: Declarative binary serialization and deserialization for Python
+Keywords: binary,serialization,deserialization,codec,protocol
+Author: ink-developer
+Author-email: ink-developer <142109011+ink-developer@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+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 :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Dist: typing-extensions>=4.16.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/ink-developer/bytespec
+Project-URL: Repository, https://github.com/ink-developer/bytespec
+Project-URL: Issues, https://github.com/ink-developer/bytespec/issues
+Project-URL: Documentation, https://bytespec.pymax.org
+Description-Content-Type: text/markdown
+
+# bytespec
+
+English · [Русский](README.md)
+
+Typed Python models over an explicit sequential binary representation.
+One model reads and writes numbers, strings, lists, and nested objects;
+you choose their representation, and the library tracks lengths and offsets.
+
+```python
+from bytespec import Constructor, PayloadLength, ProtoModel, field
+from bytespec.types import UInt32
+
+
+class User(ProtoModel):
+    __constructor__ = 0x12
+    __header__ = (Constructor(1), PayloadLength(1))
+
+    id: UInt32
+    name: str = field(prefix_length=1)
+
+
+user = User(id=42, name="Anna")
+data = user.encode()
+restored = User.decode(data)
+
+print(data.hex(" "))  # 12 09 00 00 00 2a 04 41 6e 6e 61
+print(restored.name)  # Anna
+assert restored == user
+```
+
+`12` identifies the message; `09` is the computed length of its fields.
+Next come the four-byte `id` and a UTF-8 name with a one-byte length prefix.
+In your application, these are ordinary `int` and `str` values. Your first
+models can use the default framing without setting `__header__`; for an
+existing format, you can customize or remove it.
+
+bytespec fits custom or existing sequential binary protocols when you want
+to work with classes without a separate schema language or code generation.
+It supports optional fields through flags, `IntEnum`, UUID, datetime, numeric
+encodings, and custom codecs. This is a small 0.1.0 library: for a flexible
+binary parser DSL, consider Construct; for standard JSON/MessagePack, msgspec;
+for a schema ecosystem with its own wire format, protobuf.
+
+## Installation
+
+Python 3.10+:
+
+```bash
+pip install bytespec
+```
+
+Or `uv add bytespec`.
+
+## Documentation
+
+The full guide and API reference are available in Russian and English.
+To build both versions from a checkout:
+
+```bash
+uv sync --locked --group docs
+uv run --no-sync python -m sphinx -E -a -n -W --keep-going -b html -D language=ru docs docs/_build/html/ru
+uv run --no-sync python -m sphinx -E -a -n -W --keep-going -b html -D language=en docs docs/_build/html/en
+```
+
+Open `docs/_build/html/en/index.html`. The language switcher keeps you on
+the same page. Start with **Getting started**, **Why bytespec?**, or
+**Headers and framing**, then consult the **API reference**.
+The [documentation sources](docs/index.rst) and
+[build instructions](docs/building.rst) are in Russian; Sphinx applies
+the [English translation catalogs](docs/locale/en/LC_MESSAGES/index.po)
+when building the English version.
+
+Take a known packet from your protocol, describe a few fields, and compare
+the re-encoded result with the original bytes. That is a useful first check
+of whether the library fits your format.
+
+[MIT license](LICENSE).

bytespec-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+bytespec/__init__.py,sha256=L2s5JSDjoixP9aSOftmNLSEKfiZZ70TkLpX7EURARw0,446
+bytespec/base.py,sha256=OSx_NxVK0SaayWBv37RMYvreqQzPMfVxh1xUBNYtMBU,1847
+bytespec/codecs/__init__.py,sha256=3vuT_fvaGSsu6mHagqAXqo1ldCK7MHJ1980XYh5Z1Lk,973
+bytespec/codecs/_utils.py,sha256=LGgt7damTPbyJ9B96jzov-P9C4HfPSZqvsWLBX19wDc,531
+bytespec/codecs/base.py,sha256=gjmKYwJjq3r8cKDQESd0ETRQZFBVnqibbaQjoZVDBc4,2026
+bytespec/codecs/bool.py,sha256=zBiL7sXKKURuMh_lWWkPxk6TES6Zcv1-MhYCG_RFf34,1249
+bytespec/codecs/bytes.py,sha256=epICoyDjSd8iYGE9NApye8D5qVTB0L2Wy9W7VeqeBhM,3178
+bytespec/codecs/datetime.py,sha256=Xeyrh-TH4dsqdlqTo4XGNpXhUpgd-yEov9kmzMcv9Nw,2091
+bytespec/codecs/enum.py,sha256=JW_txevzslLhycgeCALoJ7lcHQNt96ONpnXhf3BaN9c,1573
+bytespec/codecs/float.py,sha256=sFnGwnMEU4tBe2DHm2wapFUBSCIIswudbUWt3BZQDeI,529
+bytespec/codecs/int.py,sha256=C-ktOUwLMA12jH-sv-HvmZETW6T7viJYHoY4vvyTNCI,3754
+bytespec/codecs/list.py,sha256=TIAzORqZaD2q5EBSeKX8KmhXdr0gMeBrJwTUFa92NIM,2620
+bytespec/codecs/map.py,sha256=XdnJDrIqN6JQO5XqLCiNB5eMxNljF1IFOuWp4BDohSo,450
+bytespec/codecs/model.py,sha256=MUfTi3VOYtZcdTmNuSp2SzlW3909jfobPRe-mmveJEU,1342
+bytespec/codecs/str.py,sha256=cCEz9BmTgHE3pQXSit01Byz2R5mpwkK5_-E_NPizwTU,3032
+bytespec/codecs/uuid.py,sha256=75waS0z5A4RUcAv96O_uQobI_CCkmCiG1w4H6r_Jnv4,1118
+bytespec/codecs/varint.py,sha256=3ejY0ncFA2zLoA04wLtDUYsiSp2h6yyFN94-DGNCqVE,3471
+bytespec/core.py,sha256=AxsNQ7oq0CwudXhgAHFlkfYieOHrdnSFDNV8CiKaekI,18921
+bytespec/enums.py,sha256=Fo6FjGsNgA6t93eI4C543RS7qb3FU80STup42uMIF6k,368
+bytespec/errors.py,sha256=nlOgCkYVK7roR4ZlLRlAopWAu4XP5BgQA8Yy7ElYH-o,954
+bytespec/headers.py,sha256=mZHrE5-Z5wXzwSUVQ2bhQV__zr8aK2vTf6sSveSI2go,4657
+bytespec/missing.py,sha256=ABFcpZl_gJMU6wO-MfLluUOV4Bxb3n5wi2hqQFyOOcc,296
+bytespec/models.py,sha256=ZZOxKWHj0hrZe23UC9UqYjh6kAoSO8WJQGBGXyOTaaU,1377
+bytespec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bytespec/resolver.py,sha256=iOB63wFCjb95pMBb49xSRRwWSHZMeQiGUnp01t04Pto,5914
+bytespec/resolvers.py,sha256=tDNin1KH1J-kXp_6ZS4DBM0BAosCdKI_IWQaS5A_JM0,3590
+bytespec/schema.py,sha256=i5hqVeUC52tyUmOvRt7spsA2bT9vTmXL4yu54ttLQxE,761
+bytespec/types/__init__.py,sha256=gNi2fkiwx16T8Ssv3tI9xPb0bThtgDnLvDeTxvU-viY,875
+bytespec/types/spec.py,sha256=ntTnvhwwXk6qXAU9pNil9fkh4TxaSsAvKlvyqULkod4,1902
+bytespec-0.1.0.dist-info/licenses/LICENSE,sha256=b4HOpR9v54uGV7-BR4xWN5pu3pjhJWWRQRdWutlWPwA,1070
+bytespec-0.1.0.dist-info/WHEEL,sha256=Qb5DWjqM6GZuPp3VmTlAFSGqNRK8vceyVqRFxrfa8YA,80
+bytespec-0.1.0.dist-info/METADATA,sha256=9NM3l750FAl-tTCcAsHlYXmm1d_mKBrSMZbxaH7-Hog,3773
+bytespec-0.1.0.dist-info/RECORD,,

bytespec-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.4
+Root-Is-Purelib: true
+Tag: py3-none-any

bytespec-0.1.0.dist-info/licenses/LICENSE

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