slick-stream-buffer-py 0.1.0__tar.gz

slick_stream_buffer_py-0.1.0/API_DIFFERENCES.md

@@ -0,0 +1,94 @@
+# API Differences: Python vs C++
+
+The Python implementation is binary-compatible with the C++ `slick::SlickStreamBuffer`
+at the shared memory level — every byte, offset, and memory ordering matches. The
+*language-level* API differs in the following ways.
+
+## Construction
+
+| C++ | Python |
+|---|---|
+| `stream_buffer buf(capacity, control_size)` | `SlickStreamBuffer(capacity=..., control_size=...)` |
+| `stream_buffer buf(capacity, control_size, "name")` | `SlickStreamBuffer(capacity=..., control_size=..., name="name")` |
+| `stream_buffer buf("name")` | `SlickStreamBuffer(name="name")` |
+| throws `std::invalid_argument` (bad sizes) | raises `ValueError` |
+| throws `std::runtime_error` (shm failures) | raises `RuntimeError` (or `FileNotFoundError` when opening a missing segment) |
+
+## Consumer cursor is passed by value
+
+C++ updates the cursor through a reference; Python has no by-reference ints, so the
+updated cursor is returned:
+
+```cpp
+// C++
+uint64_t cursor = 0;
+auto [data, length] = buf.read(cursor);   // cursor updated in place
+```
+
+```python
+# Python
+cursor = 0
+data, length, cursor = buf.read(cursor)   # updated cursor returned
+```
+
+`read()` returns `(None, 0, cursor)` where C++ returns `{nullptr, 0}`.
+`read_last()` returns `(None, 0)` / `(bytes, length)`.
+
+## Zero-copy vs copies
+
+| Operation | C++ | Python |
+|---|---|---|
+| `prepare(n)` | `uint8_t*` into the ring | writable `memoryview` into the ring (zero-copy) |
+| `data()` | `const uint8_t*` into the ring | read-only `memoryview` into the ring (zero-copy) |
+| `read(cursor)` | pointer into the ring | **`bytes` copy** |
+| `read_last()` | pointer into the ring | **`bytes` copy** |
+| `consume(n).data` | pointer into the ring | **`bytes` copy** |
+
+Consumer-side data is copied because the ring is lossy: the producer may overwrite the
+bytes at any moment after the validity check (the same caveat exists in C++, where the
+caller must finish with the pointer before the producer laps). A `bytes` copy makes the
+Python API safe by default.
+
+`prepare()`/`data()` memoryviews are invalidated by the next `prepare()` (which may
+relocate the region) — same semantics as C++ flat_buffer-style invalidation.
+
+## prepare() overflow
+
+C++ throws `std::length_error` when `size() + n > capacity()`; Python raises
+`ValueError`. C++ `consume()` asserts messages are < 4 GiB (debug builds); Python
+always raises `ValueError`.
+
+## consume() return value
+
+Both return the published record. Python's `PublishedRecord` mirrors C++
+`published_record` (`sequence`, `data`, `length`) and is falsy when nothing was
+published (`data is None`), matching C++ `operator bool`.
+
+## loss_count()
+
+C++ counts losses only when `SLICK_STREAM_BUFFER_ENABLE_LOSS_DETECTION` is enabled
+(default: debug builds only). Python always counts. The counter is per-instance in
+both implementations, not shared through the segment.
+
+## Memory orderings
+
+Python routes every shared-atomic access through C++ `std::atomic` (via the
+`ssb_atomic_ops_ext` extension), using the same orderings on the synchronization
+edges (record `seq` store-release / load-acquire, `next_seq_`/`reserve_end_`
+release/acquire, `init_state` acq_rel CAS). Where the C++ side uses
+`memory_order_relaxed` (e.g. `committed_`/`consumed_` stores), Python uses
+release/acquire — strictly stronger, therefore still correct.
+
+## Lifecycle
+
+Python adds explicit lifecycle management that C++ handles via RAII:
+
+- `close()` — detach from the segment (does not delete it)
+- `unlink()` — delete the segment (call once, from the owner, after all users closed)
+- context manager support: `with SlickStreamBuffer(...) as buf: ...` (closes on exit)
+- `get_shm_name()` — the exact segment name to pass to C++ (`/`-prefixed on POSIX)
+
+On POSIX with Python >= 3.13, attaching to an existing segment uses
+`SharedMemory(track=False)` so Python's resource tracker never unlinks a segment the
+process does not own. On older Pythons the tracker may log a harmless warning at exit
+(see `tests/run_test.py`, which filters it).

slick_stream_buffer_py-0.1.0/LICENSE

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

slick_stream_buffer_py-0.1.0/MANIFEST.in

@@ -0,0 +1,29 @@
+# Include documentation
+include README.md
+include LICENSE
+include API_DIFFERENCES.md
+
+# Include C++ source files for extension
+include ssb_atomic_ops_ext.cpp
+include setup.py
+include pyproject.toml
+
+# Include requirements
+include requirements.txt
+
+# Exclude build artifacts
+global-exclude *.pyc
+global-exclude __pycache__
+global-exclude *.so
+global-exclude *.pyd
+global-exclude *.dll
+global-exclude .DS_Store
+
+# Exclude test outputs
+recursive-exclude tests *.txt
+recursive-exclude tests __pycache__
+
+# Exclude build directories
+prune build
+prune dist
+prune *.egg-info

slick_stream_buffer_py-0.1.0/PKG-INFO

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: slick-stream-buffer-py
+Version: 0.1.0
+Summary: Lock-free SPMC byte stream buffer with C++ interoperability via shared memory
+Home-page: https://github.com/SlickQuant/slick-stream-buffer-py
+Author: Slick Quant
+Author-email: Slick Quant <slickquant@slickquant.com>
+License: MIT
+Project-URL: Homepage, https://github.com/SlickQuant/slick-stream-buffer-py
+Project-URL: Documentation, https://github.com/SlickQuant/slick-stream-buffer-py#readme
+Project-URL: Repository, https://github.com/SlickQuant/slick-stream-buffer-py
+Project-URL: Bug Tracker, https://github.com/SlickQuant/slick-stream-buffer-py/issues
+Keywords: stream-buffer,lock-free,atomic,shared-memory,ipc,multiprocessing,spmc
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Distributed Computing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: C++
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# slick-stream-buffer-py
+
+A Python implementation of [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer) —
+a lock-free single-producer multi-consumer (SPMC) byte stream buffer with shared memory support.
+
+**Maintains exact binary compatibility with the C++ version**: a Python producer and a C++
+consumer (or vice versa) communicate seamlessly through the same shared memory segment, using
+the same `std::atomic` synchronization primitives.
+
+## Features
+
+- **Byte stream, message records**: the producer writes raw bytes (`prepare`/`commit`) and
+  publishes them as discrete message records (`consume`), like a network receive buffer
+  feeding a framing layer
+- **Lock-free SPMC**: one producer, any number of consumers, no locks anywhere
+- **Binary-compatible with C++**: identical 64-byte header, 32-byte control records, and
+  acquire/release memory orderings (`slick/stream_buffer.hpp`, header magic `'SSB1'`)
+- **Shared memory IPC**: built on `multiprocessing.shared_memory`, matching the C++
+  slick-shm naming conventions on Windows, Linux, and macOS
+- **Lossy by design**: slow consumers skip overwritten data and count the loss instead of
+  blocking the producer
+- **Local memory mode**: same API without shared memory for single-process use
+- **No runtime dependencies**: Python 3.8+ standard library plus a small bundled C++
+  extension for the atomics
+
+## Requirements
+
+- Python 3.8+
+- 64-bit platform (Windows x86-64, Linux x86-64/ARM64, macOS x86-64/ARM64)
+- A C++17 compiler to build the `ssb_atomic_ops_ext` extension (MSVC 2017+, GCC 5+, Clang 3.8+)
+
+## Installation
+
+```bash
+pip install -e .
+# or just build the extension in place:
+python setup.py build_ext --inplace
+```
+
+## Quick Start
+
+### Producer (creates the shared memory segment)
+
+```python
+from slick_stream_buffer_py import SlickStreamBuffer
+
+# 64 MB data ring, 65536 message records
+stream = SlickStreamBuffer(capacity=1 << 26, control_size=1 << 16, name="market_data")
+
+while True:
+    mv = stream.prepare(64 * 1024)      # contiguous writable memoryview (zero-copy)
+    n = sock.recv_into(mv)              # write network bytes directly into the ring
+    stream.commit(n)
+
+    # publish every complete package as one message record
+    while (package_size := find_complete_package(stream.data(), stream.size())):
+        stream.consume(package_size)
+```
+
+### Consumer (opens the existing segment — can be C++ or Python)
+
+```python
+from slick_stream_buffer_py import SlickStreamBuffer
+
+stream = SlickStreamBuffer(name="market_data")   # geometry read from the segment header
+
+cursor = stream.initial_reading_index()          # skip history; use 0 to read from the start
+while True:
+    data, length, cursor = stream.read(cursor)
+    if data is None:
+        continue
+    handle_package(data, length)
+```
+
+### Local memory mode (single process)
+
+```python
+buf = SlickStreamBuffer(capacity=1024, control_size=16)
+
+mv = buf.prepare(5)
+mv[:] = b"hello"
+buf.commit(5)
+buf.consume(5)                     # publish as one record
+
+data, length, cursor = buf.read(0)  # -> b"hello", 5, 1
+```
+
+## C++ Interoperability
+
+The C++ side uses the identical layout — either side can create the segment, the other
+attaches to it:
+
+```cpp
+#include <slick/stream_buffer.hpp>
+
+slick::stream_buffer stream("market_data");   // open segment created by Python
+
+uint64_t cursor = stream.initial_reading_index();
+for (;;) {
+    auto [data, length] = stream.read(cursor);
+    if (data == nullptr) continue;
+    handle_package(data, length);
+}
+```
+
+Shared memory naming: use `get_shm_name()` to obtain the exact name to pass to C++
+(on POSIX it includes the leading `/` that `shm_open()` requires; on Windows it is the
+raw name).
+
+### Shared memory layout
+
+```
+[HEADER: 64 bytes]
+  0-7   atomic<uint64> committed_    - monotonic end of committed bytes
+  8-15  atomic<uint64> consumed_     - monotonic publish boundary
+  16-23 atomic<uint64> next_seq_     - next record sequence number
+  24-31 atomic<uint64> reserve_end_  - prepared-region high-water mark
+  32-39 uint64 capacity_             - data ring size in bytes (power of 2)
+  40-43 uint32 control_size_         - control ring record count (power of 2)
+  44-47 uint32 header_magic          - 0x53534231 ('SSB1')
+  48-51 atomic<uint32> init_state    - 0=uninit, 2=initializing, 3=ready
+  52-63 padding
+[CONTROL RING: 32 bytes x control_size]
+  each record: atomic<uint64> seq | uint64 offset | uint32 length | 12 bytes padding
+[DATA RING: capacity bytes]
+```
+
+Total segment size: `64 + 32 * control_size + capacity`.
+
+## API Summary
+
+| Method | Role | Description |
+|---|---|---|
+| `prepare(n) -> memoryview` | producer | contiguous writable region; may relocate unconsumed bytes on wrap |
+| `commit(n)` | producer | move n prepared bytes into the readable region (clamped) |
+| `consume(n) -> PublishedRecord` | producer | publish the first n readable bytes as ONE record (clamped) |
+| `discard()` | producer | drop unconsumed + prepared bytes without publishing |
+| `data() -> memoryview` / `size()` | producer | the committed-but-unconsumed region |
+| `read(cursor) -> (data, length, cursor)` | consumer | next record, or `(None, 0, cursor)`; skips lost records |
+| `read_last() -> (data, length)` | consumer | newest record without a cursor |
+| `initial_reading_index()` | consumer | cursor for a late joiner (skips history) |
+| `loss_count()` | consumer | records skipped by this instance due to overwrite |
+| `reset()` | owner | clear all state (not thread-safe) |
+| `close()` / `unlink()` | lifecycle | detach / delete the segment |
+
+See [API_DIFFERENCES.md](API_DIFFERENCES.md) for the exact deviations from the C++ API
+(cursor passed by value, bytes copies vs pointers, exceptions).
+
+### Caveats (same as C++)
+
+- Producer methods (`prepare`/`commit`/`consume`/`discard`/`data`/`size`/`reset`) must be
+  called from a single thread.
+- The buffer is lossy: if the producer outruns a consumer by more than the control ring or
+  data ring size, the consumer skips ahead and the loss is counted.
+- `prepare()` may relocate the readable region: memoryviews previously returned by `data()`
+  or `prepare()` are invalidated.
+- A single message (one `consume()` call) is limited to < 4 GiB.
+
+## Building and Testing
+
+```bash
+# 1. Build the atomics extension
+python setup.py build_ext --inplace
+
+# 2. Pure-Python tests
+python tests/test_atomic_ops.py
+python tests/test_local_mode.py
+python tests/test_shm_mode.py
+
+# 3. C++ interop tests (requires CMake + a C++20 compiler)
+cmake -S . -B build
+cmake --build build --config Debug
+cd build && ctest -C Debug --output-on-failure
+```
+
+The interop tests fetch [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer)
+(which pulls [slick-shm](https://github.com/SlickQuant/slick-shm)) from GitHub and build real
+C++ producer/consumer binaries against the actual `stream_buffer.hpp`. To build against local
+checkouts instead (no network):
+
+```bash
+cmake -S . -B build \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-STREAM-BUFFER=/path/to/slick-stream-buffer \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-SHM=/path/to/slick-shm
+```
+
+If a failed test run leaves segments behind: `python tests/cleanup_shm.py`
+
+## Related Projects
+
+- [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer) — the C++ implementation
+- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) / [slick-queue](https://github.com/SlickQuant/slick-queue) — MPMC fixed-element queue with the same interop approach
+
+## License
+
+MIT

slick_stream_buffer_py-0.1.0/README.md

@@ -0,0 +1,196 @@
+# slick-stream-buffer-py
+
+A Python implementation of [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer) —
+a lock-free single-producer multi-consumer (SPMC) byte stream buffer with shared memory support.
+
+**Maintains exact binary compatibility with the C++ version**: a Python producer and a C++
+consumer (or vice versa) communicate seamlessly through the same shared memory segment, using
+the same `std::atomic` synchronization primitives.
+
+## Features
+
+- **Byte stream, message records**: the producer writes raw bytes (`prepare`/`commit`) and
+  publishes them as discrete message records (`consume`), like a network receive buffer
+  feeding a framing layer
+- **Lock-free SPMC**: one producer, any number of consumers, no locks anywhere
+- **Binary-compatible with C++**: identical 64-byte header, 32-byte control records, and
+  acquire/release memory orderings (`slick/stream_buffer.hpp`, header magic `'SSB1'`)
+- **Shared memory IPC**: built on `multiprocessing.shared_memory`, matching the C++
+  slick-shm naming conventions on Windows, Linux, and macOS
+- **Lossy by design**: slow consumers skip overwritten data and count the loss instead of
+  blocking the producer
+- **Local memory mode**: same API without shared memory for single-process use
+- **No runtime dependencies**: Python 3.8+ standard library plus a small bundled C++
+  extension for the atomics
+
+## Requirements
+
+- Python 3.8+
+- 64-bit platform (Windows x86-64, Linux x86-64/ARM64, macOS x86-64/ARM64)
+- A C++17 compiler to build the `ssb_atomic_ops_ext` extension (MSVC 2017+, GCC 5+, Clang 3.8+)
+
+## Installation
+
+```bash
+pip install -e .
+# or just build the extension in place:
+python setup.py build_ext --inplace
+```
+
+## Quick Start
+
+### Producer (creates the shared memory segment)
+
+```python
+from slick_stream_buffer_py import SlickStreamBuffer
+
+# 64 MB data ring, 65536 message records
+stream = SlickStreamBuffer(capacity=1 << 26, control_size=1 << 16, name="market_data")
+
+while True:
+    mv = stream.prepare(64 * 1024)      # contiguous writable memoryview (zero-copy)
+    n = sock.recv_into(mv)              # write network bytes directly into the ring
+    stream.commit(n)
+
+    # publish every complete package as one message record
+    while (package_size := find_complete_package(stream.data(), stream.size())):
+        stream.consume(package_size)
+```
+
+### Consumer (opens the existing segment — can be C++ or Python)
+
+```python
+from slick_stream_buffer_py import SlickStreamBuffer
+
+stream = SlickStreamBuffer(name="market_data")   # geometry read from the segment header
+
+cursor = stream.initial_reading_index()          # skip history; use 0 to read from the start
+while True:
+    data, length, cursor = stream.read(cursor)
+    if data is None:
+        continue
+    handle_package(data, length)
+```
+
+### Local memory mode (single process)
+
+```python
+buf = SlickStreamBuffer(capacity=1024, control_size=16)
+
+mv = buf.prepare(5)
+mv[:] = b"hello"
+buf.commit(5)
+buf.consume(5)                     # publish as one record
+
+data, length, cursor = buf.read(0)  # -> b"hello", 5, 1
+```
+
+## C++ Interoperability
+
+The C++ side uses the identical layout — either side can create the segment, the other
+attaches to it:
+
+```cpp
+#include <slick/stream_buffer.hpp>
+
+slick::stream_buffer stream("market_data");   // open segment created by Python
+
+uint64_t cursor = stream.initial_reading_index();
+for (;;) {
+    auto [data, length] = stream.read(cursor);
+    if (data == nullptr) continue;
+    handle_package(data, length);
+}
+```
+
+Shared memory naming: use `get_shm_name()` to obtain the exact name to pass to C++
+(on POSIX it includes the leading `/` that `shm_open()` requires; on Windows it is the
+raw name).
+
+### Shared memory layout
+
+```
+[HEADER: 64 bytes]
+  0-7   atomic<uint64> committed_    - monotonic end of committed bytes
+  8-15  atomic<uint64> consumed_     - monotonic publish boundary
+  16-23 atomic<uint64> next_seq_     - next record sequence number
+  24-31 atomic<uint64> reserve_end_  - prepared-region high-water mark
+  32-39 uint64 capacity_             - data ring size in bytes (power of 2)
+  40-43 uint32 control_size_         - control ring record count (power of 2)
+  44-47 uint32 header_magic          - 0x53534231 ('SSB1')
+  48-51 atomic<uint32> init_state    - 0=uninit, 2=initializing, 3=ready
+  52-63 padding
+[CONTROL RING: 32 bytes x control_size]
+  each record: atomic<uint64> seq | uint64 offset | uint32 length | 12 bytes padding
+[DATA RING: capacity bytes]
+```
+
+Total segment size: `64 + 32 * control_size + capacity`.
+
+## API Summary
+
+| Method | Role | Description |
+|---|---|---|
+| `prepare(n) -> memoryview` | producer | contiguous writable region; may relocate unconsumed bytes on wrap |
+| `commit(n)` | producer | move n prepared bytes into the readable region (clamped) |
+| `consume(n) -> PublishedRecord` | producer | publish the first n readable bytes as ONE record (clamped) |
+| `discard()` | producer | drop unconsumed + prepared bytes without publishing |
+| `data() -> memoryview` / `size()` | producer | the committed-but-unconsumed region |
+| `read(cursor) -> (data, length, cursor)` | consumer | next record, or `(None, 0, cursor)`; skips lost records |
+| `read_last() -> (data, length)` | consumer | newest record without a cursor |
+| `initial_reading_index()` | consumer | cursor for a late joiner (skips history) |
+| `loss_count()` | consumer | records skipped by this instance due to overwrite |
+| `reset()` | owner | clear all state (not thread-safe) |
+| `close()` / `unlink()` | lifecycle | detach / delete the segment |
+
+See [API_DIFFERENCES.md](API_DIFFERENCES.md) for the exact deviations from the C++ API
+(cursor passed by value, bytes copies vs pointers, exceptions).
+
+### Caveats (same as C++)
+
+- Producer methods (`prepare`/`commit`/`consume`/`discard`/`data`/`size`/`reset`) must be
+  called from a single thread.
+- The buffer is lossy: if the producer outruns a consumer by more than the control ring or
+  data ring size, the consumer skips ahead and the loss is counted.
+- `prepare()` may relocate the readable region: memoryviews previously returned by `data()`
+  or `prepare()` are invalidated.
+- A single message (one `consume()` call) is limited to < 4 GiB.
+
+## Building and Testing
+
+```bash
+# 1. Build the atomics extension
+python setup.py build_ext --inplace
+
+# 2. Pure-Python tests
+python tests/test_atomic_ops.py
+python tests/test_local_mode.py
+python tests/test_shm_mode.py
+
+# 3. C++ interop tests (requires CMake + a C++20 compiler)
+cmake -S . -B build
+cmake --build build --config Debug
+cd build && ctest -C Debug --output-on-failure
+```
+
+The interop tests fetch [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer)
+(which pulls [slick-shm](https://github.com/SlickQuant/slick-shm)) from GitHub and build real
+C++ producer/consumer binaries against the actual `stream_buffer.hpp`. To build against local
+checkouts instead (no network):
+
+```bash
+cmake -S . -B build \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-STREAM-BUFFER=/path/to/slick-stream-buffer \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-SHM=/path/to/slick-shm
+```
+
+If a failed test run leaves segments behind: `python tests/cleanup_shm.py`
+
+## Related Projects
+
+- [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer) — the C++ implementation
+- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) / [slick-queue](https://github.com/SlickQuant/slick-queue) — MPMC fixed-element queue with the same interop approach
+
+## License
+
+MIT

slick_stream_buffer_py-0.1.0/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "slick-stream-buffer-py"
+dynamic = ["version"]
+description = "Lock-free SPMC byte stream buffer with C++ interoperability via shared memory"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Slick Quant", email = "slickquant@slickquant.com"}
+]
+keywords = ["stream-buffer", "lock-free", "atomic", "shared-memory", "ipc", "multiprocessing", "spmc"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Distributed Computing",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: C++",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+]
+
+[project.urls]
+Homepage = "https://github.com/SlickQuant/slick-stream-buffer-py"
+Documentation = "https://github.com/SlickQuant/slick-stream-buffer-py#readme"
+Repository = "https://github.com/SlickQuant/slick-stream-buffer-py"
+"Bug Tracker" = "https://github.com/SlickQuant/slick-stream-buffer-py/issues"
+
+[tool.setuptools]
+py-modules = ["slick_stream_buffer_py", "ssb_atomic_ops"]
+
+[tool.setuptools.dynamic]
+version = {attr = "slick_stream_buffer_py.__version__"}
+
+[tool.cibuildwheel]
+# Build for CPython 3.8-3.14
+build = "cp38-* cp39-* cp310-* cp311-* cp312-* cp313-* cp314-*"
+# Skip musllinux builds (only build manylinux for Linux)
+skip = "*-musllinux_*"
+
+# Test the wheels after building
+test-command = "python -c \"import slick_stream_buffer_py; import ssb_atomic_ops; print('Import successful')\""
+test-requires = []
+
+# Build settings
+build-verbosity = 1
+
+# Platform-specific settings
+[tool.cibuildwheel.linux]
+archs = ["x86_64"]
+# Use manylinux2014 for compatibility (RHEL 7+, Ubuntu 14.04+, Debian 8+)
+manylinux-x86_64-image = "manylinux2014"
+
+[tool.cibuildwheel.windows]
+archs = ["AMD64"]
+
+[tool.cibuildwheel.macos]
+archs = ["universal2"]

slick_stream_buffer_py-0.1.0/requirements.txt

@@ -0,0 +1,2 @@
+# No runtime dependencies (Python 3.8+ standard library only)
+# multiprocessing.shared_memory is included in Python 3.8+

slick_stream_buffer_py-0.1.0/setup.cfg

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