dtools.datastructures 0.25.1__py3-none-any.whl → 0.25.2__py3-none-any.whl

dtools/datastructures/__init__.py

@@ -13,20 +13,20 @@
 # limitations under the License.
 
 """
-### package datastructures
+### Developer Tools - data structures for algorithms **DEPRICATED**
 
 Designed to be helpful when using and implementation algorithms.
 
 #### Modules and sub-packages
 
-* module dtools.datastructures.nodes: nodes for graph-like data structures
-* package dtools.datastructures.splitends: data sharing between mutable objects
-* module dtools.datastructures.tuples: tuple-like data structures
-* module dtools.datastructures.queues: queue data structures
+* module dtools.datastructures.nodes: partly incorporated into dtools.splitends
+* package dtools.datastructures.splitends: now dtools.splitends
+* module dtools.datastructures.tuples: now dtools.tuples
+* module dtools.datastructures.queues: now dtools.queues
 
 """
-__version__ = "0.25.1"
-__author__ = "Geoffrey R. Scheller"
-__copyright__ = "Copyright (c) 2023-2025 Geoffrey R. Scheller"
-__license__ = "Apache License 2.0"
 
+__version__ = '0.25.2'
+__author__ = 'Geoffrey R. Scheller'
+__copyright__ = 'Copyright (c) 2023-2025 Geoffrey R. Scheller'
+__license__ = 'Apache License 2.0'

dtools/datastructures/nodes.py

@@ -25,18 +25,20 @@ other data structures which contain these data structures.
 * class **Tree_Node:**
 
 """
+
 from __future__ import annotations
 from collections.abc import Callable, Iterator
-from typing import Callable, cast, Iterator, TypeVar
+from typing import cast, TypeVar
 from dtools.fp.err_handling import MB
 
 __all__ = ['SL_Node', 'DL_Node', 'Tree_Node']
 
-D = TypeVar('D')
+D = TypeVar('D')  # Not needed for mypy, hint for pdoc.
 M = TypeVar('M')
 T = TypeVar('T')
 
-class SL_Node[D]():
+
+class SL_Node[D]:
     """Data node for rearward Pointing (tip-to-root) singularly linked graphs.
 
     * for mutable and immutable linear data structures
@@ -52,6 +54,7 @@ class SL_Node[D]():
     * more than one node can point to the same node forming bush like graphs
 
     """
+
     __slots__ = '_data', '_prev'
 
     def __init__(self, data: D, prev: MB[SL_Node[D]]) -> None:
@@ -69,12 +72,14 @@ class SL_Node[D]():
         return self._prev != MB()
 
     def data_eq(self, other: SL_Node[D]) -> bool:
+        """Return true if other has same or equal data."""
         if self._data is other._data:
             return True
-        elif self._data == other._data:
+
+        if self._data == other._data:
             return True
-        else:
-            return False
+
+        return False
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, type(self)):
@@ -82,13 +87,14 @@ class SL_Node[D]():
 
         if self._prev is not other._prev:
             return False
-        else:
-            return self.data_eq(other)
+
+        return self.data_eq(other)
 
     def get_data(self) -> D:
+        """Return contained data"""
         return self._data
 
-    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 data across linked nodes.
 
         * with a function and an optional starting value
@@ -117,7 +123,8 @@ class SL_Node[D]():
         """Push data onto the stack and return a new node containing the data."""
         return SL_Node(data, MB(self))
 
-class DL_Node[D]():
+
+class DL_Node[D]:
     """Doubly Linked Node.
 
     Doubly linked nodes for graph-like data structures.
@@ -129,6 +136,7 @@ class DL_Node[D]():
     * simple recursive binary trees possible
 
     """
+
     __slots__ = '_left', '_data', '_right'
 
     def __init__(self, left: MB[DL_Node[D]], data: D, right: MB[DL_Node[D]]):
@@ -162,33 +170,33 @@ class DL_Node[D]():
     def has_right(self) -> bool:
         return self._right != MB()
 
-class Tree_Node[D, M]():
-    """Binary Tree Node with metadata.
+
+class Tree_Node[D]:
+    """Binary Tree Node.
 
     Nodes useful for binary trees.
 
     * this type of node always contain data, even if that data is None
     * in a Boolean context return true if not at the top of the tree
-    * potential uses of metadata can be for re-balancing or repeat counts
     """
+
     __slots__ = '_data', '_left', '_right', '_up'
 
-    def __init__(self, data: D,
-                 up: MB[Tree_Node[D,M]],
-                 left: MB[Tree_Node[D,M]],
-                 right: MB[Tree_Node[D,M]],
-                 meta: tuple[M, ...] = ()):
+    def __init__(
+        self,
+        data: D,
+        up: MB[Tree_Node[D]],
+        left: MB[Tree_Node[D]],
+        right: MB[Tree_Node[D]]
+    ):
         self._data = data
         self._up = up
         self._left = left
         self._right = right
 
     def __bool__(self) -> bool:
-        if self._up == MB():
-            return False
-        else:
-            return True
+        return bool(self)
 
     def is_top(self) -> bool:
+        """Return true if top node"""
         return self._up == MB()
-

dtools/datastructures/queues.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""### Queue based data structures
+"""
+### Queue based data structures
 
 * stateful queue data structures with amortized O(1) pushes and pops each end
 * obtaining length (number of elements) of a queue is an O(1) operation
@@ -39,6 +40,7 @@
 * function DQ: Constructs a DoubleQueue from a variable number of arguments
 
 """
+
 from __future__ import annotations
 
 from collections.abc import Callable, Iterable, Iterator, Sequence
@@ -46,14 +48,14 @@ from typing import Never, overload, TypeVar
 from dtools.circular_array.ca import ca, CA
 from dtools.fp.err_handling import MB
 
-__all__ = [ 'DoubleQueue', 'FIFOQueue', 'LIFOQueue', 'QueueBase',
-            'DQ', 'FQ', 'LQ' ]
+__all__ = ['DoubleQueue', 'FIFOQueue', 'LIFOQueue', 'QueueBase', 'DQ', 'FQ', 'LQ']
 
-D = TypeVar('D')
+D = TypeVar('D')  # Not needed for mypy, hint for pdoc.
 L = TypeVar('L')
 R = TypeVar('R')
 U = TypeVar('U')
 
+
 class QueueBase[D](Sequence[D]):
     """Base class for circular area based queues.
 
@@ -62,7 +64,8 @@ class QueueBase[D](Sequence[D]):
     * slicing not yet implemented
 
     """
-    __slots__ = '_ca'
+
+    __slots__ = ('_ca',)
 
     def __init__(self, *dss: Iterable[D]) -> None:
         if len(dss) < 2:
@@ -70,7 +73,7 @@ class QueueBase[D](Sequence[D]):
         else:
             msg1 = f'{type(self).__name__}: expected at most 1 '
             msg2 = f'iterable argument, got {len(dss)}.'
-            raise TypeError(msg1+msg2)
+            raise TypeError(msg1 + msg2)
 
     def __bool__(self) -> bool:
         return len(self._ca) > 0
@@ -88,11 +91,12 @@ class QueueBase[D](Sequence[D]):
     @overload
     def __getitem__(self, idx: slice, /) -> Sequence[D]: ...
 
-    def __getitem__(self, idx: int|slice, /) -> D|Sequence[D]|Never:
+    def __getitem__(self, idx: int | slice, /) -> D | Sequence[D] | Never:
         if isinstance(idx, slice):
             raise NotImplementedError
         return self._ca[idx]
 
+
 class FIFOQueue[D](QueueBase[D]):
     """FIFO Queue
 
@@ -100,6 +104,7 @@ class FIFOQueue[D](QueueBase[D]):
     * initial data pushed on in natural FIFO order
 
     """
+
     __slots__ = ()
 
     def __iter__(self) -> Iterator[D]:
@@ -112,7 +117,7 @@ class FIFOQueue[D](QueueBase[D]):
             return 'FQ(' + ', '.join(map(repr, self._ca)) + ')'
 
     def __str__(self) -> str:
-        return "<< " + " < ".join(map(str, self)) + " <<"
+        return '<< ' + ' < '.join(map(str, self)) + ' <<'
 
     def copy(self) -> FIFOQueue[D]:
         """Return a shallow copy of the `FIFOQueue`."""
@@ -164,7 +169,7 @@ class FIFOQueue[D](QueueBase[D]):
         else:
             return MB()
 
-    def fold[L](self, f: Callable[[L, D], L], initial: L|None=None, /) -> MB[L]:
+    def fold[L](self, f: Callable[[L, D], L], initial: L | None = None, /) -> MB[L]:
         """Fold `FIFOQueue` in natural order.
 
         Reduce with `f` using an optional initial value.
@@ -191,6 +196,7 @@ class FIFOQueue[D](QueueBase[D]):
         """
         return FIFOQueue(map(f, self._ca))
 
+
 class LIFOQueue[D](QueueBase[D]):
     """LIFO Queue.
 
@@ -198,6 +204,7 @@ class LIFOQueue[D](QueueBase[D]):
     * initial data pushed on in natural LIFO order
 
     """
+
     __slots__ = ()
 
     def __iter__(self) -> Iterator[D]:
@@ -206,11 +213,10 @@ class LIFOQueue[D](QueueBase[D]):
     def __repr__(self) -> str:
         if len(self) == 0:
             return 'LQ()'
-        else:
-            return 'LQ(' + ', '.join(map(repr, self._ca)) + ')'
+        return 'LQ(' + ', '.join(map(repr, self._ca)) + ')'
 
     def __str__(self) -> str:
-        return "|| " + " > ".join(map(str, self)) + " ><"
+        return '|| ' + ' > '.join(map(str, self)) + ' ><'
 
     def copy(self) -> LIFOQueue[D]:
         """Return a shallow copy of the `LIFOQueue`."""
@@ -233,8 +239,7 @@ class LIFOQueue[D](QueueBase[D]):
         """
         if self._ca:
             return MB(self._ca.popR())
-        else:
-            return MB()
+        return MB()
 
     def peak(self) -> MB[D]:
         """Peak next data out of `LIFOQueue`.
@@ -246,10 +251,9 @@ class LIFOQueue[D](QueueBase[D]):
         """
         if self._ca:
             return MB(self._ca[-1])
-        else:
-            return MB()
+        return MB()
 
-    def fold[R](self, f: Callable[[D, R], R], initial: R|None=None, /) -> MB[R]:
+    def fold[R](self, f: Callable[[D, R], R], initial: R | None = None, /) -> MB[R]:
         """Fold `LIFOQueue` in natural order.
 
         Reduce with `f` using an optional initial value.
@@ -276,6 +280,7 @@ class LIFOQueue[D](QueueBase[D]):
         """
         return LIFOQueue(reversed(CA(*map(f, reversed(self._ca)))))
 
+
 class DoubleQueue[D](QueueBase[D]):
     """Double Ended Queue
 
@@ -283,6 +288,7 @@ class DoubleQueue[D](QueueBase[D]):
     * order of initial data retained
 
     """
+
     __slots__ = ()
 
     def __iter__(self) -> Iterator[D]:
@@ -294,11 +300,10 @@ class DoubleQueue[D](QueueBase[D]):
     def __repr__(self) -> str:
         if len(self) == 0:
             return 'DQ()'
-        else:
-            return 'DQ(' + ', '.join(map(repr, self._ca)) + ')'
+        return 'DQ(' + ', '.join(map(repr, self._ca)) + ')'
 
     def __str__(self) -> str:
-        return ">< " + " | ".join(map(str, self)) + " ><"
+        return '>< ' + ' | '.join(map(str, self)) + ' ><'
 
     def copy(self) -> DoubleQueue[D]:
         """Return a shallow copy of the `DoubleQueue`."""
@@ -341,8 +346,7 @@ class DoubleQueue[D](QueueBase[D]):
         """
         if self._ca:
             return MB(self._ca.popR())
-        else:
-            return MB()
+        return MB()
 
     def peakL(self) -> MB[D]:
         """Peak left side of `DoubleQueue`.
@@ -354,8 +358,7 @@ class DoubleQueue[D](QueueBase[D]):
         """
         if self._ca:
             return MB(self._ca[0])
-        else:
-            return MB()
+        return MB()
 
     def peakR(self) -> MB[D]:
         """Peak right side of `DoubleQueue`.
@@ -367,10 +370,9 @@ class DoubleQueue[D](QueueBase[D]):
         """
         if self._ca:
             return MB(self._ca[-1])
-        else:
-            return MB()
+        return MB()
 
-    def foldL[L](self, f: Callable[[L, D], L], initial: L|None=None, /) -> MB[L]:
+    def foldL[L](self, f: Callable[[L, D], L], initial: L | None = None, /) -> MB[L]:
         """Fold `DoubleQueue` left to right.
 
         Reduce left with `f` using an optional initial value.
@@ -385,7 +387,7 @@ class DoubleQueue[D](QueueBase[D]):
                 return MB()
         return MB(self._ca.foldL(f, initial=initial))
 
-    def foldR[R](self, f: Callable[[D, R], R], initial: R|None=None, /) -> MB[R]:
+    def foldR[R](self, f: Callable[[D, R], R], initial: R | None = None, /) -> MB[R]:
         """Fold `DoubleQueue` right to left.
 
         Reduce right with `f` using an optional initial value.
@@ -411,15 +413,17 @@ class DoubleQueue[D](QueueBase[D]):
         """
         return DoubleQueue(map(f, self._ca))
 
+
 def FQ[D](*ds: D) -> FIFOQueue[D]:
     """Return a FIFOQueue where data is pushed on in natural FIFO order."""
     return FIFOQueue(ds)
 
+
 def LQ[D](*ds: D) -> LIFOQueue[D]:
     """Return a LIFOQueue where data is pushed on in natural LIFO order."""
     return LIFOQueue(ds)
 
+
 def DQ[D](*ds: D) -> DoubleQueue[D]:
     """Return a DoubleQueue whose data is pushed on from the right."""
     return DoubleQueue(ds)
-

dtools/datastructures/splitends/__init__.py

@@ -22,7 +22,7 @@ Singularly linked datastructures that can safely share data between themselves.
 * module **dtools.datastructures.splitends.se: Basic SplitEnd data structure
 
 """
-__author__ = "Geoffrey R. Scheller"
-__copyright__ = "Copyright (c) 2024-2025 Geoffrey R. Scheller"
-__license__ = "Apache License 2.0"
 
+__author__ = 'Geoffrey R. Scheller'
+__copyright__ = 'Copyright (c) 2024-2025 Geoffrey R. Scheller'
+__license__ = 'Apache License 2.0'

dtools/datastructures/splitends/se.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""### SplitEnd stack related data structures
+"""
+### SplitEnd stack related data structures
 
 With use I am finding this data structure needs some sort of supporting
 infrastructure. Hence I split the original splitend module out to be its own
@@ -24,19 +25,21 @@ subpackage.
 * function SE: create SplitEnd from a variable number of arguments
 
 """
+
 from __future__ import annotations
 
 from collections.abc import Callable, Iterable, Iterator
-from typing import cast, Never, TypeVar
-from ..nodes import SL_Node
+from typing import Never, TypeVar
 from dtools.fp.err_handling import MB
+from ..nodes import SL_Node
 
-__all__ = [ 'SplitEnd', 'SE' ]
+__all__ = ['SplitEnd', 'SE']
 
 D = TypeVar('D')
 T = TypeVar('T')
 
-class SplitEnd[D]():
+
+class SplitEnd[D]:
     """Class SplitEnd
 
     LIFO stacks which can safely share immutable data between themselves.
@@ -51,10 +54,11 @@ class SplitEnd[D]():
     * in boolean context, return true if split end is not empty
 
     """
+
     __slots__ = '_count', '_tip'
 
     def __init__(self, *dss: Iterable[D]) -> None:
-        if length:=len(dss) < 2:
+        if length := len(dss) < 2:
             self._tip: MB[SL_Node[D]] = MB()
             self._count: int = 0
             if length == 1:
@@ -62,7 +66,7 @@ class SplitEnd[D]():
         else:
             msg1 = 'SplitEnd: expected at most 1 '
             msg2 = f'iterable argument, got {length}.'
-            raise TypeError(msg1+msg2)
+            raise TypeError(msg1 + msg2)
 
     def __iter__(self) -> Iterator[D]:
         if self._tip == MB():
@@ -84,7 +88,7 @@ class SplitEnd[D]():
         return 'SE(' + ', '.join(map(repr, reversed(self))) + ')'
 
     def __str__(self) -> str:
-        return ('>< ' + ' -> '.join(map(str, self)) + ' ||')
+        return '>< ' + ' -> '.join(map(str, self)) + ' ||'
 
     def __eq__(self, other: object, /) -> bool:
         if not isinstance(other, type(self)):
@@ -112,15 +116,15 @@ class SplitEnd[D]():
         """Push data onto the top of the SplitEnd."""
         for d in ds:
             node = SL_Node(d, self._tip)
-            self._tip, self._count = MB(node), self._count+1
+            self._tip, self._count = MB(node), self._count + 1
 
     def push(self, *ds: D) -> None:
         """Push data onto the top of the SplitEnd."""
         for d in ds:
             node = SL_Node(d, self._tip)
-            self._tip, self._count = MB(node), self._count+1
+            self._tip, self._count = MB(node), self._count + 1
 
-    def pop(self, default: D|None = None, /) -> D|Never:
+    def pop(self, default: D | None = None, /) -> D | Never:
         """Pop data off of the top of the SplitEnd.
 
         * raises ValueError if
@@ -131,13 +135,12 @@ class SplitEnd[D]():
         if self._count == 0:
             if default is None:
                 raise ValueError('SE: Popping from an empty SplitEnd')
-            else:
-                return default
+            return default
 
-        data, self._tip, self._count = self._tip.get().pop2() + (self._count-1,)
+        data, self._tip, self._count = self._tip.get().pop2() + (self._count - 1,)
         return data
 
-    def peak(self, default: D|None = None, /) -> D:
+    def peak(self, default: D | None = None, /) -> D:
         """Return the data at the top of the SplitEnd.
 
         * does not consume the data
@@ -147,8 +150,7 @@ class SplitEnd[D]():
         if self._count == 0:
             if default is None:
                 raise ValueError('SE: Popping from an empty SplitEnd')
-            else:
-                return default
+            return default
 
         return self._tip.get().get_data()
 
@@ -163,7 +165,7 @@ class SplitEnd[D]():
         se._tip, se._count = self._tip, self._count
         return se
 
-    def fold[T](self, f:Callable[[T, D], T], init: T|None = None, /) -> T|Never:
+    def fold[T](self, f: Callable[[T, D], T], init: T | None = None, /) -> T | Never:
         """Reduce with a function.
 
         * folds in natural LIFO Order
@@ -171,12 +173,13 @@ class SplitEnd[D]():
         """
         if self._tip != MB():
             return self._tip.get().fold(f, init)
-        elif init is not None:
+
+        if init is not None:
             return init
-        else:
-            msg = 'SE: Folding empty SplitEnd but no initial value supplied'
-            raise ValueError(msg)
+
+        msg = 'SE: Folding empty SplitEnd but no initial value supplied'
+        raise ValueError(msg)
+
 
 def SE[D](*ds: D) -> SplitEnd[D]:
     return SplitEnd(ds)
-

dtools/datastructures/tuples.py

@@ -12,19 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""### Tuple based data structures
+"""
+### Tuple based data structures
 
 Only example here is the ftuple, basically an FP interface wrapping a tuple.
-Originally it inherited from tuple, but I found containing the tuple in a 
+Originally it inherited from tuple, but I found containing the tuple in a
 "has-a" relationship makes for a faster implementation. Buried in the git
 history is another example called a "process array" (parray) which I might
 return to someday. The idea of the parray is a fixed length sequence with
-sentinel values. 
+sentinel values.
 
 #### FTuple and FT factory function.
 
 * class FTuple: Wrapped tuple with a Functional Programming API
-* function FE: 
+* function FE:
 
 """
 
@@ -36,12 +37,13 @@ from dtools.fp.iterables import FM, accumulate, concat, exhaust, merge
 
 __all__ = ['FTuple', 'FT']
 
-D = TypeVar('D')
+D = TypeVar('D')  # Not needed for mypy, hint for pdoc.
 E = TypeVar('E')
 L = TypeVar('L')
-R = TypeVar('L')
+R = TypeVar('R')
 U = TypeVar('U')
 
+
 class FTuple[D](Sequence[D]):
     """
     #### Functional Tuple
@@ -53,7 +55,8 @@ class FTuple[D](Sequence[D]):
       * both left and right int multiplication supported
 
     """
-    __slots__ = '_ds'
+
+    __slots__ = ('_ds',)
 
     def __init__(self, *dss: Iterable[D]) -> None:
         if len(dss) < 2:
@@ -69,7 +72,7 @@ class FTuple[D](Sequence[D]):
         return reversed(self._ds)
 
     def __bool__(self) -> bool:
-        return bool(len(self._ds))
+        return bool(self._ds)
 
     def __len__(self) -> int:
         return len(self._ds)
@@ -78,7 +81,7 @@ class FTuple[D](Sequence[D]):
         return 'FT(' + ', '.join(map(repr, self)) + ')'
 
     def __str__(self) -> str:
-        return "((" + ", ".join(map(repr, self)) + "))"
+        return '((' + ', '.join(map(repr, self)) + '))'
 
     def __eq__(self, other: object, /) -> bool:
         if self is other:
@@ -92,16 +95,18 @@ class FTuple[D](Sequence[D]):
     @overload
     def __getitem__(self, idx: slice, /) -> FTuple[D]: ...
 
-    def __getitem__(self, idx: slice|int, /) -> FTuple[D]|D:
+    def __getitem__(self, idx: slice | int, /) -> FTuple[D] | D:
         if isinstance(idx, slice):
             return FTuple(self._ds[idx])
-        else:
-            return self._ds[idx]
-
-    def foldL[L](self,
-              f: Callable[[L, D], L], /,
-              start: L|None=None,
-              default: L|None=None) -> L|None:
+        return self._ds[idx]
+
+    def foldL[L](
+        self,
+        f: Callable[[L, D], L],
+        /,
+        start: L | None = None,
+        default: L | None = None,
+    ) -> L | None:
         """
         **Fold Left**
 
@@ -124,10 +129,13 @@ class FTuple[D](Sequence[D]):
             acc = f(acc, v)
         return acc
 
-    def foldR[R](self,
-              f: Callable[[D, R], R], /,
-              start: R|None=None,
-              default: R|None=None) -> R|None:
+    def foldR[R](
+        self,
+        f: Callable[[D, R], R],
+        /,
+        start: R | None = None,
+        default: R | None = None,
+    ) -> R | None:
         """
         **Fold Right**
 
@@ -159,7 +167,7 @@ class FTuple[D](Sequence[D]):
         """
         return FTuple(self)
 
-    def __add__[E](self, other: FTuple[E], /) -> FTuple[D|E]:
+    def __add__[E](self, other: FTuple[E], /) -> FTuple[D | E]:
         return FTuple(concat(self, other))
 
     def __mul__(self, num: int, /) -> FTuple[D]:
@@ -168,7 +176,9 @@ class FTuple[D](Sequence[D]):
     def __rmul__(self, num: int, /) -> FTuple[D]:
         return FTuple(self._ds.__mul__(num if num > 0 else 0))
 
-    def accummulate[L](self, f: Callable[[L, D], L], s: L|None=None, /) -> FTuple[L]:
+    def accummulate[L](
+        self, f: Callable[[L, D], L], s: L | None = None, /
+    ) -> FTuple[L]:
         """
         **Accumulate partial folds**
 
@@ -178,13 +188,14 @@ class FTuple[D](Sequence[D]):
         """
         if s is None:
             return FTuple(accumulate(self, f))
-        else:
-            return FTuple(accumulate(self, f, s))
+        return FTuple(accumulate(self, f, s))
 
     def map[U](self, f: Callable[[D], U], /) -> FTuple[U]:
         return FTuple(map(f, self))
 
-    def bind[U](self, f: Callable[[D], FTuple[U]], type: FM=FM.CONCAT, /) -> FTuple[U]:
+    def bind[U](
+        self, f: Callable[[D], FTuple[U]], type: FM = FM.CONCAT, /
+    ) -> FTuple[U]:
         """
         Bind function `f` to the `FTuple`.
 
@@ -195,15 +206,15 @@ class FTuple[D](Sequence[D]):
         """
         match type:
             case FM.CONCAT:
-                return FTuple(concat(*map(lambda x: iter(x), map(f, self))))
+                return FTuple(concat(*map(f, self)))
             case FM.MERGE:
-                return FTuple(merge(*map(lambda x: iter(x), map(f, self))))
+                return FTuple(merge(*map(f, self)))
             case FM.EXHAUST:
-                return FTuple(exhaust(*map(lambda x: iter(x), map(f, self))))
+                return FTuple(exhaust(*map(f, self)))
             case '*':
                 raise ValueError('Unknown FM type')
 
+
 def FT[D](*ds: D) -> FTuple[D]:
     """Return an FTuple whose values are the function arguments."""
     return FTuple(ds)
-

{dtools_datastructures-0.25.1.dist-info → dtools_datastructures-0.25.2.dist-info}/METADATA

@@ -1,18 +1,19 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: dtools.datastructures
-Version: 0.25.1
-Summary: ### package datastructures
+Version: 0.25.2
+Summary: ### Developer Tools - data structures for algorithms **DEPRICATED**
 Keywords: datastructures,data structures,fifo,lifo,stack,queue,SplitEnd
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 7 - Inactive
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
+License-File: LICENSE
 Requires-Dist: dtools.circular-array >= 3.9.0, < 3.10
 Requires-Dist: dtools.fp >= 1.4.0, < 1.5
 Requires-Dist: pytest >=8.3.2 ; extra == "test"
@@ -21,21 +22,27 @@ Project-URL: Documentation, https://grscheller.github.io/dtools-docs/datastructu
 Project-URL: Source, https://github.com/grscheller/dtools-datastructures
 Provides-Extra: test
 
-# Developer Tools - Datastructures Useful for Algorithms
+# Developer Tools - data structures useful for algorithms
+
+**DEPRECATED** This project was broken up into separate projects.
+
+* package dtools.datastructures.splitends `->` dtools.splitends
+* module dtools.datastructures.tuples `->` dtools.tuples
+* module dtools.datastructures.queues `->` dtools.queues
 
 Python package of data structures which support the use and
 implementation of algorithms.
 
-* **Repositories**
-  * [dtools.datastructures][1] project on *PyPI*
-  * [Source code][2] on *GitHub*
-* **Detailed documentation**
-  * [Detailed API documentation][3] on *GH-Pages*
+- **Repositories**
+  - [dtools.datastructures][1] project on *PyPI*
+  - [Source code][2] on *GitHub*
+- **Detailed documentation**
+  - [Detailed API documentation][3] on *GH-Pages*
 
 This project is part of the
 [Developer Tools for Python][4] **dtools.** namespace project.
 
-### Overview
+## Overview
 
 Data structures allowing developers to focus on the algorithms they are
 using instead of all the "bit fiddling" required to implement behaviors,
@@ -47,23 +54,22 @@ introducing inordinate complexity. Some of these data structures allow
 data to be safely shared between multiple data structure instances by
 making shared data immutable and inaccessible to client code.
 
-* functional & imperative programming styles supported
-  * functional programming encouraged
-  * project endeavors to remain Pythonic
-    * methods which mutate objects don't return anything
-      * like Python lists
-    * in caparisons identity is considered before equality
-      * like Python builtins
+- functional & imperative programming styles supported
+  - functional programming encouraged
+  - project endeavors to remain Pythonic
+    - methods which mutate objects don't return anything
+      - like Python lists
+    - in caparisons identity is considered before equality
+      - like Python builtins
 
 Sometimes the real power of a data structure comes not from what it
 empowers you to do, but from what it prevents you from doing to
 yourself.
 
----
+______________________________________________________________________
 
 [1]: https://pypi.org/project/dtools.datastructures/
 [2]: https://github.com/grscheller/dtools-datastructures/
 [3]: https://grscheller.github.io/dtools-docs/datastructures/
 [4]: https://github.com/grscheller/dtools-docs
 
-

dtools_datastructures-0.25.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+dtools/datastructures/__init__.py,sha256=edwJO3bIyCDcMy7ljHgr87gDlJCO8FvnrM0Ca3wH1iA,1181
+dtools/datastructures/nodes.py,sha256=diz30k76co1DX30jGlQKiR6PdbaUEUgp-Qsgsv0467c,5666
+dtools/datastructures/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dtools/datastructures/queues.py,sha256=DJLvhmW_CKvZu3ghiCm2ud74lUEQsoHcnwFCEJBSk2I,12111
+dtools/datastructures/tuples.py,sha256=TjGyA2roVZSBozRx9MxQRJ5aYaiLTckYwsesKoVcJ0k,6677
+dtools/datastructures/splitends/__init__.py,sha256=EvDVQRe7P7utFSTyLcglYxkXLpDP9ccjQzWxz-mcWZ4,946
+dtools/datastructures/splitends/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dtools/datastructures/splitends/se.py,sha256=XNVfoOfZh3KAQDTg4ZbinPLUyGokFywrfKLEVcmZF4k,5591
+dtools_datastructures-0.25.2.dist-info/licenses/LICENSE,sha256=csqbZRvA3Nyuav1aszWvswE8CZtaKr-hMjjjcKqms7w,10774
+dtools_datastructures-0.25.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+dtools_datastructures-0.25.2.dist-info/METADATA,sha256=1UgIeHlr9DYBjLkfK2b1XAhKEJw4PQXZm4V2WP5w6T0,3143
+dtools_datastructures-0.25.2.dist-info/RECORD,,

{dtools_datastructures-0.25.1.dist-info → dtools_datastructures-0.25.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.10.1
+Generator: flit 3.12.0
 Root-Is-Purelib: true
 Tag: py3-none-any

dtools_datastructures-0.25.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-dtools/datastructures/__init__.py,sha256=ST-ArKsBdvwM8l48BLTBGr-cljt6ulNw9N4QIRCC2Ck,1164
-dtools/datastructures/nodes.py,sha256=kbk1rcHhicQZssDguRxybakUi450qrfrHBSrf6blM78,5757
-dtools/datastructures/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dtools/datastructures/queues.py,sha256=BkvGl1Opooozz46mgPNPMgXnI57yXcABAP9lwXKk8_M,12173
-dtools/datastructures/tuples.py,sha256=uc1kU87rf6L9sOaBVRMKP8ZT1roACIm2pJUBaF_M5-k,6678
-dtools/datastructures/splitends/__init__.py,sha256=y9zPBG_ZM_l0uDWZr4Xown72VnR3dvqlhrvTybLP09c,946
-dtools/datastructures/splitends/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dtools/datastructures/splitends/se.py,sha256=M0lsaLVmb_zbt8CvXXGd090FUKzuxPgWtRfLvXtls_A,5644
-dtools_datastructures-0.25.1.dist-info/LICENSE,sha256=csqbZRvA3Nyuav1aszWvswE8CZtaKr-hMjjjcKqms7w,10774
-dtools_datastructures-0.25.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-dtools_datastructures-0.25.1.dist-info/METADATA,sha256=pG5tlUXUTkoolVEUtSzSgH_PcZvpgU_eYwmPfcoohGg,2764
-dtools_datastructures-0.25.1.dist-info/RECORD,,