pythonic-fp.containers 2.0.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

pythonic_fp/containers/queues/de.py

@@ -0,0 +1,178 @@
+# Copyright 2023-2025 Geoffrey R. Scheller
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Stateful Double-Ended (DE) Queue data structure.
+
+- O(1) pops each end
+- O(1) amortized pushes each end
+- O(1) length determination
+- will automatically increase storage capacity when needed
+- in a Boolean context, true if not empty, false if empty
+- neither indexable nor sliceable by design
+
+"""
+from collections.abc import Callable, Iterable, Iterator
+from typing import TypeVar
+from pythonic_fp.circulararray.auto import CA
+from pythonic_fp.fptools.maybe import MayBe
+
+__all__ = ['DEQueue', 'de_queue']
+
+D = TypeVar('D')
+
+
+class DEQueue[D]:
+
+    __slots__ = ('_ca',)
+
+    def __init__(self, *dss: Iterable[D]) -> None:
+        """Initial data in FIFO order, newest to oldest, as if
+        pushed on from the right side.
+
+        :param dss: takes up to one iterable
+        :raises ValueError: if more than 1 iterable is given
+
+        """
+        if (size := len(dss)) > 1:
+            msg = f'DEQueue expects at most 1 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
+
+    def __len__(self) -> int:
+        return len(self._ca)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DEQueue):
+            return False
+        return self._ca == other._ca
+
+    def __iter__(self) -> Iterator[D]:
+        return iter(list(self._ca))
+
+    def __reversed__(self) -> Iterator[D]:
+        return reversed(list(self._ca))
+
+    def __repr__(self) -> str:
+        if len(self) == 0:
+            return 'DEQueue()'
+        return 'DEQueue(' + ', '.join(map(repr, self._ca)) + ')'
+
+    def __str__(self) -> str:
+        return '>< ' + ' | '.join(map(str, self)) + ' ><'
+
+    def copy(self) -> 'DEQueue[D]':
+        """Shallow copy.
+
+        :return: shallow copy of the DEQueue
+
+        """
+        return DEQueue(self._ca)
+
+    def pushl(self, *ds: D) -> None:
+        """Push data onto left side of DEQueue.
+
+        :param ds: items to be pushed onto DEQueue from the left
+
+        """
+        self._ca.pushl(*ds)
+
+    def pushr(self, *ds: D) -> None:
+        """Push data onto right side of DEQueue.
+
+        :param ds: items to be pushed onto DEQueue from the right
+
+        """
+        self._ca.pushr(*ds)
+
+    def popl(self) -> MayBe[D]:
+        """Pop next data item from left side DEQueue, if it exists.
+
+        :return: MayBe of popped item if queue was not empty, empty MayBe otherwise
+
+        """
+        if self._ca:
+            return MayBe(self._ca.popl())
+        return MayBe()
+
+    def popr(self) -> MayBe[D]:
+        """Pop next item off right side DEQueue.
+
+        :return: MayBe of popped item if queue was not empty, empty MayBe otherwise
+
+        """
+        if self._ca:
+            return MayBe(self._ca.popr())
+        return MayBe()
+
+    def peakl(self) -> MayBe[D]:
+        """Peak at data on left side of DEQueue.
+
+        :return: MayBe of leftmost data if queue not empty, empty MayBe otherwise
+
+        """
+        if self._ca:
+            return MayBe(self._ca[0])
+        return MayBe()
+
+    def peakr(self) -> MayBe[D]:
+        """Peak at right side of DEQueue. Does not consume item.
+
+        :return: MayBe of rightmost data if queue not empty, empty MayBe otherwise
+
+        """
+        if self._ca:
+            return MayBe(self._ca[-1])
+        return MayBe()
+
+    def foldl[L](self, f: Callable[[L, D], L], start: L | None = None) -> MayBe[L]:
+        """Reduces DEQueue left to right.
+
+        :param f: reducing function, first argument is for accumulator
+        :param start: optional starting value
+        :return: MayBe of reduced value with f, empty MayBe if queue empty and no starting value given
+
+        """
+        if start is None:
+            if not self._ca:
+                return MayBe()
+        return MayBe(self._ca.foldl(f, start))
+
+    def foldr[R](self, f: Callable[[D, R], R], start: R | None = None) -> MayBe[R]:
+        """Reduces DEQueue right to left.
+
+        :param f: reducing function, second argument is for accumulator
+        :param start: optional starting value
+        :return: MayBe of reduced value with f, empty MayBe if queue empty and no starting value given
+
+        """
+        if start is None:
+            if not self._ca:
+                return MayBe()
+        return MayBe(self._ca.foldr(f, start))
+
+    def map[U](self, f: Callable[[D], U]) -> 'DEQueue[U]':
+        """Map f over the DEQueue left to right, retain original order.
+
+        :return: new DEQueue instance
+
+        """
+        return DEQueue(map(f, self._ca))
+
+
+def de_queue[D](*ds: D) -> DEQueue[D]:
+    """DEQueue factory function."""
+    return DEQueue(ds)

pythonic_fp/containers/queues/de.pyi

@@ -0,0 +1,45 @@
+# Copyright 2023-2025 Geoffrey R. Scheller
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Callable, Iterable, Iterator
+from typing import TypeVar
+from pythonic_fp.fptools.maybe import MayBe
+
+__all__ = ['DEQueue', 'de_queue']
+
+D = TypeVar('D')
+
+class DEQueue[D]:
+    __slots__ = ('_ca',)
+
+    def __init__(self, *dss: Iterable[D]) -> None: ...
+    def __bool__(self) -> bool: ...
+    def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __iter__(self) -> Iterator[D]: ...
+    def __reversed__(self) -> Iterator[D]: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def copy(self) -> DEQueue[D]: ...
+    def pushl(self, *ds: D) -> None: ...
+    def pushr(self, *ds: D) -> None: ...
+    def popl(self) -> MayBe[D]: ...
+    def popr(self) -> MayBe[D]: ...
+    def peakl(self) -> MayBe[D]: ...
+    def peakr(self) -> MayBe[D]: ...
+    def foldl[L](self, f: Callable[[L, D], L], start: L | None = None) -> MayBe[L]: ...
+    def foldr[R](self, f: Callable[[D, R], R], start: R | None = None) -> MayBe[R]: ...
+    def map[U](self, f: Callable[[D], U]) -> DEQueue[U]: ...
+
+def de_queue[D](*ds: D) -> DEQueue[D]: ...

pythonic_fp/containers/queues/fifo.py

@@ -0,0 +1,143 @@
+# Copyright 2023-2024 Geoffrey R. Scheller
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Stateful First-In-First-Out (FIFO) Queue data structure.
+
+- O(1) pops
+- O(1) amortized pushes
+- in a Boolean context, true if not empty, false if empty
+- will automatically increase storage capacity when needed
+- neither indexable nor sliceable by design
+- O(1) length determination
+
+"""
+from collections.abc import Callable, Iterable, Iterator
+from typing import TypeVar
+from pythonic_fp.circulararray.auto import CA
+from pythonic_fp.fptools.maybe import MayBe
+
+__all__ = ['FIFOQueue', 'fifo_queue']
+
+D = TypeVar('D')
+
+
+class FIFOQueue[D]:
+
+    __slots__ = ('_ca',)
+
+    def __init__(self, *dss: Iterable[D]) -> None:
+        """Initial data in natural FIFO order, newest to oldest.
+
+        :param dss: takes up to one iterable
+        :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
+
+    def __len__(self) -> int:
+        return len(self._ca)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FIFOQueue):
+            return False
+        return self._ca == other._ca
+
+    def __iter__(self) -> Iterator[D]:
+        return iter(list(self._ca))
+
+    def __repr__(self) -> str:
+        if len(self) == 0:
+           return 'FIFOQueue()'
+        return 'FIFOQueue(' + ', '.join(map(repr, self._ca)) + ')'
+
+    def __str__(self) -> str:
+        return '<< ' + ' < '.join(map(str, self)) + ' <<'
+
+    def copy(self) -> 'FIFOQueue[D]':
+        """Shallow copy.
+
+        :return: shallow copy of the FIFOQueue
+
+        """
+        return FIFOQueue(self._ca)
+
+    def push(self, *ds: D) -> None:
+        """Push data onto FIFOQueue.
+
+        :param ds: data items to be pushed onto FIFOQueue
+
+        """
+        self._ca.pushr(*ds)
+
+    def pop(self) -> MayBe[D]:
+        """Pop oldest data item off of FIFOQueue.
+
+        :return: MayBe of popped data item if queue was not empty, empty MayBe otherwise
+
+        """
+        if self._ca:
+            return MayBe(self._ca.popl())
+        return MayBe()
+
+    def peak_last_in(self) -> MayBe[D]:
+        """Peak at newest data item on queue.
+
+        :return: MayBe of newest data item on queue, empty MayBe if queue empty
+        
+        """
+        if self._ca:
+            return MayBe(self._ca[-1])
+        return MayBe()
+
+    def peak_next_out(self) -> MayBe[D]:
+        """Peak at oldest data item on queue.
+
+        :return: MayBe of oldest data item on queue, empty MayBe if queue empty
+
+        """
+        if self._ca:
+            return MayBe(self._ca[0])
+        return MayBe()
+
+    def fold[T](self, f: Callable[[T, D], T], start: T | None = None) -> MayBe[T]:
+        """Reduces FIFOQueue in natural FIFO Order, oldest to newest.
+
+        :param f: reducing function, first argument is for accumulator
+        :param start: optional starting value
+        :return: MayBe of reduced value with f, empty MayBe if queue empty and no starting value given
+
+        """
+        if start is None:
+            if not self._ca:
+                return MayBe()
+        return MayBe(self._ca.foldl(f, start))
+
+    def map[U](self, f: Callable[[D], U]) -> 'FIFOQueue[U]':
+        """Map f over the FIFOQueue, retain original order.
+
+        :return: new FIFOQueue instance
+
+        """
+        return FIFOQueue(map(f, self._ca))
+
+
+def fifo_queue[D](*ds: D) -> FIFOQueue[D]:
+    """FIFOQueue factory function."""
+    return FIFOQueue(ds)

pythonic_fp/containers/queues/fifo.pyi

@@ -0,0 +1,44 @@
+# Copyright 2023-2024 Geoffrey R. Scheller
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Callable, Iterable, Iterator
+from typing import TypeVar
+from pythonic_fp.circulararray.auto import CA
+from pythonic_fp.fptools.maybe import MayBe
+
+__all__ = ['FIFOQueue', 'fifo_queue']
+
+D = TypeVar('D')
+
+
+class FIFOQueue[D]:
+
+    __slots__ = ('_ca',)
+
+    def __init__(self, *dss: Iterable[D]) -> None: ...
+    def __bool__(self) -> bool: ...
+    def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __iter__(self) -> Iterator[D]: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def copy(self) -> FIFOQueue[D]: ...
+    def push(self, *ds: D) -> None: ...
+    def pop(self) -> MayBe[D]: ...
+    def peak_last_in(self) -> MayBe[D]: ...
+    def peak_next_out(self) -> MayBe[D]: ...
+    def fold[T](self, f: Callable[[T, D], T], start: T | None = None) -> MayBe[T]: ...
+    def map[U](self, f: Callable[[D], U]) -> FIFOQueue[U]: ...
+
+def fifo_queue[D](*ds: D) -> FIFOQueue[D]: ...

pythonic_fp/containers/queues/lifo.py

@@ -0,0 +1,134 @@
+# Copyright 2023-2024 Geoffrey R. Scheller
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Stateful Last-In-First-Out (LIFO) Queue data structure.
+
+- O(1) pops
+- O(1) amortized pushes
+- in a Boolean context, true if not empty, false if empty
+- will automatically increase storage capacity when needed
+- neither indexable nor sliceable by design
+- O(1) length determination
+
+"""
+from collections.abc import Callable, Iterable, Iterator
+from typing import TypeVar
+from pythonic_fp.circulararray.auto import CA
+from pythonic_fp.fptools.function import swap
+from pythonic_fp.fptools.maybe import MayBe
+
+__all__ = ['LIFOQueue', 'lifo_queue']
+
+D = TypeVar('D')
+
+
+class LIFOQueue[D]:
+
+    __slots__ = ('_ca',)
+
+    def __init__(self, *dss: Iterable[D]) -> None:
+        """Initial data in natural LIFO order, oldest to newest.
+
+        :param dss: takes up to one iterable
+        :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 ValueError(msg)
+        self._ca = CA(dss[0]) if size == 1 else CA()
+
+    def __bool__(self) -> bool:
+        return len(self._ca) > 0
+
+    def __len__(self) -> int:
+        return len(self._ca)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, LIFOQueue):
+            return False
+        return self._ca == other._ca
+
+    def __iter__(self) -> Iterator[D]:
+        return reversed(list(self._ca))
+
+    def __repr__(self) -> str:
+        if len(self) == 0:
+            return 'LIFOQueue()'
+        return 'LIFOQueue(' + ', '.join(map(repr, self._ca)) + ')'
+
+    def __str__(self) -> str:
+        return '|| ' + ' > '.join(map(str, self)) + ' ><'
+
+    def copy(self) -> 'LIFOQueue[D]':
+        """Shallow copy.
+
+        :return: shallow copy of the LIFOQueue
+
+        """
+        return LIFOQueue(reversed(self._ca))
+
+    def push(self, *ds: D) -> None:
+        """Push data onto LIFOQueue.
+
+        :param ds: data items to be pushed onto LIFOQueue
+
+        """
+        self._ca.pushr(*ds)
+
+    def pop(self) -> MayBe[D]:
+        """Pop newest data item off of LIFOQueue.
+
+        :return: MayBe of popped data item if queue was not empty, empty MayBe otherwise
+
+        """
+        if self._ca:
+            return MayBe(self._ca.popr())
+        return MayBe()
+
+    def peak(self) -> MayBe[D]:
+        """Peak at newest data item on queue.
+
+        :return: MayBe of newest data item on queue, empty MayBe if queue empty
+
+        """
+        if self._ca:
+            return MayBe(self._ca[-1])
+        return MayBe()
+
+    def fold[T](self, f: Callable[[T, D], T], start: T | None = None) -> MayBe[T]:
+        """Reduces LIFOQUEUE in natural LIFO Order, newest to oldest.
+
+        :param f: reducing function, first argument is for accumulator
+        :param start: optional starting value
+        :return: MayBe of reduced value with f, empty MayBe if queue empty and no starting value given
+
+        """
+        if start is None:
+            if not self._ca:
+                return MayBe()
+        return MayBe(self._ca.foldr(swap(f), start))
+
+    def map[U](self, f: Callable[[D], U]) -> 'LIFOQueue[U]':
+        """Map f over the LIFOQueue, retain original order.
+
+        :return: new LIFOQueue instance
+
+        """
+        return LIFOQueue(reversed(CA(map(f, reversed(self._ca)))))
+
+
+def lifo_queue[D](*ds: D) -> LIFOQueue[D]:
+    """LIFOQueue factory function."""
+    return LIFOQueue(ds)

pythonic_fp/containers/queues/lifo.pyi

@@ -0,0 +1,40 @@
+# Copyright 2023-2024 Geoffrey R. Scheller
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Callable, Iterable, Iterator
+from typing import TypeVar
+from pythonic_fp.fptools.maybe import MayBe
+
+__all__ = ['LIFOQueue', 'lifo_queue']
+
+D = TypeVar('D')
+
+class LIFOQueue[D]:
+    __slots__ = ('_ca',)
+
+    def __init__(self, *dss: Iterable[D]) -> None: ...
+    def __bool__(self) -> bool: ...
+    def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __iter__(self) -> Iterator[D]: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def copy(self) -> LIFOQueue[D]: ...
+    def push(self, *ds: D) -> None: ...
+    def pop(self) -> MayBe[D]: ...
+    def peak(self) -> MayBe[D]: ...
+    def fold[T](self, f: Callable[[T, D], T], start: T | None = None) -> MayBe[T]: ...
+    def map[U](self, f: Callable[[D], U]) -> LIFOQueue[U]: ...
+
+def lifo_queue[D](*ds: D) -> LIFOQueue[D]: ...

pythonic_fp_containers-3.0.1.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: pythonic-fp-containers
+Version: 3.0.1
+Summary: Package of container like data structures.
+Keywords: boxes,dequeue,dqueue,fifo,functional_tuple,immutable_list,lifo,queue
+Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+License-File: LICENSE
+Requires-Dist: pythonic-fp-circulararray>=5.3.2
+Requires-Dist: pythonic-fp-fptools>=5.1.0
+Requires-Dist: pythonic-fp-iterables>=5.1.0
+Requires-Dist: pytest>=8.4.1 ; extra == "test"
+Requires-Dist: pythonic-fp-splitends>=1.0.1 ; extra == "test"
+Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-containers/blob/main/CHANGELOG.rst
+Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/containers/development/build/html/releases.html
+Project-URL: Homepage, https://github.com/grscheller/pythonic-fp/blob/main/README.md
+Project-URL: Source, https://github.com/grscheller/pythonic-fp-containers
+Provides-Extra: test
+
+Pythonic FP - Containers
+========================
+
+PyPI project
+`pythonic-fp.containers <https://pypi.org/project/pythonic-fp.containers>`_.
+
+Python package of container like data structures.
+
++------------------+------------------------------------------------------+
+| Description      |                        Module                        |
++==================+======================================================+
+| Functional tuple | *module* ``pythonic_fp.containers.functional_tuple`` |
++------------------+------------------------------------------------------+
+| Immutable list   | *module* ``pythonic_fp.containers.immutable_list``   |
++------------------+------------------------------------------------------+
+
+**DEPRECATION WARNING:** ``pythonic_fp.fptools.box`` as been deprecated.
+Use ``pythonic_fp.box`` instead.
+
+This PyPI project is part of of the grscheller
+`pythonic-fp namespace projects <https://github.com/grscheller/pythonic-fp/blob/main/README.md>`_.
+
+Documentation
+-------------
+
+Documentation for this project is hosted on
+`GitHub Pages
+<https://grscheller.github.io/pythonic-fp/containers/development/build/html>`_.
+
+Copyright and License
+---------------------
+
+Copyright (c) 2023-2025 Geoffrey R. Scheller. Licensed under the Apache
+License, Version 2.0. See the LICENSE file for details.
+

pythonic_fp_containers-3.0.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+pythonic_fp/containers/__init__.py,sha256=D8meKk6jpSNZMgWlM_2tuoxffLgyKHeJwHkRwHJd2C8,1524
+pythonic_fp/containers/functional_tuple.py,sha256=k__UAhGALm-gHR8TC9DzBuASlPXeTeFYESc53JLHjl4,5636
+pythonic_fp/containers/functional_tuple.pyi,sha256=Ca3nLJVZqnicsJ2AJpp7sHoqYFOD4d15a5lO5xBOdYA,2030
+pythonic_fp/containers/immutable_list.py,sha256=qxXffc1uY3x9lHGRR4wt_0xJHAUNiT6Mb4Mupj8oF4U,6573
+pythonic_fp/containers/immutable_list.pyi,sha256=48WFxgkyB-JBD2qH3WIZjWfMArxkTWRs731rv87SRzA,2349
+pythonic_fp/containers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonic_fp/containers/queues/__init__.py,sha256=GJdzodYt32pADih2UHOiR9U4jfZ6SQSw6PsCYZ2r1wg,1459
+pythonic_fp/containers/queues/de.py,sha256=s7R-_SqF6AcWjfzOkqCfG816aZIa3Te0TVKs7GNOUVQ,5256
+pythonic_fp/containers/queues/de.pyi,sha256=BmjhyOiKk69Zh5et0vw5Btm-z5yRc1KDq9qH84O7L-A,1696
+pythonic_fp/containers/queues/fifo.py,sha256=4Pc75fSxmLScb4dQQ6qUdLIg_kvPU8sBxB8kudQQB48,4189
+pythonic_fp/containers/queues/fifo.pyi,sha256=FCXUvreC9C_4QhdnnT9o7K2cvgCcxTGp9IXv9p7hc2o,1558
+pythonic_fp/containers/queues/lifo.py,sha256=zjz9HEjRTmY3PkXHPcpdwTSvtbha1AGPnEa1Ez31r6g,3999
+pythonic_fp/containers/queues/lifo.pyi,sha256=EBS5tGedLZCHQK35xNzgOz_KJJGeMQR0KvlXQLiFbLU,1457
+pythonic_fp/containers/queues/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonic_fp_containers-3.0.1.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
+pythonic_fp_containers-3.0.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pythonic_fp_containers-3.0.1.dist-info/METADATA,sha256=Qa1VF6iMX1qoL032CD-AvHegUpGzr1bAxO-lXwpT_0o,2613
+pythonic_fp_containers-3.0.1.dist-info/RECORD,,