knit-graphs 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

knit_graphs/Course.py

@@ -4,11 +4,13 @@ This module contains the Course class which represents a horizontal row of loops
 """
 from __future__ import annotations
 
-from typing import Iterator, cast
+from typing import TYPE_CHECKING, Iterator, cast
 
-from knit_graphs._base_classes import _Base_Knit_Graph
 from knit_graphs.Loop import Loop
 
+if TYPE_CHECKING:
+    from knit_graphs.Knit_Graph import Knit_Graph
+
 
 class Course:
     """Course object for organizing loops into knitting rows.
@@ -17,15 +19,32 @@ class Course:
     It maintains an ordered list of loops and provides methods for analyzing the structure and relationships between courses in the knitted fabric.
     """
 
-    def __init__(self, _knit_graph: _Base_Knit_Graph) -> None:
+    def __init__(self, knit_graph: Knit_Graph) -> None:
         """Initialize an empty course associated with a knit graph.
 
         Args:
-            _knit_graph (Knit_Graph): The knit graph that this course belongs to.
+            knit_graph (Knit_Graph): The knit graph that this course belongs to.
         """
-        self.loops_in_order: list[Loop] = []
+        self._knit_graph: Knit_Graph = knit_graph
+        self._loops_in_order: list[Loop] = []
         self._loop_set: set[Loop] = set()
 
+    @property
+    def loops_in_order(self) -> list[Loop]:
+        """
+        Returns:
+            list[Loop]: The list of loops in this course.
+        """
+        return self._loops_in_order
+
+    @property
+    def knit_graph(self) -> Knit_Graph:
+        """
+        Returns:
+            Knit_Graph: The knit graph that this course belongs to.
+        """
+        return self._knit_graph
+
     def add_loop(self, loop: Loop, index: int | None = None) -> None:
         """Add a loop to the course at the specified index or at the end.
 

knit_graphs/Knit_Graph.py

@@ -5,9 +5,10 @@ It manages the relationships between loops, yarns, and structural elements like
 """
 from __future__ import annotations
 
-from typing import Any, cast
+from typing import Any, Iterator, cast
+
+from networkx import DiGraph
 
-from knit_graphs._base_classes import _Base_Knit_Graph
 from knit_graphs.artin_wale_braids.Crossing_Direction import Crossing_Direction
 from knit_graphs.artin_wale_braids.Loop_Braid_Graph import Loop_Braid_Graph
 from knit_graphs.artin_wale_braids.Wale import Wale
@@ -17,8 +18,11 @@ from knit_graphs.Loop import Loop
 from knit_graphs.Pull_Direction import Pull_Direction
 from knit_graphs.Yarn import Yarn
 
+# from knit_graphs.artin_wale_braids.Wale import Wale
+# from knit_graphs.artin_wale_braids.Wale_Group import Wale_Group
+
 
-class Knit_Graph(_Base_Knit_Graph):
+class Knit_Graph:
     """A representation of knitted structures as connections between loops on yarns.
 
     The Knit_Graph class is the main data structure for representing knitted fabrics.
@@ -28,7 +32,7 @@ class Knit_Graph(_Base_Knit_Graph):
 
     def __init__(self) -> None:
         """Initialize an empty knit graph with no loops or yarns."""
-        super().__init__()
+        self.stitch_graph: DiGraph = DiGraph()
         self.braid_graph: Loop_Braid_Graph = Loop_Braid_Graph()
         self._last_loop: None | Loop = None
         self.yarns: set[Yarn] = set()
@@ -69,7 +73,7 @@ class Knit_Graph(_Base_Knit_Graph):
         """
         self.stitch_graph.add_node(loop)
         if loop.yarn not in self.yarns:
-            self.add_yarn(cast(Yarn, loop.yarn))
+            self.add_yarn(loop.yarn)
         if self._last_loop is None or loop > self._last_loop:
             self._last_loop = loop
 
@@ -129,12 +133,14 @@ class Knit_Graph(_Base_Knit_Graph):
             list[Wale]: The set of wales that end at this loop. Only returns multiple wales if this loop is a child of a decrease stitch.
         """
         wales = []
-        for top_stitch_parent in self.stitch_graph.predecessors(last_loop):
+        if len(last_loop.parent_loops) == 0:
+            return [Wale(last_loop)]
+        for top_stitch_parent in last_loop.parent_loops:
             wale = Wale(last_loop)
             wale.add_loop_to_beginning(top_stitch_parent, cast(Pull_Direction, self.get_pull_direction(top_stitch_parent, last_loop)))
             cur_loop = top_stitch_parent
             while len(cur_loop.parent_loops) == 1:  # stop at split for decrease or start of wale
-                cur_loop = [*self.stitch_graph.predecessors(cur_loop)][0]
+                cur_loop = cur_loop.parent_loops[0]
                 wale.add_loop_to_beginning(cur_loop, cast(Pull_Direction, self.get_pull_direction(cur_loop, cast(Loop, wale.first_loop))))
             wales.append(wale)
         return wales
@@ -148,8 +154,8 @@ class Knit_Graph(_Base_Knit_Graph):
         """
         courses = []
         course = Course(self)
-        for loop in sorted([*self.stitch_graph.nodes]):
-            for parent in self.stitch_graph.predecessors(loop):
+        for loop in self.sorted_loops():
+            for parent in loop.parent_loops:
                 if parent in course:  # start a new course
                     courses.append(course)
                     course = Course(self)
@@ -165,21 +171,38 @@ class Knit_Graph(_Base_Knit_Graph):
             dict[Loop, Wale_Group]: Dictionary mapping terminal loops to the wale groups they terminate. Each wale group represents a collection of wales that end at the same terminal loop.
         """
         wale_groups = {}
-        for loop in self.stitch_graph.nodes:
+        for loop in self:
             if self.is_terminal_loop(loop):
                 wale_groups.update({loop: Wale_Group(wale, self) for wale in self.get_wales_ending_with_loop(loop)})
         return wale_groups
 
-    def __contains__(self, item: Loop) -> bool:
+    def __contains__(self, item: Loop | tuple[Loop, Loop]) -> bool:
         """Check if a loop is contained in the knit graph.
 
         Args:
-            item (Loop): The loop being checked for in the graph.
+            item (Loop | tuple[Loop, Loop]): The loop being checked for in the graph or the parent-child stitch edge to check for in the knit graph.
+
+        Returns:
+            bool: True if the given loop or stitch edge is in the graph, False otherwise.
+        """
+        if isinstance(item, Loop):
+            return bool(self.stitch_graph.has_node(item))
+        else:
+            return bool(self.stitch_graph.has_edge(item[0], item[1]))
 
+    def __iter__(self) -> Iterator[Loop]:
+        """
+        Returns:
+            Iterator[Loop]: An iterator over all loops in the knit graph.
+        """
+        return cast(Iterator[Loop], iter(self.stitch_graph.nodes))
+
+    def sorted_loops(self) -> list[Loop]:
+        """
         Returns:
-            bool: True if the loop is in the graph, False otherwise.
+            list[Loop]: The list of loops in the stitch graph sorted from the earliest formed loop to the latest formed loop.
         """
-        return bool(self.stitch_graph.has_node(item))
+        return sorted(list(self.stitch_graph.nodes))
 
     def get_pull_direction(self, parent: Loop, child: Loop) -> Pull_Direction | None:
         """Get the pull direction of the stitch edge between parent and child loops.

knit_graphs/Loop.py

@@ -5,12 +5,13 @@ Loops are the fundamental building blocks of knitted structures and maintain rel
 """
 from __future__ import annotations
 
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
-from knit_graphs._base_classes import _Base_Loop, _Base_Yarn
+if TYPE_CHECKING:
+    from knit_graphs.Yarn import Yarn
 
 
-class Loop(_Base_Loop):
+class Loop:
     """A class to represent a single loop structure for modeling a single loop in a knitting pattern.
 
     The Loop class manages yarn relationships, parent-child connections for stitches, and float positioning for complex knitting structures.
@@ -23,15 +24,17 @@ class Loop(_Base_Loop):
         back_floats (dict[Loop, set[Loop]]): A dictionary tracking loops that this loop floats behind.
     """
 
-    def __init__(self, loop_id: int, yarn: _Base_Yarn) -> None:
+    def __init__(self, loop_id: int, yarn: Yarn) -> None:
         """Construct a Loop object with the specified identifier and yarn.
 
         Args:
             loop_id (int): A unique identifier for the loop, must be non-negative.
-            yarn (_Base_Yarn): The yarn that creates and holds this loop.
+            yarn (Yarn): The yarn that creates and holds this loop.
         """
-        super().__init__(loop_id)
-        self.yarn: _Base_Yarn = yarn
+        if loop_id < 0:
+            raise ValueError(f"Loop identifier must be non-negative but got {loop_id}")
+        self._loop_id: int = loop_id
+        self.yarn: Yarn = yarn
         self.parent_loops: list[Loop] = []
         self.front_floats: dict[Loop, set[Loop]] = {}
         self.back_floats: dict[Loop, set[Loop]] = {}
@@ -102,7 +105,7 @@ class Loop(_Base_Loop):
         if loop is None:
             return None
         else:
-            return cast(Loop, loop)
+            return loop
 
     def next_loop_on_yarn(self) -> Loop:
         """Get the loop that follows this loop on the same yarn.
@@ -132,10 +135,57 @@ class Loop(_Base_Loop):
         else:
             self.parent_loops.append(parent)
 
-    def __str__(self) -> str:
-        """Get a string representation of this loop.
+    @property
+    def loop_id(self) -> int:
+        """Get the unique identifier of this loop.
 
         Returns:
-            str: String representation showing the loop ID and associated yarn.
+            int: The id of the loop.
         """
-        return f"{self.loop_id} on yarn {self.yarn}"
+        return self._loop_id
+
+    def __hash__(self) -> int:
+        """Return hash value based on loop_id for use in sets and dictionaries.
+
+        Returns:
+            int: Hash value of the loop_id.
+        """
+        return self.loop_id
+
+    def __int__(self) -> int:
+        """Convert loop to integer representation using loop_id.
+
+        Returns:
+            int: The loop_id as an integer.
+        """
+        return self.loop_id
+
+    def __eq__(self, other: Loop) -> bool:
+        """Check equality with another base loop based on loop_id and type.
+
+        Args:
+            other (Loop): The other loop to compare with.
+
+        Returns:
+            bool: True if both loops have the same class and loop_id, False otherwise.
+        """
+        return isinstance(other, other.__class__) and self.loop_id == other.loop_id
+
+    def __lt__(self, other: Loop | int) -> bool:
+        """Compare loop_id with another loop or integer for ordering.
+
+        Args:
+            other (Loop | int): The other loop or integer to compare with.
+
+        Returns:
+            bool: True if this loop's id is less than the other's id.
+        """
+        return int(self.loop_id) < int(other)
+
+    def __repr__(self) -> str:
+        """Return string representation of the loop.
+
+        Returns:
+            str: String representation showing "Loop {loop_id}".
+        """
+        return f"Loop {self.loop_id}"

knit_graphs/Yarn.py

@@ -6,13 +6,15 @@ The Yarn class manages the sequence of loops along a yarn and their floating rel
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Iterator, cast
+from typing import TYPE_CHECKING, Iterator, cast
 
-from networkx import dfs_edges, dfs_preorder_nodes
+from networkx import DiGraph, dfs_edges, dfs_preorder_nodes
 
-from knit_graphs._base_classes import _Base_Knit_Graph, _Base_Yarn
 from knit_graphs.Loop import Loop
 
+if TYPE_CHECKING:
+    from knit_graphs.Knit_Graph import Knit_Graph
+
 
 @dataclass(frozen=True)
 class Yarn_Properties:
@@ -70,33 +72,34 @@ class Yarn_Properties:
         return hash((self.name, self.plies, self.weight, self.color))
 
 
-class Yarn(_Base_Yarn):
+class Yarn:
     """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.
     """
 
-    def __init__(self, yarn_properties: None | Yarn_Properties = None, knit_graph: None | _Base_Knit_Graph = None):
+    def __init__(self, yarn_properties: None | Yarn_Properties = None, knit_graph: None | Knit_Graph = 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.
         """
-        super().__init__()
+        self.loop_graph: DiGraph = DiGraph()
         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 | _Base_Knit_Graph = knit_graph
+        self._knit_graph: None | Knit_Graph = knit_graph
 
     @property
-    def knit_graph(self) -> None | _Base_Knit_Graph:
+    def knit_graph(self) -> None | Knit_Graph:
         """Get the knit graph that owns this yarn.
 
         Returns:
@@ -105,7 +108,7 @@ class Yarn(_Base_Yarn):
         return self._knit_graph
 
     @knit_graph.setter
-    def knit_graph(self, knit_graph: _Base_Knit_Graph) -> None:
+    def knit_graph(self, knit_graph: Knit_Graph) -> None:
         """Set the knit graph that owns this yarn.
 
         Args:

knit_graphs/artin_wale_braids/Wale.py

@@ -6,14 +6,13 @@ from __future__ import annotations
 
 from typing import Iterator, cast
 
-from networkx import dfs_preorder_nodes
+from networkx import DiGraph, dfs_preorder_nodes
 
-from knit_graphs._base_classes import _Base_Wale
 from knit_graphs.Loop import Loop
 from knit_graphs.Pull_Direction import Pull_Direction
 
 
-class Wale(_Base_Wale):
+class Wale:
     """A data structure representing stitch relationships between loops in a vertical column of a knitted structure.
 
     A wale represents a vertical sequence of loops connected by stitch edges, forming a column in the knitted fabric.
@@ -31,7 +30,7 @@ class Wale(_Base_Wale):
         Args:
             first_loop (Loop | None, optional): The initial loop to start the wale with. If provided, it will be added as both the first and last loop. Defaults to None.
         """
-        super().__init__()
+        self.stitches: DiGraph = DiGraph()
         self.first_loop: None | Loop = first_loop
         self.last_loop: None | Loop = None
         if isinstance(self.first_loop, Loop):

knit_graphs/artin_wale_braids/Wale_Group.py

@@ -4,14 +4,16 @@ This module provides the Wale_Group class which represents a collection of inter
 """
 from __future__ import annotations
 
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
 from networkx import DiGraph, dfs_preorder_nodes
 
-from knit_graphs._base_classes import _Base_Knit_Graph
 from knit_graphs.artin_wale_braids.Wale import Wale
 from knit_graphs.Loop import Loop
 
+if TYPE_CHECKING:
+    from knit_graphs.Knit_Graph import Knit_Graph
+
 
 class Wale_Group:
     """A graph structure maintaining relationships between connected wales through decrease operations.
@@ -27,7 +29,7 @@ class Wale_Group:
         bottom_loops (dict[Loop, Wale]): Mapping from the first (bottom) loop of each wale to the wale itself.
     """
 
-    def __init__(self, terminal_wale: Wale, knit_graph: _Base_Knit_Graph):
+    def __init__(self, terminal_wale: Wale, knit_graph: Knit_Graph):
         """Initialize a wale group starting from a terminal wale and building downward.
 
         Args:
@@ -36,7 +38,7 @@ class Wale_Group:
         """
         self.wale_graph: DiGraph = DiGraph()
         self.stitch_graph: DiGraph = DiGraph()
-        self._knit_graph: _Base_Knit_Graph = knit_graph
+        self._knit_graph: Knit_Graph = knit_graph
         self.terminal_wale: Wale | None = terminal_wale
         self.top_loops: dict[Loop, Wale] = {}
         self.bottom_loops: dict[Loop, Wale] = {}
@@ -79,7 +81,7 @@ class Wale_Group:
         """
         added_wales = []
         for parent_loop in cast(Loop, wale.first_loop).parent_loops:
-            parent_wales = cast(list[Wale], self._knit_graph.get_wales_ending_with_loop(parent_loop))
+            parent_wales = self._knit_graph.get_wales_ending_with_loop(parent_loop)
             for parent_wale in parent_wales:
                 self.add_wale(parent_wale)
             added_wales.extend(parent_wales)

{knit_graphs-0.0.8.dist-info → knit_graphs-0.0.9.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: knit-graphs
-Version: 0.0.8
+Version: 0.0.9
 Summary: A graph representation of knitted structures where each loop is a node and edges represent yarn and stitch relationships.
-Home-page: https://mhofmann-Khoury.github.io/knit-graphs/
+Home-page: https://mhofmann-khoury.github.io/knit_graph/
 License: MIT
 Keywords: ACT Lab,Northeastern University,knit,machine knit,fabrication,textile
 Author: Megan Hofmann
@@ -22,8 +22,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Requires-Dist: networkx (>=3.5)
 Requires-Dist: plotly (>=6.3.0,<7.0.0)
-Project-URL: Documentation, https://mhofmann-Khoury.github.io/knit-graphs/
-Project-URL: Repository, https://github.com/mhofmann-Khoury/knit-graphs
+Project-URL: Documentation, https://mhofmann-khoury.github.io/knit_graph/
+Project-URL: Repository, https://github.com/mhofmann-Khoury/knit_graph/
 Description-Content-Type: text/markdown
 
 # knit_graphs

{knit_graphs-0.0.8.dist-info → knit_graphs-0.0.9.dist-info}/RECORD

@@ -20,23 +20,22 @@ docs/source/api/knit_graphs.rst,sha256=w9HIhWI8P0_gG0H_efRUMHYBtWbgCprcS9moclgM_
 docs/source/conf.py,sha256=TZK8Rz0JNgQs2J_cUhVX5_4tmMBvRdGtILJsnAnAFWo,13350
 docs/source/index.rst,sha256=D4KmCX1_d2-WrPgxSeggHHsc9-TeQwSUGYOkehRQWrw,1462
 docs/source/installation.rst,sha256=GyNRk_oXKVgOZ4KFLAgkXLwjHYzDYsx8gcokLRrS0ZI,1247
-knit_graphs/Course.py,sha256=oT-YghPdAg7A51GI_StdfF8oxYGWGkoad72woEkRKeY,5818
-knit_graphs/Knit_Graph.py,sha256=KgcWQPzZJ-Iif7g3zWq6hBy4fdJXkJXnFxGOSMYOn-g,10795
+knit_graphs/Course.py,sha256=hO768vPM0KFRsjCYsBTUgasqMzlvl0gsuSrsBX0UUSs,6280
+knit_graphs/Knit_Graph.py,sha256=3NUeznjxAJPkvmwl_qxGpwxeN1LbsQBruAzLu551AZQ,11614
 knit_graphs/Knit_Graph_Visualizer.py,sha256=s2zp6Z7-ZF_52x3zTx8oQr__tQScpkGthIoWck57ykE,40227
-knit_graphs/Loop.py,sha256=zp1ZiVRFSCPL2CnXNxgwNPv7WrcuqFRe3S_ZATxEBAo,5781
+knit_graphs/Loop.py,sha256=WQh9ag1lv7_cJndZLGhhoGx1msdLEGixpahdXd2PhGk,7189
 knit_graphs/Pull_Direction.py,sha256=8xRLN-j7V1mExgmt3YjcJcTDa5rLedA2bF4wI8gd-DE,2334
-knit_graphs/Yarn.py,sha256=wNOmj15dnSA56Qw2D5ksgbmQqug-u5kPPxKGuitQ_qI,15901
+knit_graphs/Yarn.py,sha256=Stm-_1SRJTdN1hFPjtuBPyY0Ln55zC15FKGu5vyqerA,16000
 knit_graphs/__init__.py,sha256=qzZAOxTqjgLkhoGnKNZwOkuYbKEyzfWKkKpKkV6lVfk,111
-knit_graphs/_base_classes.py,sha256=ZEv_jkUglHzkfg-0TD6oonBq7QQmA4G7jrC_A6OubpY,6401
 knit_graphs/artin_wale_braids/Crossing_Direction.py,sha256=71ckmEFfL0s25NJb8lfYwH2zku0uM1C5X9gGM7PYC5A,2820
 knit_graphs/artin_wale_braids/Loop_Braid_Graph.py,sha256=2tsE16IzcvgsIKij1JNHWah6hLOgrpXCcjb6eocbfFs,4575
-knit_graphs/artin_wale_braids/Wale.py,sha256=PK8IQDnTFXk5924QZYiGCqfckS62laG9_XhK7xH2zAo,7171
+knit_graphs/artin_wale_braids/Wale.py,sha256=pdzGYdpy88UWPa1ePvu9YUsDkRAB2wGrqCnMA_vIwAA,7135
 knit_graphs/artin_wale_braids/Wale_Braid.py,sha256=Ws0QmU7s63nrBKe69acDza-r-LozDyyaKVDNxQMy10Y,2662
 knit_graphs/artin_wale_braids/Wale_Braid_Word.py,sha256=4YBlVMUZkqp85r46ETQSbFVS_WrT4PsWthHmFv5Ny9M,4587
-knit_graphs/artin_wale_braids/Wale_Group.py,sha256=HTl01PHzFhInhFJuB30OScWx7pIejmo3-HwHN4RB4V4,6868
+knit_graphs/artin_wale_braids/Wale_Group.py,sha256=JJXR5TvLuoC2LXvNfmwbHhvBObn0MONUVE9ZsBcSmUc,6867
 knit_graphs/artin_wale_braids/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 knit_graphs/basic_knit_graph_generators.py,sha256=doDH2MiXbMzGU9b3enEr3KdY8Fw90cssHi_lkts6VpY,11720
-knit_graphs-0.0.8.dist-info/LICENSE,sha256=Oazk3oiRu5ZN7b-EdYNYh0vu-I3Av2uIPQ-9L_cZ6Oo,1070
-knit_graphs-0.0.8.dist-info/METADATA,sha256=H8xfTEPGsLFE-_j4ZfleigF2RlmbKJU9SycIFhkDuX4,5195
-knit_graphs-0.0.8.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-knit_graphs-0.0.8.dist-info/RECORD,,
+knit_graphs-0.0.9.dist-info/LICENSE,sha256=Oazk3oiRu5ZN7b-EdYNYh0vu-I3Av2uIPQ-9L_cZ6Oo,1070
+knit_graphs-0.0.9.dist-info/METADATA,sha256=XzWrqXe9vJDLKHiA7a3wTNY4foVu6MemvqqWRyuDQ8s,5193
+knit_graphs-0.0.9.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+knit_graphs-0.0.9.dist-info/RECORD,,

knit_graphs/_base_classes.py

@@ -1,173 +0,0 @@
-"""Private module containing base classes for Loops and Yarns. Used to resolve circular dependencies."""
-from __future__ import annotations
-
-from networkx import DiGraph
-
-
-class _Base_Loop:
-    """Base class for Loop objects providing common functionality and interface.
-
-    This class serves as a foundation for Loop implementations and helps resolve circular dependencies between modules. It provides basic loop identification and comparison functionality.
-    """
-
-    def __init__(self, loop_id: int):
-        """Initialize a base loop with the given identifier.
-
-        Args:
-            loop_id (int): The unique identifier for this loop. Must be non-negative.
-        """
-        assert loop_id >= 0, f"{loop_id}: Loop_id must be non-negative"
-        self._loop_id: int = loop_id
-
-    @property
-    def loop_id(self) -> int:
-        """Get the unique identifier of this loop.
-
-        Returns:
-            int: The id of the loop.
-        """
-        return self._loop_id
-
-    def __hash__(self) -> int:
-        """Return hash value based on loop_id for use in sets and dictionaries.
-
-        Returns:
-            int: Hash value of the loop_id.
-        """
-        return self.loop_id
-
-    def __int__(self) -> int:
-        """Convert loop to integer representation using loop_id.
-
-        Returns:
-            int: The loop_id as an integer.
-        """
-        return self.loop_id
-
-    def __eq__(self, other: _Base_Loop) -> bool:
-        """Check equality with another base loop based on loop_id and type.
-
-        Args:
-            other (_Base_Loop): The other loop to compare with.
-
-        Returns:
-            bool: True if both loops have the same class and loop_id, False otherwise.
-        """
-        return isinstance(other, other.__class__) and self.loop_id == other.loop_id
-
-    def __lt__(self, other: _Base_Loop | int) -> bool:
-        """Compare loop_id with another loop or integer for ordering.
-
-        Args:
-            other (_Base_Loop | int): The other loop or integer to compare with.
-
-        Returns:
-            bool: True if this loop's id is less than the other's id.
-        """
-        return int(self.loop_id) < int(other)
-
-    def __repr__(self) -> str:
-        """Return string representation of the loop.
-
-        Returns:
-            str: String representation showing "Loop {loop_id}".
-        """
-        return f"Loop {self.loop_id}"
-
-
-class _Base_Yarn:
-    """Base class for Yarn objects providing common functionality and interface.
-
-    This class serves as a foundation for Yarn implementations and helps resolve circular dependencies between modules. It maintains a directed graph structure for managing loop relationships.
-    """
-
-    def __init__(self) -> None:
-        """Initialize a base yarn with an empty directed graph for loop relationships."""
-        self.loop_graph: DiGraph = DiGraph()
-
-    def prior_loop(self, loop: _Base_Loop) -> _Base_Loop | None:
-        """Find the loop that precedes the given loop on this yarn.
-
-        Args:
-            loop (_Base_Loop): The loop to find the preceding loop of.
-
-        Returns:
-            _Base_Loop | None: The loop that precedes the given loop on the yarn, or None if there is no prior loop.
-
-        Raises:
-            NotImplementedError: This is an abstract base class which must be extended with the correct implementation.
-        """
-        raise NotImplementedError("Implemented by base class")
-
-    def next_loop(self, loop: _Base_Loop) -> _Base_Loop | None:
-        """Find the loop that follows the given loop on this yarn.
-
-        Args:
-            loop (_Base_Loop): The loop to find the next loop of.
-
-        Returns:
-            _Base_Loop | None: The loop that follows the given loop on the yarn, or None if there is no next loop.
-
-        Raises:
-            NotImplementedError: This is an abstract base class which must be extended with the correct implementation.
-        """
-        raise NotImplementedError("Implemented by base class")
-
-
-class _Base_Wale:
-    """Base class for Wale objects providing common functionality and interface.
-
-    This class serves as a foundation for Wale implementations and maintains a directed graph structure for managing stitch relationships within a wale (vertical column of stitches).
-    """
-
-    def __init__(self) -> None:
-        """Initialize a base wale with an empty directed graph for stitch relationships."""
-        self.stitches: DiGraph = DiGraph()
-
-
-class _Base_Knit_Graph:
-    """Base class for Knit Graph objects providing common functionality and interface.
-
-    This class serves as a foundation for Knit Graph implementations and maintains a directed graph structure for managing stitch relationships throughout the entire knitted structure.
-    """
-
-    def __init__(self) -> None:
-        """Initialize a base knit graph with an empty directed graph for stitch relationships."""
-        self.stitch_graph: DiGraph = DiGraph()
-
-    @property
-    def last_loop(self) -> None | _Base_Loop:
-        """Get the most recently added loop in the graph.
-
-        Returns:
-            None | _Base_Loop: The last loop added to the graph, or None if the graph contains no loops.
-
-        Raises:
-            NotImplementedError: This is an abstract base class which must be extended with the correct implementation.
-        """
-        raise NotImplementedError("Implemented by base class")
-
-    def add_loop(self, loop: _Base_Loop) -> None:
-        """Add a loop to the knit graph structure.
-
-        Args:
-            loop (_Base_Loop): The loop to add to the graph.
-
-        Raises:
-            NotImplementedError: This is an abstract base class which must be extended with the correct implementation.
-        """
-        raise NotImplementedError("Implemented by base class")
-
-    def get_wales_ending_with_loop(self, last_loop: _Base_Loop) -> list[_Base_Wale]:
-        """Get all wales (vertical columns) that terminate at the specified loop.
-
-        Args:
-            last_loop (_Base_Loop): The loop terminating the list of wales to be returned.
-
-        Returns:
-            list[_Base_Wale]: The list of wales that end at the given loop. This will only be multiple wales if the loop is a child of a decrease stitch.
-
-        Raises:
-            NotImplementedError: This is an abstract base class which must be extended with the correct implementation.
-        """
-        raise NotImplementedError