knit-graphs 0.0.8__tar.gz → 0.0.10__tar.gz

{knit_graphs-0.0.8 → knit_graphs-0.0.10}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: knit-graphs
-Version: 0.0.8
+Version: 0.0.10
 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 → knit_graphs-0.0.10}/pyproject.toml

@@ -12,15 +12,15 @@ build-backend = "poetry.core.masonry.api"  # Use Poetry's build system
 # All the information about your project that will appear on PyPI
 [tool.poetry]
 name = "knit-graphs"
-version = "0.0.8"
+version = "0.0.10"
 description = "A graph representation of knitted structures where each loop is a node and edges represent yarn and stitch relationships."
 authors = ["Megan Hofmann <m.hofmann@northeastern.edu>"]
 maintainers = ["Megan Hofmann <m.hofmann@northeastern.edu>"]
 license = "MIT"                     # License type (shows up on PyPI)
 readme = "README.md"                # File to use as long description on PyPI
-homepage = "https://mhofmann-Khoury.github.io/knit-graphs/"
-repository = "https://github.com/mhofmann-Khoury/knit-graphs"
-documentation = "https://mhofmann-Khoury.github.io/knit-graphs/"
+homepage = "https://mhofmann-khoury.github.io/knit_graph/"
+repository = "https://github.com/mhofmann-Khoury/knit_graph/"
+documentation = "https://mhofmann-khoury.github.io/knit_graph/"
 keywords = ["ACT Lab", "Northeastern University", "knit", "machine knit", "fabrication", "textile"]
 classifiers = [                     # PyPI classifiers for categorization
     "Development Status :: 3 - Alpha",                     # Update as project matures (Alpha -> Beta -> Production/Stable)
@@ -52,8 +52,6 @@ include = [
     "README.md",                    # Project description
     "LICENSE",                      # License file
     "docs/**/*",                    # All documentation files
-    # "src/**/data/**/*",           # Example: include data files
-    # "src/**/templates/**/*",      # Example: include template files
 ]
 
 # Exclude files from the distribution package (keeps package size down)
@@ -80,29 +78,11 @@ exclude = [
 python = ">=3.11,<3.14"
 networkx = ">=3.5"
 plotly = "^6.3.0"
-# Examples:
-# requests = "^2.31.0"              # For HTTP requests
-# pydantic = "^2.0.0"               # For data validation
-# click = "^8.1.0"                  # For CLI applications
-# numpy = "^1.24.0"                 # For numerical computing
-# pandas = "^2.0.0"                 # For data manipulation
-
-# =============================================================================
-# OPTIONAL DEPENDENCIES (EXTRAS)
-# =============================================================================
-# Optional dependency groups that users can install with pip install "package[extra]"
-#[tool.poetry.extras]
-# Examples:
-# cli = ["click", "rich"]           # For command-line interface features
-# viz = ["matplotlib", "plotly"]    # For visualization features
-# dev = ["pytest", "mypy"]          # For development tools (though prefer dev dependencies)
 
 # =============================================================================
 # DEVELOPMENT DEPENDENCIES
 # =============================================================================
 # These packages are only needed during development and testing
-
-
 [tool.poetry.group.dev.dependencies]
 importlib-resources = ">=6.5.2"
 
@@ -136,49 +116,12 @@ sphinx-autoapi = "^3.0.0"          # Automatically generates API documentation
 # -------------------------------------------------------------------------
 # DEVELOPMENT TOOLS AND UTILITIES
 # -------------------------------------------------------------------------
-ipython = "^8.14.0"                # Enhanced interactive Python shell for debugging
-rich = "^13.5.0"                   # Beautiful terminal output and debugging
 tox = "^4.11.0"                    # Test across multiple Python versions locally
 
 # -------------------------------------------------------------------------
 # RELEASE AND BUILD TOOLS
 # -------------------------------------------------------------------------
 build = "^0.10.0"                  # PEP 517 build tool (for creating distributions)
-bump2version = "^1.0.0"            # Automated version bumping tool
-
-# -------------------------------------------------------------------------
-# PLATFORM-SPECIFIC DEPENDENCIES
-# -------------------------------------------------------------------------
-# Only install on Windows systems (for colored terminal output)
-colorama = {version = "^0.4.6", markers = "sys_platform == 'win32'"}
-
-# =============================================================================
-# DOCUMENTATION-SPECIFIC DEPENDENCIES
-# =============================================================================
-# Separate dependency group for building documentation (allows selective installation)
-[tool.poetry.group.docs.dependencies]
-sphinx = "^7.1.0"                    # Documentation generator (main tool)
-sphinx-rtd-theme = "^1.3.0"         # Professional-looking theme
-sphinx-autodoc-typehints = "^1.24.0" # Automatically include type hints in docs
-sphinx-autoapi = "^3.0.0"           # Automatically generates API documentation
-myst-parser = "^2.0.0"              # Support for Markdown files in documentation
-
-# =============================================================================
-# COMMAND LINE SCRIPTS
-# =============================================================================
-# Define command-line entry points for your package
-#[tool.poetry.scripts]
-# Example:
-# your-command = "your_project_name.cli:main"  # Creates 'your-command' executable
-
-# =============================================================================
-# PROJECT URLS FOR PYPI
-# =============================================================================
-# Additional URLs that will be displayed on your PyPI project page
-#[tool.poetry.urls]
-#"Bug Tracker" = "https://github.com/mhofmann-Khoury/knit-graphs/issues"
-#"Changelog" = "https://github.com/mhofmann-Khoury/knit-graphs/blob/main/CHANGELOG.md"
-#"Discussions" = "https://github.com/your-username/your-project-name/discussions"
 
 # =============================================================================
 # ISORT IMPORT SORTER CONFIGURATION
@@ -244,12 +187,6 @@ check_untyped_defs = false          # Don't type-check untyped test methods
 warn_return_any = false             # Don't warn about returning 'Any' in tests
 warn_unused_ignores = false         # Don't warn about unused type ignores in tests
 
-# Add overrides for specific third-party libraries that may have type issues
-# Example:
-# [[tool.mypy.overrides]]
-# module = ["problematic_library.*"]
-# ignore_errors = true
-
 # =============================================================================
 # UNITTEST TESTING FRAMEWORK CONFIGURATION
 # =============================================================================

{knit_graphs-0.0.8 → knit_graphs-0.0.10}/src/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-0.0.8 → knit_graphs-0.0.10}/src/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
@@ -18,7 +19,7 @@ from knit_graphs.Pull_Direction import Pull_Direction
 from knit_graphs.Yarn import Yarn
 
 
-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 +29,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,10 +70,46 @@ 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
 
+    def remove_loop(self, loop: Loop) -> None:
+        """
+        Remove the given loop from the knit graph.
+        Args:
+            loop (Loop): The loop to be removed.
+
+        Raises:
+            KeyError: If the loop is not in the knit graph.
+
+        """
+        if loop not in self:
+            raise KeyError(f"Loop {loop} not on the knit graph")
+        self.braid_graph.remove_loop(loop)  # remove any crossing associated with this loop.
+        # Remove any stitch edges involving this loop.
+        loop.remove_parent_loops()
+        if self.has_child_loop(loop):
+            child_loop = self.get_child_loop(loop)
+            assert isinstance(child_loop, Loop)
+            child_loop.remove_parent(loop)
+        self.stitch_graph.remove_node(loop)
+        # Remove loop from any floating positions
+        loop.remove_loop_from_front_floats()
+        loop.remove_loop_from_back_floats()
+        # Remove loop from yarn
+        yarn = loop.yarn
+        yarn.remove_loop(loop)
+        if len(yarn) == 0:  # This was the only loop on that yarn
+            self.yarns.discard(yarn)
+        # Reset last loop
+        if loop is self.last_loop:
+            if len(self.yarns) == 0:  # No loops left
+                assert len(self.stitch_graph.nodes) == 0
+                self._last_loop = None
+            else:  # Set to the newest loop formed at the end of any yarns.
+                self._last_loop = max(y.last_loop for y in self.yarns if isinstance(y.last_loop, Loop))
+
     def add_yarn(self, yarn: Yarn) -> None:
         """Add a yarn to the graph without adding its loops.
 
@@ -102,42 +139,31 @@ class Knit_Graph(_Base_Knit_Graph):
         self.stitch_graph.add_edge(parent_loop, child_loop, pull_direction=pull_direction)
         child_loop.add_parent_loop(parent_loop, stack_position)
 
-    def get_wale_starting_with_loop(self, first_loop: Loop) -> Wale:
-        """Get a wale (vertical column of stitches) starting from the specified loop.
+    def get_wales_ending_with_loop(self, last_loop: Loop) -> set[Wale]:
+        """Get all wales (vertical columns of stitches) that end at the specified loop.
 
         Args:
-            first_loop (Loop): The loop at the start of the wale to be constructed.
+            last_loop (Loop): The last loop of the joined set of wales.
 
         Returns:
-            Wale: A wale object representing the vertical column of stitches starting from the given loop.
+            set[Wale]: The set of wales that end at this loop.
         """
-        wale = Wale(first_loop)
-        cur_loop = first_loop
-        while len(self.stitch_graph.successors(cur_loop)) == 1:
-            cur_loop = [*self.stitch_graph.successors(cur_loop)][0]
-            assert isinstance(wale.last_loop, Loop)
-            wale.add_loop_to_end(cur_loop, self.get_pull_direction(wale.last_loop, cur_loop))
-        return wale
-
-    def get_wales_ending_with_loop(self, last_loop: Loop) -> list[Wale]:
-        """Get all wales (vertical columns of stitches) that end at the specified loop.
+        if len(last_loop.parent_loops) == 0:
+            return {Wale(last_loop, self)}
+        ancestors = last_loop.ancestor_loops()
+        return {Wale(l, self) for l in ancestors}
 
-        Args:
-            last_loop (Loop): The last loop of the joined set of wales.
+    def get_terminal_wales(self) -> dict[Loop, list[Wale]]:
+        """
+        Get wale groups organized by their terminal loops.
 
         Returns:
-            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):
-            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]
-                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
+            dict[Loop, list[Wale]]: Dictionary mapping terminal loops to list of wales that terminate that wale.
+        """
+        wale_groups = {}
+        for loop in self.terminal_loops():
+            wale_groups[loop] = [wale for wale in self.get_wales_ending_with_loop(loop)]
+        return wale_groups
 
     def get_courses(self) -> list[Course]:
         """Get all courses (horizontal rows) in the knit graph in chronological order.
@@ -148,8 +174,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)
@@ -158,28 +184,47 @@ class Knit_Graph(_Base_Knit_Graph):
         courses.append(course)
         return courses
 
-    def get_wale_groups(self) -> dict[Loop, Wale_Group]:
+    def get_wale_groups(self) -> set[Wale_Group]:
         """Get wale groups organized by their terminal loops.
 
         Returns:
-            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.
+            set[Wale_Group]: The set of wale-groups that lead to the terminal loops of this graph. Each wale group represents a collection of wales that end at the same terminal loop.
         """
-        wale_groups = {}
-        for loop in self.stitch_graph.nodes:
-            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
+        return set(Wale_Group(l, self) for l in self.terminal_loops())
 
-    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 loop is in the graph, False otherwise.
+            bool: True if the given loop or stitch edge is in the graph, False otherwise.
         """
-        return bool(self.stitch_graph.has_node(item))
+        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 __getitem__(self, item: int) -> Loop:
+        loop = next((l for l in self if l.loop_id == item), None)
+        if loop is None:
+            raise KeyError(f"Loop of id {item} not in knit graph")
+        return loop
+
+    def sorted_loops(self) -> list[Loop]:
+        """
+        Returns:
+            list[Loop]: The list of loops in the stitch graph sorted from the earliest formed loop to the latest formed loop.
+        """
+        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.
@@ -247,3 +292,10 @@ class Knit_Graph(_Base_Knit_Graph):
             bool: True if the loop has no child loops and terminates a wale, False otherwise.
         """
         return not self.has_child_loop(loop)
+
+    def terminal_loops(self) -> Iterator[Loop]:
+        """
+        Returns:
+            Iterator[Loop]: An iterator over all terminal loops in the knit graph.
+        """
+        return iter(l for l in self if self.is_terminal_loop(l))

{knit_graphs-0.0.8 → knit_graphs-0.0.10}/src/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
 
-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]] = {}
@@ -44,7 +47,12 @@ class Loop(_Base_Loop):
         Args:
             u (Loop): The first loop in the float pair.
             v (Loop): The second loop in the float pair.
+
+        Raises:
+            ValueError: If u and v are not on the same yarn.
         """
+        if u.yarn != v.yarn:
+            raise ValueError("Loops of a float must share a yarn.")
         if u not in self.back_floats:
             self.back_floats[u] = set()
         if v not in self.back_floats:
@@ -52,6 +60,18 @@ class Loop(_Base_Loop):
         self.back_floats[u].add(v)
         self.back_floats[v].add(u)
 
+    def remove_loop_from_front_floats(self) -> None:
+        """
+        Removes this loop from being in front of all marked floats. Mutates the yarns that own edges of those floats.
+        """
+        visited: set[Loop] = set()
+        for u, v_loops in self.front_floats.items():
+            visited.add(u)
+            for v in v_loops:
+                if v not in visited and v in u.yarn:  # float shares a yarn
+                    u.yarn.loop_graph.edges[u, v]["Back_Loops"].remove(self)
+        self.front_floats = {}
+
     def add_loop_behind_float(self, u: Loop, v: Loop) -> None:
         """Set this loop to be behind the float between loops u and v.
 
@@ -60,7 +80,12 @@ class Loop(_Base_Loop):
         Args:
             u (Loop): The first loop in the float pair.
             v (Loop): The second loop in the float pair.
+
+        Raises:
+            ValueError: If u and v are not on the same yarn.
         """
+        if u.yarn != v.yarn:
+            raise ValueError("Loops of a float must share a yarn.")
         if u not in self.front_floats:
             self.front_floats[u] = set()
         if v not in self.front_floats:
@@ -68,6 +93,18 @@ class Loop(_Base_Loop):
         self.front_floats[u].add(v)
         self.front_floats[v].add(u)
 
+    def remove_loop_from_back_floats(self) -> None:
+        """
+        Removes this loop from being behind of all marked floats. Mutates the yarns that own edges of those floats.
+        """
+        visited = set()
+        for u, v_loops in self.back_floats.items():
+            visited.add(u)
+            for v in v_loops:
+                if v not in visited and v in u.yarn:  # float shares a yarn
+                    u.yarn.loop_graph.edges[u, v]["Front_Loops"].remove(self)
+        self.back_floats = {}
+
     def is_in_front_of_float(self, u: Loop, v: Loop) -> bool:
         """Check if this loop is positioned in front of the float between loops u and v.
 
@@ -98,19 +135,25 @@ class Loop(_Base_Loop):
         Returns:
             Loop | None: The prior loop on the yarn, or None if this is the first loop on the yarn.
         """
-        loop = self.yarn.prior_loop(self)
-        if loop is None:
-            return None
-        else:
-            return cast(Loop, loop)
+        return self.yarn.prior_loop(self)
 
-    def next_loop_on_yarn(self) -> Loop:
+    def next_loop_on_yarn(self) -> Loop | None:
         """Get the loop that follows this loop on the same yarn.
 
         Returns:
-            Loop: The next loop on the yarn, or None if this is the last loop on the yarn.
+            Loop | None: The next loop on the yarn, or None if this is the last loop on the yarn.
         """
-        return cast(Loop, self.yarn.next_loop(self))
+        return self.yarn.next_loop(self)
+
+    def remove_parent_loops(self) -> list[Loop]:
+        """
+        Removes the list of parent loops from this loop.
+        Returns:
+            list[Loop]: The list of parent loops that were removed.
+        """
+        parents = self.parent_loops
+        self.parent_loops = []
+        return parents
 
     def has_parent_loops(self) -> bool:
         """Check if this loop has any parent loops connected through stitch edges.
@@ -132,10 +175,82 @@ class Loop(_Base_Loop):
         else:
             self.parent_loops.append(parent)
 
-    def __str__(self) -> str:
-        """Get a string representation of this loop.
+    def remove_parent(self, parent: Loop) -> None:
+        """
+        Removes the given parent loop from the set of parents of this loop.
+        If the given loop is not a parent of this loop, nothing happens.
+        Args:
+            parent (Loop): The parent loop to remove.
+        """
+        if parent in self.parent_loops:
+            self.parent_loops.remove(parent)
+
+    def ancestor_loops(self) -> set[Loop]:
+        """
+        Returns:
+            set[Loop]: The set of loops that initiate all wales that lead to this loop. The empty set if this loop has no parents.
+        """
+        if not self.has_parent_loops():
+            return set()
+        ancestors = set()
+        for parent_loop in self.parent_loops:
+            if parent_loop.has_parent_loops():
+                ancestors.update(parent_loop.ancestor_loops())
+            else:
+                ancestors.add(parent_loop)
+        return ancestors
+
+    @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: 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 the loop ID and associated yarn.
+            str: String representation showing "Loop {loop_id}".
         """
-        return f"{self.loop_id} on yarn {self.yarn}"
+        return f"Loop {self.loop_id}"