pythonic-fp.splitends 1.0.2__py3-none-any.whl → 2.0.2__py3-none-any.whl

pythonic_fp/splitends/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2024-2025 Geoffrey R. Scheller
+# Copyright 2024-2026 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.
@@ -14,21 +14,25 @@
 
 """Mutable stack objects that can safely share data.
 
-Python package Implementing a singularly linked LIFO queue
-called a ``SplitEnd``. These data structures can safely share
-data nodes between themselves.
+Python package implementing a singularly linked stack of nodes called a ``SplitEnd``.
+While mutable, these data structures can safely share immutable data nodes between
+themselves. These nodes, of type ``SENode``, always contain data. A root node is
+a node whose previous node is itself. Root nodes mark the bottom of the stack.
 
-- each ``SplitEnd`` is a very simple stateful (mutable) LIFO stack
-- data can be "extended" to or "snipped" off of the end (tip)
-- the "root" value of a ``SplitEnd`` is fixed and cannot be "snipped"
-- different mutable split ends can safely share the same "tail"
-- each ``SplitEnd`` sees itself as a singularly linked list
-- bush-like datastructures can be formed using multiple ``SplitEnds``
-- the ``SplitEnd`` copy method and ``len`` are O(1)
-- in boolean context returns true if the ``SplitEnd`` is not just a "root"
+Like one of many "split ends" from shafts of hair, a ``SplitEnd`` can be "snipped"
+shorter or "extended" further from its "end" node at the top of the stack. Its "root"
+node is at the bottom of the stack and can not be "snipped" or "cut" off.
+
+A ``SplitEnd`` can be duplicated onto a compatible root node. By compatible, the
+new root must contain data that compares as equal to the old root node.
+
+**TODO:** A ``scalp`` is a container of root nodes all of whose contained data must
+be hashable. The ``scalp.add(d)`` method will return the unique root node with data
+that compares as equal to ``d``, or create a new root node if such a contained node
+does not exist.
 
 """
 
 __author__ = 'Geoffrey R. Scheller'
-__copyright__ = 'Copyright (c) 2023-2025 Geoffrey R. Scheller'
+__copyright__ = 'Copyright (c) 2023-2026 Geoffrey R. Scheller'
 __license__ = 'Apache License 2.0'

pythonic_fp/splitends/splitend.py

@@ -1,4 +1,4 @@
-# Copyright 2023-2025 Geoffrey R. Scheller
+# Copyright 2023-2026 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.
@@ -12,51 +12,83 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""LIFO stacks safely sharing immutable data between themselves."""
+"""
+Class SplitEnds
+---------------
 
-from collections.abc import Callable, Hashable, Iterator
-from typing import TypeVar
-from pythonic_fp.iterables.folding import maybe_fold_left
+.. admonition:: LIFO stacks safely sharing immutable data.
+
+    - each ``SplitEnd`` is a very simple stateful (mutable) LIFO stack
+    - data can be either "extended" to or "snipped" off the "end" 
+    - the "root" of a ``SplitEnd``
+
+      - it is fixed and cannot be removed from the ``SplitEnd``
+
+    - different mutable split ends can safely share the same "tail"
+    - each ``SplitEnd`` sees itself as a singularly linked list
+    - bush-like datastructures can be formed using multiple ``SplitEnds``
+    - the ``SplitEnd.split`` and ``len`` methods are O(1)
+    - in boolean context returns true if the ``SplitEnd`` is not just its "root"
+
+"""
+
+from collections.abc import Callable, Iterator
+from typing import cast, Final, overload
+from pythonic_fp.gadgets.sentinels.flavored import Sentinel
+from pythonic_fp.iterables.folding import reduce_left, fold_left
+from pythonic_fp.queues.lifo import LIFOQueue
 from .splitend_node import SENode
 
 __all__ = ['SplitEnd']
 
-D = TypeVar('D', bound=Hashable)
+type _SecretType = tuple[str, str, str]
+_secret_value: Final[_SecretType] = 'split', 'end', '_private'
+type _Sentinel = Sentinel[_SecretType]
+_sentinel: Final[_Sentinel] = Sentinel(_secret_value)
 
 
 class SplitEnd[D]:
-    """Like one of many "split ends" from a shaft of hair,
-    a ``splitend`` can be "snipped" shorter or "extended"
-    further from its "tip". Its root is irremovable and
-    cannot be "snipped" off. While mutable, different
-    splitends can safely share data with each other.
-
-    """
-
-    __slots__ = '_count', '_tip', '_root'
+    __slots__ = '_end', '_root', '_count'
 
-    def __init__(self, root_data: D, *data: D) -> None:
+    def __init__(self, *ds: D, root: SENode[D] | _Sentinel = _sentinel) -> None:
         """
-        :param root_data: irremovable initial data at bottom of stack
-        :param data: removable data to be pushed onto splitend stack
+        :param root_data: Irremovable initial data at bottom of stack.
+        :param data: Removable data to be pushed onto splitend stack.
 
         """
-        node: SENode[D] = SENode(root_data)
-        self._root = node
-        self._tip, self._count = node, 1
-        for d in data:
-            node = SENode(d, self._tip)
-            self._tip, self._count = node, self._count + 1
+        if root is _sentinel:
+            if ds:
+                root_node: SENode[D] = SENode(ds[0])
+                ds = ds[1:]
+            else:
+                msg = 'SplitEnd: No data provided for root node'
+                raise ValueError(msg)
+        else:
+            if root:
+                root_node = cast(SENode[D], root)
+            else:
+                msg = 'SplitEnd: Provided node is not a root node'
+                raise ValueError(msg)
+
+        end, count = root_node, 1
+        for d in ds:
+            node = SENode(d, end)
+            end, count = node, count + 1
+
+        self._end, self._root, self._count = end, root_node, count
 
     def __iter__(self) -> Iterator[D]:
-        return iter(self._tip)
+        return iter(self._end)
 
     def __reversed__(self) -> Iterator[D]:
         return reversed(list(self))
 
     def __bool__(self) -> bool:
-        # Returns true until all data is exhausted
-        return bool(self._tip)
+        """
+        :returns: ``True`` is ``SplitEnd`` is not just its root node.
+
+        """
+        return bool(self._end)
 
     def __len__(self) -> int:
         return self._count
@@ -76,18 +108,44 @@ class SplitEnd[D]:
         if self._root != other._root:
             return False
 
-        left = self._tip
-        right = other._tip
+        left = self._end
+        right = other._end
         for _ in range(self._count):
             if left is right:
                 return True
-            if left.peak() != right.peak():
+            if left.data() != right.data():
                 return False
             if left:
-                left = left._prev.get()
-                right = right._prev.get()
+                left = left.prev()
+                right = right.prev()
         return True
 
+    def cut(self, num: int | None = None) -> tuple[D, ...]:
+        """Cut data off end of ``SplitEnd``.
+
+        :param num: Optional number of nodes to cut, default is entire stack.
+        :returns: Tuple of data cut off from end.
+
+        """
+        if num is None or num > self._count:
+            num = self._count
+
+        data: tuple[D, ...] = ()
+        node = self._end
+        count = self._count
+        n = num
+        while n > 0:
+            d, node = node.both()
+            data = data + (d,)
+            n -= 1
+
+        if self._count - num > 1:
+            self._end, self._count = node, count - num
+        else:
+            self._end, self._count = node, 1
+
+        return data
+
     def extend(self, *ds: D) -> None:
         """Add data onto the tip of the SplitEnd. Like adding a hair
         extension.
@@ -96,59 +154,111 @@ class SplitEnd[D]:
 
         """
         for d in ds:
-            node = SENode(d, self._tip)
-            self._tip, self._count = node, self._count + 1
+            node = SENode(d, self._end)
+            self._end, self._count = node, self._count + 1
+
+    def peak(self) -> D:
+        """Return the data at end (top) of SplitEnd without consuming it.
+
+        :returns: The data at the end of the SplitEnd.
+
+        """
+        return self._end.data()
+
+    def root(self) -> SENode[D]:
+        """
+        :returns: The root SENode node of the SplitEnd.
+
+        """
+        return self._root
+
+    def reroot(self, root: SENode[D]) -> 'SplitEnd[D]':
+        """Create a brand new SplitEnd with the same data but different root.
+
+        .. note::
+
+            Two nodes are compatible root nodes if and only if
+
+            - they are both actually root nodes
+
+              - which implies that their previous nodes are themselves
+
+            - their data compare as equal
+
+              - comparing by identity is too strong for some use cases
+
+        :returns: New SplitEnd with the same data and the new ``root``.
+        :raises ValueError: If new and original root nodes are not compatible.
+
+        """
+        if not root:
+            msg = 'New root node is not a root node.'
+            raise ValueError(msg)
+        if root.data() != self._root.data():
+            msg = 'New root node not compatible with current root node.'
+            raise ValueError(msg)
+
+        lifo = LIFOQueue[D]()
+        for data in self:
+            lifo.push(data)
+        lifo.pop()
+
+        return SplitEnd(*lifo, root = root)
 
     def snip(self) -> D:
         """Snip data off tip of SplitEnd. Just return data if tip is root.
 
-        :returns: data snipped off tip, otherwise root data if tip is root
+        :returns: Data snipped off tip, just return root data if at root.
 
         """
         if self._count > 1:
-            data, self._tip, self._count = self._tip.pop2() + (self._count - 1,)
+            data, self._end, self._count = self._end.both() + (self._count - 1,)
         else:
-            data = self._tip.peak()
+            data = self._end.data()
 
         return data
 
-    def peak(self) -> D:
-        """Return data from tip of SplitEnd, do not consume it.
-
-        :returns: data at the end of the SplitEnd
+    def split(self, *ds: D) -> 'SplitEnd[D]':
+        """Split the end and add more data.
 
-        """
-        return self._tip.peak()
-
-    def copy(self) -> 'SplitEnd[D]':
-        """Return a copy of the SplitEnd. O(1) space & time complexity.
-
-        :returns: a new SplitEnd instance with same data and root
+        :returns: New instance, same data nodes plus additional ones on end.
 
         """
-        se: SplitEnd[D] = SplitEnd(self._root.peak())
-        se._count, se._tip, se._root = self._count, self._tip, self._root
+        se: SplitEnd[D] = SplitEnd(self._root.data())
+        se._count, se._end, se._root = self._count, self._end, self._root
+        se.extend(*ds)
         return se
 
+    @overload
+    def fold[T](self, f: Callable[[D, D], D]) -> D: ...
+    @overload
+    def fold[T](self, f: Callable[[T, D], T], init: T) -> T: ...
+
     def fold[T](self, f: Callable[[T, D], T], init: T | None = None) -> T:
-        """Reduce with a function, fold in natural LIFO Order.
+        """Reduce with a function, folding from tip to root.
 
-        :param f: folding function, for argument is for the accumulator
-        :param init: optional initial starting value for the fold
-        :returns: reduced value folding from tip to root in natural LIFO order
+        :param f: Folding function, first argument is for the accumulator.
+        :param init: Optional initial starting value for the fold.
+        :returns: Reduced value folding from tip to root in natural LIFO order.
 
         """
-        return self._tip.fold(f, init)
+        if init is None:
+            return self._end.fold(f)  # type: ignore
+        return self._end.fold(f, init)
+
+    @overload
+    def rev_fold[T](self, f: Callable[[D, D], D]) -> D: ...
+    @overload
+    def rev_fold[T](self, f: Callable[[T, D], T], init: T) -> T: ...
 
     def rev_fold[T](self, f: Callable[[T, D], T], init: T | None = None) -> T:
         """Reduce with a function, fold from root to tip.
 
-        :param f: folding function, for argument is for the accumulator
-        :param init: optional initial starting value for the fold
-        :returns: reduced value folding from tip to root in natural LIFO order
+        :param f: Folding function, first argument is for the accumulator.
+        :param init: Optional initial starting value for the fold.
+        :returns: Reduced value folding from root to tip.
 
         """
-        # The get() is safe because SplitEnds are never "empty" due to the root.
         if init is None:
-            return maybe_fold_left(reversed(self), f).get()
-        return maybe_fold_left(reversed(self), f, init).get()
+            return cast(T, reduce_left(reversed(self), cast(Callable[[D, D], D], f)))
+        return fold_left(reversed(self), f, init)

pythonic_fp/splitends/splitend.pyi

@@ -1,38 +1,31 @@
-# 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, Hashable, Iterator
-from typing import TypeVar
+from .splitend_node import SENode
+from collections.abc import Callable, Iterator
+from pythonic_fp.gadgets.sentinels.flavored import Sentinel
+from typing import overload
 
 __all__ = ['SplitEnd']
 
-D = TypeVar('D', bound=Hashable)
-
+type _SecretType = tuple[str, str, str]
+type _Sentinel = Sentinel[_SecretType]
 class SplitEnd[D]:
-    __slots__ = '_count', '_tip', '_root'
-
-    def __init__(self, root_data: D, *data: D) -> None: ...
+    def __init__(self, *ds: D, root: SENode[D] | _Sentinel = ...) -> None: ...
     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: ...
+    def __eq__(self, other: object) -> bool: ...
+    def cut(self, num: int | None = None) -> tuple[D, ...]: ...
     def extend(self, *ds: D) -> None: ...
-    def snip(self) -> D: ...
     def peak(self) -> D: ...
-    def copy(self) -> SplitEnd[D]: ...
-    def fold[T](self, f: Callable[[T, D], T], init: T | None = None) -> T: ...
-    def rev_fold[T](self, f: Callable[[T, D], T], init: T | None = None) -> T: ...
+    def root(self) -> SENode[D]: ...
+    def reroot(self, root: SENode[D]) -> SplitEnd[D]: ...
+    def snip(self) -> D: ...
+    def split(self, *ds: D) -> SplitEnd[D]: ...
+    @overload
+    def fold[T](self, f: Callable[[D, D], D]) -> D: ...
+    @overload
+    def fold[T](self, f: Callable[[T, D], T], init: T) -> T: ...
+    @overload
+    def rev_fold[T](self, f: Callable[[D, D], D]) -> D: ...
+    @overload
+    def rev_fold[T](self, f: Callable[[T, D], T], init: T) -> T: ...

pythonic_fp/splitends/splitend_node.py

@@ -1,4 +1,4 @@
-# Copyright 2023-2025 Geoffrey R. Scheller
+# Copyright 2023-2026 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.
@@ -12,123 +12,137 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Data node class used privately by class SplitEnd.
-
-Node classes used to make bush-like graphs. API made public since it
-might prove useful to someone designing other data structures similar
-to a ``splitend``.
-
 """
+Class SENode
+------------
 
-from collections.abc import Callable, Hashable, Iterator
-from typing import cast, TypeVar
-from pythonic_fp.fptools.maybe import MayBe
-
-__all__ = ['SENode']
-
-D = TypeVar('D', bound=Hashable)
+.. admonition:: Used to make inwardly directed bush-like graphs
 
-
-class SENode[D]:
-    """Data node for class SplitEnd
-
-    - hashable data node for a end-to-root singularly linked list.
     - designed so multiple splitends can safely share the same data
-
+    - nodes always contain data
+    - data node ``SENode[D]`` make up end-to-root singularly linked lists
     - two nodes compare as equal if
 
       - both their previous Nodes are the same
       - their data compare as equal
 
+    - a root node is a node whose previous node is itself
+
+      - root nodes mark the bottom of splitend stacks
+
     - more than one node can point to the same proceeding node
 
       - forming bush like graphs
 
-    """
+"""
 
+from collections.abc import Callable, Iterator
+from typing import cast, Final, overload, Self
+from pythonic_fp.gadgets.sentinels.flavored import Sentinel
+
+__all__ = ['SENode']
+
+type _Sentinel = Sentinel[str]
+_sentinel: Final[_Sentinel] = Sentinel('_split_end_node_private_str')
+
+
+class SENode[D]:
     __slots__ = '_data', '_prev'
 
-    def __init__(self, data: D, prev: 'SENode[D] | None' = None) -> None:
+    def __init__(self, data: D, prev: Self | _Sentinel = _sentinel) -> None:
         """
-        :param data: nodes always contain data of type D
-        :param prev: potential link to a previous node
+        :param data: Nodes always contain data of type ``D``.
+        :param prev: Link to previous node. Points to ``self`` if a root node.
+        """
+        self._data = data
+        if prev is not _sentinel:
+            self._prev = cast(Self, prev)
+        else:
+            self._prev = self
 
+    def __bool__(self) -> bool:
         """
-        self._data: D = data
-        self._prev: MayBe[SENode[D]] = MayBe(prev) if prev is not None else MayBe()
+        :returns: ``True`` if ``SENode`` is not a root node.
+        """
+        return self._prev is not self
 
     def __iter__(self) -> Iterator[D]:
         node = self
         while node:
             yield node._data
-            node = node._prev.get()
+            node = node._prev
         yield node._data
 
-    def __bool__(self) -> bool:
-        return self._prev != MayBe()
-
     def __eq__(self, other: object) -> bool:
+        """
+        Two ``SENodes`` nodes are equal if their previous nodes are the
+        same object and their data compare as equal.
+
+        """
         if not isinstance(other, type(self)):
             return False
 
-        if self._prev != other._prev:
+        if self._prev is not other._prev:
             return False
         if self._data == other._data:
             return True
         return False
 
-    def peak(self) -> D:
-        """Returns contained data.
+    def both(self) -> tuple[D, Self]:
+        """Peak at data and previous node, if a root then data and self.
 
-        :returns: data stored in SENode
+        :returns: tuple of type tuple[D, SENode[D]]
 
         """
-        return self._data
+        return self._data, self._prev
 
-    def pop2(self) -> 'tuple[D, SENode[D]]':
-        """Return the data at the tip and the tail of the SENode.
+    def data(self) -> D:
+        """Peak at data.
 
-        :returns: a tuple of the data at the tip and the previous SENode
+        :returns: The data stored in the ``SENode``.
 
         """
-        if self._prev:
-            return self._data, self._prev.get()
-        return self._data, self
+        return self._data
 
-    def push(self, data: D) -> 'SENode[D]':
-        """Push data onto the queue and return a new node containing the data.
+    def prev(self) -> Self:
+        """Peak at previous node.
 
-        :param data: data to be pushed onto the SENode stack
-        :returns: the resulting SENode[D] representing the top of the stack
+        :returns: The previous node stored in the ``SENode``.
 
         """
-        return SENode(data, self)
+        return self._prev
 
-    def fold[T](self, f: Callable[[T, D], T], init: T | None = None) -> T:
-        """Fold data across linked nodes with a function..
+    def push(self, data: D) -> Self:
+        """Create a new ``SENode[D]``.
 
-        .. code:: python
+        :param data: Data for new node to contain.
+        :returns: New ``SENode`` whose previous node is the current node.
 
-            def fold[T](
-                    self,
-                    f: Callable([T, D], T],
-                    init: T | None = None
-            ) -> T
+        """
+        return cast(Self, SENode(data, self))
 
-        :param f: folding function, first argument is for accumulated value
-        :param init: optional initial starting value for the fold
-        :returns: reduced value folding from end to root in natural LIFO order
+    @overload
+    def fold(self, f: Callable[[D, D], D]) -> D: ...
+    @overload
+    def fold[T](self, f: Callable[[T, D], T], init: T) -> T: ...
+
+    def fold[T](self, f: Callable[[T, D], T], init: T | _Sentinel = _sentinel) -> T:
+        """Fold data across linked nodes with a function..
+
+        :param f: Folding function, first argument is for accumulated value.`
+        :param init: Optional initial starting value for the fold.
+        :returns: Reduced value folded from end to root in natural LIFO order.
 
         """
-        if init is None:
-            acc: T = cast(T, self._data)
-            node = self._prev.get()
-        else:
-            acc = init
+        if init is not _sentinel:
+            acc = cast(T, init)
             node = self
+        else:
+            acc = cast(T, self._data)  # in this case T = D
+            node = self._prev
 
         while node:
             acc = f(acc, node._data)
-            node = node._prev.get()
+            node = node._prev
         acc = f(acc, node._data)
         return acc

pythonic_fp/splitends/splitend_node.pyi

@@ -1,36 +1,20 @@
-# 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, Hashable, Iterator
-from typing import TypeVar
-from pythonic_fp.fptools.maybe import MayBe
+from collections.abc import Callable, Iterator
+from pythonic_fp.gadgets.sentinels.flavored import Sentinel
+from typing import Self, overload
 
 __all__ = ['SENode']
 
-D = TypeVar('D', bound=Hashable)
-
+type _Sentinel = Sentinel[str]
 class SENode[D]:
-    __slots__ = '_data', '_prev'
-
-    _data: D
-    _prev: MayBe[SENode[D]]
-
-    def __init__(self, data: D, prev: SENode[D] | None = None) -> None: ...
-    def __iter__(self) -> Iterator[D]: ...
+    def __init__(self, data: D, prev: Self | _Sentinel = ...) -> None: ...
     def __bool__(self) -> bool: ...
+    def __iter__(self) -> Iterator[D]: ...
     def __eq__(self, other: object) -> bool: ...
-    def peak(self) -> D: ...
-    def pop2(self) -> tuple[D, SENode[D]]: ...
-    def push(self, data: D) -> SENode[D]: ...
-    def fold[T](self, f: Callable[[T, D], T], init: T | None = None) -> T: ...
+    def both(self) -> tuple[D, Self]: ...
+    def data(self) -> D: ...
+    def prev(self) -> Self: ...
+    def push(self, data: D) -> Self: ...
+    @overload
+    def fold(self, f: Callable[[D, D], D]) -> D: ...
+    @overload
+    def fold[T](self, f: Callable[[T, D], T], init: T) -> T: ...

{pythonic_fp_splitends-1.0.2.dist-info → pythonic_fp_splitends-2.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonic-fp-splitends
-Version: 1.0.2
+Version: 2.0.2
 Summary: Mutable stack objects that can safely share data.
 Keywords: SplitEnd,lifo,stack
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
@@ -14,13 +14,13 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: pythonic-fp-fptools>=5.1.1
-Requires-Dist: pythonic-fp-iterables>=5.1.1
+Requires-Dist: pythonic-fp-fptools>=5.2.0
+Requires-Dist: pythonic-fp-iterables>=5.1.3
+Requires-Dist: pythonic-fp-queues>=5.1.1
 Requires-Dist: pytest>=8.4.1 ; extra == "test"
-Requires-Dist: pythonic-fp-gadgets>=3.0.0 ; extra == "test"
 Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-splitends/blob/main/CHANGELOG.rst
-Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/splitends/development/build/html/releases.html
-Project-URL: Homepage, https://github.com/grscheller/pythonic-fp/blob/main/README.md
+Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/splitends/development/build/html/
+Project-URL: Homepage, https://grscheller.github.io/pythonic-fp/homepage/build/html/
 Project-URL: Source, https://github.com/grscheller/pythonic-fp-splitends
 Provides-Extra: test
 
@@ -43,18 +43,17 @@ between themselves.
 - the ``SplitEnd`` copy method and ``len`` are O(1)
 - in boolean context returns true if the ``SplitEnd`` is not just a "root"
 
-This PyPI project is part of of the grscheller
-`pythonic-fp namespace projects <https://github.com/grscheller/pythonic-fp/blob/main/README.md>`_
-
-**Warning:** This PyPI project is Alpha level software and subject to
-change.
+Part of the
+`pythonic-fp
+<https://grscheller.github.io/pythonic-fp>`_
+PyPI projects.
 
 Documentation
 -------------
 
 Documentation for this project is hosted on
 `GitHub Pages
-<https://grscheller.github.io/pythonic-fp/splitends/development/build/html>`_.
+<https://grscheller.github.io/pythonic-fp/splitends>`_.
 
 Copyright and License
 ---------------------

pythonic_fp_splitends-2.0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+pythonic_fp/splitends/__init__.py,sha256=T3FgFehJkrlKx2OKHJJETDcEJ_2nKfyl96wTb4Nw6Fw,1780
+pythonic_fp/splitends/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonic_fp/splitends/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonic_fp/splitends/splitend.py,sha256=TkLQ5o4-SCnnC_HTpda6cSotaxyQ6aNbc8DB81qNqSI,8317
+pythonic_fp/splitends/splitend.pyi,sha256=OdTRATFXX5smbpwc8wm3gt4yyeTd_kN8VbMeNYl2Cho,1193
+pythonic_fp/splitends/splitend_node.py,sha256=0Qz_oIvwbvtlYZOD-tZ0lD4PxMRysFPkBNPTBkGdkQk,4306
+pythonic_fp/splitends/splitend_node.pyi,sha256=TozeGg4lmjMf0UPfZRTxRJR2kRpq0053VjbjIBUeosk,705
+pythonic_fp_splitends-2.0.2.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
+pythonic_fp_splitends-2.0.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pythonic_fp_splitends-2.0.2.dist-info/METADATA,sha256=l9gYIuYaAd9pIQwLAe_6AHnSjowRzx6JKsV4uxtI6dQ,2381
+pythonic_fp_splitends-2.0.2.dist-info/RECORD,,

pythonic_fp_splitends-1.0.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-pythonic_fp/splitends/__init__.py,sha256=gZzfqx_ODj0p32Zije6mFB-VUovxn2e8MGXjtpqcP2g,1457
-pythonic_fp/splitends/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pythonic_fp/splitends/splitend.py,sha256=k5oBCoTDL3OGKAgJ9bYeHZ5JL-FnRKwdQ7mEqS1e3x0,5018
-pythonic_fp/splitends/splitend.pyi,sha256=xBJHTBdMO0VzeyhIUTiflm3BA3Pfq1GOjy9kvJOju1Q,1437
-pythonic_fp/splitends/splitend_node.py,sha256=Fr74SpejGuLPK4giv1jKslX7NXxYe6Zh31Q3HDyAvEE,3894
-pythonic_fp/splitends/splitend_node.pyi,sha256=3vmKwiQBsJV0v043fkA6CVPaNSFeJ02chUuwIs3G-YY,1273
-pythonic_fp_splitends-1.0.2.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
-pythonic_fp_splitends-1.0.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pythonic_fp_splitends-1.0.2.dist-info/METADATA,sha256=jTPGsuy0qVW39R7EgbG60p2Gvwt3yYZY6v-cV8uICkQ,2575
-pythonic_fp_splitends-1.0.2.dist-info/RECORD,,