fastqueue-lib 0.0.17__tar.gz → 0.0.18__tar.gz

{fastqueue-lib-0.0.17/fastqueue_lib.egg-info → fastqueue_lib-0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fastqueue-lib
-Version: 0.0.17
+Version: 0.0.18
 Summary: Fast single ended queue library for python
 Author-email: Matthew Taylor <matthew.taylor.andre@gmail.com>
 Project-URL: Homepage, https://github.com/MatthewAndreTaylor/fastqueue
@@ -26,6 +26,7 @@ Requires-Dist: numpy; extra == "examples"
 Requires-Dist: pandas; extra == "examples"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
+Dynamic: license-file
 
 # fastqueue
 
@@ -43,7 +44,7 @@ Single-ended fast queues built in C tuned for Python.
 
 ## Installation
 
-To install fastqueue, using pip:
+To install fastqueue, using [pip](https://pypi.org/project/fastqueue-lib): 
 
 ```bash
 pip install fastqueue-lib
@@ -97,9 +98,6 @@ True
 ['🚒', '🛴', '🚅', '🚗']
 ```
 
-Another alternative is `fastqueue.LockQueue()` which supports all queue operations.
-`fastqueue.LockQueue()` is built as a thread-safe alternative to the other queue types.
-
 ## Example Benchmarks
 
 ### Queue operations

{fastqueue-lib-0.0.17 → fastqueue_lib-0.0.18}/README.md

@@ -14,7 +14,7 @@ Single-ended fast queues built in C tuned for Python.
 
 ## Installation
 
-To install fastqueue, using pip:
+To install fastqueue, using [pip](https://pypi.org/project/fastqueue-lib): 
 
 ```bash
 pip install fastqueue-lib
@@ -68,9 +68,6 @@ True
 ['🚒', '🛴', '🚅', '🚗']
 ```
 
-Another alternative is `fastqueue.LockQueue()` which supports all queue operations.
-`fastqueue.LockQueue()` is built as a thread-safe alternative to the other queue types.
-
 ## Example Benchmarks
 
 ### Queue operations

fastqueue_lib-0.0.18/fastqueue/__init__.py

@@ -0,0 +1,3 @@
+__all__ = "Queue", "QueueC"
+
+from _fastqueue import Queue, QueueC

fastqueue_lib-0.0.18/fastqueue/__init__.pyi

@@ -0,0 +1,39 @@
+"""
+fastqueue
+=====
+
+* Queue
+* QueueC
+
+"""
+from typing import Any, Optional
+from collections.abc import Iterable
+from typing_extensions import Self
+
+__all__ = "Queue", "QueueC"
+
+class Queue:
+    def __init__(self, iterable: Optional[Iterable] = None) -> None: ...
+    def enqueue(self, item: Any) -> None: ...
+    def dequeue(self) -> Any: ...
+    def extend(self, items: Iterable[Any]) -> None: ...
+    def clear(self) -> None: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, index: int) -> Any: ...
+    def __setitem__(self, index: int, item: Any) -> None: ...
+    def __contains__(self, item: Any) -> bool: ...
+    def copy(self) -> Self: ...
+    def __copy__(self) -> Self: ...
+
+class QueueC:
+    def __init__(self, iterable: Optional[Iterable] = None) -> None: ...
+    def enqueue(self, item: Any) -> None: ...
+    def dequeue(self) -> Any: ...
+    def extend(self, items: Iterable[Any]) -> None: ...
+    def clear(self) -> None: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, index: int) -> Any: ...
+    def __setitem__(self, index: int, item: Any) -> None: ...
+    def __contains__(self, item: Any) -> bool: ...
+    def copy(self) -> Self: ...
+    def __copy__(self) -> Self: ...

{fastqueue-lib-0.0.17 → fastqueue_lib-0.0.18}/fastqueue/prototypes.py

@@ -27,20 +27,21 @@ class LLNodeQueue(Structure):
 
 
 __libfile = Path(__file__).parent / "cllqueue.so"
-llqueue_lib = CDLL(str(__libfile))
+# Native calls own Python references and must keep the GIL.
+llqueue_lib = PyDLL(str(__libfile))
 
 llqueue_lib.new_node_queue.argtypes = []
 llqueue_lib.new_node_queue.restype = POINTER(LLNodeQueue)
 
-llqueue_lib.is_empty.argtypes = [POINTER(LLNodeQueue)]
-llqueue_lib.is_empty.restype = c_bool
-
 llqueue_lib.enqueue.argtypes = [POINTER(LLNodeQueue), py_object]
 llqueue_lib.enqueue.restype = None
 
 llqueue_lib.dequeue.argtypes = [POINTER(LLNodeQueue)]
 llqueue_lib.dequeue.restype = py_object
 
+llqueue_lib.clear_q.argtypes = [POINTER(LLNodeQueue)]
+llqueue_lib.clear_q.restype = None
+
 llqueue_lib.free_q.argtypes = [POINTER(LLNodeQueue)]
 llqueue_lib.free_q.restype = None
 
@@ -52,9 +53,6 @@ class LLQueue:
     def __init__(self):
         self.queue = llqueue_lib.new_node_queue()
 
-    def is_empty(self) -> bool:
-        return llqueue_lib.is_empty(self.queue)
-
     def __len__(self) -> int:
         return self.queue.contents.length
 
@@ -62,44 +60,43 @@ class LLQueue:
         llqueue_lib.enqueue(self.queue, item)
 
     def dequeue(self) -> Any:
-        if self.is_empty():
-            raise IndexError
         return llqueue_lib.dequeue(self.queue)
 
     def clear(self):
-        llqueue_lib.free_q(self.queue)
-        self.queue = llqueue_lib.new__queue()
+        llqueue_lib.clear_q(self.queue)
 
     def __del__(self):
-        llqueue_lib.free_q(self.queue)
+        queue = getattr(self, "queue", None)
+        self.queue = None
+        llqueue_lib.free_q(queue)
 
 
 # Matt's Contiguous Queue
 class ContiguousQueue(Structure):
     _fields_ = [
         ("objects", POINTER(py_object)),
-        ("length", c_int),
-        ("capacity", c_int),
-        ("front", c_int),
-        ("back", c_int),
+        ("length", c_size_t),
+        ("capacity", c_size_t),
+        ("front", c_size_t),
+        ("back", c_size_t),
     ]
 
 
 __libfile = Path(__file__).parent / "ccqueue.so"
-cqueue_lib = CDLL(str(__libfile))
+cqueue_lib = PyDLL(str(__libfile))
 
 cqueue_lib.new__queue.argtypes = []
 cqueue_lib.new__queue.restype = POINTER(ContiguousQueue)
 
-cqueue_lib.is_empty.argtypes = [POINTER(ContiguousQueue)]
-cqueue_lib.is_empty.restype = c_bool
-
 cqueue_lib.enqueue.argtypes = [POINTER(ContiguousQueue), py_object]
 cqueue_lib.enqueue.restype = None
 
 cqueue_lib.dequeue.argtypes = [POINTER(ContiguousQueue)]
 cqueue_lib.dequeue.restype = py_object
 
+cqueue_lib.clear_q.argtypes = [POINTER(ContiguousQueue)]
+cqueue_lib.clear_q.restype = None
+
 cqueue_lib.free_q.argtypes = [POINTER(ContiguousQueue)]
 cqueue_lib.free_q.restype = None
 
@@ -111,9 +108,6 @@ class ContQueue:
     def __init__(self):
         self.queue = cqueue_lib.new__queue()
 
-    def is_empty(self) -> bool:
-        return cqueue_lib.is_empty(self.queue)
-
     def __len__(self) -> int:
         return self.queue.contents.length
 
@@ -121,13 +115,12 @@ class ContQueue:
         cqueue_lib.enqueue(self.queue, item)
 
     def dequeue(self) -> Any:
-        if self.is_empty():
-            raise IndexError
         return cqueue_lib.dequeue(self.queue)
 
     def clear(self):
-        cqueue_lib.free_q(self.queue)
-        self.queue = cqueue_lib.new__queue()
+        cqueue_lib.clear_q(self.queue)
 
     def __del__(self):
-        cqueue_lib.free_q(self.queue)
+        queue = getattr(self, "queue", None)
+        self.queue = None
+        cqueue_lib.free_q(queue)

{fastqueue-lib-0.0.17 → fastqueue_lib-0.0.18/fastqueue_lib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fastqueue-lib
-Version: 0.0.17
+Version: 0.0.18
 Summary: Fast single ended queue library for python
 Author-email: Matthew Taylor <matthew.taylor.andre@gmail.com>
 Project-URL: Homepage, https://github.com/MatthewAndreTaylor/fastqueue
@@ -26,6 +26,7 @@ Requires-Dist: numpy; extra == "examples"
 Requires-Dist: pandas; extra == "examples"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
+Dynamic: license-file
 
 # fastqueue
 
@@ -43,7 +44,7 @@ Single-ended fast queues built in C tuned for Python.
 
 ## Installation
 
-To install fastqueue, using pip:
+To install fastqueue, using [pip](https://pypi.org/project/fastqueue-lib): 
 
 ```bash
 pip install fastqueue-lib
@@ -97,9 +98,6 @@ True
 ['🚒', '🛴', '🚅', '🚗']
 ```
 
-Another alternative is `fastqueue.LockQueue()` which supports all queue operations.
-`fastqueue.LockQueue()` is built as a thread-safe alternative to the other queue types.
-
 ## Example Benchmarks
 
 ### Queue operations

{fastqueue-lib-0.0.17 → fastqueue_lib-0.0.18}/fastqueue_lib.egg-info/SOURCES.txt

@@ -1,11 +1,12 @@
 LICENSE
 MANIFEST.in
 README.md
-fastqueue.py
 pyproject.toml
 setup.py
 fastqueue/__init__.py
+fastqueue/__init__.pyi
 fastqueue/prototypes.py
+fastqueue/py.typed
 fastqueue_lib.egg-info/PKG-INFO
 fastqueue_lib.egg-info/SOURCES.txt
 fastqueue_lib.egg-info/dependency_links.txt
@@ -14,4 +15,5 @@ fastqueue_lib.egg-info/top_level.txt
 src/ccqueue.cpp
 src/cllqueue.cpp
 src/fastqueue.c
+tests/test_memory.py
 tests/test_queue.py

{fastqueue-lib-0.0.17 → fastqueue_lib-0.0.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastqueue-lib"
-version = "0.0.17"
+version = "0.0.18"
 description="Fast single ended queue library for python"
 authors = [
     {name = "Matthew Taylor", email = "matthew.taylor.andre@gmail.com"},

fastqueue_lib-0.0.18/src/ccqueue.cpp

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2023 Matthew Andre Taylor
+ */
+#ifdef _WIN32
+#define QUEUE_LIBRARY_API extern "C" __declspec(dllexport)
+#else
+#define QUEUE_LIBRARY_API extern "C"
+#endif
+
+#include <Python.h>
+#include <stdlib.h>
+
+// Matt's C Contiguous Queue
+QUEUE_LIBRARY_API typedef struct queue {
+    PyObject** objects;
+    size_t length;
+    size_t capacity;
+    size_t front;
+    size_t back;
+} queue_t;
+
+QUEUE_LIBRARY_API queue_t* new__queue() {
+    queue_t* queue = (queue_t*)malloc(sizeof(queue_t));
+    if (queue == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    queue->length = 0;
+    queue->capacity = 256;
+    queue->front = 0;
+    queue->back = queue->capacity - 1;
+    queue->objects = (PyObject**)malloc(256 * sizeof(PyObject*));
+    if (queue->objects == NULL) {
+        free(queue);
+        PyErr_NoMemory();
+        return NULL;
+    }
+    return queue;
+}
+
+int resize(queue_t* queue, size_t newCapacity) {
+    if (newCapacity > PY_SSIZE_T_MAX / sizeof(PyObject*)) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    PyObject** newObjects = (PyObject**)malloc(newCapacity * sizeof(PyObject*));
+    if (newObjects == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    for (size_t i = 0; i < queue->length; ++i) {
+        newObjects[i] = queue->objects[(queue->front + i) % queue->capacity];
+    }
+
+    free(queue->objects);
+    queue->objects = newObjects;
+    queue->front = 0;
+    queue->back = (queue->length + newCapacity - 1) % newCapacity;
+    queue->capacity = newCapacity;
+    return 0;
+}
+
+QUEUE_LIBRARY_API void enqueue(queue_t* queue, PyObject* object) {
+    if (queue == NULL) {
+        PyErr_SetString(PyExc_RuntimeError, "Queue is not allocated");
+        return;
+    }
+    if (object == Py_None)
+        return;
+
+    if (queue->length == queue->capacity) {
+        if (queue->capacity > PY_SSIZE_T_MAX / sizeof(PyObject*) / 2) {
+            PyErr_NoMemory();
+            return;
+        }
+        if (resize(queue, queue->capacity ? queue->capacity * 2 : 256) < 0)
+            return;
+    }
+
+    Py_INCREF(object);
+    queue->front = (queue->front + queue->capacity - 1) % queue->capacity;
+    queue->objects[queue->front] = object;
+    queue->length++;
+}
+
+QUEUE_LIBRARY_API PyObject* dequeue(queue_t* queue) {
+    if (queue == NULL || queue->length == 0) {
+        PyErr_SetString(PyExc_IndexError, "dequeue from an empty queue");
+        return NULL;
+    }
+
+    PyObject* object = queue->objects[queue->back];
+    queue->back = (queue->back + queue->capacity - 1) % queue->capacity;
+    queue->length--;
+    return object;
+}
+
+QUEUE_LIBRARY_API void clear_q(queue_t* queue) {
+    if (queue == NULL || queue->length == 0) {
+        return;
+    }
+
+    PyObject** objects = queue->objects;
+    size_t length = queue->length;
+    size_t capacity = queue->capacity;
+    size_t front = queue->front;
+    // Detach before decrefs so callbacks cannot overwrite the old payloads.
+    queue->objects = NULL;
+    queue->length = queue->capacity = queue->front = queue->back = 0;
+    for (size_t i = 0; i < length; ++i) {
+        Py_DECREF(objects[(front + i) % capacity]);
+    }
+    if (queue->objects == NULL) {
+        queue->objects = objects;
+        queue->capacity = capacity;
+        queue->front = 0;
+        queue->back = capacity - 1;
+    } else {
+        free(objects);
+    }
+}
+
+QUEUE_LIBRARY_API void free_q(queue_t* queue) {
+    if (queue == NULL) {
+        return;
+    }
+
+    clear_q(queue);
+    free(queue->objects);
+    free(queue);
+}

{fastqueue-lib-0.0.17 → fastqueue_lib-0.0.18}/src/cllqueue.cpp

@@ -8,7 +8,6 @@
 #endif
 
 #include <Python.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 // Matt's C Linked List Queue
@@ -26,8 +25,10 @@ QUEUE_LIBRARY_API typedef struct queue {
 
 node_t* new_node(PyObject* object) {
     node_t* node = (node_t*)malloc(sizeof(node_t));
-    if (node == NULL)
+    if (node == NULL) {
+        PyErr_NoMemory();
         return NULL;
+    }
 
     Py_INCREF(object);
     node->object = object;
@@ -37,25 +38,27 @@ node_t* new_node(PyObject* object) {
 
 QUEUE_LIBRARY_API queue_t* new_node_queue() {
     queue_t* queue = (queue_t*)malloc(sizeof(queue_t));
+    if (queue == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
     queue->front = NULL;
     queue->back = NULL;
     queue->length = 0;
     return queue;
 }
 
-QUEUE_LIBRARY_API int is_empty(queue_t* queue) {
+QUEUE_LIBRARY_API void enqueue(queue_t* queue, PyObject* object) {
     if (queue == NULL) {
-        perror("Queue not allocated");
-        return 1;
+        PyErr_SetString(PyExc_RuntimeError, "Queue is not allocated");
+        return;
     }
-    return queue->length == 0;
-}
-
-QUEUE_LIBRARY_API void enqueue(queue_t* queue, PyObject* object) {
     if (object == Py_None)
         return;
 
     node_t* node = new_node(object);
+    if (node == NULL)
+        return;
     if (queue->back == NULL) {
         queue->front = node;
         queue->back = node;
@@ -67,8 +70,10 @@ QUEUE_LIBRARY_API void enqueue(queue_t* queue, PyObject* object) {
 }
 
 QUEUE_LIBRARY_API PyObject* dequeue(queue_t* queue) {
-    if (is_empty(queue))
+    if (queue == NULL || queue->length == 0) {
+        PyErr_SetString(PyExc_IndexError, "dequeue from an empty queue");
         return NULL;
+    }
 
     node_t* temp = queue->front;
     PyObject* object = temp->object;
@@ -80,13 +85,16 @@ QUEUE_LIBRARY_API PyObject* dequeue(queue_t* queue) {
     return object;
 }
 
-QUEUE_LIBRARY_API void free_q(queue_t* queue) {
+QUEUE_LIBRARY_API void clear_q(queue_t* queue) {
     if (queue == NULL) {
-        perror("Queue not allocated");
         return;
     }
 
     node_t* current = queue->front;
+    // Detach before decrefs so finalizers can safely reuse this queue.
+    queue->front = NULL;
+    queue->back = NULL;
+    queue->length = 0;
     node_t* next;
     while (current != NULL) {
         next = current->next;
@@ -94,5 +102,13 @@ QUEUE_LIBRARY_API void free_q(queue_t* queue) {
         free(current);
         current = next;
     }
+}
+
+QUEUE_LIBRARY_API void free_q(queue_t* queue) {
+    if (queue == NULL) {
+        return;
+    }
+
+    clear_q(queue);
     free(queue);
 }