sharedbox 0.6.0__tar.gz → 0.8.0__tar.gz

{sharedbox-0.6.0 → sharedbox-0.8.0}/.github/workflows/ci.yaml

@@ -114,11 +114,11 @@ jobs:
           ref: ${{ github.event_name == 'release' && github.event.release.tag_name || '' }}
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v4.3.2
+        uses: pypa/cibuildwheel@v4.3.4
         env:
           CIBW_BUILD: ${{ matrix.python }}-${{ matrix.platform_id }}
           CIBW_CONTAINER_ENGINE: "docker; create_args: --shm-size=1g"
-          CIBW_TEST_REQUIRES: pytest hypothesis numpy
+          CIBW_TEST_REQUIRES: pytest hypothesis numpy attrs
           CIBW_TEST_COMMAND: pytest {project}/tests
         with:
           package-dir: .
@@ -212,11 +212,11 @@ jobs:
         shell: bash
         run: |
           uv venv --python 3.12 .stress
-          uv pip install --python .stress wheelhouse/*.whl pytest hypothesis
+          uv pip install --python .stress wheelhouse/*.whl pytest hypothesis numpy attrs
           python=.stress/bin/python
           [ -x "$python" ] || python=.stress/Scripts/python.exe
           "$python" -m pytest -m stress -q -p no:cacheprovider
-          "$python" -m pytest tests/test_properties_codec.py tests/test_properties_layout.py tests/test_properties_forged.py tests/test_properties_stateful.py -q -p no:cacheprovider --hypothesis-profile=thorough
+          "$python" -m pytest tests/test_properties_*.py -q -p no:cacheprovider --hypothesis-profile=thorough
 
       - uses: actions/upload-artifact@v7
         if: always()
@@ -246,7 +246,7 @@ jobs:
       - uses: actions/checkout@v7
         with:
           fetch-depth: 0
-          ref: ${{ github.event_name == 'release' && github.event.release.tag_name || '' }}
+          ref: ${{ github.event.release.tag_name }}
 
       - name: Check the changelog has a section for a final release
         env:

{sharedbox-0.6.0 → sharedbox-0.8.0}/.github/workflows/ops.yaml

@@ -8,6 +8,7 @@ on:
       - src/sharedbox/_native/**
       - src/sharedbox/benchmarks/ops.py
       - .github/workflows/ops.yaml
+      - CMakeLists.txt
   workflow_dispatch:
 
 permissions:
@@ -41,13 +42,28 @@ jobs:
 
       - name: Run benchbox ops, alternating base and head
         shell: bash
+        env:
+          # The 64k set and dict rows nearly double the job, so a pull request skips them.
+          SIZES: ${{ github.event_name == 'pull_request' && '[!6]*' || '*' }}
         run: |
           mkdir results
+          step=0
+          total=18 # 3 rounds x 2 sides x (int, record), plus list, set and dict once per side
           for round in 1 2 3; do
             for side in base head; do
-              for rows in int record; do
+              for rows in int record list set dict; do
+                case "$rows" in list|set|dict) [ "$round" != 1 ] && continue ;; esac # not gated, one round is enough
+                step=$((step + 1))
+                echo "::group::[$step/$total] round $round, $side, $rows rows"
+                case "$rows" in
+                  list) pattern="*list*/*" ;;
+                  set) pattern="*set$SIZES/*" ;;
+                  dict) pattern="*dict$SIZES/*" ;;
+                  *) pattern="*$rows/SharedBox" ;;
+                esac
                 (cd "$side" && uv run --no-sync benchbox ops --fast \
-                  --filter "*$rows/SharedBox" --json "../results/$side-$round-$rows.json")
+                  --filter "$pattern" --json "../results/$side-$round-$rows.json")
+                echo "::endgroup::"
               done
             done
           done
@@ -69,7 +85,9 @@ jobs:
               side = path.name.split("-")[0]
               for bench in pyperf.BenchmarkSuite.load(str(path)).get_benchmarks():
                   means.setdefault((bench.get_name(), side), []).append(bench.mean())
-          print("### benchbox ops on Windows cp311, median of three rounds")
+          print("### benchbox ops on Windows cp311, median of three rounds, list, set and dict rows one round")
+          print()
+          print("A pull request skips the 64k set and dict rows; start the workflow by hand for them.")
           print()
           print(machine())
           print()

{sharedbox-0.6.0 → sharedbox-0.8.0}/CHANGELOG.md

@@ -9,6 +9,192 @@ Dates are marked as `DD-MM-YYYY`
 
 <!-- towncrier release notes start -->
 
+## [0.8.0](https://github.com/jacopoabramo/sharedbox/releases/tag/v0.8.0) - 30-10-2026
+
+### Breaking
+
+- `sharedbox.Shape` takes its dimensions as one tuple, `Shape((480, 640))`, in
+  place of one argument per dimension. See
+  [How to migrate from 0.7](https://jacopoabramo.github.io/sharedbox/how-to/migrate-from-0.7/). ([#88](https://github.com/jacopoabramo/sharedbox/pull/88))
+- `SharedBox` reserves the names `metadata`, `metadata_version` and
+  `metadata_version_of`: a field or `InitVar` with one of them raises
+  `TypeError` when the class is defined. Rename the field:
+
+  ```python
+  # 0.7
+  class Parcel(SharedBox):
+      metadata: Annotated[str, Capacity(64)] = ""
+
+  # 0.8
+  class Parcel(SharedBox):
+      label: Annotated[str, Capacity(64)] = ""
+  ```
+
+  `SharedBox.update` takes the keyword `metadata`, so a type checker refuses
+  `update(**values)` when the values of the dictionary have a type that the
+  box's metadata type does not accept, such as `str`:
+
+  ```python
+  # 0.7
+  def restock(parcel: Parcel, values: dict[str, str]) -> None:
+      parcel.update(**values)
+
+  # 0.8
+  def restock(parcel: Parcel, values: dict[str, Any]) -> None:
+      parcel.update(**values)
+  ```
+
+  See
+  [How to migrate from 0.7](https://jacopoabramo.github.io/sharedbox/how-to/migrate-from-0.7/). ([#91](https://github.com/jacopoabramo/sharedbox/pull/91))
+
+### Added
+
+- `MaxShape`: an array of a stream item declared with a maximum shape, as in
+  `Annotated[npt.NDArray[np.uint16], MaxShape((2048, 2048))]`, stores its own
+  shape with each item, as kind 75 of stream layout 1.2. `writing()` views the
+  slot in the shape of the template's array, `slot.send` publishes the first
+  rows of that view without a copy, and `receive_into` returns a view of the
+  stored shape over `out`. ([#88](https://github.com/jacopoabramo/sharedbox/pull/88))
+- `SharedStream.sender(on_full="release")`: a send that has waited its whole
+  `timeout` releases the lossless readers a full ring behind and sends, as in
+  `stream.sender(on_full="release").send(item, timeout=0.1)`. Each released
+  reader raises `ReaderReleased`, whose `missed` counts the items it lost, and
+  goes on at the newest item; `ReceiveEvents.released` reports the count to
+  callbacks. `SharedSendStream.asend` and `awriting` take a `timeout`. In
+  `stream.hpp`, `send`, `send_with` and `begin` take an `on_full` policy, and a
+  released reader's `receive` gives `status::released`, in stream layout 1.3. ([#89](https://github.com/jacopoabramo/sharedbox/pull/89))
+- `MetadataFullError` and `MetadataGoneError`: raised when an add finds no
+  room for a version, and when the version a read asks for is no longer held. ([#91](https://github.com/jacopoabramo/sharedbox/pull/91))
+- `SharedStream.metadata`: a stream keeps metadata the same way.
+  `SharedStream.create(Reading, capacity=8, metadata={"unit": "kg"})` stores
+  version 1. `SharedSendStream.send`, `asend`, `send_nowait` and
+  `SendSlot.send` take `metadata=` and add a version that applies from that
+  item. `SharedReceiveStream.metadata` and `metadata_version` give the version
+  of the item the reader received last. `SharedStream.create` takes
+  `metadata_capacity` and `metadata_versions`, and `create` and `attach` take
+  `metadata_type`. `sharedbox` 0.7.0 and earlier cannot open a stream created
+  with metadata or a `metadata_capacity`. ([#91](https://github.com/jacopoabramo/sharedbox/pull/91))
+- `box.hpp`, `stream.hpp` and `sharedbox_c.h`: box layout 3.2 and stream
+  layout 1.4 hold metadata after the record or the description table.
+  `handle` and `stream` gain `metadata_head` and `read_metadata`, and
+  `stream_reader` gains `metadata_version_at`. `handle` and `stream_sender`
+  gain `add_metadata`. `handle::write(values, doc, lock_timeout)` and
+  `write_large` with the same arguments write fields and add a version in one
+  write, and
+  `stream_sender::can_add_metadata` checks an add without making it.
+  `sharedbox_c.h` adds `sbx_metadata_head`, `sbx_read_metadata`,
+  `sbx_add_metadata` and `SBX_E_METADATA_FULL`. ([#91](https://github.com/jacopoabramo/sharedbox/pull/91))
+- `SharedBox.metadata`: a box keeps metadata, JSON-like values stored as CBOR
+  in its segment, in numbered versions. `Scale.create(name, metadata={"unit":
+  "kg"})` stores version 1, and `SharedBox.update(metadata=...)` adds the next
+  one from any process, with or without field values, in one write.
+  `metadata`, `metadata_version` and `metadata_version_of` read the versions,
+  a map as a read-only mapping and a list as a tuple. `BoxEvents.metadata` is
+  emitted with each new version. The class keywords `metadata_capacity` and
+  `metadata_versions` size the room for versions, and
+  `class Scale(SharedBox[Calibration])` gives the metadata's type to type
+  checkers. ([#91](https://github.com/jacopoabramo/sharedbox/pull/91))
+
+### Changed
+
+- `sharedbox.DType` is a `StrEnum` with one member per element type:
+  `DType(numpy.uint8)` returns `DType.uint8`, which equals `"uint8"`. ([#88](https://github.com/jacopoabramo/sharedbox/pull/88))
+
+### Fixed
+
+- `SharedBox` and `SharedStream` at exit: the `atexit` hook of `sharedbox`
+  closes every box and stream the process still has open and releases the
+  native objects of `SharedBox` subclasses, their watches and events groups,
+  so nanobind reports no leaked instances when a box class defined at module
+  level outlives shutdown. A box or stream used after the hook raises
+  `BoxClosedError` or `StreamClosedError`, and creating or attaching a box
+  raises `BoxClosedError`. ([#90](https://github.com/jacopoabramo/sharedbox/pull/90))
+
+
+## [0.7.0](https://github.com/jacopoabramo/sharedbox/releases/tag/v0.7.0) - 28-10-2026
+
+### Added
+
+- `np.int8`, `np.int16`, `np.int32`, `np.uint8`, `np.uint16`, `np.uint32`,
+  `np.uint64`, `np.float16`, `np.float32`, `np.complex64` and `np.datetime64`
+  as field types, record members, collection elements and stream items,
+  stored at their own width as kinds 13 to 23 of box layout 3.1 and stream
+  layout 1.1. A field reads back as its numpy type, and a value that does not
+  fit the width raises `OverflowError`. A `np.datetime64` field stores
+  nanoseconds since 1970. ([#66](https://github.com/jacopoabramo/sharedbox/pull/66))
+- `sbx_read_float16`, `sbx_write_float16`, `sbx_read_float32` and
+  `sbx_write_float32` in `sharedbox_c.h`. ([#66](https://github.com/jacopoabramo/sharedbox/pull/66))
+- An array annotated `X | None` as a field, record member or stream item,
+  holding `None` or an array of its sizes, as in
+  `scan: npt.NDArray[np.uint8] | None = field(default=None, shape=(32, 32))`.
+  `receive_into` does not fill one. ([#67](https://github.com/jacopoabramo/sharedbox/pull/67))
+- `field(capacity=...)`: the capacity of a box field of text, bytes,
+  `bytearray`, `Decimal` or a collection, as in
+  `samples: list[float] = field(capacity=16)`. ([#68](https://github.com/jacopoabramo/sharedbox/pull/68))
+- An array member of a dataclass or attrs record takes its sizes from
+  `metadata={"shape": (32, 32)}` on its field. ([#68](https://github.com/jacopoabramo/sharedbox/pull/68))
+- `BoundedList[T]`: a list value that keeps the stored bytes of a list field,
+  as in `samples: Annotated[BoundedList[float], Capacity(65536)]`. It takes
+  every element type `list[T]` takes and is stored as `list[T]` is. A read
+  copies the bytes without decoding an element, a write of a `BoundedList` of
+  the field's element type copies them back, indexing decodes or encodes one
+  element, and a change past the capacity raises `ValueError`. Subclasses,
+  generic or with a fixed element type, can be declared in its place. ([#73](https://github.com/jacopoabramo/sharedbox/pull/73))
+- `BoundedSet[T]`: a set value that keeps the stored bytes of a set field,
+  as in `seen: Annotated[BoundedSet[int], Capacity(65536)]`. It is stored as
+  `set[T]` is. A read copies the bytes without decoding an element, a write
+  of a `BoundedSet` of the field's element type copies them back, and `in`,
+  `add` and `remove` encode one key and compare stored bytes, through an
+  index after 64 lookups in a set of more than 8 elements. The set operators take any set and return a
+  `BoundedSet` of the same class and capacity, the comparisons take any set,
+  and a change past the capacity raises `ValueError`. A declaration raises
+  `TypeError` for an element type whose equal values could be stored
+  differently, such as `Decimal` or `int | float`. Subclasses, generic or
+  with a fixed element type, can be declared in its place. ([#77](https://github.com/jacopoabramo/sharedbox/pull/77))
+- `BoundedDict[K, V]`: a dict value that keeps the stored bytes of a dict
+  field, as in `weights: Annotated[BoundedDict[int, float], Capacity(4096)]`.
+  It is stored as `dict[K, V]` is. A read copies the bytes without decoding
+  an item, a write of a `BoundedDict` of the field's key and value types
+  copies them back, and `d[key]`, `get` and `in` encode one key and compare
+  stored bytes, through an index after 64 lookups in a dict of more than 8
+  keys. It keeps insertion order, `|` takes any mapping and returns a
+  `BoundedDict` of the same class and capacity, and a change past the
+  capacity raises `ValueError`. Keys follow the rules of `BoundedSet`
+  elements, and values can be of any type a `dict` field holds. Subclasses,
+  generic or with fixed key and value types, can be declared in its place. ([#82](https://github.com/jacopoabramo/sharedbox/pull/82))
+- `BoundedList` of `int`, `float`, `bool`, `complex` or NumPy integer, float,
+  complex or `bool_` elements supports the buffer protocol: `np.asarray(value)`
+  and `memoryview(value)` share its elements without decoding them, read only
+  for `bool` and `bool_`, and a change of length raises `BufferError` while
+  such a view exists. ([#85](https://github.com/jacopoabramo/sharedbox/pull/85))
+
+### Changed
+
+- Reading a `list`, `tuple`, `set`, `frozenset` or `dict` field allocates and
+  copies less, and reading a record whose class takes every member by position
+  no longer builds a dict of keyword arguments. ([#65](https://github.com/jacopoabramo/sharedbox/pull/65))
+- A union stores a number through its first member of the same kind of
+  number, so `np.int64(5)` written to `float | int` reads back as `5`. ([#66](https://github.com/jacopoabramo/sharedbox/pull/66))
+- `int`, `float`, `complex` and `bool` fields take numpy's integer, floating,
+  complex and bool scalars, and read back the Python type. `np.int64`,
+  `np.float64`, `np.complex128` and `np.bool_` fields read back as those types
+  and hash as `int`, `float`, `complex` and `bool`. ([#66](https://github.com/jacopoabramo/sharedbox/pull/66))
+- The extension is compiled for speed instead of size. Writing a `list`, `set`
+  or `dict` field, and reading, indexing or looking up a `BoundedList` or
+  `BoundedSet`, take less time. The wheels are about 75 KB larger on Linux and
+  17 KB larger on Windows. ([#79](https://github.com/jacopoabramo/sharedbox/pull/79))
+
+### Fixed
+
+- A `list`, `set` or `dict` whose slots end short of its alignment, such as
+  `Annotated[list[Color], Capacity(3)]` for an `Enum` `Color`, is accepted;
+  its size is rounded up to the alignment. `sharedbox` 0.6 refuses a segment
+  that holds one. ([#66](https://github.com/jacopoabramo/sharedbox/pull/66))
+- A `TypeError` about the sizes of an array member of a dataclass or attrs
+  record names its metadata shape, as in `metadata shape (3)`, instead of
+  `field(shape=...)`. ([#70](https://github.com/jacopoabramo/sharedbox/pull/70))
+
+
 ## [0.6.0](https://github.com/jacopoabramo/sharedbox/releases/tag/v0.6.0) - 24-10-2026
 
 ### Added

{sharedbox-0.6.0 → sharedbox-0.8.0}/CLAUDE.md

@@ -13,11 +13,11 @@ the layout and the native module converts values.
 ```text
 sharedbox/
 |-- include/sharedbox/
-|   |-- core.hpp               what every segment kind uses: result and error, liveness, names, mappings, the open step, waiter slots, the type codec
-|   |-- box.hpp                box layout 3.0 and its protocols: create, publish, open, lock, read, write, capsule handle
-|   |-- stream.hpp             stream layout 1.0: create, open, the sender, readers, the gate, dead ends
+|   |-- core.hpp               what every segment kind uses: result and error, liveness, names, mappings, the open step, waiter slots, the type codec, the metadata area and its CBOR check
+|   |-- box.hpp                box layout 3.2 and its protocols: create, publish, open, lock, read, write, metadata, capsule handle
+|   |-- stream.hpp             stream layout 1.4: create, open, the sender, readers, the gate, dead ends, metadata
 |   |-- sharedbox.hpp          includes every kind; the header consumers include
-|   |-- sharedbox_c.h          minimal C interface: sbx_open, sbx_import, sbx_read, sbx_write, sbx_schema_hash, sbx_release, sbx_field_desc, typed sbx_read_* and sbx_write_*
+|   |-- sharedbox_c.h          minimal C interface: sbx_open, sbx_import, sbx_read, sbx_write, sbx_schema_hash, sbx_release, sbx_field_desc, typed sbx_read_* and sbx_write_*, sbx_metadata_head, sbx_read_metadata, sbx_add_metadata
 |   `-- sharedbox_c.cpp        its implementation, compiled by the consumer (CMake target sharedbox::c)
 |-- cmake/
 |   |-- sharedbox-config.cmake       find_package(sharedbox) from an installed wheel; the build writes
@@ -28,11 +28,14 @@ sharedbox/
 |   |-- _box.py                SharedBox: class keywords, fields, fields(), create/attach, __post_init__, update, snapshot, unlink, __sharedbox_box__
 |   |-- _layout.py             Capacity, field() and Field, field offsets and kind codes, schema hash
 |   |-- _types.py              annotation parsing into TypeSpec, the description table
-|   |-- _arrays.py             Shape, DType, SupportsDLPack, register_array_type
+|   |-- _arrays.py             Shape, MaxShape, DType, SupportsDLPack, register_array_type
 |   |-- _events.py             BoxEvents, FieldWatch, the watcher thread
 |   |-- _follow.py             BoxEvents.follow and unfollow: forwarding the events of boxes that references reach
 |   |-- _stream.py             SharedStream, SharedSendStream, SharedReceiveStream, ReceiveEvents, the statistics classes, the worker threads
+|   |-- _metadata.py           metadata documents: the type variable M, CBOR encoding, read-only decoding, the cache of decoded versions
 |   |-- _refs.py               reference fields: BoxRef, the class registry, BrokenReferenceError, UnknownBoxClassError
+|   |-- _exit.py               the exit handler: stops the watcher and stream threads, closes boxes, streams and ends,
+|   |                          replaces the native objects of watchers and box classes
 |   |-- _native.pyi            hand-written stub for the extension
 |   |-- py.typed
 |   |-- benchmarks/            the benchbox command (extra: benchmarks)
@@ -53,7 +56,7 @@ sharedbox/
 |       |                      checks every value of an update before any is written,
 |       |                      with_record reads the whole record at once
 |       |-- types.{hpp,cpp}    Types: conversions of kinds above 5, arrays
-|       |-- scalars.{hpp,cpp}  kinds 6 to 12, the datetime C API on full-API builds
+|       |-- scalars.{hpp,cpp}  kinds 6 to 23, the datetime C API on full-API builds
 |       |-- segment.{hpp,cpp}  Segment: a sharedbox::handle plus error messages and the lifetime lock
 |       `-- stream.{hpp,cpp}   Stream, Sender and Reader: the Python binding of a stream and its errors
 |-- tests/                     pytest; many tests spawn processes
@@ -67,7 +70,9 @@ sharedbox/
 |   |-- test_follow.py         BoxEvents.follow, unfollow and nested
 |   |-- test_native_waiters.py waiter slots, dead owners, interrupt
 |   |-- test_box_sync_async.py a sync and an async watch on one box in two threads
+|   |-- test_metadata.py       metadata of a box: documents, versions, events, typed access, reserved names
 |   |-- test_stream.py         SharedStream, sender and reader, blocking and non-blocking calls
+|   |-- test_stream_metadata.py  metadata of a stream: the version of each item, in one process and across processes
 |   |-- test_stream_async.py   asyncio calls on a stream, cancellation
 |   |-- test_stream_events.py  ReceiveEvents delivery
 |   |-- test_stream_processes.py  streams across processes, dead senders and readers
@@ -91,7 +96,7 @@ sharedbox/
 |   |-- examples/              one script per how-to guide, included by the guide
 |   |-- javascripts/charts.js  draws each div of class sbx-chart from a plotly figure JSON file
 |   |-- assets/benchmarks/     the figure JSON files of the performance page, from benchbox plot
-|   `-- reference/segment-layout.md  core 1.0, box layout 3.0, names and protocols
+|   `-- reference/segment-layout.md  core 1.0, box layout 3.2, stream layout 1.4, names and protocols
 |-- includes/abbreviations.md  acronym tooltips appended to every page
 |-- zensical.toml              site configuration and navigation
 |-- .github/workflows/ci.yaml  lint, docs check, C++ tests, cibuildwheel wheels, tests, stress,
@@ -135,18 +140,19 @@ class's identity (the `identity` class keyword, by default
 always asks for a new name and raises `SegmentExistsError` if it is taken.
 
 Every segment starts with the same 64-byte line, whatever its kind. Core
-version 1.0, box layout 3.0, from offset 0:
+version 1.0, box layout 3.2, from offset 0:
 
 - Common line 0, written once at creation: `magic` (`SBX_BOX_` for a box,
   `SBX_STRM` for a stream), `core_major` 1, `core_minor` 0, `kind_major` 3,
-  `kind_minor` 0, `schema_hash`, `create_id`, `creator_start`,
+  `kind_minor` 2, `schema_hash`, `create_id`, `creator_start`,
   `creator_pidns`, `creator_pid`, `waiter_slots`, `size`.
 - Box line 1, at offset 64: `seq` (sequence lock; the generation is
   `seq >> 1`, there is no generation field), `writer_pid`, `wake_word`,
   `waiters` and `sleepers`, which writes and waits change; then written
   once at creation `field_count`, `record_size`, `record`, `tail` (always
-  128) and `types_size`, followed by reserved zero bytes. The header is
-  128 bytes.
+  128), `types_size`, `metadata_size` and `metadata` (the offset of the
+  metadata area, 0 for none); last `metadata_head`, the newest metadata
+  version, 0 for none, which each add changes. The header is 128 bytes.
 - The tail: `field_count` field table entries of 8 bytes (`u32 offset`,
   `u32 capacity_and_kind`: top 8 bits the kind code, the low 24 the
   capacity or size, or for kinds 64 and up the offset of the field's
@@ -155,9 +161,15 @@ version 1.0, box layout 3.0, from offset 0:
   `asleep_on`: the offset of the count the slot's current wait added 1 to,
   which freeing a dead owner's slot takes back), then the description
   table of `types_size` bytes. Kinds are 0 to 5, 6 to 12 (fixed-size
-  scalars) and 64 to 74 (described types).
-- The record, at a multiple of 64. The mapping size is rounded up to 4 KiB.
-  `record + record_size <= 2**32 - 4096`.
+  scalars), 13 to 23 (fixed-width numbers and `datetime64`) and 64 to 75
+  (described types; 75, an array up to a maximum shape, only in a stream).
+- The record, at a multiple of 64. `record + record_size <= 2**32 - 4096`.
+- The metadata area, when `metadata` is not 0, at the first multiple of 64
+  after the record, `metadata + metadata_size <= 2**32 - 4096`: a 64-byte
+  line (`entries`, `ring_size`), `entries` version entries of 32 bytes
+  (`seq`, `version`, `position`, `offset`, `length`), then a ring of
+  `ring_size` bytes holding one CBOR document per version. The mapping size
+  is rounded up to 4 KiB.
 
 `magic` is stored last on create, with release ordering, after the initial
 values are in the record; attach waits for it. Attach copies line 0 and the
@@ -173,8 +185,11 @@ layout 1.0 or 2.0, which 0.5 and earlier wrote.
 A stream's segment starts with a 256-byte header: the common line, a line
 of geometry written once, the sender's line and the readers' line. Then
 come a 64-byte entry per reader, the waiter slots, `capacity` slots each
-holding a `seq` and one item, and the description table. Every offset is
-64-bit. The full specification is in `docs/reference/segment-layout.md`.
+holding a `seq` and one item, the description table, and the metadata
+area laid out as a box's. Stream layout 1.4 keeps `metadata_size` and
+`metadata` in the geometry line and `metadata_head` in the sender's line.
+Every offset is 64-bit. The full specification is in
+`docs/reference/segment-layout.md`.
 
 ### Record encoding
 

{sharedbox-0.6.0 → sharedbox-0.8.0}/CMakeLists.txt

@@ -41,11 +41,16 @@ nanobind_add_module(_native
     STABLE_ABI
     FREE_THREADED
     LTO
+    NOMINSIZE
     NB_DOMAIN sharedbox
     src/sharedbox/_native/codec.cpp
+    src/sharedbox/_native/collection.cpp
+    src/sharedbox/_native/dict.cpp
+    src/sharedbox/_native/keys.cpp
     src/sharedbox/_native/module.cpp
     src/sharedbox/_native/scalars.cpp
     src/sharedbox/_native/segment.cpp
+    src/sharedbox/_native/set.cpp
     src/sharedbox/_native/stream.cpp
     src/sharedbox/_native/types.cpp)
 target_link_libraries(_native PRIVATE sharedbox::headers)

{sharedbox-0.6.0 → sharedbox-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sharedbox
-Version: 0.6.0
+Version: 0.8.0
 Summary: Python containers using shared memory.
 Author-Email: Jacopo Abramo <jacopo.abramo@gmail.com>
 License-Expression: Apache-2.0
@@ -14,7 +14,9 @@ Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
 Classifier: Programming Language :: C++
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
+Requires-Dist: cbor2>=6.1.5
 Requires-Dist: psygnal>=0.16.1
+Requires-Dist: typing-extensions>=4.16.0; python_full_version < "3.13"
 Provides-Extra: benchmarks
 Requires-Dist: numpy>=2.4.6; extra == "benchmarks"
 Requires-Dist: plotly>=7.1.0; extra == "benchmarks"