knit-graphs 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

knit_graphs/Yarn.py

@@ -8,15 +8,17 @@ from __future__ import annotations
 
 from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, cast
-
-from networkx import DiGraph, dfs_edges, dfs_preorder_nodes
+from typing import TYPE_CHECKING, Self, TypeVar, cast, overload
 
+from knit_graphs.directed_loop_graph import Directed_Loop_Graph, Float_Edge
+from knit_graphs.knit_graph_errors.knit_graph_error import Use_Cut_Yarn_ValueError
 from knit_graphs.Loop import Loop
 
 if TYPE_CHECKING:
     from knit_graphs.Knit_Graph import Knit_Graph
 
+LoopT = TypeVar("LoopT", bound=Loop)
+
 
 @dataclass(frozen=True)
 class Yarn_Properties:
@@ -26,8 +28,6 @@ class Yarn_Properties:
     """
 
     name: str = "yarn"  # name (str): The name or identifier for this yarn type.
-    plies: int = 2  # plies (int): The number of individual strands twisted together to form the yarn.
-    weight: float = 28  # weight (float): The weight category or thickness of the yarn.
     color: str = "green"  # color (str): The color of the yarn for visualization purposes.
 
     def __str__(self) -> str:
@@ -36,7 +36,7 @@ class Yarn_Properties:
         Returns:
             str: String representation in format "name(plies-weight,color)".
         """
-        return f"{self.name}({self.plies}-{self.weight},{self.color})"
+        return f"{self.name}({self.color})"
 
     def __repr__(self) -> str:
         """Get the name of the yarn for debugging purposes.
@@ -64,13 +64,7 @@ class Yarn_Properties:
         Returns:
             bool: True if all properties (name, plies, weight, color) are equal, False otherwise.
         """
-        return (
-            isinstance(other, Yarn_Properties)
-            and self.name == other.name
-            and self.plies == other.plies
-            and self.weight == other.weight
-            and self.color == other.color
-        )
+        return isinstance(other, Yarn_Properties) and self.name == other.name and self.color == other.color
 
     def __hash__(self) -> int:
         """Get hash value for use in sets and dictionaries.
@@ -78,53 +72,57 @@ class Yarn_Properties:
         Returns:
             int: Hash value based on all yarn properties.
         """
-        return hash((self.name, self.plies, self.weight, self.color))
+        return hash((self.name, self.color))
 
 
-class Yarn:
+class Yarn(Directed_Loop_Graph[LoopT, Float_Edge[LoopT]]):
     """A class to represent a yarn structure as a sequence of connected loops.
 
     The Yarn class manages a directed graph of loops representing the physical yarn path through a knitted structure.
     It maintains the sequential order of loops and their floating relationships, providing methods for navigation and manipulation of the yarn structure.
 
     Attributes:
-        loop_graph (DiGraph): The directed graph loops connected by yarn-wise float edges.
         properties (Yarn_Properties): The physical and visual properties of this yarn.
     """
 
-    FRONT_LOOPS: str = "Front_Loops"
-    _BACK_LOOPS: str = "Back_Loops"
-
     def __init__(
         self,
-        yarn_properties: None | Yarn_Properties = None,
-        knit_graph: None | Knit_Graph = None,
+        yarn_properties: Yarn_Properties | None = None,
+        knit_graph: Knit_Graph[LoopT] | None = None,
+        instance: int = 0,
+        loop_class: type[LoopT] | None = None,
     ):
         """Initialize a yarn with the specified properties and optional knit graph association.
 
         Args:
             yarn_properties (None | Yarn_Properties, optional): The properties defining this yarn. If None, uses default properties. Defaults to standard properties.
             knit_graph (None | Knit_Graph, optional): The knit graph that will own this yarn. Can be None for standalone yarns. Defaults to None.
+            instance (int, optional): The instance of this yarn. As new yarns are formed by cuts, the instance will increase. Defaults to 0 (first instance of this yarn).
+            loop_class (type[LoopT], optional): The type of loop to create by default in this class. Defaults to Loop class.
         """
-        self.loop_graph: DiGraph = DiGraph()
+        super().__init__()
+        self._instance: int = instance
+        self._is_cut: bool = False
+        self._loop_class: type[LoopT] = loop_class if loop_class is not None else cast(type[LoopT], Loop)
         if yarn_properties is None:
             yarn_properties = Yarn_Properties.default_yarn()
         self.properties: Yarn_Properties = yarn_properties
-        self._first_loop: Loop | None = None
-        self._last_loop: Loop | None = None
-        self._knit_graph: None | Knit_Graph = knit_graph
+        self._first_loop: LoopT | None = None
+        self._last_loop: LoopT | None = None
+        self._knit_graph: Knit_Graph[LoopT] = knit_graph if knit_graph is not None else Knit_Graph[LoopT]()
+        if self not in self.knit_graph.yarns:
+            self.knit_graph.add_yarn(self)
 
     @property
-    def knit_graph(self) -> None | Knit_Graph:
-        """Get the knit graph that owns this yarn.
-
+    def knit_graph(self) -> Knit_Graph[LoopT]:
+        """
         Returns:
-            None | Knit_Graph: The knit graph that owns this yarn, or None if not associated with a graph.
+            Knit_Graph | Knit_Graph: The knit graph that owns this yarn, or None if not associated with a graph.
         """
         return self._knit_graph
 
     @knit_graph.setter
-    def knit_graph(self, knit_graph: Knit_Graph) -> None:
+    def knit_graph(self, knit_graph: Knit_Graph[LoopT]) -> None:
         """Set the knit graph that owns this yarn.
 
         Args:
@@ -132,88 +130,8 @@ class Yarn:
         """
         self._knit_graph = knit_graph
 
-    def has_float(self, u: Loop, v: Loop) -> bool:
-        """Check if there is a float edge between two loops on this yarn.
-
-        Args:
-            u (Loop): The first loop to check for float connection.
-            v (Loop): The second loop to check for float connection.
-
-        Returns:
-            bool: True if there is a float edge between the loops, False otherwise.
-        """
-        return bool(self.loop_graph.has_edge(u, v))
-
-    def add_loop_in_front_of_float(self, front_loop: Loop, u: Loop, v: Loop) -> None:
-        """Record that a loop falls in front of the float between two other loops.
-
-        Args:
-            front_loop (Loop): The loop that is positioned in front of the float.
-            u (Loop): The first loop in the float pair.
-            v (Loop): The second loop in the float pair.
-        """
-        if not self.has_float(u, v):
-            if self.has_float(v, u):
-                self.add_loop_in_front_of_float(front_loop, v, u)
-            else:
-                return
-        self.loop_graph.edges[u, v][self.FRONT_LOOPS].add(front_loop)
-        front_loop.add_loop_in_front_of_float(u, v)
-
-    def add_loop_behind_float(self, back_loop: Loop, u: Loop, v: Loop) -> None:
-        """Record that a loop falls behind the float between two other loops.
-
-        Args:
-            back_loop (Loop): The loop that is positioned behind the float.
-            u (Loop): The first loop in the float pair.
-            v (Loop): The second loop in the float pair.
-        """
-        if not self.has_float(u, v):
-            if self.has_float(v, u):
-                self.add_loop_behind_float(back_loop, v, u)
-            else:
-                return
-        self.loop_graph.edges[u, v][self._BACK_LOOPS].add(back_loop)
-        back_loop.add_loop_behind_float(u, v)
-
-    def get_loops_in_front_of_float(self, u: Loop, v: Loop) -> set[Loop]:
-        """Get all loops positioned in front of the float between two loops.
-
-        Args:
-            u (Loop): The first loop in the float pair.
-            v (Loop): The second loop in the float pair.
-
-        Returns:
-            set[Loop]: Set of loops positioned in front of the float between u and v, or empty set if no float exists.
-        """
-        if not self.has_float(u, v):
-            if self.has_float(v, u):
-                return self.get_loops_in_front_of_float(v, u)
-            else:
-                return set()
-        else:
-            return cast(set[Loop], self.loop_graph.edges[u, v][self.FRONT_LOOPS])
-
-    def get_loops_behind_float(self, u: Loop, v: Loop) -> set[Loop]:
-        """Get all loops positioned behind the float between two loops.
-
-        Args:
-            u (Loop): The first loop in the float pair.
-            v (Loop): The second loop in the float pair.
-
-        Returns:
-            set[Loop]: Set of loops positioned behind the float between u and v, or empty set if no float exists.
-        """
-        if not self.has_float(u, v):
-            if self.has_float(v, u):
-                return self.get_loops_behind_float(v, u)
-            else:
-                return set()
-        else:
-            return cast(set[Loop], self.loop_graph.edges[u, v][self._BACK_LOOPS])
-
     @property
-    def last_loop(self) -> Loop | None:
+    def last_loop(self) -> LoopT | None:
         """Get the most recently added loop at the end of the yarn.
 
         Returns:
@@ -222,7 +140,7 @@ class Yarn:
         return self._last_loop
 
     @property
-    def first_loop(self) -> Loop | None:
+    def first_loop(self) -> LoopT | None:
         """Get the first loop at the beginning of the yarn.
 
         Returns:
@@ -239,6 +157,14 @@ class Yarn:
         """
         return self.last_loop is not None
 
+    @property
+    def is_cut(self) -> bool:
+        """
+        Returns:
+            bool: True if yarn has been cut and will no longer form loops, False otherwise.
+        """
+        return self._is_cut
+
     @property
     def yarn_id(self) -> str:
         """Get the string identifier for this yarn.
@@ -248,105 +174,194 @@ class Yarn:
         """
         return str(self.properties)
 
-    def __str__(self) -> str:
-        """Get the string representation of this yarn.
+    @property
+    def float_iter(self) -> Iterator[tuple[LoopT, LoopT]]:
+        """
+        Returns:
+            Iterator[tuple[Loop, Loop]]: An iterator over tuples of connected loops representing the yarn path.
+        """
+        if self.first_loop is None:
+            return iter([])
+        return self.dfs_edges(self.first_loop)
+
+    def loops_in_front_of_floats(self) -> Iterator[tuple[LoopT, LoopT, set[LoopT]]]:
+        """Get all float segments with loops positioned in front of them.
 
         Returns:
-            str: The yarn identifier string.
+            list[tuple[Loop, Loop, set[Loop]]]: List of tuples containing the two loops defining each float and the set of loops positioned in front of that float.
+            Only includes floats that have loops in front of them.
         """
-        return self.yarn_id
+        return ((u, v, d.front_loops) for u, v, d in self.edge_iter if len(d.front_loops) > 0)
 
-    def __repr__(self) -> str:
-        """Get the representation string of this yarn for debugging.
+    def loops_behind_floats(self) -> Iterator[tuple[LoopT, LoopT, set[LoopT]]]:
+        """Get all float segments with loops positioned behind them.
 
         Returns:
-            str: The representation of the yarn properties.
+            list[tuple[Loop, Loop, set[Loop]]]: List of tuples containing the two loops defining each float and the set of loops positioned behind that float.
+            Only includes floats that have loops behind them.
         """
-        return repr(self.properties)
+        return ((u, v, d.back_loops) for u, v, d in self.edge_iter if len(d.back_loops) > 0)
 
-    def __hash__(self) -> int:
-        """Get the hash value of this yarn for use in sets and dictionaries.
+    def next_loop(self, loop: LoopT) -> LoopT | None:
+        """
+        Args:
+            loop (LoopT): The loop to find the next loop from.
 
         Returns:
-            int: Hash value based on the yarn properties.
+            LoopT | None: The next loop on yarn after the specified loop, or None if it's the last loop.
+
+        Raises:
+            KeyError: If the specified loop is not on this yarn.
         """
-        return hash(self.properties)
+        if loop not in self:
+            raise KeyError(f"Loop {loop} is not on Yarn")
+        successors = self.successors(loop)
+        return successors.pop() if len(successors) > 0 else None
 
-    def __len__(self) -> int:
-        """Get the number of loops on this yarn.
+    def prior_loop(self, loop: LoopT) -> LoopT | None:
+        """
+        Args:
+            loop (Loop): The loop to find the prior loop from.
 
         Returns:
-            int: The total number of loops on this yarn.
+            Loop | None: The prior loop on yarn before the specified loop, or None if it's the first loop.
+
+        Raises:
+            KeyError: If the specified loop is not on this yarn.
         """
-        return len(self.loop_graph.nodes)
+        if loop not in self:
+            raise KeyError(f"Loop {loop} is not on Yarn")
+        predecessors = self.predecessors(loop)
+        if len(predecessors) > 0:
+            return predecessors.pop()
+        else:
+            return None
+
+    def has_float(self, u: LoopT, v: LoopT) -> bool:
+        """Check if there is a float edge between two loops on this yarn.
+
+        Args:
+            u (Loop): The first loop to check for float connection.
+            v (Loop): The second loop to check for float connection.
+
+        Returns:
+            bool: True if there is a float edge between the loops, False otherwise.
+        """
+        return bool(self.has_edge(u, v))
+
+    def get_loops_in_front_of_float(self, u: LoopT, v: LoopT) -> set[LoopT]:
+        """Get all loops positioned in front of the float between two loops.
+
+        Args:
+            u (Loop): The first loop in the float pair.
+            v (Loop): The second loop in the float pair.
+
+        Returns:
+            set[Loop]: Set of loops positioned in front of the float between u and v, or empty set if no float exists.
+        """
+        if not self.has_float(u, v):
+            if self.has_float(v, u):
+                return self.get_loops_in_front_of_float(v, u)
+            else:
+                return set()
+        else:
+            return self.get_edge(u, v).front_loops
+
+    def get_loops_behind_float(self, u: LoopT, v: LoopT) -> set[LoopT]:
+        """Get all loops positioned behind the float between two loops.
 
-    def make_loop_on_end(self) -> Loop:
+        Args:
+            u (Loop): The first loop in the float pair.
+            v (Loop): The second loop in the float pair.
+
+        Returns:
+            set[Loop]: Set of loops positioned behind the float between u and v, or empty set if no float exists.
+        """
+        if not self.has_float(u, v):
+            if self.has_float(v, u):
+                return self.get_loops_behind_float(v, u)
+            else:
+                return set()
+        else:
+            return self.get_edge(u, v).back_loops
+
+    def make_loop_on_end(self) -> LoopT:
         """Create and add a new loop at the end of the yarn.
 
         Returns:
             Loop: The newly created loop that was added to the end of this yarn.
         """
         loop_id = self._next_loop_id()
-        loop = Loop(loop_id, self)
-        return self.add_loop_to_end(loop)
+        return self.add_loop_to_end(self._new_loop(loop_id))
 
     def _next_loop_id(self) -> int:
-        """Get the ID for the next loop to be added to this yarn.
-
+        """
         Returns:
             int: The ID of the next loop to be added to this yarn based on the knit graph or, if no knit graph is associated with this yarn, based on the last loop on this yarn.
         """
-        if self.knit_graph is not None:
-            if self.knit_graph.last_loop is None:
-                return 0
-            else:
-                return self.knit_graph.last_loop.loop_id + 1
-        elif self.last_loop is None:
+        if self.knit_graph.last_loop is None:
             return 0
         else:
-            return self.last_loop.loop_id + 1
+            return self.knit_graph.last_loop.loop_id + 1
+
+    def _new_loop(self, loop_id: int) -> LoopT:
+        """
+        Args:
+            loop_id (int): The loop id to create a new loop.
+
+        Returns:
+            LoopT: A loop on this yarn with the given id.
+
+        Raises:
+            Use_Cut_Yarn_ValueError: If the yarn has been cut and can no longer form loops.
+        """
+        if self.is_cut:
+            raise Use_Cut_Yarn_ValueError(self)
+        elif self.first_loop is not None:
+            return self.first_loop.__class__(loop_id, self, self.knit_graph)  # type: ignore[arg-type]
+        else:
+            return self._loop_class(loop_id, self, self.knit_graph)  # type: ignore[arg-type]
 
-    def remove_loop(self, loop: Loop) -> None:
+    def remove_loop(self, loop: LoopT | int) -> None:
         """
         Remove the given loop from the yarn.
         Reconnects any neighboring loops to form a new float with the positioned in-front-of or behind the original floats positioned accordingly.
         Resets the first_loop and last_loop properties if the removed loop was the tail of the yarn.
         Args:
-            loop (Loop): The loop to remove from the yarn.
+            loop (LoopT): The loop to remove from the yarn.
 
         Raises:
             KeyError: The given loop does not exist in the yarn.
         """
         if loop not in self:
             raise KeyError(f"Loop {loop} does not exist on yarn {self}.")
+        elif isinstance(loop, int):
+            loop = self[loop]
         prior_loop = self.prior_loop(loop)
         next_loop = self.next_loop(loop)
-        if isinstance(prior_loop, Loop) and isinstance(next_loop, Loop):  # Loop is between two floats to be merged.
+        if prior_loop is not None and next_loop is not None:  # Loop is between two floats to be merged.
             front_of_float_loops = self.get_loops_in_front_of_float(prior_loop, loop)
             front_of_float_loops.update(self.get_loops_in_front_of_float(loop, next_loop))
             back_of_float_loops = self.get_loops_behind_float(prior_loop, loop)
             back_of_float_loops.update(self.get_loops_behind_float(loop, next_loop))
-            self.loop_graph.remove_node(loop)
-            self.loop_graph.add_edge(
+            super().remove_loop(loop)
+            self.add_edge(
                 prior_loop,
                 next_loop,
-                Front_Loops=front_of_float_loops,
-                Back_Loops=back_of_float_loops,
+                Float_Edge[LoopT](front_loops=front_of_float_loops, back_loops=back_of_float_loops),
             )
             for front_loop in front_of_float_loops:
                 front_loop.add_loop_in_front_of_float(prior_loop, next_loop)
             for back_loop in back_of_float_loops:
                 back_loop.add_loop_behind_float(prior_loop, next_loop)
-            return
-        if next_loop is None:  # This was the last loop, make the prior loop the last loop.
-            assert loop is self.last_loop
-            self._last_loop = prior_loop
-        if prior_loop is None:  # This was the first loop, make the next loop the first loop.
-            assert loop is self.first_loop
-            self._first_loop = next_loop
-        self.loop_graph.remove_node(loop)
-
-    def add_loop_to_end(self, loop: Loop) -> Loop:
+        else:
+            super().remove_loop(loop)
+            if next_loop is None:  # This was the last loop, make the prior loop the last loop.
+                self._last_loop = prior_loop
+            if prior_loop is None:  # This was the first loop, make the next loop the first loop.
+                self._first_loop = next_loop
+
+    def add_loop_to_end(self, loop: LoopT) -> LoopT:
         """Add an existing loop to the end of this yarn and associated knit graph.
 
         Args:
@@ -360,130 +375,128 @@ class Yarn:
             self.knit_graph.add_loop(loop)
         return loop
 
-    def insert_loop(self, loop: Loop, prior_loop: Loop | None = None) -> None:
+    def insert_loop(self, loop: LoopT, prior_loop: LoopT | None = None) -> None:
         """Insert a loop into the yarn sequence after the specified prior loop.
 
         Args:
             loop (Loop): The loop to be added to this yarn.
             prior_loop (Loop | None): The loop that should come before this loop on the yarn. If None, defaults to the last loop (adding to end of yarn).
         """
-        self.loop_graph.add_node(loop)
-        if not self.has_loops:
+        super().add_loop(loop)
+        if self.last_loop is None:
             self._last_loop = loop
             self._first_loop = loop
             return
-        elif prior_loop is None:
+        if prior_loop is None:
             prior_loop = self.last_loop
-        self.loop_graph.add_edge(prior_loop, loop, Front_Loops=set(), Back_Loops=set())
+        super().add_edge(prior_loop, loop, Float_Edge[LoopT]())
         if prior_loop == self.last_loop:
             self._last_loop = loop
 
-    def next_loop(self, loop: Loop) -> Loop | None:
-        """Get the loop that follows the specified loop on this yarn.
+    def add_loop_in_front_of_float(self, front_loop: LoopT, start_of_float: LoopT) -> None:
+        """Record that a loop falls in front of the float between two other loops.
 
         Args:
-            loop (Loop): The loop to find the next loop from.
-
-        Returns:
-            Loop | None: The next loop on yarn after the specified loop, or None if it's the last loop.
-
-        Raises:
-            KeyError: If the specified loop is not on this yarn.
+            front_loop (Loop): The loop that is positioned in front of the float.
+            start_of_float (Loop): The first loop in the float pair.
         """
-        if loop not in self:
-            raise KeyError(f"Loop {loop} is not on Yarn")
-        successors = [*self.loop_graph.successors(loop)]
-        if len(successors) > 0:
-            return cast(Loop, successors[0])
-        else:
-            return None
-
-    def prior_loop(self, loop: Loop) -> Loop | None:
-        """Get the loop that precedes the specified loop on this yarn.
+        end_of_float = self.next_loop(start_of_float)
+        if end_of_float is not None:
+            self.get_edge(start_of_float, end_of_float).add_loop_in_front_of_float(front_loop)
+            front_loop.add_loop_in_front_of_float(start_of_float, end_of_float)
 
+    def remove_loop_relative_to_floats(self, loop: LoopT) -> None:
+        """
+        Removes the given loop from positions relative to floats along this yarn.
         Args:
-            loop (Loop): The loop to find the prior loop from.
-
-        Returns:
-            Loop | None: The prior loop on yarn before the specified loop, or None if it's the first loop.
-
-        Raises:
-            KeyError: If the specified loop is not on this yarn.
+            loop (LoopT): The loop to remove from positions relative to floats on this yarn.
         """
-        if loop not in self:
-            raise KeyError(f"Loop {loop} is not on Yarn")
-        predecessors = [*self.loop_graph.predecessors(loop)]
-        if len(predecessors) > 0:
-            return cast(Loop, predecessors[0])
-        else:
-            return None
+        for _u, _v, float_data in self.edge_iter:
+            float_data.remove_loop_relative_to_floats(loop)
 
-    def __contains__(self, item: Loop | int) -> bool:
-        """Check if a loop is contained on this yarn.
+    def add_loop_behind_float(self, back_loop: LoopT, start_of_float: LoopT) -> None:
+        """Record that a loop falls in front of the float between two other loops.
 
         Args:
-            item (Loop | int): The loop or loop ID being checked for in the yarn.
+            back_loop (Loop): The loop that is positioned behind the float.
+            start_of_float (Loop): The first loop in the float pair.
+        """
+        end_of_float = self.next_loop(start_of_float)
+        if end_of_float is not None:
+            self.get_edge(start_of_float, end_of_float).add_loop_behind_float(back_loop)
+            back_loop.add_loop_behind_float(start_of_float, end_of_float)
+
+    def cut_yarn(self) -> Self:
+        """Cut yarn to make it no longer active and create a new yarn instance of the same type.
 
         Returns:
-            bool: True if the loop is on the yarn, False otherwise.
+            Yarn[LoopT]: New yarn of the same type after cutting this yarn.
         """
-        return bool(self.loop_graph.has_node(item))
+        self._is_cut = True
+        return self.__class__(self.properties, self.knit_graph, self._instance + 1, self._loop_class)
 
-    def __iter__(self) -> Iterator[Loop]:
-        """Iterate over loops on this yarn in sequence from first to last.
+    def __str__(self) -> str:
+        """Get the string representation of this yarn.
 
         Returns:
-            Iterator[Loop]: An iterator over the loops on this yarn in their natural sequence order.
+            str: The yarn identifier string.
         """
-        return cast(Iterator[Loop], dfs_preorder_nodes(self.loop_graph, self.first_loop))
+        return self.yarn_id
 
-    def edge_iter(self) -> Iterator[tuple[Loop, Loop]]:
-        """Iterate over the edges between loops on this yarn.
+    def __repr__(self) -> str:
+        """Get the representation string of this yarn for debugging.
 
         Returns:
-            Iterator[tuple[Loop, Loop]]: An iterator over tuples of connected loops representing the yarn path.
+            str: The representation of the yarn properties.
         """
-        return cast(Iterator[tuple[Loop, Loop]], dfs_edges(self.loop_graph, self.first_loop))
+        return repr(self.properties)
 
-    def loops_in_front_of_floats(self) -> list[tuple[Loop, Loop, set[Loop]]]:
-        """Get all float segments with loops positioned in front of them.
+    def __hash__(self) -> int:
+        """Get the hash value of this yarn for use in sets and dictionaries.
 
         Returns:
-            list[tuple[Loop, Loop, set[Loop]]]: List of tuples containing the two loops defining each float and the set of loops positioned in front of that float.
-            Only includes floats that have loops in front of them.
+            int: Hash value based on the yarn properties.
         """
-        return [
-            (u, v, self.get_loops_in_front_of_float(u, v))
-            for u, v in self.edge_iter()
-            if len(self.get_loops_in_front_of_float(u, v)) > 0
-        ]
+        return hash((self._instance, self.properties))
 
-    def loops_behind_floats(self) -> list[tuple[Loop, Loop, set[Loop]]]:
-        """Get all float segments with loops positioned behind them.
+    def __iter__(self) -> Iterator[LoopT]:
+        """Iterate over loops on this yarn in sequence from first to last.
 
         Returns:
-            list[tuple[Loop, Loop, set[Loop]]]: List of tuples containing the two loops defining each float and the set of loops positioned behind that float.
-            Only includes floats that have loops behind them.
+            Iterator[Loop]: An iterator over the loops on this yarn in their natural sequence order.
         """
-        return [
-            (u, v, self.get_loops_behind_float(u, v))
-            for u, v in self.edge_iter()
-            if len(self.get_loops_behind_float(u, v)) > 0
-        ]
+        if self.first_loop is None:
+            return iter([])
+        return self.dfs_preorder_loops(self.first_loop)
+
+    @overload
+    def __getitem__(self, item: int) -> LoopT: ...
+
+    @overload
+    def __getitem__(self, item: tuple[LoopT | int, LoopT | int]) -> Float_Edge[LoopT]: ...
+
+    @overload
+    def __getitem__(self, item: slice) -> list[LoopT]: ...
 
-    def __getitem__(self, item: int) -> Loop:
+    def __getitem__(
+        self, item: int | tuple[LoopT | int, LoopT | int] | slice
+    ) -> LoopT | Float_Edge[LoopT] | list[LoopT]:
         """Get a loop by its ID from this yarn.
 
         Args:
-            item (int): The loop ID to retrieve from this yarn.
+            item (int | tuple[LoopT | int, LoopT | int] | slice):
+                The loop ,loop ID, or float between two loops to retrieve from this yarn.
+                If given a slice, it will retrieve the elements between the specified indices in the standard ordering of loops along the yarn.
 
         Returns:
-            Loop: The loop on the yarn with the matching ID.
+            LoopT: The loop on the yarn with the matching ID.
+            Float_Edge[LoopT]: The float data for the given pair of loops forming a float.
+            list[LoopT]: The loops in the slice of the yarn based on their ordering along the yarn.
 
         Raises:
-            KeyError: If the loop ID is not found on this yarn.
+            KeyError: If the item is not found on this yarn.
         """
-        if item not in self:
-            raise KeyError(f"{item} is not a loop on yarn {self}")
+        if isinstance(item, slice):
+            return list(self)[item]
         else:
-            return cast(Loop, self.loop_graph.nodes[item])
+            return super().__getitem__(item)