pythonic-fp.queues 3.0.0__py3-none-any.whl → 4.0.1__py3-none-any.whl

pythonic_fp/queues/__init__.py

@@ -12,30 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Developer Tools - Queue based data structures
-
-These are modeled after Python builtins. The initializers take at most one
-iterable while factory functions stand in for Python syntax.
-
-Queue types:
-
-- *class* dtools.queues.fifo.FIFOQueue: First-In-First-Out Queue
-- *class* dtools.queues.lifo.LIFOQueue: Last-In-First-Out Queue
-- *class* dtools.queues.de.DEQueue: Double-Ended Queue
+"""
+Data structures implementing queue-like behaviors.
 
-Create queues from specific values:
+- Three Queue-like data structures:
 
-- *function* dtools.queues.fifo.fifo_queue: Create a FIFOQueue
+  - *class* **FIFOQueue** - First In First Out Queue
+  - *class* **LIFOQueue** - Last In First Out Queue
+  - *class* **DEQueue** - Double Ended Queue
 
-  - from function's arguments pushed on in natural FIFO order
+- Each with capabilities:
 
-- *function* dtools.queues.lifo.lifo_queue: Create a LIFOQueue
+  - O(1) pushes and pops
+  - O(1) length determination
+  - in a Boolean context
 
-  - from function's arguments pushed on in natural LIFO order
+    - true if not empty
+    - false if empty
 
-- *function* dtools.queues.de.de_queue: Create a DEQueue
+  - will resize themselves larger when needed
+  - not indexable or sliceable by design
 
-  - from function's arguments pushed on from the right
 """
 
 __author__ = 'Geoffrey R. Scheller'

pythonic_fp/queues/de.py

@@ -12,15 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""
-### Double-Ended (DE) Queue
-
-- stateful DE queue data structures with amortized O(1) pushes and pops each end
-- obtaining length (number of elements) of a queue is an O(1) operation
-- implemented in a "has-a" relationship with a Python list based circular array
-- will resize itself larger as needed
-
-"""
 
 from __future__ import annotations
 
@@ -28,8 +19,7 @@ from collections.abc import Callable, Iterable, Iterator, Sequence
 from typing import Never, overload, TypeVar
 
 from pythonic_fp.circulararray import CA
-from pythonic_fp.containers.maybe import MayBe as MB
-
+from pythonic_fp.containers.maybe import MayBe
 
 __all__ = ['DEQueue', 'de_queue']
 
@@ -37,10 +27,9 @@ D = TypeVar('D')
 
 
 class DEQueue[D]:
-    """Double Ended Queue
-
-    - stateful Double-Ended (DEQueue) data structure
-    - order of initial data retained, as if pushed on from the right
+    """
+    Stateful Double-Ended (DEQueue) data structure. Order of initial
+    data retained, as if pushed on from the right.
     """
     L = TypeVar('L')
     R = TypeVar('R')
@@ -50,11 +39,14 @@ class DEQueue[D]:
     U = TypeVar('U')
 
     def __init__(self, *dss: Iterable[D]) -> None:
-        if (size := len(dss)) < 2:
-            self._ca = CA(dss[0]) if size == 1 else CA()
-        else:
+        """
+        :param dss: takes one or no iterables
+        :raises ValueError: if more than 1 iterable is given
+        """
+        if (size := len(dss)) > 1:
             msg = f'DEQueue expects at most 1 iterable argument, got {size}'
-            raise TypeError(msg)
+            raise ValueError(msg)
+        self._ca = CA(dss[0]) if size == 1 else CA()
 
     def __bool__(self) -> bool:
         return len(self._ca) > 0
@@ -62,21 +54,22 @@ class DEQueue[D]:
     def __len__(self) -> int:
         return len(self._ca)
 
-    def __eq__(self, other: object, /) -> bool:
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, DEQueue):
             return False
         return self._ca == other._ca
 
     @overload
-    def __getitem__(self, idx: int, /) -> D: ...
+    def __getitem__(self, idx: int) -> D: ...
     @overload
-    def __getitem__(self, idx: slice, /) -> Sequence[D]: ...
+    def __getitem__(self, idx: slice) -> Sequence[D]: ...
 
-    def __getitem__(self, idx: int | slice, /) -> D | Sequence[D] | Never:
+    def __getitem__(self, idx: int | slice) -> Never:
         if isinstance(idx, slice):
-            msg = 'dtool.restictive queues are not slicable by design'
+            msg = 'fptools_fp.queues.DEQueue is not slicable by design'
             raise NotImplementedError(msg)
-        return self._ca[idx]
+        msg = 'fptools_fp.queues.DEQueue is not indexable by design'
+        raise NotImplementedError(msg)
 
     def __iter__(self) -> Iterator[D]:
         return iter(list(self._ca))
@@ -86,105 +79,95 @@ class DEQueue[D]:
 
     def __repr__(self) -> str:
         if len(self) == 0:
-            return 'DQ()'
-        return 'DQ(' + ', '.join(map(repr, self._ca)) + ')'
+            return 'DEQueue()'
+        return 'DEQueue(' + ', '.join(map(repr, self._ca)) + ')'
 
     def __str__(self) -> str:
         return '>< ' + ' | '.join(map(str, self)) + ' ><'
 
     def copy(self) -> DEQueue[D]:
-        """Return a shallow copy of the ``DEQueue``."""
+        """Copy.
+
+        :returns: shallow copy of the DEQueue
+        """
         return DEQueue(self._ca)
 
     def pushl(self, *ds: D) -> None:
-        """Push data onto left side (front) of ``DEQueue``."""
+        """Push items onto left side of DEQueue."""
         self._ca.pushl(*ds)
 
     def pushr(self, *ds: D) -> None:
-        """Push data onto right side (rear) of ``DEQueue``.
-        Like a Python List, does not return a value.
-        """
+        """Push items onto right side of DEQueue."""
         self._ca.pushr(*ds)
 
-    def popl(self) -> MB[D]:
-        """Pop Data from left side (front) of ``DEQueue``.
+    def popl(self) -> MayBe[D]:
+        """Pop next item from left side DEQueue.
 
-        - pop left most item off of queue, return item in a maybe monad
-        - returns an empty ``MB()`` if queue is empty
+        :returns: MayBe of next item popped off left side of queue
         """
         if self._ca:
-            return MB(self._ca.popl())
-        return MB()
+            return MayBe(self._ca.popl())
+        return MayBe()
 
-    def popr(self) -> MB[D]:
-        """Pop Data from right side (rear) of ``DEQueue``.
+    def popr(self) -> MayBe[D]:
+        """Pop next item off right side DEQueue.
 
-        - pop right most item off of queue, return item in a maybe monad
-        - returns an empty ``MB()`` if queue is empty
+        :returns: MayBe of item popped off right side of queue
         """
         if self._ca:
-            return MB(self._ca.popr())
-        return MB()
+            return MayBe(self._ca.popr())
+        return MayBe()
 
-    def peakl(self) -> MB[D]:
-        """Peak left side of ``DEQueue``.
+    def peakl(self) -> MayBe[D]:
+        """Peak at left side of DEQueue. Does not consume item.
 
-        - return left most value in a maybe monad
-        - does not consume the item
-        - returns an empty ``MB()`` if queue is empty
+        :returns: MayBe of first item on left
         """
         if self._ca:
-            return MB(self._ca[0])
-        return MB()
+            return MayBe(self._ca[0])
+        return MayBe()
 
-    def peakr(self) -> MB[D]:
-        """Peak right side of ``DEQueue``.
+    def peakr(self) -> MayBe[D]:
+        """Peak at right side of DEQueue. Does not consume item.
 
-        - return right most value in a maybe monad
-        - does not consume the item
-        - returns an empty ``MB()`` if queue is empty
+        :returns: MayBe of last item on right
         """
         if self._ca:
-            return MB(self._ca[-1])
-        return MB()
+            return MayBe(self._ca[-1])
+        return MayBe()
 
-    def foldl[L](self, f: Callable[[L, D], L], initial: L | None = None, /) -> MB[L]:
-        """Reduce left to right with ``f`` using an optional initial value.
+    def foldl[L](self, f: Callable[[L, D], L], initial: L | None = None) -> MayBe[L]:
+        """Reduces DEQueue left to right.
 
-        - note that when an initial value is not given then ``~L = ~D``
-        - if iterable empty & no initial value given, return ``MB()``
-        - traditional FP type order given for function ``f``
+        :param f: reducing function, first argument is for accumulator
+        :param initial: optional initial value
+        :returns: MayBe of reduced value with f
         """
         if initial is None:
             if not self._ca:
-                return MB()
-        return MB(self._ca.foldl(f, initial))
+                return MayBe()
+        return MayBe(self._ca.foldl(f, initial))
 
-    def foldr[R](self, f: Callable[[D, R], R], initial: R | None = None, /) -> MB[R]:
-        """Reduce right to left with ``f`` using an optional initial value.
+    def foldr[R](self, f: Callable[[D, R], R], initial: R | None = None) -> MayBe[R]:
+        """Reduces DEQueue right to left.
 
-        - note that when an initial value is not given then ``~R = ~D``
-        - if iterable empty & no initial value given, return ``MB()``
-        - traditional FP type order given for function ``f``
+        :param f: reducing function, second argument is for accumulator
+        :param initial: optional initial value
+        :returns: MayBe of reduced value with f
         """
         if initial is None:
             if not self._ca:
-                return MB()
-        return MB(self._ca.foldr(f, initial))
-
-    def map[U](self, f: Callable[[D], U], /) -> DEQueue[U]:
-        """Map a function over ``DEQueue``.
-
-        - map the function ``f`` over the ``DEQueue``
+                return MayBe()
+        return MayBe(self._ca.foldr(f, initial))
 
-          - left to right
-          - retain original order
+    def map[U](self, f: Callable[[D], U]) -> DEQueue[U]:
+        """Map f over the DEQueue left to right, retain original order.
 
-        - returns a new instance
+        :returns: new DEQueue
         """
         return DEQueue(map(f, self._ca))
 
 
 def de_queue[D](*ds: D) -> DEQueue[D]:
-    """Create a ``DEQueue`` from the function arguments."""
+    """DEQueue factory function."""
     return DEQueue(ds)

pythonic_fp/queues/fifo.py

@@ -12,16 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""First-In-Last-Out (FIFO) Queue"""
-
 from __future__ import annotations
 
 from collections.abc import Callable, Iterable, Iterator, Sequence
 from typing import Never, overload, TypeVar
 
 from pythonic_fp.circulararray import CA
-from pythonic_fp.containers.maybe import MayBe as MB
-
+from pythonic_fp.containers.maybe import MayBe
 
 __all__ = ['FIFOQueue', 'fifo_queue']
 
@@ -29,23 +26,24 @@ D = TypeVar('D')
 
 
 class FIFOQueue[D]:
-    """FIFO Queue
-
-    - stateful First-In-First-Out (FIFO) data structure
-    - initial data pushed on in natural FIFO order
     """
-
+    Stateful First In First Out (FIFO) data structure. Initial data
+    pushed on in natural FIFO order.
+    """
     __slots__ = ('_ca',)
 
     T = TypeVar('T')
     U = TypeVar('U')
 
     def __init__(self, *dss: Iterable[D]) -> None:
-        if (size := len(dss)) < 2:
-            self._ca = CA(dss[0]) if size == 1 else CA()
-        else:
+        """
+        :param dss: takes one or no iterables
+        :raises ValueError: if more than 1 iterable is given
+        """
+        if (size := len(dss)) > 1:
             msg = f'FIFOQueue expects at most 1 iterable argument, got {size}'
             raise ValueError(msg)
+        self._ca = CA(dss[0]) if size == 1 else CA()
 
     def __bool__(self) -> bool:
         return len(self._ca) > 0
@@ -53,98 +51,92 @@ class FIFOQueue[D]:
     def __len__(self) -> int:
         return len(self._ca)
 
-    def __eq__(self, other: object, /) -> bool:
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, FIFOQueue):
             return False
         return self._ca == other._ca
 
     @overload
-    def __getitem__(self, idx: int, /) -> D: ...
+    def __getitem__(self, idx: int) -> D: ...
     @overload
-    def __getitem__(self, idx: slice, /) -> Sequence[D]: ...
+    def __getitem__(self, idx: slice) -> Sequence[D]: ...
 
-    def __getitem__(self, idx: int | slice, /) -> D | Sequence[D] | Never:
+    def __getitem__(self, idx: int | slice) -> Never:
         if isinstance(idx, slice):
-            msg = 'dtool.restictive queues are not slicable by design'
+            msg = 'fptools_fp.queues.FIFOQueue is not slicable by design'
             raise NotImplementedError(msg)
-        return self._ca[idx]
+        msg = 'fptools_fp.queues.FIFOQueue is not indexable by design'
+        raise NotImplementedError(msg)
 
     def __iter__(self) -> Iterator[D]:
         return iter(list(self._ca))
 
     def __repr__(self) -> str:
         if len(self) == 0:
-            return 'FQ()'
-        return 'FQ(' + ', '.join(map(repr, self._ca)) + ')'
+            return 'FIFOQueue()'
+        return 'FIFOQueue(' + ', '.join(map(repr, self._ca)) + ')'
 
     def __str__(self) -> str:
         return '<< ' + ' < '.join(map(str, self)) + ' <<'
 
     def copy(self) -> FIFOQueue[D]:
-        """Return a shallow copy of the ``FIFOQueue``."""
+        """Copy.
+
+        :returns: shallow copy of the FIFOQueue
+        """
         return FIFOQueue(self._ca)
 
     def push(self, *ds: D) -> None:
-        """Push data onto ``FIFOQueue``, does not return a value."""
+        """Push an item onto FIFOQueue."""
         self._ca.pushr(*ds)
 
-    def pop(self) -> MB[D]:
-        """Pop data from ``FIFOQueue``.
+    def pop(self) -> MayBe[D]:
+        """Pop oldest item from FIFOQueue.
 
-        - pop item off queue, return item in a maybe monad
-        - returns an empty ``MB()`` if queue is empty
+        :returns: MayBe of item popped from queue
         """
         if self._ca:
-            return MB(self._ca.popl())
-        return MB()
+            return MayBe(self._ca.popl())
+        return MayBe()
 
-    def peak_last_in(self) -> MB[D]:
-        """Peak last data into ``FIFOQueue``.
+    def peak_last_in(self) -> MayBe[D]:
+        """Peak at end. Does not consume data.
 
-        - return a maybe monad of the last item pushed to queue
-        - does not consume the data
-        - if item already popped, return ``MB()``
+        :returns: MayBe of last item in queue
         """
         if self._ca:
-            return MB(self._ca[-1])
-        return MB()
+            return MayBe(self._ca[-1])
+        return MayBe()
 
-    def peak_next_out(self) -> MB[D]:
-        """Peak next data out of ``FIFOQueue``.
+    def peak_next_out(self) -> MayBe[D]:
+        """Peak at beginning. Does not consume data.
 
-        - returns a maybe monad of the next item to be popped from the queue.
-        - does not consume it the item
-        - returns ``MB()`` if queue is empty
+        :returns:  MayBe of next item in queue
         """
         if self._ca:
-            return MB(self._ca[0])
-        return MB()
+            return MayBe(self._ca[0])
+        return MayBe()
 
-    def fold[T](self, f: Callable[[T, D], T], initial: T | None = None, /) -> MB[T]:
-        """Reduce with ``f`` with an optional initial value.
+    def fold[T](self, f: Callable[[T, D], T], initial: T | None = None) -> MayBe[T]:
+        """Reduces in natural FIFO Order (oldest to newest).
 
-        - folds in natural FIFO Order (oldest to newest)
-        - note that when an initial value is not given then ``~L = ~D``
-        - if iterable empty & no initial value given, return ``MB()``
+        :param f: reducing function, first argument is for accumulator
+        :param initial: optional initial value
+        :returns: MayBe of reduced value with f
         """
         if initial is None:
             if not self._ca:
-                return MB()
-        return MB(self._ca.foldl(f, initial))
-
-    def map[U](self, f: Callable[[D], U], /) -> FIFOQueue[U]:
-        """Map over the ``FIFOQueue``.
-
-        - map function ``f`` over the queue
+                return MayBe()
+        return MayBe(self._ca.foldl(f, initial))
 
-          - oldest to newest
-          - retain original order
+    def map[U](self, f: Callable[[D], U]) -> FIFOQueue[U]:
+        """Map f over the FIFOQueue, retain original order.
 
-        - returns a new instance
+        :returns: new FIFOQueue
         """
         return FIFOQueue(map(f, self._ca))
 
 
 def fifo_queue[D](*ds: D) -> FIFOQueue[D]:
-    """Create a FIFOQueue from the arguments."""
+    """FIFOQueue factory function."""
     return FIFOQueue(ds)

pythonic_fp/queues/lifo.py

@@ -12,23 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""
-### Last-In-Last-Out (LIFO) Queue
-
-- stateful LIFO queue data structures with amortized O(1) pushes and pops
-- obtaining length (number of elements) of a queue is an O(1) operation
-- implemented in a "has-a" relationship with a Python list based circular array
-- will resize itself larger as needed
-
-"""
-
 from __future__ import annotations
 
 from collections.abc import Callable, Iterable, Iterator, Sequence
 from typing import Never, TypeVar, overload
 
 from pythonic_fp.circulararray import CA
-from pythonic_fp.containers.maybe import MayBe as MB
+from pythonic_fp.containers.maybe import MayBe
 from pythonic_fp.fptools.function import swap
 
 __all__ = ['LIFOQueue', 'lifo_queue']
@@ -37,11 +27,9 @@ D = TypeVar('D')
 
 
 class LIFOQueue[D]:
-    """LIFO Queue.
-
-    - stateful Last-In-First-Out (LIFO) data structure
-    - initial data pushed on in natural LIFO order
-
+    """
+    Stateful Last In First Out (LIFO) data structure. Initial data
+    pushed on in natural FIFO order.
     """
 
     __slots__ = ('_ca',)
@@ -50,11 +38,14 @@ class LIFOQueue[D]:
     U = TypeVar('U')
 
     def __init__(self, *dss: Iterable[D]) -> None:
-        if (size := len(dss)) < 2:
-            self._ca = CA(dss[0]) if size == 1 else CA()
-        else:
+        """
+        :param dss: takes one or no iterables
+        :raises ValueError: if more than 1 iterable is given
+        """
+        if (size := len(dss)) > 1:
             msg = f'LIFOQueue expects at most 1 iterable argument, got {size}'
-            raise TypeError(msg)
+            raise ValueError(msg)
+        self._ca = CA(dss[0]) if size == 1 else CA()
 
     def __bool__(self) -> bool:
         return len(self._ca) > 0
@@ -62,91 +53,83 @@ class LIFOQueue[D]:
     def __len__(self) -> int:
         return len(self._ca)
 
-    def __eq__(self, other: object, /) -> bool:
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, LIFOQueue):
             return False
         return self._ca == other._ca
 
     @overload
-    def __getitem__(self, idx: int, /) -> D: ...
+    def __getitem__(self, idx: int) -> D: ...
     @overload
-    def __getitem__(self, idx: slice, /) -> Sequence[D]: ...
+    def __getitem__(self, idx: slice) -> Sequence[D]: ...
 
-    def __getitem__(self, idx: int | slice, /) -> D | Sequence[D] | Never:
+    def __getitem__(self, idx: int | slice) -> Never:
         if isinstance(idx, slice):
-            msg = 'dtool.restictive queues are not slicable by design'
+            msg = 'fptools_fp.queues.LIFOQueue is not slicable by design'
             raise NotImplementedError(msg)
-        return self._ca[idx]
+        msg = 'fptools_fp.queues.LIFOQueue is not indexable by design'
+        raise NotImplementedError(msg)
 
     def __iter__(self) -> Iterator[D]:
         return reversed(list(self._ca))
 
     def __repr__(self) -> str:
         if len(self) == 0:
-            return 'LQ()'
-        return 'LQ(' + ', '.join(map(repr, self._ca)) + ')'
+            return 'LIFOQueue()'
+        return 'LIFOQueue(' + ', '.join(map(repr, self._ca)) + ')'
 
     def __str__(self) -> str:
         return '|| ' + ' > '.join(map(str, self)) + ' ><'
 
     def copy(self) -> LIFOQueue[D]:
-        """Return a shallow copy of the ``LIFOQueue``."""
+        """Copy.
+
+        :returns: shallow copy of the LIFOQueue
+        """
         return LIFOQueue(reversed(self._ca))
 
     def push(self, *ds: D) -> None:
-        """Push data onto ``LIFOQueue``, does not return a value."""
+        """Push an item onto LIFOQueue."""
         self._ca.pushr(*ds)
 
-    def pop(self) -> MB[D]:
-        """Pop data from ``LIFOQueue``.
-
-        - pop item off of queue, return item in a maybe monad
-        - returns an empty ``MB()`` if queue is empty
+    def pop(self) -> MayBe[D]:
+        """Pop top item off of LIFOQueue.
 
+        :returns: MayBe of item popped from queue
         """
         if self._ca:
-            return MB(self._ca.popr())
-        return MB()
-
-    def peak(self) -> MB[D]:
-        """Peak next data out of ``LIFOQueue``.
+            return MayBe(self._ca.popr())
+        return MayBe()
 
-        - return a maybe monad of the next item to be popped from the queue
-        - does not consume the item
-        - returns ``MB()`` if queue is empty
+    def peak(self) -> MayBe[D]:
+        """Peak lans in/next out. Does not consume data.
 
+        :returns: MayBe of item at top of queue.
         """
         if self._ca:
-            return MB(self._ca[-1])
-        return MB()
+            return MayBe(self._ca[-1])
+        return MayBe()
 
-    def fold[T](self, f: Callable[[T, D], T], initial: T | None = None, /) -> MB[T]:
-        """Reduce with ``f`` with an optional initial value.
-
-        - folds in natural LIFO Order (newest to oldest)
-        - note that when an initial value is not given then ``~T = ~D``
-        - if iterable empty & no initial value given, return ``MB()``
+    def fold[T](self, f: Callable[[T, D], T], initial: T | None = None) -> MayBe[T]:
+        """Reduces in natural LIFO Order (newest to oldest.
 
+        :param f: reducing function, second argument is for accumulator
+        :param initial: Optional initial value
+        :returns: MayBe of reduced value with f
         """
         if initial is None:
             if not self._ca:
-                return MB()
-        return MB(self._ca.foldr(swap(f), initial))
-
-    def map[U](self, f: Callable[[D], U], /) -> LIFOQueue[U]:
-        """Map Over the ``LIFOQueue``.
-
-        - map the function ``f`` over the queue
-
-          - newest to oldest
-          - retain original order
+                return MayBe()
+        return MayBe(self._ca.foldr(swap(f), initial))
 
-        - returns a new instance
+    def map[U](self, f: Callable[[D], U]) -> LIFOQueue[U]:
+        """Map f over the LIFOQueue, retain original order.
 
+        :returns: new LIFOQueue
         """
         return LIFOQueue(reversed(CA(map(f, reversed(self._ca)))))
 
 
 def lifo_queue[D](*ds: D) -> LIFOQueue[D]:
-    """Create a LIFOQueue from the arguments."""
+    """LIFOQueue factory function."""
     return LIFOQueue(ds)

{pythonic_fp_queues-3.0.0.dist-info → pythonic_fp_queues-4.0.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pythonic-fp.queues
-Version: 3.0.0
-Summary: Developer Tools - Queue based data structures
+Version: 4.0.1
+Summary: Data structures implementing queue-like behaviors.
 Keywords: dqueue,fifo,lifo,queue
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
 Requires-Python: >=3.12
@@ -16,9 +16,9 @@ Classifier: Typing :: Typed
 License-File: LICENSE
 Requires-Dist: pythonic-fp.circulararray >= 5.0.0
 Requires-Dist: pythonic-fp.containers >=2.0.0
-Requires-Dist: pythonic-fp.fptools >=3.0.0
-Project-URL: Changelog, https://grscheller.github.io/pythonic-fp-queues/html/changelog.html
-Project-URL: Documentation, https://grscheller.github.io/pythonic-fp-queues/html/
+Requires-Dist: pythonic-fp.fptools >=4.0.0
+Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-queues/blob/main/CHANGELOG.rst
+Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/queues/API/v4.0.1/build/html/
 Project-URL: Homepage, https://github.com/grscheller/pythonic-fp/blob/main/README.md
 Project-URL: Source, https://github.com/grscheller/pythonic-fp-queues
 
@@ -39,8 +39,9 @@ This PyPI project is part of of the grscheller
 
 ## Documentation
 
-Documentation hosted on
-[GitHub Pages](https://grscheller.github.io/pythonic-fp-queues/html).
+Documentation for package
+[GitHub Pages](https://grscheller.github.io/pythonic-fp/queues/API/development/build/html)
+hosted on GitHub pages.
 
 ## Copyright and License
 

pythonic_fp_queues-4.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+pythonic_fp/queues/__init__.py,sha256=6rZCz04NNvvXxZkXvC3MWgH7hxtu6YCyCnpHDRTL0ek,1215
+pythonic_fp/queues/de.py,sha256=pVzqs2Vd1noU2WbUdCvfDpQd-esqJ5zckOfXBbIKwa8,5193
+pythonic_fp/queues/fifo.py,sha256=dKIdP56PQ-Ssjx9TsOK956Wu5669hSsErtdIc2lydw0,4259
+pythonic_fp/queues/lifo.py,sha256=Pm6ajntvPe0d88UTpB_OZkDEP0WEHBOs71Bye3H2HOg,4116
+pythonic_fp/queues/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonic_fp_queues-4.0.1.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
+pythonic_fp_queues-4.0.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pythonic_fp_queues-4.0.1.dist-info/METADATA,sha256=MyHmDZiWJHq7guaoOYQs7po9o5Q0nnAh-jHvJ5z8Mr0,1932
+pythonic_fp_queues-4.0.1.dist-info/RECORD,,

pythonic_fp_queues-3.0.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-pythonic_fp/queues/__init__.py,sha256=9gxtZ2HyHWVcpcTmTOc_ZNf4-WYGhRMOwhoOf64ulP8,1519
-pythonic_fp/queues/de.py,sha256=d4mgLa5MMPxjzWSEbOhWv1RuJtMwViZR4dxPYKezsUk,5918
-pythonic_fp/queues/fifo.py,sha256=IePckXP722Ky_MKZySawY-q9cFJ6XcMCa_eWXRrbPhI,4519
-pythonic_fp/queues/lifo.py,sha256=LuA3sg5uTMZMXFrf3hTPVDDJ9jbmdKqZNv0zBjcCUrk,4553
-pythonic_fp/queues/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pythonic_fp_queues-3.0.0.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
-pythonic_fp_queues-3.0.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pythonic_fp_queues-3.0.0.dist-info/METADATA,sha256=svlf8vGt6_z1PwRAoyYG67cR2HbmxhnYCjkGFMtoSsI,1858
-pythonic_fp_queues-3.0.0.dist-info/RECORD,,