tmsgpack 0.2.22__tar.gz → 0.3.0__tar.gz

{tmsgpack-0.2.22 → tmsgpack-0.3.0}/MANIFEST.in

@@ -1,5 +1,5 @@
 include setup.py
-include COPYING
-include LICENSE
 include README.md
 recursive-include tmsgpack *.pyx *.c *.h
+recursive-include tmsgpack/src-parts *
+include build_pyx.py

tmsgpack-0.3.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: tmsgpack
+Version: 0.3.0
+Summary: Typed MessagePack serializer (inspired by but different from msgpack)
+Author-email: Yaakov Belch <yaakov.belch@gmail.com>
+License: ISC
+Project-URL: Source, https://github.com/Yaakov-Belch/semifun
+Project-URL: Tracker, https://github.com/Yaakov-Belch/semifun/issues
+Requires-Python: >=3.14
+Requires-Dist: xxhash
+Requires-Dist: semifun>=0.1.0

tmsgpack-0.3.0/build_pyx.py

@@ -0,0 +1,67 @@
+"""Generate `tmsgpack/core.pyx` by concatenating `tmsgpack/src-parts/*`.
+
+The Cython source is assembled from numbered fragments so that each part can
+be edited on its own.  `core.pyx` is the generated result — never edit it.
+
+`setup.py` calls `write_pyx()` before cythonizing, so a build always compiles
+the current fragments.  The generated file is committed as well, because
+`MANIFEST.in` ships `*.pyx` but not `src-parts/`: an sdist therefore contains
+the assembled source and can be built without regenerating it.
+
+`tests/test_build_pyx.py` asserts that the committed file matches what
+`render_pyx()` produces, so the two cannot drift.
+
+Run directly to regenerate by hand:
+
+    uv run python build_pyx.py
+"""
+
+from pathlib import Path
+
+PACKAGE_ROOT = Path(__file__).parent
+REPO_ROOT = PACKAGE_ROOT.parent
+SRC_PARTS = PACKAGE_ROOT / 'tmsgpack' / 'src-parts'
+PYX_PATH = PACKAGE_ROOT / 'tmsgpack' / 'core.pyx'
+VERSION_FILE = REPO_ROOT / 'VERSION'
+
+HEADER = """\
+# THIS FILE IS AUTOMATICALLY CREATED BY build_pyx.py
+# DON'T EDIT THIS FILE.  EDIT THE SOURCES, INSTEAD: tmsgpack/src-parts/*
+
+__version__ = "{version}"
+
+"""
+
+
+def read_version() -> str:
+    """The single source of truth for the version: repo-root VERSION file."""
+    return VERSION_FILE.read_text().strip()
+
+
+def render_pyx() -> str:
+    """Return the full text of `core.pyx` without writing anything."""
+    parts = sorted(SRC_PARTS.iterdir())
+    if not parts:
+        raise FileNotFoundError(f'No source fragments in {SRC_PARTS}')
+    return HEADER.format(version=read_version()) + ''.join(
+        p.read_text() for p in parts
+    )
+
+
+def write_pyx(path: Path) -> bool:
+    """Write the rendered source to `path` if it differs.  True when rewritten.
+
+    Writing only on change keeps the file's mtime stable, so an unchanged
+    build does not make Cython recompile.  The destination is an argument so
+    that tests can exercise this without touching the source tree.
+    """
+    new = render_pyx()
+    if path.exists() and path.read_text() == new:
+        return False
+    path.write_text(new)
+    return True
+
+
+if __name__ == '__main__':
+    changed = write_pyx(PYX_PATH)
+    print(f'{PYX_PATH}: {"regenerated" if changed else "already current"}')

tmsgpack-0.3.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "tmsgpack"
+version = "0.3.0"
+description = "Typed MessagePack serializer (inspired by but different from msgpack)"
+requires-python = ">=3.14"
+license = {text = "ISC"}
+authors = [
+    { name = "Yaakov Belch", email = "yaakov.belch@gmail.com" },
+]
+dependencies = [
+    "xxhash",
+    "semifun>=0.1.0",
+]
+
+[tool.uv.sources]
+semifun = { workspace = true }
+
+[project.urls]
+Source = "https://github.com/Yaakov-Belch/semifun"
+Tracker = "https://github.com/Yaakov-Belch/semifun/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
+    "pytest-timeout>=2.3.0",
+]
+
+[tool.pytest.ini_options]
+addopts = "--import-mode=importlib"
+asyncio_mode = "auto"
+timeout = 60
+testpaths = ["tests"]
+
+[build-system]
+requires = ["setuptools>=75.0", "Cython>=3.0,<4"]
+build-backend = "setuptools.build_meta"

tmsgpack-0.3.0/setup.cfg

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

{tmsgpack-0.2.22 → tmsgpack-0.3.0}/setup.py

@@ -1,12 +1,15 @@
 from setuptools import setup, find_packages
 from Cython.Build import cythonize
 import glob
+import os
+import sys
 
-# Automatically find all .pyx files in src/
-pyx_files = glob.glob("tmsgpack/*.pyx")
+sys.path.insert(0, os.getcwd())
+from build_pyx import PYX_PATH, write_pyx
 
-print("Found packages:", find_packages())
+write_pyx(PYX_PATH)
 
+pyx_files = glob.glob("tmsgpack/*.pyx")
 
 setup(
     name="tmsgpack",

tmsgpack-0.3.0/tests/test_build_pyx.py

@@ -0,0 +1,65 @@
+"""The generated Cython source must match its fragments and the declared version."""
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+PACKAGE_ROOT = Path(__file__).parent.parent
+
+
+def _load_build_pyx():
+    """Import `build_pyx.py`, which sits beside setup.py rather than in the package."""
+    spec = importlib.util.spec_from_file_location(
+        'build_pyx', PACKAGE_ROOT / 'build_pyx.py',
+    )
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_committed_pyx_matches_its_fragments():
+    """`core.pyx` is generated; a stale committed copy is a silent trap.
+
+    An sdist ships the assembled `.pyx` (MANIFEST.in), so a copy that no
+    longer matches `src-parts/` would build something nobody wrote.
+    """
+    build_pyx = _load_build_pyx()
+    assert build_pyx.PYX_PATH.read_text() == build_pyx.render_pyx(), (
+        'tmsgpack/core.pyx is out of date with tmsgpack/src-parts/*. '
+        'Regenerate it: uv run python build_pyx.py'
+    )
+
+
+def test_generated_version_matches_the_declared_version():
+    """The version compiled into the extension comes from [project] version."""
+    from tmsgpack.core import __version__
+
+    build_pyx = _load_build_pyx()
+    assert __version__ == build_pyx.read_version()
+
+
+def test_render_is_deterministic_and_ordered():
+    """Fragments concatenate in numeric-name order, so the output is stable."""
+    build_pyx = _load_build_pyx()
+    assert build_pyx.render_pyx() == build_pyx.render_pyx()
+
+    names = [p.name for p in sorted(build_pyx.SRC_PARTS.iterdir())]
+    assert names == sorted(names)
+    assert names[0].startswith('01-')
+
+
+def test_write_pyx_only_writes_when_the_content_differs(tmp_path):
+    """Rewriting an unchanged file would churn its mtime and force a rebuild.
+
+    Writes to a temporary path: a test must not modify the source tree.
+    """
+    build_pyx = _load_build_pyx()
+    target = tmp_path / 'core.pyx'
+
+    assert build_pyx.write_pyx(target) is True     # created
+    assert build_pyx.write_pyx(target) is False    # unchanged, left alone
+
+    target.write_text('stale')
+    assert build_pyx.write_pyx(target) is True     # differs, rewritten
+    assert target.read_text() == build_pyx.render_pyx()

tmsgpack-0.3.0/tests/test_codec.py

@@ -0,0 +1,197 @@
+"""Integration tests for TmsgpackCodec with DI and the feature registry."""
+
+import textwrap
+import pytest
+from pathlib import Path
+
+pytest.importorskip("semifun.di")
+pytest.importorskip("semifun.plugins")
+
+from tmsgpack.codec import NoDependencyInjector, TmsgpackCodec
+from semifun.di.injector import DependencyInjector
+from semifun.plugins.testing import create_registry_from_paths
+from semifun.plugins.registry import (
+    _feature_map_from_registry,
+)
+
+
+# --- Write a test package with annotated types ---
+
+def _write_test_types_package(tmp_path: Path) -> Path:
+    pkg = tmp_path / "test_codec_types"
+    pkg.mkdir()
+    (pkg / "__init__.py").write_text("")
+    (pkg / "types.py").write_text(textwrap.dedent("""\
+        import enum
+        from dataclasses import dataclass
+        from semifun.di.model import Inject
+
+        _HTTP_STATUS = (200, 404, 403, 401, 500)
+
+        #::testing_tmsgpack_codec:FailureSeverity
+        class FailureSeverity(enum.IntEnum):
+            OK = 0
+            PROBLEM = 1
+            NOT_AUTHORIZED = 2
+            NOT_AUTHENTICATED = 3
+            UNEXPECTED = 4
+
+            @property
+            def http_status_code(self) -> int:
+                return _HTTP_STATUS[self]
+
+            def __str__(self):
+                return self.name
+
+        #::testing_tmsgpack_codec:Foo
+        @dataclass(frozen=True)
+        class Foo:
+            x: str
+            y: int
+
+        @dataclass(frozen=True)
+        class Dbh:
+            pass
+
+        #::testing_tmsgpack_codec:Bar
+        @dataclass(frozen=True)
+        class Bar:
+            dbh: Inject[Dbh]
+            x: str
+    """))
+    return pkg
+
+
+@pytest.fixture
+def test_types(tmp_path):
+    pkg = _write_test_types_package(tmp_path)
+    registry = create_registry_from_paths(
+        packages=[("test_codec_types", pkg)],
+    )
+    feature_map = _feature_map_from_registry(registry, "testing_tmsgpack_codec")
+
+    import test_codec_types.types as t
+    return t, feature_map
+
+
+def _make_injectors_map():
+    _MISSING = object()
+    # documented-default: mirrors FeatureMap.__call__ — omitting `default`
+    # means "raise", which `None` cannot express.
+    def lookup(name, default=_MISSING):   # documented-default
+        if default is not _MISSING:
+            return default
+        raise LookupError(name)
+    return lookup
+
+
+@pytest.fixture
+def codec(test_types):
+    t, feature_map = test_types
+    di = DependencyInjector(injectors_map=_make_injectors_map(), seed_data={t.Dbh: t.Dbh()})
+    # testing-seam: pass feature_map callable instead of a string
+    return TmsgpackCodec(sort_keys=False, di=di, plugin_feature_type=feature_map), t
+
+
+@pytest.fixture
+def codec_no_di(test_types):
+    t, feature_map = test_types
+    # testing-seam: pass feature_map callable instead of a string
+    return TmsgpackCodec(sort_keys=False, di=NoDependencyInjector(),
+                          plugin_feature_type=feature_map), t
+
+
+# --- Round-trip: plain dataclass ---
+
+def test_round_trip_dataclass(codec):
+    codec, t = codec
+    foo = t.Foo(x='hello', y=123)
+    assert codec.decode(codec.encode(foo)) == foo
+
+
+# --- Round-trip: enum ---
+
+def test_round_trip_enum(codec):
+    codec, t = codec
+    for severity in t.FailureSeverity:
+        assert codec.decode(codec.encode(severity)) == severity
+
+
+# --- Round-trip: dataclass with Inject[T] fields ---
+
+def test_round_trip_dataclass_with_inject(codec):
+    codec, t = codec
+    bar = t.Bar(dbh=t.Dbh(), x='world')
+    data = codec.encode(bar)
+    decoded = codec.decode(data)
+    assert decoded.x == 'world'
+    assert isinstance(decoded.dbh, t.Dbh)
+
+
+# --- NoDependencyInjector: plain types work without DI ---
+
+def test_no_di_dataclass(codec_no_di):
+    codec, t = codec_no_di
+    foo = t.Foo(x='abc', y=42)
+    assert codec.decode(codec.encode(foo)) == foo
+
+
+def test_no_di_enum(codec_no_di):
+    codec, t = codec_no_di
+    baz = t.FailureSeverity.PROBLEM
+    assert codec.decode(codec.encode(baz)) == baz
+
+
+# --- with_seed_data ---
+
+def test_with_seed_data_round_trip(codec):
+    codec, t = codec
+    other_dbh = t.Dbh()
+    codec2 = codec.with_seed_data({t.Dbh: other_dbh})
+    bar = t.Bar(dbh=t.Dbh(), x='test')
+    decoded = codec2.decode(codec2.encode(bar))
+    assert decoded.x == 'test'
+    assert decoded.dbh is other_dbh
+
+
+# --- Encoder/decoder caches are shared after with_seed_data ---
+
+def test_with_seed_data_shares_caches(codec):
+    codec, t = codec
+    codec2 = codec.with_seed_data({t.Dbh: t.Dbh()})
+    assert codec2.encoder_cache is codec.encoder_cache
+    assert codec2.decoder_cache is codec.decoder_cache
+
+
+# --- Inject[T] without a DependencyInjector ---
+
+def test_inject_field_without_an_injector_fails_on_encode():
+    """`NoDependencyInjector` does not recognise Inject[T], so the field is serialized.
+
+    Documented in [[tmsgpack:di-on-decode]]: exclusion depends on the
+    injector, so without one the codec tries to encode the injected value and
+    fails there — not on decode.
+    """
+    from dataclasses import dataclass
+
+    from tmsgpack.codec import NoDependencyInjector, TmsgpackCodec
+    from semifun.di.model import Inject
+
+    class DbHandle:
+        pass
+
+    @dataclass(frozen=True)
+    class NeedsInjection:
+        dbh: Inject[DbHandle]
+        x: str
+
+    def feature_map(feature, default=None):
+        return {'NeedsInjection': NeedsInjection}.get(feature, default)
+
+    codec = TmsgpackCodec(
+        sort_keys=True,
+        di=NoDependencyInjector(),
+        plugin_feature_type=feature_map,
+    )
+    with pytest.raises(ValueError, match='Cannot encode this type'):
+        codec.encode(NeedsInjection(dbh=DbHandle(), x='hi'))

tmsgpack-0.3.0/tests/test_round_trip.py

@@ -0,0 +1,190 @@
+"""Round-trip tests: every value encodes and decodes back to an equal value.
+
+Corpora are parametrised by *group*, not by value.  The generators below
+produce several thousand values between them; one test item per value would be
+slow to collect and would build test ids out of 2000-character strings.  One
+item per group keeps the output readable and still names the failing value.
+"""
+
+import inspect
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import Sequence
+
+import pytest
+
+from tmsgpack.api import EncodeDecode, basic_codec
+from tmsgpack.core import TMsgpackError, __version__
+
+
+# --- Value corpora ---
+
+def _small_integers():
+    return range(-2000, 2000)
+
+
+def _integers():
+    """Values either side of every power of two, both signs."""
+    return [
+        s * (2**e + d)
+        for e in range(63)
+        for d in range(-10, 10)
+        for s in (-1, +1)
+    ]
+
+
+def _floats():
+    return [3.1415926]
+
+
+def _containers():
+    """Strings, bytes and collections across a wide range of lengths."""
+    return [
+        v
+        for e in range(18)
+        for d in range(-2, 2)
+        for f in (1, 1 / 3)
+        for n in [int(f * 2**e + d)]
+        for v in [
+            "*" * n,
+            b"*" * n,
+            [12] * n,
+            (12,) * n,
+            {m: 3 * m + 1 for m in range(n)},
+        ]
+    ]
+
+
+def _constants():
+    return [True, False, None]
+
+
+def _nested():
+    return [[1, 2, 3, 4, {'a': 'hello', 'b': ['world', 5, 6, 7]}]]
+
+
+def _large_integer():
+    return [1760628047033313535]
+
+
+BASIC_GROUPS = {
+    'small integers': _small_integers,
+    'integers': _integers,
+    'float': _floats,
+    'containers': _containers,
+    'constants': _constants,
+    'nested value': _nested,
+    'large integer': _large_integer,
+}
+
+
+@pytest.mark.parametrize('group', sorted(BASIC_GROUPS))
+def test_basic_codec_round_trip(group):
+    """Every value in the group decodes back to an equal value."""
+    for value in BASIC_GROUPS[group]():
+        decoded = basic_codec.decode(basic_codec.encode(value))
+        assert decoded == value, (
+            f'{group}: a {type(value).__name__} did not round-trip'
+            + (f' (length {len(value)})' if hasattr(value, '__len__') else '')
+        )
+
+
+# --- A codec that serializes registered dataclasses ---
+
+@dataclass
+class Foo:
+    x: int
+    y: int
+
+
+@dataclass
+class Unregistered:
+    z: int
+
+
+@dataclass
+class MyCodec(EncodeDecode):
+    """Minimal custom codec: serializes the dataclasses it is given."""
+    sort_keys = True
+    types: Sequence
+
+    encode_cache: dict = field(default_factory=dict, init=False, repr=False)
+    decode_cache: dict = field(default_factory=dict, init=False, repr=False)
+
+    @cached_property
+    def constructors(self):
+        return {t.__name__: t for t in self.types}
+
+    def prep_encode(self, value, target):
+        return [None, self, value]
+
+    def decode_codec(self, codec_type, source):
+        if codec_type is None:
+            return self
+        raise TMsgpackError(f'Unsupported codec_type: {codec_type}')
+
+    def encode_value(self, ectx):
+        t = type(ectx.value)
+        if t not in self.encode_cache:
+            type_name = self.type_to_name(t)
+            constructor = self.name_to_constructor(type_name)
+            args = self.constructor_to_args(constructor)
+
+            def encode_handler(ectx):
+                value = ectx.value
+                ectx.put_dict(type_name, {a: getattr(value, a) for a in args})
+
+            self.encode_cache[t] = encode_handler
+        self.encode_cache[t](ectx)
+
+    def decode_from_bytes(self, dctx):
+        raise TMsgpackError(f'No bytes extension defined: {dctx._type}')
+
+    def decode_from_list(self, dctx):
+        _type = dctx._type
+        if _type not in self.decode_cache:
+            constructor = self.name_to_constructor(_type)
+
+            def decode_handler(dctx):
+                return constructor(**dctx.take_dict())
+
+            self.decode_cache[_type] = decode_handler
+        return self.decode_cache[_type](dctx)
+
+    def type_to_name(self, _type):
+        return _type.__name__
+
+    def name_to_constructor(self, name):
+        if res := self.constructors.get(name, None):
+            return res
+        raise TMsgpackError(f'Unsupported type: {name}')
+
+    def constructor_to_args(self, constructor):
+        return inspect.signature(constructor).parameters.keys()
+
+
+def test_custom_codec_round_trips_a_registered_dataclass():
+    codec = MyCodec(types=[Foo])
+    for value in [Foo(1, 2), Foo(2, 3)]:
+        assert codec.decode(codec.encode(value)) == value
+
+
+def test_custom_codec_rejects_an_unregistered_type():
+    """An unregistered dataclass raises rather than encoding to something wrong."""
+    codec = MyCodec(types=[Foo])
+    with pytest.raises(TMsgpackError):
+        codec.encode(Unregistered(z=1))
+
+
+# --- Version ---
+
+def test_version_matches_the_installed_metadata():
+    """`__version__` is compiled into the extension; the metadata comes from pyproject.
+
+    A mismatch means the extension in use was built from a different version
+    than the installed package declares.  `test_build_pyx.py` checks the same
+    version against the fragments the extension is generated from.
+    """
+    from importlib.metadata import version
+
+    assert __version__ == version('tmsgpack')

{tmsgpack-0.2.22 → tmsgpack-0.3.0}/tmsgpack/api.py

@@ -1,8 +1,8 @@
-from typing import Any, Tuple
+from typing import Any
 from dataclasses import dataclass
-from tmsgpack.cython import EncodeBuffer, DecodeBuffer
-from tmsgpack.cython import ebuf_put_value, dbuf_take_value
-from tmsgpack.cython import TMsgpackError
+from tmsgpack.core import EncodeBuffer, DecodeBuffer
+from tmsgpack.core import ebuf_put_value, dbuf_take_value
+from tmsgpack.core import TMsgpackError
 
 class EncodeDecode:
     def encode(self, value, target=None):
@@ -24,11 +24,20 @@ class EncodeDecode:
 
     def dbuf_take_value(self, dbuf): return dbuf_take_value(self, dbuf)
 
+    def hash_to_bytes(self, value) -> bytes: # 16 bytes
+        import xxhash
+        assert self.sort_keys, 'hash_to_bytes: sort_keys is false --> unstable hash.'
+        return xxhash.xxh3_128_digest(self.encode(value))
 
-@dataclass
+    def hash_to_str(self, value) -> str:     # 22 chars
+        from base64 import urlsafe_b64encode
+        return urlsafe_b64encode(self.hash_to_bytes(value)).rstrip(b'=').decode('ascii')
+
+
+
+@dataclass(frozen=True)
 class BasicCodec(EncodeDecode):
     sort_keys = True
-    use_cache = False
     def prep_encode(self, value, target): return [None, self, value]
 
     def decode_codec(self, codec_type, source):