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

pythonic_fp/splitends/splitend.py

@@ -14,8 +14,6 @@
 
 """LIFO stacks safely sharing immutable data between themselves."""
 
-from __future__ import annotations
-
 from collections.abc import Callable, Hashable, Iterator
 from typing import TypeVar
 from pythonic_fp.iterables.folding import maybe_fold_left
@@ -34,6 +32,7 @@ class SplitEnd[D]:
     splitends can safely share data with each other.
 
     """
+
     __slots__ = '_count', '_tip', '_root'
 
     def __init__(self, root_data: D, *data: D) -> None:
@@ -103,7 +102,7 @@ class SplitEnd[D]:
     def snip(self) -> D:
         """Snip data off tip of SplitEnd. Just return data if tip is root.
 
-        :return: data snipped off tip, otherwise root data if tip is root
+        :returns: data snipped off tip, otherwise root data if tip is root
 
         """
         if self._count > 1:
@@ -116,48 +115,40 @@ class SplitEnd[D]:
     def peak(self) -> D:
         """Return data from tip of SplitEnd, do not consume it.
 
-        :return: data at the end of the SplitEnd
+        :returns: data at the end of the SplitEnd
 
         """
         return self._tip.peak()
 
-    def copy(self) -> SplitEnd[D]:
+    def copy(self) -> 'SplitEnd[D]':
         """Return a copy of the SplitEnd. O(1) space & time complexity.
 
-        :return: a new SplitEnd instance with same data and root
+        :returns: a new SplitEnd instance with same data and root
 
         """
         se: SplitEnd[D] = SplitEnd(self._root.peak())
         se._count, se._tip, se._root = self._count, self._tip, self._root
         return se
 
-    def fold[T](
-            self,
-            f: Callable[[T, D], T],
-            init: T | None = None
-        ) -> T:
+    def fold[T](self, f: Callable[[T, D], T], init: T | None = None) -> T:
         """Reduce with a function, fold in natural LIFO Order.
 
         :param f: folding function, for argument is for the accumulator
         :param init: optional initial starting value for the fold
-        :return: reduced value folding from tip to root in natural LIFO order
+        :returns: reduced value folding from tip to root in natural LIFO order
 
         """
         return self._tip.fold(f, init)
 
-    def rev_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:
         """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
-        :return: reduced value folding from tip to root in natural LIFO order
+        :returns: reduced value folding from tip to root in natural LIFO order
 
         """
-        # The get() is safe because SplitEnds are never "empty" due to the root. 
+        # 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()

pythonic_fp/splitends/splitend.pyi

@@ -0,0 +1,38 @@
+# 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
+
+__all__ = ['SplitEnd']
+
+D = TypeVar('D', bound=Hashable)
+
+class SplitEnd[D]:
+    __slots__ = '_count', '_tip', '_root'
+
+    def __init__(self, root_data: D, *data: D) -> 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 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: ...

pythonic_fp/splitends/splitend_node.py

@@ -19,7 +19,7 @@ might prove useful to someone designing other data structures similar
 to a ``splitend``.
 
 """
-from __future__ import annotations
+
 from collections.abc import Callable, Hashable, Iterator
 from typing import cast, TypeVar
 from pythonic_fp.fptools.maybe import MayBe
@@ -48,7 +48,7 @@ class SENode[D]:
 
     __slots__ = '_data', '_prev'
 
-    def __init__(self, data: D, prev: SENode[D] | None = None) -> None:
+    def __init__(self, data: D, prev: 'SENode[D] | None' = None) -> None:
         """
         :param data: nodes always contain data of type D
         :param prev: potential link to a previous node
@@ -78,24 +78,33 @@ class SENode[D]:
         return False
 
     def peak(self) -> D:
-        """Return contained data"""
+        """Returns contained data.
+
+        :returns: data stored in SENode
+
+        """
         return self._data
 
-    def pop2(self) -> tuple[D, SENode[D]]:
-        """Return the data at the tip and the tail of the senode."""
+    def pop2(self) -> 'tuple[D, SENode[D]]':
+        """Return the data at the tip and the tail of the SENode.
+
+        :returns: a tuple of the data at the tip and the previous SENode
+
+        """
         if self._prev:
             return self._data, self._prev.get()
         return self._data, self
 
-    def push(self, data: D) -> SENode[D]:
-        """Push data onto the queue and return a new node containing the data."""
+    def push(self, data: D) -> 'SENode[D]':
+        """Push data onto the queue and return a new node containing the data.
+
+        :param data: data to be pushed onto the SENode stack
+        :returns: the resulting SENode[D] representing the top of the stack
+
+        """
         return SENode(data, self)
 
-    def fold[T](
-            self,
-            f: Callable[[T, D], T],
-            init: T | None = None
-        ) -> T:
+    def fold[T](self, f: Callable[[T, D], T], init: T | None = None) -> T:
         """Fold data across linked nodes with a function..
 
         .. code:: python
@@ -108,7 +117,7 @@ class SENode[D]:
 
         :param f: folding function, first argument is for accumulated value
         :param init: optional initial starting value for the fold
-        :return: reduced value folding from end to root in natural LIFO order
+        :returns: reduced value folding from end to root in natural LIFO order
 
         """
         if init is None:

pythonic_fp/splitends/splitend_node.pyi

@@ -0,0 +1,36 @@
+# 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
+
+__all__ = ['SENode']
+
+D = TypeVar('D', bound=Hashable)
+
+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 __bool__(self) -> bool: ...
+    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: ...

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: pythonic-fp-splitends
-Version: 1.0.0
+Version: 1.0.2
 Summary: Mutable stack objects that can safely share data.
 Keywords: SplitEnd,lifo,stack
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
-Requires-Python: >=3.12
+Requires-Python: >=3.13
 Description-Content-Type: text/x-rst
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: Pytest
@@ -14,11 +14,10 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: pythonic-fp-iterables>=5.0.0
-Requires-Dist: pythonic-fp-fptools>=5.0.0
+Requires-Dist: pythonic-fp-fptools>=5.1.1
+Requires-Dist: pythonic-fp-iterables>=5.1.1
 Requires-Dist: pytest>=8.4.1 ; extra == "test"
-Requires-Dist: pythonic-fp>=1.1.0 ; extra == "test"
-Requires-Dist: pythonic-fp-singletons>=1.0.0 ; 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

pythonic_fp_splitends-1.0.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+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,,

pythonic_fp_splitends-1.0.0.dist-info/RECORD

@@ -1,8 +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=Th4aLzzS_fvIzt_zNn9Y3Dtb1gSJ9ZFI9QV-zQ-FEDg,5139
-pythonic_fp/splitends/splitend_node.py,sha256=YnXrbju5MW6wEjjDfGEmwZ_hjbaYWDi1p7zfM8cC_ug,3682
-pythonic_fp_splitends-1.0.0.dist-info/licenses/LICENSE,sha256=IJMkVWQUVy-SonK6SMaMotDQ6Zb-lVi2bUTiGp1GUO8,10774
-pythonic_fp_splitends-1.0.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pythonic_fp_splitends-1.0.0.dist-info/METADATA,sha256=TivzYvGfOjBAn-vNUmXsRLxowyRrgE_8g_RU3QhEIr8,2630
-pythonic_fp_splitends-1.0.0.dist-info/RECORD,,