slick-queue-py 1.0.0__cp312-cp312-win_amd64.whl → 1.1.0__cp312-cp312-win_amd64.whl

{slick_queue_py-1.0.0.dist-info → slick_queue_py-1.1.0.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
-Name: slick_queue_py
-Version: 1.0.0
+Name: slick-queue-py
+Version: 1.1.0
 Summary: Lock-free MPMC queue with C++ interoperability via shared memory
-Home-page: https://github.com/SlickQuant/slick_queue_py
+Home-page: https://github.com/SlickQuant/slick-queue-py
 Author: Slick Quant
 Author-email: Slick Quant <slickquant@slickquant.com>
 License: MIT
-Project-URL: Homepage, https://github.com/SlickQuant/slick_queue_py
-Project-URL: Documentation, https://github.com/SlickQuant/slick_queue_py#readme
-Project-URL: Repository, https://github.com/SlickQuant/slick_queue_py
-Project-URL: Bug Tracker, https://github.com/SlickQuant/slick_queue_py/issues
+Project-URL: Homepage, https://github.com/SlickQuant/slick-queue-py
+Project-URL: Documentation, https://github.com/SlickQuant/slick-queue-py#readme
+Project-URL: Repository, https://github.com/SlickQuant/slick-queue-py
+Project-URL: Bug Tracker, https://github.com/SlickQuant/slick-queue-py/issues
 Keywords: queue,lock-free,atomic,shared-memory,ipc,multiprocessing,mpmc
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -34,11 +34,15 @@ Dynamic: home-page
 Dynamic: license-file
 Dynamic: requires-python
 
-# slick_queue_py
+# slick-queue-py
 
 Python implementation of SlickQueue - a lock-free multi-producer multi-consumer (MPMC) queue with C++ interoperability through shared memory.
 
-This is the Python binding for the [SlickQueue C++ library](https://github.com/SlickQuant/slick_queue). The Python implementation maintains exact binary compatibility with the C++ version, enabling seamless interprocess communication between Python and C++ applications.
+This is the Python binding for the [SlickQueue C++ library](https://github.com/SlickQuant/slick-queue). The Python implementation maintains exact binary compatibility with the C++ version, enabling seamless interprocess communication between Python and C++ applications.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/SlickQuant/slick-queue_py/actions/workflows/ci.yml/badge.svg)](https://github.com/SlickQuant/slick-queue-py/actions/workflows/ci.yml)
+[![GitHub release](https://img.shields.io/github/v/release/SlickQuant/slick-queue-py)](https://github.com/SlickQuant/slick-queue-py/releases)
 
 ## Features
 
@@ -172,7 +176,7 @@ def consumer_worker(q, cursor, worker_id, results):
     items_processed = 0
     while True:
         # Atomically claim next item (work-stealing)
-        data, size = q.read(cursor)
+        data, size, index = q.read(cursor)
 
         if data is None:
             break  # No more data
@@ -228,7 +232,7 @@ def consumer_worker(queue_name, cursor_name, worker_id):
     items_processed = 0
     while True:
         # Atomically claim next item (work-stealing)
-        data, size = q.read(cursor)
+        data, size, index = q.read(cursor)
 
         if data is None:
             break  # No more data
@@ -273,7 +277,7 @@ q.unlink()
 
 ### C++/Python Interoperability
 
-The Python implementation is fully compatible with the C++ [SlickQueue](https://github.com/SlickQuant/slick_queue) library. Python and C++ processes can produce and consume from the same queue with:
+The Python implementation is fully compatible with the C++ [SlickQueue](https://github.com/SlickQuant/slick-queue) library. Python and C++ processes can produce and consume from the same queue with:
 
 - **Exact memory layout compatibility**: Binary-compatible with `slick::SlickQueue<T>`
 - **Atomic operation compatibility**: Same 16-byte and 8-byte CAS semantics
@@ -329,10 +333,10 @@ To use the C++ SlickQueue library with your Python queues:
 
 ```bash
 # Clone the C++ library
-git clone https://github.com/SlickQuant/slick_queue.git
+git clone https://github.com/SlickQuant/slick-queue.git
 
 # Build your C++ program
-g++ -std=c++17 -I slick_queue/include my_program.cpp -o my_program
+g++ -std=c++17 -I slick-queue/include my_program.cpp -o my_program
 ```
 
 Or use CMake (see [CMakeLists.txt](CMakeLists.txt) for reference):
@@ -340,14 +344,14 @@ Or use CMake (see [CMakeLists.txt](CMakeLists.txt) for reference):
 ```cmake
 include(FetchContent)
 FetchContent_Declare(
-    slick_queue
-    GIT_REPOSITORY https://github.com/SlickQuant/slick_queue.git
+    slick-queue
+    GIT_REPOSITORY https://github.com/SlickQuant/slick-queue.git
     GIT_TAG main
 )
-FetchContent_MakeAvailable(slick_queue)
+FetchContent_MakeAvailable(slick-queue)
 
 add_executable(my_program my_program.cpp)
-target_link_libraries(my_program PRIVATE slick_queue)
+target_link_libraries(my_program PRIVATE slick::queue)
 ```
 
 See [tests/test_interop.py](tests/test_interop.py) and [tests/cpp_*.cpp](tests/) for comprehensive examples.
@@ -436,7 +440,7 @@ data, size, read_index = q.read(read_index)
 # Python multi-consumer (atomic cursor)
 from slick_queue_py import AtomicCursor
 cursor = AtomicCursor(cursor_shm.buf, 0)
-data, size = q.read(cursor)  # Atomically claim next item
+data, size, index = q.read(cursor)  # Atomically claim next item
 
 # C++ (updates by reference for both)
 auto [data, size] = queue.read(read_index);  // read_index modified in-place
@@ -463,7 +467,7 @@ cursor.store(0)
 
 # Multiple threads can share this cursor
 while True:
-    data, size = q.read(cursor)  # Each thread atomically claims items
+    data, size, index = q.read(cursor)  # Each thread atomically claims items
     if data is not None:
         process(data)
 ```
@@ -480,17 +484,26 @@ cursor.store(0)
 
 # Multiple processes can share this cursor
 while True:
-    data, size = q.read(cursor)  # Each process atomically claims items
+    data, size, index = q.read(cursor)  # Each process atomically claims items
     if data is not None:
         process(data)
 ```
 
-#### `read_last() -> Optional[bytes]`
+#### `read_last() -> Tuple[Optional[bytes], int]`
 
 Read the most recently published item.
 
 **Returns:**
-- `Optional[bytes]`: Last published data or None
+- `Tuple[Optional[bytes], int]`: Tuple of (data, size)
+  - `data`: Last published data or None if queue is empty
+  - `size`: Number of slots the item occupies (0 if queue is empty)
+
+**Example:**
+```python
+data, size = q.read_last()
+if data is not None:
+    print(f"Last item: {data[:size * element_size]}")
+```
 
 #### `__getitem__(index) -> memoryview`
 
@@ -596,37 +609,39 @@ Offset | Size          | Content
 ## Platform Support
 
 ### Fully Supported (Lock-Free)
-- **Windows x86-64**: Uses native C++ extension (`atomic_ops_ext.pyd`) with MSVC intrinsics
-- **Linux x86-64**: Uses `libatomic` directly via ctypes (no extension needed)
-- **macOS x86-64**: Uses `libatomic` directly via ctypes (no extension needed)
+- **Windows x86-64**: Uses C++ extension (`atomic_ops_ext.pyd`) with `std::atomic`
+- **Linux x86-64**: Uses C++ extension (`atomic_ops_ext.so`) with `std::atomic`, fallback to `libatomic`
+- **macOS x86-64**: Uses C++ extension (`atomic_ops_ext.so`) with `std::atomic`, fallback to compiler builtins
 
 **Platform-specific atomic operation implementations:**
-- **Windows**: Requires building the `atomic_ops_ext` C++ extension (uses `std::atomic`)
-- **Linux/macOS**: Uses `libatomic` library directly via ctypes (uses `__sync_val_compare_and_swap_8`)
+- **All platforms**: The `atomic_ops_ext` C++ extension is now used on all platforms for the most reliable cross-process atomic operations
+- **Fallback support**: Linux/macOS can fall back to `libatomic` or compiler builtins if the extension isn't available
 
-### Building the Windows Extension
+### Building and Installation
 
-On Windows, the native extension is required for lock-free multi-producer support:
+The C++ extension is built automatically during installation:
 
 ```bash
-# Install build dependencies
-pip install setuptools wheel
+# Install with automatic extension build
+pip install -e .
 
-# Build and install the extension
+# Or build manually first
 python setup.py build_ext --inplace
-
-# Or install in development mode (builds automatically)
 pip install -e .
 ```
 
-**Windows requirements:**
-- Visual Studio 2017+ or MSVC build tools
-- Python development headers (included with standard Python installation)
+**Build requirements:**
+- **Windows**: Visual Studio 2017+ or MSVC build tools
+- **Linux**: GCC 5+ or Clang 3.8+
+- **macOS**: Xcode command line tools (clang)
+- **All platforms**: Python development headers (included with standard Python installation)
 
-The extension will be built as `atomic_ops_ext.cp312-win_amd64.pyd` (or similar based on Python version).
+The extension will be built as:
+- Windows: `atomic_ops_ext.cp3XX-win_amd64.pyd`
+- Linux: `atomic_ops_ext.cpython-3XX-x86_64-linux-gnu.so`
+- macOS: `atomic_ops_ext.cpython-3XX-darwin.so`
 
-**Linux/macOS:**
-No build step required! The `libatomic` library is typically included with GCC/Clang toolchains and is automatically loaded via ctypes.
+(where `XX` is your Python version, e.g., `312` for Python 3.12)
 
 ### Requirements for Lock-Free Operation
 
@@ -796,7 +811,7 @@ This ensures:
 
 ## Contributing
 
-Issues and pull requests welcome at [SlickQuant/slick_queue_py](https://github.com/SlickQuant/slick_queue_py).
+Issues and pull requests welcome at [SlickQuant/slick-queue-py](https://github.com/SlickQuant/slick-queue-py).
 
 ## License
 

slick_queue_py-1.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+atomic_ops.py,sha256=IowoYaE_y0QmPjrc36gggXXnZrPQXlOk_DEO-98y0kI,22206
+atomic_ops_ext.cp312-win_amd64.pyd,sha256=fjVTEjSU3eVs_0XFVdKE1yA3k9rxfFqiQREpZ-qzBAo,12800
+slick_queue_py.py,sha256=w3Ut0j7RIfbQfzyLaH4nnimVnLY-Bn1KctT-Ta4GNhk,31015
+slick_queue_py-1.1.0.dist-info/licenses/LICENSE,sha256=GsgPE6yHSgjPd--0cXVu4tmzSrApWVih5TeqOHpVeo0,1089
+slick_queue_py-1.1.0.dist-info/METADATA,sha256=QJTwXP_-Pcwe6WvI48oUboDt3f6txPpcV2nNTzoTx-4,25965
+slick_queue_py-1.1.0.dist-info/WHEEL,sha256=4SIlGrTWEevUMa-6zmQ9aBHcYatnnG9aOHYILIJiCXU,102
+slick_queue_py-1.1.0.dist-info/top_level.txt,sha256=wSnL-GmRhMTtudT__dLgRw5eZUU_XHo2OZTOP3M1MwA,41
+slick_queue_py-1.1.0.dist-info/RECORD,,

{slick_queue_py-1.0.0.dist-info → slick_queue_py-1.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64