slick-stream-buffer-multiplexer-py 0.1.0__tar.gz

slick_stream_buffer_multiplexer_py-0.1.0/API_DIFFERENCES.md

@@ -0,0 +1,78 @@
+# API Differences: Python vs C++
+
+The Python implementation is binary-compatible with the C++
+`slick::stream_buffer_multiplexer` at the shared memory level — the shared record queue
+('SLQ1', 16-byte elements) and every producer segment ('SSB1') match byte-for-byte. The
+*language-level* API differs in the following ways.
+
+## Construction
+
+| C++ | Python |
+|---|---|
+| `stream_buffer_multiplexer mux(size)` | `StreamBufferMultiplexer(shared_queue_size=size)` |
+| `stream_buffer_multiplexer mux(size, "name")` | `StreamBufferMultiplexer(shared_queue_size=size, name="name")` |
+| `stream_buffer_multiplexer mux("name")` | `StreamBufferMultiplexer(name="name")` |
+| `add_producer(id, cap, ctl)` | `add_producer(id, capacity=cap, control_size=ctl)` |
+| `add_producer(id, cap, ctl, "name")` | `add_producer(id, capacity=cap, control_size=ctl, name="name")` |
+| `add_producer(id, "name")` | `add_producer(id, name="name")` |
+| throws `std::invalid_argument` (duplicate id, bad sizes) | raises `ValueError` |
+| throws `std::runtime_error` (shm failures) | raises `RuntimeError`, `ValueError` (queue geometry mismatch), or `FileNotFoundError` (missing segment) |
+
+## Consumer cursor is passed by value
+
+```cpp
+// C++
+uint64_t cursor = 0;
+auto rec = mux.read(cursor);              // cursor updated in place
+```
+
+```python
+# Python
+cursor = 0
+rec, cursor = mux.read(cursor)            # updated cursor returned
+```
+
+For the work-stealing overload, pass an `AtomicCursor` (from slick-queue-py); the second
+return value is then the claimed shared-queue index (`-1` when nothing was available):
+
+```python
+rec, idx = mux.read(shared_cursor)
+```
+
+## Zero-copy vs copies
+
+Same policy as slick-stream-buffer-py: `prepare()` and `data()` return zero-copy
+memoryviews into the producer's ring; `read()` results (`MultiplexRecord.data`) and
+`consume()` results are **bytes copies**, safe by default under the lossy overwrite
+semantics.
+
+## Producer buffer accessors
+
+C++ exposes both `stream_buffer()` (reference) and `stream_buffer_ptr()`
+(`std::shared_ptr`); Python has no owning/non-owning distinction, so there is a single
+`producer.stream_buffer` property returning the underlying `SlickStreamBuffer`.
+Similarly, `get_producer_buffer()` and `find_producer()` both return the same
+`ProducerBuffer` object (or `None`).
+
+## Producer lookup
+
+C++ uses a dense vector for producer ids < 4096 with a hash-map fallback; Python uses a
+plain dict for all ids (already O(1) — the dense-path micro-optimization is meaningless
+in Python).
+
+## loss_count()
+
+C++ compiles the multiplexer-level counter out unless
+`SLICK_STREAM_BUFFER_MULTIPLEXER_ENABLE_LOSS_DETECTION` is enabled (debug default);
+Python always counts. Same for the shared queue's wrap-loss term (slick-queue-py always
+counts). All counters are per-instance, not shared through the segments.
+
+## Lifecycle
+
+Python adds explicit lifecycle management that C++ handles via RAII:
+
+- `close()` — detach from all producer segments and the queue segment
+- `unlink()` — delete the queue segment and all registered producers' segments
+- context manager support: `with StreamBufferMultiplexer(...) as mux: ...`
+- `get_shm_name()` — on the multiplexer (queue segment) and on each `ProducerBuffer`,
+  the exact names to pass to C++ (`/`-prefixed on POSIX)

slick_stream_buffer_multiplexer_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_multiplexer_py-0.1.0/MANIFEST.in

@@ -0,0 +1,26 @@
+# Include documentation
+include README.md
+include LICENSE
+include API_DIFFERENCES.md
+
+# Include packaging files
+include setup.py
+include pyproject.toml
+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_multiplexer_py-0.1.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: slick-stream-buffer-multiplexer-py
+Version: 0.1.0
+Summary: Lock-free MPMC byte stream multiplexer with C++ interoperability via shared memory
+Home-page: https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py
+Author: Slick Quant
+Author-email: Slick Quant <slickquant@slickquant.com>
+License: MIT
+Project-URL: Homepage, https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py
+Project-URL: Documentation, https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py#readme
+Project-URL: Repository, https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py
+Project-URL: Bug Tracker, https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py/issues
+Keywords: stream-buffer,multiplexer,lock-free,atomic,shared-memory,ipc,multiprocessing,mpmc
+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: 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
+Requires-Dist: slick-queue-py>=1.2.0
+Requires-Dist: slick-stream-buffer-py>=0.1.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# slick-stream-buffer-multiplexer-py
+
+A Python implementation of [slick-stream-buffer-multiplexer](https://github.com/SlickQuant/slick-stream-buffer-multiplexer) —
+a lock-free multi-producer multi-consumer (MPMC) byte stream multiplexer with shared memory support.
+
+**Maintains exact binary compatibility with the C++ version**: Python and C++ producers and
+consumers can be mixed freely across processes, fanning into the same shared memory segments.
+
+## Concept
+
+Each producer owns its own [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer)
+(an independently-sized byte ring with per-producer lap/loss detection). `consume()` additionally
+publishes a small 16-byte `{sequence, producer_id}` record into one shared
+[slick-queue](https://github.com/SlickQuant/slick-queue), which acts as the lock-free MPMC
+fan-in / global ordering point. Consumers read from the shared queue and dereference each record
+back into the matching producer's buffer.
+
+```
+Producer A ──prepare/commit/consume──▶ [StreamBuffer A] ──┐
+Producer B ──prepare/commit/consume──▶ [StreamBuffer B] ──┼─▶ {sequence, producer_id}
+Producer N ──prepare/commit/consume──▶ [StreamBuffer N] ──┘        16-byte records
+                                                                         │
+                                                              [shared SlickQueue]
+                                                                         │
+                                          consumers read(cursor) and dereference
+                                          into StreamBuffer[producer_id]
+```
+
+Producers and the shared queue each independently choose local memory or shared memory (IPC).
+A cross-process consumer only registers the producer ids whose shared memory it can access;
+records referencing other producer ids are silently skipped (not counted as loss).
+
+## Requirements
+
+- Python 3.8+
+- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) >= 1.2.0
+- [slick-stream-buffer-py](https://github.com/SlickQuant/slick-stream-buffer-py) >= 0.1.0
+
+Both dependencies bundle a small C++ extension for `std::atomic` operations; this package itself
+is pure Python.
+
+## Installation
+
+```bash
+pip install slick-queue-py slick-stream-buffer-py
+pip install -e .
+```
+
+## Quick Start
+
+### Producers (any process, any language)
+
+```python
+from slick_stream_buffer_multiplexer_py import StreamBufferMultiplexer
+
+# create the shared record queue (the fan-in ordering point)
+mux = StreamBufferMultiplexer(shared_queue_size=1 << 16, name="mux_records")
+
+# each producer gets its own independently-sized stream buffer
+feed_a = mux.add_producer(0, capacity=1 << 26, control_size=1 << 16, name="feed_a")
+feed_b = mux.add_producer(1, capacity=1 << 20, control_size=1 << 10, name="feed_b")
+
+mv = feed_a.prepare(64 * 1024)     # contiguous writable memoryview (zero-copy)
+n = sock.recv_into(mv)             # write network bytes directly into the ring
+feed_a.commit(n)
+feed_a.consume(n)                  # publish as ONE message + fan into the shared queue
+```
+
+### Consumer (opens everything created elsewhere — Python or C++)
+
+```python
+mux = StreamBufferMultiplexer(name="mux_records")     # open the shared record queue
+mux.add_producer(0, name="feed_a")                    # register the producers to follow
+mux.add_producer(1, name="feed_b")                    # (geometry read from each header)
+
+cursor = mux.initial_reading_index()                  # or 0 to read history
+while True:
+    rec, cursor = mux.read(cursor)
+    if not rec:
+        continue
+    handle_message(rec.producer_id, rec.data, rec.length)
+```
+
+### Work-stealing consumers (each message to exactly one consumer)
+
+```python
+from slick_stream_buffer_multiplexer_py import AtomicCursor
+from multiprocessing.shared_memory import SharedMemory
+
+cursor_shm = SharedMemory(name="mux_cursor", create=True, size=8)
+shared_cursor = AtomicCursor(cursor_shm.buf, 0)
+
+rec, idx = mux.read(shared_cursor)   # atomically claims the next message
+```
+
+## Three Loss Counters
+
+| Counter | Meaning |
+|---|---|
+| `mux.loss_count()` | shared-queue wrap loss **plus** multiplexer-level loss (registered producers lapped before dereference) |
+| `producer.loss_count()` | that producer's own inner-ring loss |
+| unregistered producer ids | **never counted** — silently skipped |
+
+## C++ Interoperability
+
+The C++ side composes the identical primitives — either language can create any segment:
+
+```cpp
+#include <slick/stream_buffer_multiplexer.hpp>
+
+slick::stream_buffer_multiplexer mux("mux_records");   // open queue created by Python
+auto feed = mux.add_producer(0, "feed_a");             // open Python's producer segment
+
+uint64_t cursor = mux.initial_reading_index();
+for (;;) {
+    auto rec = mux.read(cursor);
+    if (!rec) continue;
+    handle_message(rec.producer_id, rec.data, rec.length);
+}
+```
+
+Use `get_shm_name()` on the multiplexer (queue segment) and each producer buffer to get the
+exact names to pass to C++ (POSIX names include the required leading `/`).
+
+### Binary layout
+
+The multiplexer adds no shared-memory structures of its own:
+
+- The shared queue is a standard slick-queue segment (`'SLQ1'`, `element_size=16`) whose
+  elements are `uint64 sequence | uint32 producer_id | uint32 pad0`
+- Each producer buffer is a standard slick-stream-buffer segment (`'SSB1'`)
+
+## Caveats (same as C++)
+
+- `add_producer()` is single-threaded setup: call it before producer/consumer threads start.
+- Each producer's `prepare/commit/consume/...` must be called from a single thread.
+- Lossy semantics: slow consumers skip overwritten data (see the loss counters above).
+- A single message (one `consume()` call) is limited to < 4 GiB.
+
+See [API_DIFFERENCES.md](API_DIFFERENCES.md) for exact deviations from the C++ API.
+
+## Building and Testing
+
+```bash
+# Pure-Python tests (sibling repos slick-queue-py / slick-stream-buffer-py are
+# picked up automatically from ../ if not pip-installed)
+python tests/test_multiplexer.py
+python tests/test_multiplexer_mpmc.py
+python tests/test_multiplexer_shm.py
+
+# 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-multiplexer (which pulls slick-stream-buffer,
+slick-queue, and slick-shm) from GitHub and build real C++ producer/consumer binaries against
+the actual header. To build against local checkouts instead (no network):
+
+```bash
+cmake -S . -B build \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-STREAM-BUFFER-MULTIPLEXER=/path/to/slick-stream-buffer-multiplexer \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-STREAM-BUFFER=/path/to/slick-stream-buffer \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-QUEUE=/path/to/slick-queue \
+  -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-multiplexer](https://github.com/SlickQuant/slick-stream-buffer-multiplexer) — the C++ implementation
+- [slick-stream-buffer-py](https://github.com/SlickQuant/slick-stream-buffer-py) / [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer) — the per-producer SPMC byte stream buffer
+- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) / [slick-queue](https://github.com/SlickQuant/slick-queue) — the shared MPMC record queue
+
+## License
+
+MIT

slick_stream_buffer_multiplexer_py-0.1.0/README.md

@@ -0,0 +1,179 @@
+# slick-stream-buffer-multiplexer-py
+
+A Python implementation of [slick-stream-buffer-multiplexer](https://github.com/SlickQuant/slick-stream-buffer-multiplexer) —
+a lock-free multi-producer multi-consumer (MPMC) byte stream multiplexer with shared memory support.
+
+**Maintains exact binary compatibility with the C++ version**: Python and C++ producers and
+consumers can be mixed freely across processes, fanning into the same shared memory segments.
+
+## Concept
+
+Each producer owns its own [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer)
+(an independently-sized byte ring with per-producer lap/loss detection). `consume()` additionally
+publishes a small 16-byte `{sequence, producer_id}` record into one shared
+[slick-queue](https://github.com/SlickQuant/slick-queue), which acts as the lock-free MPMC
+fan-in / global ordering point. Consumers read from the shared queue and dereference each record
+back into the matching producer's buffer.
+
+```
+Producer A ──prepare/commit/consume──▶ [StreamBuffer A] ──┐
+Producer B ──prepare/commit/consume──▶ [StreamBuffer B] ──┼─▶ {sequence, producer_id}
+Producer N ──prepare/commit/consume──▶ [StreamBuffer N] ──┘        16-byte records
+                                                                         │
+                                                              [shared SlickQueue]
+                                                                         │
+                                          consumers read(cursor) and dereference
+                                          into StreamBuffer[producer_id]
+```
+
+Producers and the shared queue each independently choose local memory or shared memory (IPC).
+A cross-process consumer only registers the producer ids whose shared memory it can access;
+records referencing other producer ids are silently skipped (not counted as loss).
+
+## Requirements
+
+- Python 3.8+
+- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) >= 1.2.0
+- [slick-stream-buffer-py](https://github.com/SlickQuant/slick-stream-buffer-py) >= 0.1.0
+
+Both dependencies bundle a small C++ extension for `std::atomic` operations; this package itself
+is pure Python.
+
+## Installation
+
+```bash
+pip install slick-queue-py slick-stream-buffer-py
+pip install -e .
+```
+
+## Quick Start
+
+### Producers (any process, any language)
+
+```python
+from slick_stream_buffer_multiplexer_py import StreamBufferMultiplexer
+
+# create the shared record queue (the fan-in ordering point)
+mux = StreamBufferMultiplexer(shared_queue_size=1 << 16, name="mux_records")
+
+# each producer gets its own independently-sized stream buffer
+feed_a = mux.add_producer(0, capacity=1 << 26, control_size=1 << 16, name="feed_a")
+feed_b = mux.add_producer(1, capacity=1 << 20, control_size=1 << 10, name="feed_b")
+
+mv = feed_a.prepare(64 * 1024)     # contiguous writable memoryview (zero-copy)
+n = sock.recv_into(mv)             # write network bytes directly into the ring
+feed_a.commit(n)
+feed_a.consume(n)                  # publish as ONE message + fan into the shared queue
+```
+
+### Consumer (opens everything created elsewhere — Python or C++)
+
+```python
+mux = StreamBufferMultiplexer(name="mux_records")     # open the shared record queue
+mux.add_producer(0, name="feed_a")                    # register the producers to follow
+mux.add_producer(1, name="feed_b")                    # (geometry read from each header)
+
+cursor = mux.initial_reading_index()                  # or 0 to read history
+while True:
+    rec, cursor = mux.read(cursor)
+    if not rec:
+        continue
+    handle_message(rec.producer_id, rec.data, rec.length)
+```
+
+### Work-stealing consumers (each message to exactly one consumer)
+
+```python
+from slick_stream_buffer_multiplexer_py import AtomicCursor
+from multiprocessing.shared_memory import SharedMemory
+
+cursor_shm = SharedMemory(name="mux_cursor", create=True, size=8)
+shared_cursor = AtomicCursor(cursor_shm.buf, 0)
+
+rec, idx = mux.read(shared_cursor)   # atomically claims the next message
+```
+
+## Three Loss Counters
+
+| Counter | Meaning |
+|---|---|
+| `mux.loss_count()` | shared-queue wrap loss **plus** multiplexer-level loss (registered producers lapped before dereference) |
+| `producer.loss_count()` | that producer's own inner-ring loss |
+| unregistered producer ids | **never counted** — silently skipped |
+
+## C++ Interoperability
+
+The C++ side composes the identical primitives — either language can create any segment:
+
+```cpp
+#include <slick/stream_buffer_multiplexer.hpp>
+
+slick::stream_buffer_multiplexer mux("mux_records");   // open queue created by Python
+auto feed = mux.add_producer(0, "feed_a");             // open Python's producer segment
+
+uint64_t cursor = mux.initial_reading_index();
+for (;;) {
+    auto rec = mux.read(cursor);
+    if (!rec) continue;
+    handle_message(rec.producer_id, rec.data, rec.length);
+}
+```
+
+Use `get_shm_name()` on the multiplexer (queue segment) and each producer buffer to get the
+exact names to pass to C++ (POSIX names include the required leading `/`).
+
+### Binary layout
+
+The multiplexer adds no shared-memory structures of its own:
+
+- The shared queue is a standard slick-queue segment (`'SLQ1'`, `element_size=16`) whose
+  elements are `uint64 sequence | uint32 producer_id | uint32 pad0`
+- Each producer buffer is a standard slick-stream-buffer segment (`'SSB1'`)
+
+## Caveats (same as C++)
+
+- `add_producer()` is single-threaded setup: call it before producer/consumer threads start.
+- Each producer's `prepare/commit/consume/...` must be called from a single thread.
+- Lossy semantics: slow consumers skip overwritten data (see the loss counters above).
+- A single message (one `consume()` call) is limited to < 4 GiB.
+
+See [API_DIFFERENCES.md](API_DIFFERENCES.md) for exact deviations from the C++ API.
+
+## Building and Testing
+
+```bash
+# Pure-Python tests (sibling repos slick-queue-py / slick-stream-buffer-py are
+# picked up automatically from ../ if not pip-installed)
+python tests/test_multiplexer.py
+python tests/test_multiplexer_mpmc.py
+python tests/test_multiplexer_shm.py
+
+# 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-multiplexer (which pulls slick-stream-buffer,
+slick-queue, and slick-shm) from GitHub and build real C++ producer/consumer binaries against
+the actual header. To build against local checkouts instead (no network):
+
+```bash
+cmake -S . -B build \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-STREAM-BUFFER-MULTIPLEXER=/path/to/slick-stream-buffer-multiplexer \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-STREAM-BUFFER=/path/to/slick-stream-buffer \
+  -DFETCHCONTENT_SOURCE_DIR_SLICK-QUEUE=/path/to/slick-queue \
+  -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-multiplexer](https://github.com/SlickQuant/slick-stream-buffer-multiplexer) — the C++ implementation
+- [slick-stream-buffer-py](https://github.com/SlickQuant/slick-stream-buffer-py) / [slick-stream-buffer](https://github.com/SlickQuant/slick-stream-buffer) — the per-producer SPMC byte stream buffer
+- [slick-queue-py](https://github.com/SlickQuant/slick-queue-py) / [slick-queue](https://github.com/SlickQuant/slick-queue) — the shared MPMC record queue
+
+## License
+
+MIT

slick_stream_buffer_multiplexer_py-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "slick-stream-buffer-multiplexer-py"
+dynamic = ["version"]
+description = "Lock-free MPMC byte stream multiplexer 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", "multiplexer", "lock-free", "atomic", "shared-memory", "ipc", "multiprocessing", "mpmc"]
+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",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+]
+dependencies = [
+    "slick-queue-py>=1.2.0",
+    "slick-stream-buffer-py>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py"
+Documentation = "https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py#readme"
+Repository = "https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py"
+"Bug Tracker" = "https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py/issues"
+
+[tool.setuptools]
+py-modules = ["slick_stream_buffer_multiplexer_py"]
+
+[tool.setuptools.dynamic]
+version = {attr = "slick_stream_buffer_multiplexer_py.__version__"}

slick_stream_buffer_multiplexer_py-0.1.0/requirements.txt

@@ -0,0 +1,3 @@
+# Runtime dependencies (binary-compatible Python ports of the C++ dependencies)
+slick-queue-py>=1.2.0
+slick-stream-buffer-py>=0.1.0

slick_stream_buffer_multiplexer_py-0.1.0/setup.cfg

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

slick_stream_buffer_multiplexer_py-0.1.0/setup.py

@@ -0,0 +1,60 @@
+from setuptools import setup
+import re
+from pathlib import Path
+
+# Read version from slick_stream_buffer_multiplexer_py.py
+def get_version():
+    with open('slick_stream_buffer_multiplexer_py.py', 'r', encoding='utf-8') as f:
+        content = f.read()
+        match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", content, re.M)
+        if match:
+            return match.group(1)
+        raise RuntimeError("Unable to find version string.")
+
+# Read long description from README
+def get_long_description():
+    readme_path = Path(__file__).parent / 'README.md'
+    if readme_path.exists():
+        with open(readme_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    return ''
+
+setup(
+    name='slick-stream-buffer-multiplexer-py',
+    version=get_version(),
+    description='Lock-free MPMC byte stream multiplexer with C++ interoperability via shared memory',
+    long_description=get_long_description(),
+    long_description_content_type='text/markdown',
+    author='Slick Quant',
+    author_email='slickquant@slickquant.com',
+    url='https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py',
+    project_urls={
+        'Bug Tracker': 'https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py/issues',
+        'Documentation': 'https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py#readme',
+        'Source Code': 'https://github.com/SlickQuant/slick-stream-buffer-multiplexer-py',
+    },
+    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',
+        'Operating System :: Microsoft :: Windows',
+        'Operating System :: POSIX :: Linux',
+        'Operating System :: MacOS',
+    ],
+    keywords='stream-buffer, multiplexer, lock-free, atomic, shared-memory, ipc, multiprocessing, mpmc',
+    py_modules=['slick_stream_buffer_multiplexer_py'],
+    install_requires=[
+        'slick-queue-py>=1.2.0',
+        'slick-stream-buffer-py>=0.1.0',
+    ],
+    python_requires='>=3.8',
+    license='MIT',
+)

slick_stream_buffer_multiplexer_py-0.1.0/slick_stream_buffer_multiplexer_py.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+API_DIFFERENCES.md
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+slick_stream_buffer_multiplexer_py.py
+tests/test_interop.py
+tests/test_multiplexer.py
+tests/test_multiplexer_mpmc.py
+tests/test_multiplexer_shm.py