pythonic-fp-circulararray 6.1.0__tar.gz → 6.1.1__tar.gz

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/.github/workflows/static.yml

@@ -6,7 +6,7 @@ on:
   workflow_dispatch:
 
 env:
-  RELEASE: '6.1.0'
+  RELEASE: '6.1.1'
   DEVEL: '6.1.1'
   PYTHON: '3.14'
 
@@ -42,7 +42,7 @@ jobs:
       - name: Build Release Docs
         run: |
           pip install pythonic-fp-circulararray
-          docs/gen_conf.py release ${{ env.RELEASE }} CircularArray circulararray > docs/source/conf.py
+          docs/gen_conf.py release ${{ env.RELEASE }} Circulararray circulararray > docs/source/conf.py
           sphinx-build -M html docs/source docs/build/release
 
       - name: Build Development Docs

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/.gitignore

@@ -3,7 +3,6 @@
 dist/
 docs/build/
 docs/source/conf.py
-docs/source/index.rst
 **/.dmypy.json
 **/.mypy_cache/
 **/.pytest_cache/

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/CHANGELOG.rst

@@ -17,6 +17,14 @@ See `Semantic Versioning 2.0.0 <https://semver.org>`_.
 Releases and Important Milestones
 ---------------------------------
 
+PyPI 6.1.0 - 2026-05-10
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Documentation is now complete and is now in maintenance mode.
+
+Maintainer appraises the Development Status for
+pythonic-fp-circulararray to be ``"5 - Production/Stable"``.
+
 PyPI 6.1.0 - 2026-05-03
 ~~~~~~~~~~~~~~~~~~~~~~~
 

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonic-fp-circulararray
-Version: 6.1.0
+Version: 6.1.1
 Summary: Circular Array
 Keywords: auto resizing,circular array,circulararray,dequeue,indexable,pop,push
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/docs/Makefile

@@ -3,9 +3,9 @@
 # Last and future releases
 #  - former needs to agree with PyPI
 #  - later needs to agree with pyproject.toml
-PROJECT_NAME = CircularArray
-PYPI_NAME = circularArray
-RELEASE_VERSION = 6.1.0
+PROJECT_NAME = Circular Array
+PYPI_NAME = circulararray
+RELEASE_VERSION = 6.1.1
 DEVEL_VERSION = 6.1.1
 CUSTOM_VERSION = 0.0.0
 

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/docs/source/docs/index.rst

@@ -1,8 +1,10 @@
 Circular Arrays
----------------
+===============
 
 .. automodule:: pythonic_fp.circulararray
-    :synopsis:
+    :no-members:
+    :ignore-module-all:
+    :no-index:
 
 .. toctree::
     :caption: Auto resizing circular array

pythonic_fp_circulararray-6.1.1/docs/source/index.rst

@@ -0,0 +1,30 @@
+pythonic-fp-circulararray
+=========================
+
+Project
+`Pythonic FP - Circulararray <https://pypi.org/project/pythonic-fp-circulararray/>`_
+one of the
+`Pythonic FP <https://grscheller.github.io/pythonic-fp/>`_
+PyPI projects.
+
+|RELEASE_STRING|
+
+.. toctree::
+    :caption: Overview
+    :hidden:
+
+    self
+
+.. toctree::
+    :caption: User Documentation
+
+    description
+    usage
+    releases
+    changelog
+
+.. toctree::
+    :caption: API Documentation
+    :maxdepth: 1
+
+    docs/index

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/docs/source/releases.rst

@@ -8,7 +8,13 @@ PyPI releases
 +===========================================================================================+==============+
 | `development <https://grscheller.github.io/pythonic-fp-circulararray/development/html/>`_ |              |
 +-------------------------------------------------------------------------------------------+--------------+
-| `v6.0.2 <https://grscheller.github.io/pythonic-fp-circulararray/release/html/>`_          | 2026-04-21   |
+| `v6.1.1 <https://grscheller.github.io/pythonic-fp-circulararray/release/html/>`_          | 2026-05-10   |
++-------------------------------------------------------------------------------------------+--------------+
+| v6.1.0                                                                                    | 2026-05-03   |
++-------------------------------------------------------------------------------------------+--------------+
+| v6.0.4                                                                                    | 2026-04-25   |
++-------------------------------------------------------------------------------------------+--------------+
+| v6.0.2                                                                                    | 2026-04-21   |
 +-------------------------------------------------------------------------------------------+--------------+
 | v6.0.1                                                                                    | 2026-01-08   |
 +-------------------------------------------------------------------------------------------+--------------+

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "pythonic-fp-circulararray"
-version = "6.1.0"
+version = "6.1.1"
 readme = "README.rst"
 requires-python = ">=3.13"
 authors = [

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/src/pythonic_fp/circulararray/auto.py

@@ -23,26 +23,32 @@ nada: Final[NoValue] = NoValue()
 
 class CA[X]:
     """
-    .. admonition:: Variable storage capacity circular array CA
+    .. admonition:: Auto resizing circular array CA
 
         - O(1) pops either end
         - O(1) amortized pushes either end
         - O(1) indexing, fully supports slicing
-        - auto-resizing more storage capacity when necessary, manually compatible
+        - auto-resizing more storage capacity when necessary,
+          manually compatible
         - iterable but not threadsafe
         - comparisons compare identity before equality, like builtins
         - in boolean context, falsy when empty, otherwise truthy
-        - function ``ca`` produces auto-resizing circular array from arguments
+        - function ``ca`` produces auto-resizing circular array
+          from arguments
 
     """
     __slots__ = '_xs', '_cnt', '_cap', '_front', '_rear'
 
     def __init__(self, *xs: Iterable[X]) -> None:
         """
-        :param xs: Takes 0 or 1 iterable parameters to initially
-                   populate the ``CA`` left (front) to right (back).
-        :raises ValueError: When more than one iterable is provided.
-        :raises TypeError: When passed a non-iterable parameter.
+        .. admonition:: initializer
+
+            Populate ``CA`` with an optional iterable
+            from front (left) to rear (right).
+
+            :param xs: Takes 0 or 1 iterable parameters.
+            :raises ValueError: When more than one parameter is provided.
+            :raises TypeError: When passed a non-iterable parameter.
 
         """
         if (size := len(xs)) > 1:
@@ -140,21 +146,39 @@ class CA[X]:
                     )
 
     def __bool__(self) -> bool:
+        """
+        .. admonition:: bool
+
+            - falsy when empty
+            - truthy when not empty
+
+            :returns: ``True`` when not empty,
+                      ``False`` otherwise.
+
+        """
         return self._cnt > 0
 
     def __len__(self) -> int:
+        """
+        .. admonition:: length
+
+            Number of items in the ``CA``.
+
+            :returns: The number of items in the ``CA``.
+
+        """
         return self._cnt
 
     def __eq__(self, other: object) -> bool:
         """
-        .. admonition:: Equality comparison
+        .. admonition:: equality comparison
 
             Efficiently compare ``CA`` to another object.
 
-        :param other: The object to be compared.
-        :returns: ``True`` if ``other`` is another ``CA`` whose
-                  contents compare as equal to the corresponding
-                  contents of the ``CA``, otherwise ``False``.
+            :param other: The object to be compared.
+            :returns: ``True`` if ``other`` is another ``CA`` whose
+                      contents compare as equal to the corresponding
+                      contents of the ``CA``, otherwise ``False``.
 
         """
         if self is other:
@@ -195,6 +219,22 @@ class CA[X]:
         return True
 
     def __iter__(self) -> Iterator[X]:
+        """
+        .. admonition:: iterate
+
+            Iterates circular array, front (left) to rear (right).
+
+            .. warning
+
+                Not thread safe, especially for long living iterators.
+
+                .. tip::
+
+                    Cache contents to make more thread tolerant. Put
+                    a lock around circular array during caching process
+                    to make threadsafe.
+
+        """
         if self._cnt > 0:
             (
                 capacity,
@@ -214,6 +254,22 @@ class CA[X]:
             yield cast(X, current_state[position])
 
     def __reversed__(self) -> Iterator[X]:
+        """
+        .. admonition:: reverse iterate
+
+            Iterates circular array, rear (right) to front (left).
+
+            .. warning
+
+                Not thread safe, especially for long living iterators.
+
+                .. tip::
+
+                    Cache contents to make more thread tolerant. Put
+                    a lock around circular array during caching process
+                    to make threadsafe.
+
+        """
         if self._cnt > 0:
             (
                 capacity,
@@ -238,6 +294,13 @@ class CA[X]:
     def __getitem__(self, idx: slice) -> 'CA[X]': ...
 
     def __getitem__(self, idx: int | slice) -> X | 'CA[X]':
+        """
+        .. admonition:: getitem
+
+            Auto resizing circular arrays are fully indexable
+            and sliceable.
+
+        """
         if isinstance(idx, slice):
             return CA(list(self)[idx])
 
@@ -263,6 +326,13 @@ class CA[X]:
     def __setitem__(self, idx: slice, vals: Iterable[X]) -> None: ...
 
     def __setitem__(self, idx: int | slice, vals: X | Iterable[X]) -> None:
+        """
+        .. admonition:: setitem
+
+            Auto resizing circular arrays are fully indexable
+            and sliceable.
+
+        """
         if isinstance(idx, slice):
             if isinstance(vals, Iterable):
                 item_list = list(self)
@@ -306,6 +376,13 @@ class CA[X]:
     def __delitem__(self, idx: slice) -> None: ...
 
     def __delitem__(self, idx: int | slice) -> None:
+        """
+        .. admonition:: delitem
+
+            Auto resizing circular arrays are fully indexable
+            and sliceable.
+
+        """
         item_list = list(self)
         del item_list[idx]
         _ca = CA(item_list)
@@ -326,38 +403,37 @@ class CA[X]:
 
     def __repr__(self) -> str:
         """
-        .. admonition:: String representation
+        .. admonition:: repr string
 
-            Return 'CA("repr(x1)", "repr(x2)", ..., "repr(xn)")'
-            where x1, x2, ..., xn are the circular array's
-            contents and "repr(xi)" is the repr-string for xi.
+            Construct string 'CA(x₁, x₂, … xₙ)' where
+            x₁, x₂, … xₙ are the contents displayed with ``repr()``.
 
-        :returns: A string to reproduce the ``CA``. 
+            :returns: A string to reproduce the ``CA``. 
 
         """
         return 'ca(' + ', '.join(map(repr, self)) + ')'
 
     def __str__(self) -> str:
         r"""
-        .. admonition:: User string
+        .. admonition:: user string
 
-            Return string '(\| x1, x2, ..., xn \|)'
-            where x1, x2, ..., xn are the circular array's
-            contents displayed as strings.
+            Construct string '(\| x₁, x₂, … xₙ \|)' where
+            x₁, x₂, ..., xₙ are the contents displayed with ``str()``.
 
-        :returns: A string meaningful to an end user.
+            :returns: A estring meaningful to an end user.
 
         """
         return '(| ' + ', '.join(map(str, self)) + ' |)'
 
     def pushl(self, *xs: X) -> None:
         """
-        .. admonition:: Push left
+        .. admonition:: push left
 
             Push items from the left onto the ``CA`` in the
             order they were iterated.
 
-        :param xs: Items to be pushed onto the front of the circular array from the left.
+            :param xs: Items to be pushed onto the front of the ``CA``
+                       from the left.
 
         """
         for x in xs:
@@ -375,12 +451,13 @@ class CA[X]:
 
     def pushr(self, *xs: X) -> None:
         """
-        .. admonition:: Push right
+        .. admonition:: push right
 
             Push items from the right onto the ``CA`` in the
             order they were iterated.
 
-        :param xs: Items to be pushed onto the rear of the ``CA`` from the right.
+            :param xs: Items to be pushed onto the rear of
+                       the ``CA`` from the right.
 
         """
         for item in xs:
@@ -398,12 +475,12 @@ class CA[X]:
 
     def popl(self) -> X:
         """
-        .. admonition:: Pop left
+        .. admonition:: pop left
 
             Pop a single items off the left side of the ``CA``.
 
-        :returns: Item popped from left side (front) of circular array.
-        :raises ValueError: When called on an empty circular array.
+            :returns: Item popped from left side (front) of the ``CA``.
+            :raises ValueError: When called on an empty ``CA``.
 
         """
         if self._cnt > 1:
@@ -439,12 +516,12 @@ class CA[X]:
 
     def popr(self) -> X:
         """
-        .. admonition:: Pop right
+        .. admonition:: pop right
 
             Pop a single items off the right side of the ``CA``.
 
-        :returns: Item popped from right side (rear) of circular array.
-        :raises ValueError: When called on an empty circular array.
+            :returns: Item popped from right side (rear) of the ``CA``.
+            :raises ValueError: When called on an empty ``CA``.
 
         """
         if self._cnt > 1:
@@ -480,14 +557,14 @@ class CA[X]:
 
     def popld(self, default: X) -> X:
         """
-        .. admonition:: Pop Left with default
+        .. admonition:: pop Left with default
 
             Pop a single items off the left side of the ``CA``.
 
-        :param default: Default value to return if ``CA`` is empty.
-        :returns: Item popped from left side (front) of circular array
-                  if not empty, otherwise return the provided default
-                  value.
+            :param default: Default value to return if ``CA`` is empty.
+            :returns: Item popped from left side (front) of the ``CA``
+                      if not empty, otherwise return the provided
+                      default value.
 
         """
         try:
@@ -497,14 +574,14 @@ class CA[X]:
 
     def poprd(self, default: X) -> X:
         """
-        .. admonition:: Pop Right with default
+        .. admonition:: pop Right with default
 
             Pop a single items off the right side of the ``CA``.
 
-        :param default: Default value to return if ``CA`` is empty.
-        :returns: Item popped from right side (rear) of circular array
-                  if not empty, otherwise return the provided default
-                  value.
+            :param default: Default value to return if ``CA`` is empty.
+            :returns: Item popped from right side (rear) of the ``CA``
+                      if not empty, otherwise return the provided
+                      default value.
 
         """
         try:
@@ -518,8 +595,9 @@ class CA[X]:
 
             Pop items off the left side of the ``CA``.
 
-        :param maximum: Maximum number of items to pop, may pop less if not enough items in ``CA``.
-        :returns: A ``tuple`` of the items popped, left to right.
+            :param maximum: Maximum number of items to pop,
+                            may pop less if not enough items in ``CA``.
+            :returns: A ``tuple`` of the items popped, left to right.
 
         """
         xs: list[X] = []
@@ -540,8 +618,9 @@ class CA[X]:
 
             Pop items off the right side of the ``CA``.
 
-        :param maximum: Maximum number of items to pop, may pop less if not enough items in ``CA``.
-        :returns: A ``tuple`` of the items popped, right to left.
+            :param maximum: Maximum number of items to pop,
+                            may pop less if not enough items in ``CA``.
+            :returns: A ``tuple`` of the items popped, right to left.
 
         """
         item_list: list[X] = []
@@ -561,7 +640,8 @@ class CA[X]:
             Rotate contents of ``CA`` to the left putting first
             item onto rear.
 
-        :param n: Number of times to shift items left. Default 1 time.
+            :param n: Number of times to shift items left.
+                      Default 1 time.
 
         """
         if self._cnt < 2:
@@ -576,7 +656,8 @@ class CA[X]:
             Rotate contents of ``CA`` to the right putting last
             item onto front.
 
-        :param n: Number of times to shift items right. Default 1 time.
+            :param n: Number of times to shift items right.
+                      Default 1 time.
 
         """
         if self._cnt < 2:
@@ -590,8 +671,8 @@ class CA[X]:
 
             Apply function ``f`` over the circular array's contents.
 
-        :param f: Callable from type ``X`` to type ``Y``.
-        :returns: New auto-resizing circular array instance.
+            :param f: Callable from type ``X`` to type ``Y``.
+            :returns: New auto-resizing circular array instance.
 
         """
         return CA(map(f, self))
@@ -607,10 +688,12 @@ class CA[X]:
 
             Fold ``CA`` left with a function and optional starting item.
 
-        :param f: Folding function, first argument to ``f`` is for the accumulator.
-        :param start: Optional starting item.
-        :returns: Reduced value produced by the left fold.
-        :raises ValueError: When circular array empty and ``start`` not given.
+            :param f: Folding function, first argument to ``f`` is for
+                      the accumulator.
+            :param start: Optional starting item.
+            :returns: Reduced value produced by the left fold.
+            :raises ValueError: When circular array empty and ``start``
+                                not given.
 
         """
         if self._cnt == 0:
@@ -641,10 +724,12 @@ class CA[X]:
 
             Fold ``CA`` right with a function and optional starting item.
 
-        :param f: Folding function, second argument to ``f`` is for the accumulator.
-        :param start: Optional starting item.
-        :returns: Reduced value produced by the right fold.
-        :raises ValueError: When circular array empty and ``start`` not given.
+            :param f: Folding function, second argument to ``f`` is for
+                      the accumulator.
+            :param start: Optional starting item.
+            :returns: Reduced value produced by the right fold.
+            :raises ValueError: When circular array empty and ``start``
+                                not given.
 
         """
         if self._cnt == 0:
@@ -670,7 +755,7 @@ class CA[X]:
 
             Get the current storage capacity of the circular array.
 
-        :returns: Current storage capacity.
+            :returns: Current storage capacity.
 
         """
         return self._cap
@@ -700,7 +785,7 @@ class CA[X]:
 
             Find fraction of the storage capacity which is filled.
 
-        :returns: The ratio count/capacity.
+            :returns: The ratio count/capacity.
 
         """
         return self._cnt / self._cap
@@ -713,7 +798,8 @@ class CA[X]:
             minimum storage capacity. To just compact the circular
             array, do not provide ``minimum_capacity``.
 
-        :param minimum_capacity: Minimum storage capacity to compact the circular array.
+        :param minimum_capacity: Minimum storage capacity to compact
+                                 the circular array.
 
         """
         self._compact_storage_capacity()
@@ -733,10 +819,11 @@ def ca[T](*ts: T) -> CA[T]:
     """
     .. admonition:: Circular array factory function
 
-        Produce a circular array from a variable number of arguments.
+        Produce a auto resizing circular array from
+        a variable number of arguments.
 
-    :param ts: Initial items for a new auto-resizing circular array.
-    :returns: New variable storage capacity circular array.
+        :param ts: Initial items for a new auto-resizing circular array.
+        :returns: New variable storage capacity circular array.
 
     """
     return CA(ts)

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/src/pythonic_fp/circulararray/fixed.py

@@ -31,19 +31,24 @@ class CAF[X]:
         - fixed total storage capacity
         - iterable but not threadsafe
         - comparisons compare identity before equality, like builtins
-        - in boolean context, falsy when either empty or full, otherwise truthy
-        - function ``caf`` produces fixed capacity circular array from arguments
+        - in boolean context, falsy when either empty or full,
+          otherwise truthy
+        - function ``caf`` produces fixed capacity circular array
+          from arguments
 
     """
     __slots__ = '_xs', '_cnt', '_cap', '_front', '_rear'
 
     def __init__(self, *xs: Iterable[X], cap: int = 2) -> None:
         """
-        :param xs: Takes 0 or 1 iterable parameters to initially
-                   populate the ``CAF`` left (front) to right (back).
-        :param cap: Minimum fixed storage capacity of circular array.
-        :raises ValueError: When more than one iterable is provided.
-        :raises TypeError: When passed a non-iterable positional parameter.
+        .. admonition:: initializer
+
+            Populate ``CAF`` with an optional iterable
+            from front (left) to rear (right).
+
+            :param xs: Takes 0 or 1 iterable parameters.
+            :raises ValueError: When more than one parameter is provided.
+            :raises TypeError: When passed a non-iterable parameter.
 
         """
         cap = max(2, cap)
@@ -68,21 +73,39 @@ class CAF[X]:
             self._rear = cnt - 1
 
     def __bool__(self) -> bool:
+        """
+        .. admonition:: bool
+
+            - falsy if either empty or full
+            - truthy otherwise
+
+            :returns: ``True`` when partially filled,
+                      ``False`` otherwise.
+
+        """
         return 0 < self._cnt < self._cap
 
     def __len__(self) -> int:
+        """
+        .. admonition:: length
+
+            Number of items in the ``CAF``.
+
+            :returns: The number of items in the ``CAF``.
+
+        """
         return self._cnt
 
     def __eq__(self, other: object) -> bool:
         """
-        .. admonition:: Equality comparison
+        .. admonition:: equality comparison
 
             Efficiently compare ``CAF`` to another object.
 
-        :param other: The object to be compared.
-        :returns: ``True`` if ``other`` is another ``CAF`` whose
-                  contents compare as equal to the corresponding
-                  contents of the ``CAF``, otherwise ``False``.
+            :param other: The object to be compared.
+            :returns: ``True`` if ``other`` is another ``CAF`` whose
+                      contents compare as equal to the corresponding
+                      contents of the ``CAF``, otherwise ``False``.
 
         """
         if self is other:
@@ -123,6 +146,22 @@ class CAF[X]:
         return True
 
     def __iter__(self) -> Iterator[X]:
+        """
+        .. admonition:: iterate
+
+            Iterates circular array, front (left) to rear (right).
+
+            .. warning
+
+                Not thread safe, especially for long living iterators.
+
+                .. tip::
+
+                    Cache contents to make more thread tolerant. Put
+                    a lock around circular array during caching process
+                    to make threadsafe.
+
+        """
         if self._cnt > 0:
             (
                 cap,
@@ -142,6 +181,22 @@ class CAF[X]:
             yield cast(X, current_state[position])
 
     def __reversed__(self) -> Iterator[X]:
+        """
+        .. admonition:: reverse iterate
+
+            Iterates circular array, rear (right) to front (left).
+
+            .. warning
+
+                Not thread safe, especially for long living iterators.
+
+                .. tip::
+
+                    Cache contents to make more thread tolerant. Put
+                    a lock around circular array during caching process
+                    to make threadsafe.
+
+        """
         if self._cnt > 0:
             (
                 cap,
@@ -161,6 +216,13 @@ class CAF[X]:
             yield cast(X, current_state[position])
 
     def __getitem__(self, idx: int) -> X:
+        """
+        .. admonition:: getitem
+
+            Fixed capacity circular arrays are indexable but
+            not sliceable.
+
+        """
         cnt = self._cnt
         if 0 <= idx < cnt:
             return cast(X, self._xs[(self._front + idx) % self._cap])
@@ -178,6 +240,13 @@ class CAF[X]:
         raise IndexError(msg1 + msg2 + msg3)
 
     def __setitem__(self, idx: int, val: X) -> None:
+        """
+        .. admonition:: setitem
+
+            Fixed capacity circular arrays are indexable but
+            not sliceable.
+
+        """
         cnt = self._cnt
         if 0 <= idx < cnt:
             self._xs[(self._front + idx) % self._cap] = val
@@ -193,6 +262,13 @@ class CAF[X]:
             raise IndexError(msg1 + msg2 + msg3)
 
     def __delitem__(self, idx: int) -> None:
+        """
+        .. admonition:: delitem
+
+            Fixed capacity circular arrays are indexable but
+            not sliceable.
+
+        """
         item_list = list(self)
         del item_list[idx]
         _ca = CAF(item_list, cap = self._cap)
@@ -211,38 +287,37 @@ class CAF[X]:
 
     def __repr__(self) -> str:
         """
-        .. admonition:: String representation
+        .. admonition:: repr string
 
-            Return 'CAF("repr(x1)", "repr(x2)", ..., "repr(xn)")'
-            where x1, x2, ..., xn are the circular array's
-            contents and "repr(xi)" is the repr-string for xi.
+            Construct string 'CAF(x₁, x₂, … xₙ)' where
+            x₁, x₂, … xₙ are the contents displayed with ``repr()``.
 
-        :returns: A string to reproduce the ``CAF``.
+            :returns: A string to reproduce the ``CAF``.
 
         """
         return 'caf(' + ', '.join(map(repr, self)) + ')'
 
     def __str__(self) -> str:
         r"""
-        .. admonition:: User string
+        .. admonition:: user string
+            Construct string '(\|x₁, x₂, … xₙ\|)' where
+            x₁, x₂, ..., xₙ are the contents displayed with ``str()``.
 
-            Return '(\|x1, x2, ..., xn\|)'
-            where x1, x2, ..., xn are the circular array's
-            contents displayed as strings.
-
-        :returns: A string meaningful to an end user.
+            :returns: A string meaningful to an end user.
 
         """
         return '(|' + ', '.join(map(str, self)) + '|)'
 
     def pushl(self, x: X) -> None:
         """
-        .. admonition:: Push left
+        .. admonition:: push left
 
             Push single item from the left onto the ``CAF``.
 
-        :param x: Single item to be pushed onto the front of the circular array from the left.
-        :raises ValueError: When called on a full fixed storage capacity circular array.
+            :param x: Single item to be pushed onto the front of
+                      the ``CAF`` from the left.
+            :raises ValueError: When called on a full fixed storage
+                                capacity circular array.
 
         """
         if self._cnt == self._cap:
@@ -261,12 +336,14 @@ class CAF[X]:
 
     def pushr(self, x: X) -> None:
         """
-        .. admonition:: Push right
+        .. admonition:: push right
 
             Push single item from the right onto the ``CAF``.
 
-        :param x: Single item to be pushed onto the rear of the circular array from the right.
-        :raises ValueError: When called on a full fixed storage capacity circular array.
+            :param x: Single item to be pushed onto the rear of
+                      the ``CAF`` from the right.
+            :raises ValueError: When called on a full fixed
+                                storage capacity circular array.
 
         """
         if self._cnt == self._cap:
@@ -285,12 +362,12 @@ class CAF[X]:
 
     def popl(self) -> X:
         """
-        .. admonition:: Pop left
+        .. admonition:: pop left
 
             Pop a single items off the left side of the ``CAF``.
 
-        :returns: Item popped from left side (front) of circular array.
-        :raises ValueError: When called on an empty circular array.
+            :returns: Item popped from left side (front) of the ``CAF``.
+            :raises ValueError: When called on an empty ``CAF``.
 
         """
         if self._cnt > 1:
@@ -326,12 +403,12 @@ class CAF[X]:
 
     def popr(self) -> X:
         """
-        .. admonition:: Pop right
+        .. admonition:: pop right
 
             Pop a single items off the right side of the ``CAF``.
 
-        :returns: Item popped from right side (rear) of circular array.
-        :raises ValueError: When called on an empty circular array.
+            :returns: Item popped from right side (rear) of the ``CAF``.
+            :raises ValueError: When called on an empty ``CAF``.
 
         """
         if self._cnt > 1:
@@ -367,14 +444,14 @@ class CAF[X]:
 
     def popld(self, default: X) -> X:
         """
-        .. admonition:: Pop Left with default
+        .. admonition:: pop Left with default
 
             Pop a single items off the left side of the ``CAF``.
 
-        :param default: Default value to return if ``CAF`` is empty.
-        :returns: Item popped from left side (front) of circular array
-                  if not empty, otherwise return the provided default
-                  value.
+            :param default: Default value to return if ``CAF`` is empty.
+            :returns: Item popped from left side (front) of the ``CAF``
+                      if not empty, otherwise return the provided
+                      default value.
 
         """
         try:
@@ -384,14 +461,14 @@ class CAF[X]:
 
     def poprd(self, default: X) -> X:
         """
-        .. admonition:: Pop Right with default
+        .. admonition:: pop Right with default
 
             Pop a single items off the right side of the ``CAF``.
 
-        :param default: Default value to return if ``CAF`` is empty.
-        :returns: Item popped from right side (rear) of circular array
-                  if not empty, otherwise return the provided default
-                  value.
+            :param default: Default value to return if ``CAF`` is empty.
+            :returns: Item popped from right side (rear) of the ``CAF``
+                      if not empty, otherwise return the provided
+                      default value.
 
         """
         try:
@@ -405,8 +482,9 @@ class CAF[X]:
 
             Pop items off the left side of the ``CAF``.
 
-        :param maximum: Maximum number of items to pop, may pop less if not enough items in ``CAF``.
-        :returns: A ``tuple`` of the items popped, left to right.
+            :param maximum: Maximum number of items to pop,
+                            may pop less if not enough items in ``CAF``.
+            :returns: A ``tuple`` of the items popped, left to right.
 
         """
         xs: list[X] = []
@@ -427,8 +505,9 @@ class CAF[X]:
 
             Pop items off the right side of the ``CAF``.
 
-        :param maximum: Maximum number of items to pop, may pop less if not enough items in ``CAF``.
-        :returns: A ``tuple`` of the items popped, right to left.
+            :param maximum: Maximum number of items to pop,
+                            may pop less if not enough items in ``CAF``.
+            :returns: A ``tuple`` of the items popped, right to left.
 
         """
         xs: list[X] = []
@@ -448,7 +527,8 @@ class CAF[X]:
             Rotate contents of ``CAF`` to the left putting first
             item onto rear.
 
-        :param n: Number of times to shift items left. Default 1 time.
+            :param n: Number of times to shift items left.
+                      Default 1 time.
 
         """
         if self._cnt < 2:
@@ -463,7 +543,8 @@ class CAF[X]:
             Rotate contents of ``CAF`` to the right putting last
             item onto front.
 
-        :param n: Number of times to shift items right. Default 1 time.
+            :param n: Number of times to shift items right.
+                      Default 1 time.
 
         """
         if self._cnt < 2:
@@ -477,8 +558,8 @@ class CAF[X]:
 
             Apply function ``f`` over the circular array's contents.
 
-        :param f: Callable from type ``X`` to type ``Y``.
-        :returns: New fixed capacity circular array instance.
+            :param f: Callable from type ``X`` to type ``Y``.
+            :returns: New fixed capacity circular array instance.
 
         """
         return CAF(map(f, self), cap = self._cap)
@@ -494,10 +575,12 @@ class CAF[X]:
 
             Fold ``CAF`` left with a function and optional starting item.
 
-        :param f: Folding function, first argument to ``f`` is for the accumulator.
-        :param start: Optional starting item.
-        :returns: Reduced value produced by the left fold.
-        :raises ValueError: When circular array empty and ``start`` not given.
+            :param f: Folding function, first argument to ``f`` is for
+                      the accumulator.
+            :param start: Optional starting item.
+            :returns: Reduced value produced by the left fold.
+            :raises ValueError: When circular array empty and ``start``
+                                not given.
 
         """
         if self._cnt == 0:
@@ -528,10 +611,12 @@ class CAF[X]:
 
             Fold ``CAF`` right left with a function and optional starting item.
 
-        :param f: Folding function, second argument to ``f`` is for the accumulator.
-        :param start: Optional starting item.
-        :returns: Reduced value produced by the right fold.
-        :raises ValueError: When circular array empty and ``start`` not given.
+            :param f: Folding function, second argument to ``f`` is for
+                      the accumulator.
+            :param start: Optional starting item.
+            :returns: Reduced value produced by the right fold.
+            :raises ValueError: When circular array empty and ``start``
+                                not given.
 
         """
         if self._cnt == 0:
@@ -557,8 +642,7 @@ class CAF[X]:
 
             Get the fixed storage capacity of the circular array.
 
-
-        :returns: Fixed storage capacity.
+            :returns: Fixed storage capacity.
 
         """
         return self._cap
@@ -588,7 +672,7 @@ class CAF[X]:
 
             Find fraction of the storage capacity which is filled.
 
-        :returns: The ratio count/capacity.
+            :returns: The ratio count/capacity.
 
         """
         return self._cnt / self._cap
@@ -598,11 +682,12 @@ def caf[T](*ts: T, cap: int = 2) -> CAF[T]:
     """
     .. admonition:: Circular array factory function
 
-        Produce a circular array from a variable number of arguments.
+        Produce a fixed capacity circular array from
+        a variable number of arguments.
 
-    :param ts: Initial items for a new fixed capacity circular array.
-    :param cap: The minimum storage capacity to set.
-    :returns: New fixed storage capacity circular array.
+        :param ts: Initial items for a new fixed capacity circular array.
+        :param cap: The minimum storage capacity to set.
+        :returns: New fixed storage capacity circular array.
 
     """
     return CAF(ts, cap=cap)

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/src/pythonic_fp/circulararray/fixed.pyi

@@ -5,16 +5,16 @@ __all__ = ['CAF', 'caf']
 
 class CAF[X]:
     def __init__(self, *xs: Iterable[X], cap: int = 2) -> None: ...
-    def __iter__(self) -> Iterator[X]: ...
-    def __reversed__(self) -> Iterator[X]: ...
     def __bool__(self) -> bool: ...
     def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __iter__(self) -> Iterator[X]: ...
+    def __reversed__(self) -> Iterator[X]: ...
     def __getitem__(self, idx: int) -> X: ...
     def __setitem__(self, idx: int, val: X) -> None: ...
     def __delitem__(self, idx: int) -> None: ...
-    def __eq__(self, other: object) -> bool: ...
-    def pushl(self, item: X) -> None: ...
-    def pushr(self, item: X) -> None: ...
+    def pushl(self, x: X) -> None: ...
+    def pushr(self, x: X) -> None: ...
     def popl(self) -> X: ...
     def popr(self) -> X: ...
     def popld(self, default: X) -> X: ...

{pythonic_fp_circulararray-6.1.0 → pythonic_fp_circulararray-6.1.1}/src/pythonic_fp/circulararray/auto.pyi

@@ -5,10 +5,11 @@ __all__ = ['CA', 'ca']
 
 class CA[X]:
     def __init__(self, *xs: Iterable[X]) -> None: ...
-    def __iter__(self) -> Iterator[X]: ...
-    def __reversed__(self) -> Iterator[X]: ...
     def __bool__(self) -> bool: ...
     def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __iter__(self) -> Iterator[X]: ...
+    def __reversed__(self) -> Iterator[X]: ...
     @overload
     def __getitem__(self, idx: int) -> X: ...
     @overload
@@ -21,7 +22,6 @@ class CA[X]:
     def __delitem__(self, idx: int) -> None: ...
     @overload
     def __delitem__(self, idx: slice) -> None: ...
-    def __eq__(self, other: object) -> bool: ...
     def pushl(self, *xs: X) -> None: ...
     def pushr(self, *xs: X) -> None: ...
     def popl(self) -> X: ...