pythonic-fp.containers 3.0.0__tar.gz → 3.0.1__tar.gz

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/.gitignore

@@ -1,6 +1,7 @@
 # Minimal version - only add to when necessary
 **/__pycache__/
 dist/
+**/.dmypy.json
 **/.mypy_cache/
 **/.pytest_cache/
 **/.ruff_cache

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: pythonic-fp-containers
-Version: 3.0.0
+Version: 3.0.1
 Summary: Package of container like data structures.
-Keywords: boxes,functional_tuple,immutable_list,queue,fifo,lifo,dqueue,dequeue
+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 :: 5 - Production/Stable
+Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -14,12 +14,11 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: pythonic-fp-circulararray>= 5.3.0
-Requires-Dist: pythonic-fp-fptools>=5.0.0
-Requires-Dist: pythonic-fp-iterables>=5.0.0
-Requires-Dist: pythonic-fp-singletons>=1.0.0
+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.0 ; 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
@@ -37,8 +36,8 @@ Python package of container like data structures.
 +------------------+------------------------------------------------------+
 | Description      |                        Module                        |
 +==================+======================================================+
-| Single item box  | *module* ``pythonic_fp.containers.box``              |
 | Functional tuple | *module* ``pythonic_fp.containers.functional_tuple`` |
++------------------+------------------------------------------------------+
 | Immutable list   | *module* ``pythonic_fp.containers.immutable_list``   |
 +------------------+------------------------------------------------------+
 

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/README.rst

@@ -9,8 +9,8 @@ Python package of container like data structures.
 +------------------+------------------------------------------------------+
 | Description      |                        Module                        |
 +==================+======================================================+
-| Single item box  | *module* ``pythonic_fp.containers.box``              |
 | Functional tuple | *module* ``pythonic_fp.containers.functional_tuple`` |
++------------------+------------------------------------------------------+
 | Immutable list   | *module* ``pythonic_fp.containers.immutable_list``   |
 +------------------+------------------------------------------------------+
 

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/pyproject.toml

@@ -1,26 +1,22 @@
-[build-system]
-requires = ["flit_core>=3.12,<4"]
-build-backend = "flit_core.buildapi"
-
 [project]
 name = "pythonic-fp-containers"
-version = "3.0.0"
+version = "3.0.1"
 readme = "README.rst"
 requires-python = ">=3.12"
 license = { file = "LICENSE" }
 authors = [{ name = "Geoffrey R. Scheller", email = "geoffrey@scheller.com" }]
 keywords = [
   "boxes",
+  "dequeue",
+  "dqueue",
+  "fifo",
   "functional_tuple",
   "immutable_list",
-  "queue",
-  "fifo",
   "lifo",
-  "dqueue",
-  "dequeue",
+  "queue",
 ]
 classifiers = [
-  "Development Status :: 5 - Production/Stable",
+  "Development Status :: 4 - Beta",
   "Framework :: Pytest",
   "Intended Audience :: Developers",
   "License :: OSI Approved :: Apache Software License",
@@ -29,32 +25,37 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-  "pythonic-fp-circulararray>= 5.3.0",
-  "pythonic-fp-fptools>=5.0.0",
-  "pythonic-fp-iterables>=5.0.0",
-  "pythonic-fp-singletons>=1.0.0",
+  "pythonic-fp-circulararray>=5.3.2",
+  "pythonic-fp-fptools>=5.1.0",
+  "pythonic-fp-iterables>=5.1.0",
 ]
 dynamic = ["description"]
 
-[project.optional-dependencies]
-test = [
-  "pytest>=8.4.1",
-  "pythonic-fp-splitends>=1.0.0",
-]
-
 [project.urls]
 Changelog = "https://github.com/grscheller/pythonic-fp-containers/blob/main/CHANGELOG.rst"
 Documentation = "https://grscheller.github.io/pythonic-fp/containers/development/build/html/releases.html"
 Homepage = "https://github.com/grscheller/pythonic-fp/blob/main/README.md"
 Source = "https://github.com/grscheller/pythonic-fp-containers"
 
+[project.optional-dependencies]
+test = [
+  "pytest>=8.4.1",
+  "pythonic-fp-splitends>=1.0.1",
+]
+
+[build-system]
+requires = ["flit_core>=3.12,<4"]
+build-backend = "flit_core.buildapi"
+
 [tool.flit.module]
 name = "pythonic_fp.containers"
 
 [tool.mypy]
-enable_incomplete_feature = ["NewGenericSyntax"]
+enable_incomplete_feature = "NewGenericSyntax"
+explicit_package_bases = true
 implicit_reexport = false
 local_partial_types = true
+namespace_packages = true
 warn_redundant_casts = true
 warn_return_any = true
 warn_unused_configs = true
@@ -62,21 +63,25 @@ warn_unused_configs = true
 [tool.pylsp-mypy]
 enabled = true
 live-mode = true
+dmypy = false
 strict = true
 report_progress = true
 
 [tool.pytest.ini_options]
+addopts = "-ra"
 consider_namespace_packages = true
 testpaths = ["tests/"]
-addopts = "-ra"
 
 [tool.ruff]
 target-version = "py313"
-ignore = ["E741"]
 
 [tool.ruff.lint.flake8-quotes]
 docstring-quotes = "double"
 
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["C901"]
+"**/*.py" = ["E741"]
+
 [tool.ruff.format]
 quote-style = "single"
 docstring-code-line-length = 72

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/src/pythonic_fp/containers/__init__.py

@@ -24,10 +24,6 @@
 | Queues           |        | package ``pythonic_fp.containers.queues``          |
 +------------------+--------+----------------------------------------------------+
 
-.. note::
-
-    Module ``box`` has  been moved to ``pythonic_fp.gadgets.box``.
-
 """
 
 __author__ = 'Geoffrey R. Scheller'

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/src/pythonic_fp/containers/functional_tuple.py

@@ -14,10 +14,8 @@
 
 """Pythonic FP - Functional Tuple"""
 
-from __future__ import annotations
-
 from collections.abc import Callable, Iterator
-from typing import cast, Never, overload, TypeVar
+from typing import cast, Never, overload, TypeVar, SupportsIndex
 from pythonic_fp.iterables.folding import accumulate
 from pythonic_fp.iterables.merging import blend, concat, MergeEnum
 
@@ -25,6 +23,7 @@ __all__ = ['FTuple']
 
 D = TypeVar('D', covariant=True)
 
+
 class FTuple[D](tuple[D, ...]):
     """Functional Tuple suitable for inheritance
 
@@ -40,6 +39,7 @@ class FTuple[D](tuple[D, ...]):
     - Since these tuples are homogeneous, their covariance may be quirky
 
     """
+
     def __reversed__(self) -> Iterator[D]:
         for ii in range(len(self) - 1, -1, -1):
             yield (self[ii])
@@ -59,17 +59,14 @@ class FTuple[D](tuple[D, ...]):
                 return False
         return True
 
-    @overload    # type:ignore
-    def __getitem__(self, x: int) -> D: ...
     @overload
-    def __getitem__(self, x: slice) -> tuple[D, ...]: ...
-
-    def __getitem__(self, idx: int | slice, /) -> tuple[D, ...] | D:
-        def newtup(tup: tuple[D, ...]) -> tuple[D, ...]:
-            return tup[0:-1] + tup[-1:]
+    def __getitem__(self, idx: SupportsIndex) -> D: ...
+    @overload
+    def __getitem__(self, idx: slice) -> tuple[D, ...]: ...
 
+    def __getitem__(self, idx: SupportsIndex | slice) -> tuple[D, ...] | D:
         if isinstance(idx, slice):
-            return self.__class__(newtup(super().__getitem__(idx)))
+            return self.__class__(super().__getitem__(idx))
         else:
             return super().__getitem__(idx)
 
@@ -131,25 +128,25 @@ class FTuple[D](tuple[D, ...]):
             acc = f(v, acc)
         return acc
 
-    def copy(self) -> FTuple[D]:
+    def copy(self) -> 'FTuple[D]':
         """Return a shallow copy of ``FTuple`` in O(1) time & space complexity."""
         return self.__class__(self)
 
     def __add__(self, other: object, /) -> tuple[D, ...]:
-        if not isinstance(other, FTuple):
+        if not isinstance(other, tuple):
             msg = 'FTuple being added to something not an FTuple'
             raise ValueError(msg)
         return self.__class__(concat(self, other))
 
-    def __mul__(self, num: int, /) -> tuple[D, ...]:
+    def __mul__(self, num: SupportsIndex) -> tuple[D, ...]:
         return self.__class__(super().__mul__(num))
 
-    def __rmul__(self, num: int, /) -> tuple[D]:
+    def __rmul__(self, num: SupportsIndex) -> tuple[D, ...]:
         return self.__class__(super().__rmul__(num))
 
     def accummulate[L](
         self, f: Callable[[L, D], L], s: L | None = None, /
-    ) -> FTuple[L]:
+    ) -> 'FTuple[L]':
         """Accumulate partial folds
 
         Accumulate partial fold results in an ``FTuple`` with an optional
@@ -160,14 +157,15 @@ class FTuple[D](tuple[D, ...]):
             return FTuple(accumulate(self, f))
         return FTuple(accumulate(self, f, s))
 
-    def map[U](self, f: Callable[[D], U], /) -> FTuple[U]:
+    def map[U](self, f: Callable[[D], U], /) -> 'FTuple[U]':
         return FTuple(map(f, self))
 
     def bind[U](
-            self, f: Callable[[D], FTuple[U]],
-            merge_enum: MergeEnum = MergeEnum.Concat,
-            yield_partials: bool = False,
-        ) -> FTuple[U] | Never:
+        self,
+        f: 'Callable[[D], FTuple[U]]',
+        merge_enum: MergeEnum = MergeEnum.Concat,
+        yield_partials: bool = False,
+    ) -> 'FTuple[U] | Never':
         """Bind function ``f`` to the ``FTuple``.
 
         :param ds: values to instantiate FTuple
@@ -176,9 +174,5 @@ class FTuple[D](tuple[D, ...]):
 
         """
         return FTuple(
-            blend(
-                *map(f, self),
-                merge_enum=merge_enum,
-                yield_partials=yield_partials
-            )
+            blend(*map(f, self), merge_enum=merge_enum, yield_partials=yield_partials)
         )

pythonic_fp_containers-3.0.1/src/pythonic_fp/containers/functional_tuple.pyi

@@ -0,0 +1,58 @@
+# 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, Iterator
+from typing import Never, overload, TypeVar, SupportsIndex
+from pythonic_fp.iterables.merging import MergeEnum
+
+__all__ = ['FTuple']
+
+D = TypeVar('D', covariant=True)
+
+class FTuple[D](tuple[D, ...]):
+    def __reversed__(self) -> Iterator[D]: ...
+    def __repr__(self) -> str: ...
+    def __eq__(self, other: object, /) -> bool: ...
+    @overload
+    def __getitem__(self, idx: SupportsIndex) -> D: ...
+    @overload
+    def __getitem__(self, idx: slice) -> tuple[D, ...]: ...
+    def foldl[L](
+        self,
+        f: Callable[[L, D], L],
+        /,
+        start: L | None = None,
+        default: L | None = None,
+    ) -> L | None: ...
+    def foldr[R](
+        self,
+        f: Callable[[D, R], R],
+        /,
+        start: R | None = None,
+        default: R | None = None,
+    ) -> R | None: ...
+    def copy(self) -> FTuple[D]: ...
+    def __add__(self, other: object, /) -> tuple[D, ...]: ...
+    def __mul__(self, num: SupportsIndex) -> tuple[D, ...]: ...
+    def __rmul__(self, num: SupportsIndex) -> tuple[D, ...]: ...
+    def accummulate[L](
+        self, f: Callable[[L, D], L], s: L | None = None, /
+    ) -> FTuple[L]: ...
+    def map[U](self, f: Callable[[D], U], /) -> FTuple[U]: ...
+    def bind[U](
+        self,
+        f: Callable[[D], FTuple[U]],
+        merge_enum: MergeEnum = MergeEnum.Concat,
+        yield_partials: bool = False,
+    ) -> FTuple[U] | Never: ...

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/src/pythonic_fp/containers/immutable_list.py

@@ -23,8 +23,6 @@
 
 """
 
-from __future__ import annotations
-
 from collections.abc import Callable, Iterable, Iterator, Hashable
 from typing import cast, Never, overload, TypeVar
 from pythonic_fp.iterables.folding import accumulate
@@ -35,6 +33,7 @@ __all__ = ['IList']
 D = TypeVar('D', covariant=True)
 T = TypeVar('T')
 
+
 class IList[D](Hashable):
     """Immutable List like data structure.
 
@@ -45,6 +44,7 @@ class IList[D](Hashable):
     - both left and right int multiplication supported
 
     """
+
     __slots__ = ('_ds', '_len', '_hash')
     __match_args__ = ('_ds', '_len')
 
@@ -98,9 +98,9 @@ class IList[D](Hashable):
     @overload
     def __getitem__(self, idx: int, /) -> D: ...
     @overload
-    def __getitem__(self, idx: slice, /) -> IList[D]: ...
+    def __getitem__(self, idx: slice, /) -> 'IList[D]': ...
 
-    def __getitem__(self, idx: slice | int, /) -> IList[D] | D:
+    def __getitem__(self, idx: slice | int, /) -> 'IList[D] | D':
         if isinstance(idx, slice):
             return IList(self._ds[idx])
         return self._ds[idx]
@@ -116,7 +116,7 @@ class IList[D](Hashable):
 
         - fold left with an optional starting value
         - first argument of function ``f`` is for the accumulated value
-        
+
         "raises ValueError: when empty and a start value not given
 
         """
@@ -167,22 +167,22 @@ class IList[D](Hashable):
             acc = f(v, acc)
         return acc
 
-    def __add__(self, other: IList[D], /) -> IList[D]:
+    def __add__(self, other: 'IList[D]', /) -> 'IList[D]':
         if not isinstance(other, IList):
             msg = 'IList being added to something not a IList'
             raise ValueError(msg)
 
         return IList(concat(self, other))
 
-    def __mul__(self, num: int, /) -> IList[D]:
+    def __mul__(self, num: int, /) -> 'IList[D]':
         return IList(self._ds.__mul__(num if num > 0 else 0))
 
-    def __rmul__(self, num: int, /) -> IList[D]:
+    def __rmul__(self, num: int, /) -> 'IList[D]':
         return IList(self._ds.__mul__(num if num > 0 else 0))
 
     def accummulate[L](
         self, f: Callable[[L, D], L], s: L | None = None, /
-    ) -> IList[L]:
+    ) -> 'IList[L]':
         """Accumulate partial folds
 
         Accumulate partial fold results in an IList with
@@ -193,15 +193,15 @@ class IList[D](Hashable):
             return IList(accumulate(self, f))
         return IList(accumulate(self, f, s))
 
-    def map[U](self, f: Callable[[D], U], /) -> IList[U]:
+    def map[U](self, f: Callable[[D], U], /) -> 'IList[U]':
         return IList(map(f, self))
 
     def bind[U](
-            self,
-            f: Callable[[D], IList[U]],
-            merge_enum: MergeEnum = MergeEnum.Concat,
-            yield_partials: bool = False,
-        ) -> IList[U] | Never:
+        self,
+        f: 'Callable[[D], IList[U]]',
+        merge_enum: MergeEnum = MergeEnum.Concat,
+        yield_partials: bool = False,
+    ) -> 'IList[U] | Never':
         """Bind function `f` to the `IList`.
 
         :param ds: values to instantiate IList
@@ -210,9 +210,5 @@ class IList[D](Hashable):
 
         """
         return IList(
-            blend(
-                *map(f, self),
-                merge_enum=merge_enum,
-                yield_partials=yield_partials
-            )
+            blend(*map(f, self), merge_enum=merge_enum, yield_partials=yield_partials)
         )

pythonic_fp_containers-3.0.1/src/pythonic_fp/containers/immutable_list.pyi

@@ -0,0 +1,72 @@
+# 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, Hashable
+from typing import Never, overload, TypeVar
+from pythonic_fp.iterables.merging import MergeEnum
+
+__all__ = ['IList']
+
+D = TypeVar('D', covariant=True)
+T = TypeVar('T')
+
+
+class IList[D](Hashable):
+    __slots__ = ('_ds', '_len', '_hash')
+    __match_args__ = ('_ds', '_len')
+
+    L = TypeVar('L')
+    R = TypeVar('R')
+    U = TypeVar('U')
+
+    def __init__(self, *dss: Iterable[D]) -> None: ...
+    def __hash__(self) -> int: ...
+    def __iter__(self) -> Iterator[D]: ...
+    def __reversed__(self) -> Iterator[D]: ...
+    def __bool__(self) -> bool: ...
+    def __len__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __eq__(self, other: object, /) -> bool: ...
+    @overload
+    def __getitem__(self, idx: int, /) -> D: ...
+    @overload
+    def __getitem__(self, idx: slice, /) -> IList[D]: ...
+    def foldl[L](
+        self,
+        f: Callable[[L, D], L],
+        /,
+        start: L | None = None,
+        default: L | None = None,
+    ) -> L | None: ...
+    def foldr[R](
+        self,
+        f: Callable[[D, R], R],
+        /,
+        start: R | None = None,
+        default: R | None = None,
+    ) -> R | None: ...
+    def __add__(self, other: IList[D], /) -> IList[D]: ...
+    def __mul__(self, num: int, /) -> IList[D]: ...
+    def __rmul__(self, num: int, /) -> IList[D]: ...
+    def accummulate[L](
+        self, f: Callable[[L, D], L], s: L | None = None, /
+    ) -> IList[L]: ...
+    def map[U](self, f: Callable[[D], U], /) -> IList[U]: ...
+    def bind[U](
+        self,
+        f: Callable[[D], IList[U]],
+        merge_enum: MergeEnum = MergeEnum.Concat,
+        yield_partials: bool = False,
+    ) -> IList[U] | Never: ...

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/src/pythonic_fp/containers/queues/de.py

@@ -22,8 +22,6 @@
 - neither indexable nor sliceable by design
 
 """
-from __future__ import annotations
-
 from collections.abc import Callable, Iterable, Iterator
 from typing import TypeVar
 from pythonic_fp.circulararray.auto import CA
@@ -76,7 +74,7 @@ class DEQueue[D]:
     def __str__(self) -> str:
         return '>< ' + ' | '.join(map(str, self)) + ' ><'
 
-    def copy(self) -> DEQueue[D]:
+    def copy(self) -> 'DEQueue[D]':
         """Shallow copy.
 
         :return: shallow copy of the DEQueue
@@ -166,7 +164,7 @@ class DEQueue[D]:
                 return MayBe()
         return MayBe(self._ca.foldr(f, start))
 
-    def map[U](self, f: Callable[[D], U]) -> DEQueue[U]:
+    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

pythonic_fp_containers-3.0.1/src/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-3.0.0 → pythonic_fp_containers-3.0.1}/src/pythonic_fp/containers/queues/fifo.py

@@ -22,8 +22,6 @@
 - O(1) length determination
 
 """
-from __future__ import annotations
-
 from collections.abc import Callable, Iterable, Iterator
 from typing import TypeVar
 from pythonic_fp.circulararray.auto import CA
@@ -72,7 +70,7 @@ class FIFOQueue[D]:
     def __str__(self) -> str:
         return '<< ' + ' < '.join(map(str, self)) + ' <<'
 
-    def copy(self) -> FIFOQueue[D]:
+    def copy(self) -> 'FIFOQueue[D]':
         """Shallow copy.
 
         :return: shallow copy of the FIFOQueue
@@ -131,7 +129,7 @@ class FIFOQueue[D]:
                 return MayBe()
         return MayBe(self._ca.foldl(f, start))
 
-    def map[U](self, f: Callable[[D], U]) -> FIFOQueue[U]:
+    def map[U](self, f: Callable[[D], U]) -> 'FIFOQueue[U]':
         """Map f over the FIFOQueue, retain original order.
 
         :return: new FIFOQueue instance

pythonic_fp_containers-3.0.1/src/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-3.0.0 → pythonic_fp_containers-3.0.1}/src/pythonic_fp/containers/queues/lifo.py

@@ -22,8 +22,6 @@
 - O(1) length determination
 
 """
-from __future__ import annotations
-
 from collections.abc import Callable, Iterable, Iterator
 from typing import TypeVar
 from pythonic_fp.circulararray.auto import CA
@@ -73,7 +71,7 @@ class LIFOQueue[D]:
     def __str__(self) -> str:
         return '|| ' + ' > '.join(map(str, self)) + ' ><'
 
-    def copy(self) -> LIFOQueue[D]:
+    def copy(self) -> 'LIFOQueue[D]':
         """Shallow copy.
 
         :return: shallow copy of the LIFOQueue
@@ -122,7 +120,7 @@ class LIFOQueue[D]:
                 return MayBe()
         return MayBe(self._ca.foldr(swap(f), start))
 
-    def map[U](self, f: Callable[[D], U]) -> LIFOQueue[U]:
+    def map[U](self, f: Callable[[D], U]) -> 'LIFOQueue[U]':
         """Map f over the LIFOQueue, retain original order.
 
         :return: new LIFOQueue instance

pythonic_fp_containers-3.0.1/src/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.0 → pythonic_fp_containers-3.0.1}/tests/queues/test_queues.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import annotations
 from typing import Optional
 from pythonic_fp.circulararray.auto import ca
 from pythonic_fp.circulararray.fixed import caf
@@ -24,6 +23,7 @@ from pythonic_fp.containers.queues.lifo import LIFOQueue as LQ
 from pythonic_fp.containers.queues.lifo import lifo_queue as lq
 from pythonic_fp.fptools.maybe import MayBe
 
+
 class TestQueueTypes:
     def test_mutate_map(self) -> None:
         de1: DE[int] = DE()

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/tests/test_functional_tuple.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import annotations
 from pythonic_fp.containers.functional_tuple import FTuple as FT
 from pythonic_fp.iterables.merging import MergeEnum
 
+
 class TestFunctionalTuple:
     """FunctionalTuple test suite"""
     def test_method_returns_copy(self) -> None:

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/tests/test_immutable_list.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import annotations
 from pythonic_fp.containers.immutable_list import IList
 from pythonic_fp.iterables.merging import MergeEnum
 
@@ -27,7 +26,6 @@ class TestImmutableList:
         assert il2[2] == il2[5] == 0
         assert il1[2] is not None and il1[2] * 2 == il1[5] == 6
 
-
     def test_empty(self) -> None:
         """Test functionality"""
         il1: IList[int] = IList()

{pythonic_fp_containers-3.0.0 → pythonic_fp_containers-3.0.1}/tests/test_immutable_list_fp.py

@@ -14,7 +14,6 @@
 
 """Test FP use cases"""
 
-from __future__ import annotations
 from pythonic_fp.containers.immutable_list import IList
 from pythonic_fp.splitends.splitend import SplitEnd as SE
 from pythonic_fp.iterables.merging import MergeEnum