pythonic-fp.containers 4.0.1__tar.gz → 4.2.0__tar.gz

pythonic_fp_containers-4.2.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: pythonic-fp-containers
+Version: 4.2.0
+Summary: Containers with FP interfaces.
+Keywords: functional_containers,functional_tuple,immutable_list
+Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
+License-File: LICENSE
+Requires-Dist: pythonic-fp-circulararray>=6.2.2,<6.3
+Requires-Dist: pythonic-fp-fptools>=6,<6.2
+Requires-Dist: pythonic-fp-iterables>=5.1.4,<6
+Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-containers/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://grscheller.github.io/pythonic-fp-containers/release/html/
+Project-URL: Homepage, https://grscheller.github.io/pythonic-fp/
+Project-URL: Source, https://github.com/grscheller/pythonic-fp-containers
+
+# Pythonic FP - Containers
+
+Python package for containers of like data structures with functional
+programming inspired tweaks.
+
+PyPI project
+[pythonic-fp-containers](https://pypi.org/project/pythonic-fp-containers).
+Part of the
+[pythonic-fp](https://grscheller.github.io/pythonic-fp/)
+PyPI projects.
+
+## Documentation
+
+Documentation and other links for this project are hosted on
+[GitHub Pages](https://grscheller.github.io/pythonic-fp/projects/containers.html).
+
+| module | class | name |
+|:------ |:-----:|:---- |
+| `pythonic_fp.containers.functional_tuple` | FTuple | Functional Tuple |
+| `pythonic_fp.containers.immutable_list` | IList | Immutable List |
+
+## Copyright and License
+
+Copyright (c) 2023-2026 Geoffrey R. Scheller. Licensed under the Apache
+License, Version 2.0. See the LICENSE file for details.
+

pythonic_fp_containers-4.2.0/README.md

@@ -0,0 +1,25 @@
+# Pythonic FP - Containers
+
+Python package for containers of like data structures with functional
+programming inspired tweaks.
+
+PyPI project
+[pythonic-fp-containers](https://pypi.org/project/pythonic-fp-containers).
+Part of the
+[pythonic-fp](https://grscheller.github.io/pythonic-fp/)
+PyPI projects.
+
+## Documentation
+
+Documentation and other links for this project are hosted on
+[GitHub Pages](https://grscheller.github.io/pythonic-fp/projects/containers.html).
+
+| module | class | name |
+|:------ |:-----:|:---- |
+| `pythonic_fp.containers.functional_tuple` | FTuple | Functional Tuple |
+| `pythonic_fp.containers.immutable_list` | IList | Immutable List |
+
+## Copyright and License
+
+Copyright (c) 2023-2026 Geoffrey R. Scheller. Licensed under the Apache
+License, Version 2.0. See the LICENSE file for details.

{pythonic_fp_containers-4.0.1 → pythonic_fp_containers-4.2.0}/pyproject.toml

@@ -1,10 +1,16 @@
+[build-system]
+requires = ["flit_core>=3.12,<4"]
+build-backend = "flit_core.buildapi"
+
 [project]
 name = "pythonic-fp-containers"
-version = "4.0.1"
-readme = "README.rst"
-requires-python = ">=3.12"
-license = { file = "LICENSE" }
-authors = [{ name = "Geoffrey R. Scheller", email = "geoffrey@scheller.com" }]
+version = "4.2.0"
+description = "Containers with FP interfaces."
+readme = "README.md"
+requires-python = ">=3.14"  # floor: PEP 649/749 deferred annotations — class-level self-reference possible NameErrors on <3.14
+authors = [
+  { name = "Geoffrey R. Scheller", email = "geoffrey@scheller.com" },
+]
 keywords = [
   "functional_containers",
   "functional_tuple",
@@ -16,65 +22,67 @@ classifiers = [
   "Intended Audience :: Developers",
   "License :: OSI Approved :: Apache Software License",
   "Operating System :: OS Independent",
-  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Typing :: Typed",
 ]
 dependencies = [
-  "pythonic-fp-circulararray>=6.0.1",
-  "pythonic-fp-fptools>=5.2.0",
-  "pythonic-fp-iterables>=5.1.3",
+  "pythonic-fp-circulararray>=6.2.2,<6.3",
+  "pythonic-fp-fptools>=6,<6.2",
+  "pythonic-fp-iterables>=5.1.4,<6",
 ]
-dynamic = ["description"]
 
 [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/"
-Homepage = "https://grscheller.github.io/pythonic-fp/homepage/build/html/"
+Changelog = "https://github.com/grscheller/pythonic-fp-containers/blob/main/CHANGELOG.md"
+Documentation ="https://grscheller.github.io/pythonic-fp-containers/release/html/"
+Homepage = "https://grscheller.github.io/pythonic-fp/"
 Source = "https://github.com/grscheller/pythonic-fp-containers"
 
-[project.optional-dependencies]
+[dependency-groups]
+docs = [
+  "furo>=2025.12.19",
+  "sphinx>=9.1",
+]
 test = [
   "pytest>=8.4.1",
 ]
 
-[build-system]
-requires = ["flit_core>=3.12,<4"]
-build-backend = "flit_core.buildapi"
-
 [tool.flit.module]
 name = "pythonic_fp.containers"
 
+[tool.flit.sdist]
+exclude = [
+  "docs/",
+  "tests/",
+]
+
+[tool.pytest]
+addopts = ["-ra"]
+consider_namespace_packages = true
+testpaths = ["tests/"]
+
 [tool.mypy]
-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
 
-[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/"]
-
 [tool.ruff]
-target-version = "py313"
+target-version = "py314"
+
+[tool.ruff.lint]
+ignore = ["RUF022", "E741"]
 
 [tool.ruff.lint.flake8-quotes]
 docstring-quotes = "double"
 
 [tool.ruff.lint.per-file-ignores]
-"tests/*" = ["C901"]
-"**/*.py" = ["E741"]
+"tests/**/*.py" = [
+  "E731",
+  "C901",
+]
 
 [tool.ruff.format]
 quote-style = "single"

{pythonic_fp_containers-4.0.1 → pythonic_fp_containers-4.2.0}/src/pythonic_fp/containers/__init__.py

@@ -13,16 +13,15 @@
 # limitations under the License.
 
 """
-Container with FP interfaces
-----------------------------
+Containers with FP interfaces
+-----------------------------
 
-+---------------------------------------------+-----------+------------------+
-| module                                      | class     | description      |
-+=============================================+===========+==================+
-| ``pythonic_fp.containers.functional_tuple`` | FTuple    | Functional Tuple |
-+---------------------------------------------+-----------+------------------+
-| ``pythonic_fp.containers.immutable_list``   | IList     | Immutable List   |
-+---------------------------------------------+-----------+------------------+
+.. admonition:: Functional variants of Python builtins
+
+    Not sure the direction this should take.
+
+    - class **FTuple:** A tuple-like object with a functional interface.
+    - class **IList:** An immutable, hashable list-like object.
 
 """
 

{pythonic_fp_containers-4.0.1 → pythonic_fp_containers-4.2.0}/src/pythonic_fp/containers/functional_tuple.py

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Pythonic FP - Functional Tuple"""
-
 from collections.abc import Callable, Iterator
 from typing import cast, Never, overload, SupportsIndex
 from pythonic_fp.iterables.folding import accumulate
@@ -25,26 +23,42 @@ __all__ = ['FTuple']
 
 class FTuple[D](tuple[D, ...]):
     """
-    .. admonition:: Functional Tuple suitable for inheritance.
+    .. admonition:: Functional Tuple
 
+        - intended for further inheritance
         - supports both indexing and slicing
         - int multiplication and FTuple addition supported
         - addition concatenates results, resulting in a Union type
         - both left and right int multiplication supported
         - homogeneous in its data type
-        - supports being further inherited from
         - unslotted
 
+        .. note::
+
+            Example of code very early in project. Different ways
+            to use __dunders__ than what I do lately.
+
     """
 
     def __reversed__(self) -> Iterator[D]:
+        """
+        .. admonition:: reverse iter
+
+            :yields: the tuples elements in reverse order
+
+        """
         for ii in range(len(self) - 1, -1, -1):
             yield (self[ii])
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}(' + ', '.join(map(repr, self)) + ')'
-
     def __eq__(self, other: object, /) -> bool:
+        """
+        .. admonition:: equality comparison
+
+            :param other: The ``object`` to which to be compared.
+            :returns: ``True`` if ``other`` is the same type and 
+                      corresponding elements compare as equal.
+
+        """
         if not isinstance(other, self.__class__):
             return False
         if (length := len(self)) != len(other):
@@ -67,6 +81,9 @@ class FTuple[D](tuple[D, ...]):
         else:
             return super().__getitem__(idx)
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}(' + ', '.join(map(repr, self)) + ')'
+
     def foldl[L](
         self,
         f: Callable[[L, D], L],
@@ -74,16 +91,20 @@ class FTuple[D](tuple[D, ...]):
         start: L | None = None,
         default: L | None = None,
     ) -> L:
-        """Fold Left with optional starting and default values.
+        """
+        .. admonition:: fold left
 
-        - fold left with an optional starting value
-        - first argument of function ``f`` is for the accumulated value
+            Reduce left with optional starting and default values.
 
-        :param f: The folding function, first argument is for the accumulated value.
-        :param start: An optional starting value.
-        :param default: An optional default value if fold does not exist.
-        :raises ValueError: When ``FTuple`` empty and a start value not given.
-        :returns: The folded value if it exists, otherwise the default value.
+            :param f: The folding function, first argument is for
+                      the accumulated value.
+            :param start: An optional starting value.
+            :param default: An optional default value
+                            if fold does not exist.
+            :raises ValueError: When ``FTuple`` empty and a start value
+                                was not not given.
+            :returns: Folded value if it exists, otherwise
+                      the default value if given.
 
         """
         it_self = iter(self)
@@ -107,13 +128,20 @@ class FTuple[D](tuple[D, ...]):
         start: R | None = None,
         default: R | None = None,
     ) -> R:
-        """Fold Right with optional starting and default values.
+        """
+        .. admonition:: fold right
 
-        :param f: The folding function, second argument is for the accumulated value.
-        :param start: An optional starting value.
-        :param default: An optional default value if fold does not exist.
-        :raises ValueError: when FTuple empty and a start value not given
-        :returns: The folded value if it exists, otherwise the default value.
+            Reduce right with optional starting and default values.
+
+            :param f: The folding function, second argument is for
+                    the accumulated value.
+            :param start: An optional starting value.
+            :param default: An optional default value
+                            if fold does not exist.
+            :raises ValueError: when ``FTuple`` empty and a start value
+                                was not given
+            :returns: The folded value if it exists, otherwise
+                      the default value if given.
 
         """
         it_self = reversed(self)
@@ -131,9 +159,13 @@ class FTuple[D](tuple[D, ...]):
         return acc
 
     def copy(self) -> 'FTuple[D]':
-        """Return a shallow copy of ``FTuple`` in O(1) time & space complexity.
+        """
+        .. admonition:: copy
 
-        :returns: New ``FTuple``.
+            Return a shallow copy of ``FTuple`` in O(1)
+            time & space complexity.
+
+            :returns: A new ``FTuple`` instance.
 
         """
         return self.__class__(self)
@@ -153,14 +185,12 @@ class FTuple[D](tuple[D, ...]):
     def accummulate[L](
         self, f: Callable[[L, D], L], s: L | None = None, /
     ) -> 'FTuple[L]':
-        """Accumulate partial folds.
-
-        Accumulate partial fold with an optional starting value,
-        results in an ``FTuple``.
+        """
+        .. admonition:: accumulate partial folds
 
-        :param f: Folding function used to produce partial folds.
-        :param s: Optional starting value.
-        :returns: New ``FTuple`` of the partial folds.
+            :param f: Folding function used to produce partial folds.
+            :param s: Optional starting value.
+            :returns: New ``FTuple`` of the partial folds.
 
         """
         if s is None:
@@ -168,6 +198,13 @@ class FTuple[D](tuple[D, ...]):
         return FTuple(accumulate(self, f, s))
 
     def map[U](self, f: Callable[[D], U], /) -> 'FTuple[U]':
+        """
+        .. admonition:: map
+
+            :param f: Folding function used to produce partial folds.
+            :returns: A new ``FTuple`` instance.
+
+        """
         return FTuple(map(f, self))
 
     def bind[U](
@@ -176,13 +213,17 @@ class FTuple[D](tuple[D, ...]):
         merge_type: MergeEnum = MergeEnum.Concat,
         yield_partials: bool = False,
     ) -> 'FTuple[U] | Never':
-        """Bind function ``f`` to the ``FTuple``.
+        """
+        .. admonition:: bind
+
+            Flat map function ``f`` with the ``FTuple`` with different
+            merging strategies.
 
-        :param f: Function ``D -> FTuple[U]``
-        :param merge_type: ``MergeEnum`` to determine how to merge the result. 
-        :param yield_partials: Yield unmatched values if ``MergeEnum`` given as merge type.
-        :return: Resulting ``FTuple``.
-        :raises ValueError: If given an unknown merge enumeration.
+            :param f: Function ``D -> FTuple[U]``
+            :param merge_type: ``MergeEnum`` to determine how to merge the result.
+            :param yield_partials: Yield unmatched values if ``MergeEnum`` given as merge type.
+            :returns: A new ``FTuple`` instance.
+            :raises ValueError: If given an unknown merge enumeration.
 
         """
         return FTuple(