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

knit_graphs/Loop.py

@@ -3,9 +3,10 @@
 This module defines the Loop class which represents individual loops in a knitting pattern.
 Loops are the fundamental building blocks of knitted structures and maintain relationships with parent loops, yarn connections, and float positions.
 """
+
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from knit_graphs.Yarn import Yarn
@@ -47,7 +48,12 @@ class 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:
@@ -55,6 +61,18 @@ class 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.
 
@@ -63,7 +81,12 @@ class 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:
@@ -71,6 +94,18 @@ class 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.
 
@@ -101,19 +136,25 @@ class 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 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 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.
         """
-        return cast(Loop, self.yarn.next_loop(self))
+        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.
@@ -135,6 +176,31 @@ class Loop:
         else:
             self.parent_loops.append(parent)
 
+    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.
@@ -160,7 +226,7 @@ class Loop:
         """
         return self.loop_id
 
-    def __eq__(self, other: Loop) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Check equality with another base loop based on loop_id and type.
 
         Args:
@@ -169,7 +235,7 @@ class Loop:
         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
+        return isinstance(other, Loop) and 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.

knit_graphs/Pull_Direction.py

@@ -2,6 +2,7 @@
 
 This module defines the Pull_Direction enumeration which represents the two ways a loop can be pulled through other loops in knitting: from back to front (knit) or from front to back (purl).
 """
+
 from __future__ import annotations
 
 from enum import Enum
@@ -13,6 +14,7 @@ class Pull_Direction(Enum):
     This enumeration represents the two directions that yarn can be pulled through loops to create different stitch types.
     BtF (Back to Front) creates knit stitches, while FtB (Front to Back) creates purl stitches.
     """
+
     BtF = "Knit"
     FtB = "Purl"
 

knit_graphs/Yarn.py

@@ -3,10 +3,12 @@
 This module contains the Yarn class and Yarn_Properties dataclass which together represent the physical yarn used in knitting patterns.
 The Yarn class manages the sequence of loops along a yarn and their floating relationships.
 """
+
 from __future__ import annotations
 
+from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Iterator, cast
+from typing import TYPE_CHECKING, cast
 
 from networkx import DiGraph, dfs_edges, dfs_preorder_nodes
 
@@ -22,6 +24,7 @@ class Yarn_Properties:
 
     This frozen dataclass contains all the physical and visual properties that characterize a yarn, including its structure, weight, and appearance.
     """
+
     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.
@@ -52,7 +55,7 @@ class Yarn_Properties:
         """
         return Yarn_Properties()
 
-    def __eq__(self, other: Yarn_Properties) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Check equality with another Yarn_Properties instance.
 
         Args:
@@ -61,7 +64,13 @@ class Yarn_Properties:
         Returns:
             bool: True if all properties (name, plies, weight, color) are equal, False otherwise.
         """
-        return 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.plies == other.plies
+            and self.weight == other.weight
+            and self.color == other.color
+        )
 
     def __hash__(self) -> int:
         """Get hash value for use in sets and dictionaries.
@@ -83,7 +92,14 @@ class Yarn:
         properties (Yarn_Properties): The physical and visual properties of this yarn.
     """
 
-    def __init__(self, yarn_properties: None | Yarn_Properties = None, knit_graph: None | Knit_Graph = None):
+    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,
+    ):
         """Initialize a yarn with the specified properties and optional knit graph association.
 
         Args:
@@ -141,7 +157,7 @@ class Yarn:
                 self.add_loop_in_front_of_float(front_loop, v, u)
             else:
                 return
-        self.loop_graph.edges[u, v]["Front_Loops"].add(front_loop)
+        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:
@@ -157,7 +173,7 @@ class Yarn:
                 self.add_loop_behind_float(back_loop, v, u)
             else:
                 return
-        self.loop_graph.edges[u, v]["Back_Loops"].add(back_loop)
+        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]:
@@ -176,7 +192,7 @@ class Yarn:
             else:
                 return set()
         else:
-            return cast(set[Loop], self.loop_graph.edges[u, v]['Front_Loops'])
+            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.
@@ -194,7 +210,7 @@ class Yarn:
             else:
                 return set()
         else:
-            return cast(set[Loop], self.loop_graph.edges[u, v]['Back_Loops'])
+            return cast(set[Loop], self.loop_graph.edges[u, v][self._BACK_LOOPS])
 
     @property
     def last_loop(self) -> Loop | None:
@@ -290,6 +306,46 @@ class Yarn:
         else:
             return self.last_loop.loop_id + 1
 
+    def remove_loop(self, loop: Loop) -> 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.
+
+        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}.")
+        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.
+            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(
+                prior_loop,
+                next_loop,
+                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:
         """Add an existing loop to the end of this yarn and associated knit graph.
 
@@ -396,8 +452,11 @@ class Yarn:
             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 [(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 [
+            (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
+        ]
 
     def loops_behind_floats(self) -> list[tuple[Loop, Loop, set[Loop]]]:
         """Get all float segments with loops positioned behind them.
@@ -406,8 +465,11 @@ class Yarn:
             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 [(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]
+        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
+        ]
 
     def __getitem__(self, item: int) -> Loop:
         """Get a loop by its ID from this yarn.

knit_graphs/artin_wale_braids/Crossing_Direction.py

@@ -2,6 +2,7 @@
 
 This module defines the Crossing_Direction enumeration which represents the different ways loops can cross over or under each other in cable knitting patterns.
 """
+
 from __future__ import annotations
 
 from enum import Enum
@@ -13,6 +14,7 @@ class Crossing_Direction(Enum):
     This enumeration represents the three possible crossing relationships between loops: crossing over to the right, crossing under to the right, or no crossing at all.
     These directions are fundamental to representing cable structures in knitted fabrics.
     """
+
     Over_Right = "+"
     Under_Right = "-"
     No_Cross = "|"

knit_graphs/artin_wale_braids/Loop_Braid_Graph.py

@@ -2,6 +2,7 @@
 
 This module provides the Loop_Braid_Graph class which tracks crossing relationships between loops in cable knitting patterns using a directed graph structure.
 """
+
 from typing import cast
 
 from networkx import DiGraph
@@ -20,6 +21,8 @@ class Loop_Braid_Graph:
         loop_crossing_graph (DiGraph): A NetworkX directed graph storing loop crossing relationships with crossing direction attributes.
     """
 
+    _CROSSING = "crossing"
+
     def __init__(self) -> None:
         """Initialize an empty loop braid graph with no crossings."""
         self.loop_crossing_graph: DiGraph = DiGraph()
@@ -34,6 +37,15 @@ class Loop_Braid_Graph:
         """
         self.loop_crossing_graph.add_edge(left_loop, right_loop, crossing=crossing_direction)
 
+    def remove_loop(self, loop: Loop) -> None:
+        """
+        Removes any crossings that involve the given loop.
+        Args:
+            loop (Loop): The loop to remove.
+        """
+        if loop in self:
+            self.loop_crossing_graph.remove_node(loop)
+
     def __contains__(self, item: Loop | tuple[Loop, Loop]) -> bool:
         """Check if a loop or loop pair is contained in the braid graph.
 
@@ -60,8 +72,11 @@ class Loop_Braid_Graph:
         if left_loop not in self:
             return []
         else:
-            return [rl for rl in self.loop_crossing_graph.successors(left_loop)
-                    if self.get_crossing(left_loop, rl) is not Crossing_Direction.No_Cross]
+            return [
+                rl
+                for rl in self.loop_crossing_graph.successors(left_loop)
+                if self.get_crossing(left_loop, rl) is not Crossing_Direction.No_Cross
+            ]
 
     def right_crossing_loops(self, right_loop: Loop) -> list[Loop]:
         """Get all loops that cross with the given loop when it is on the right side.
@@ -75,8 +90,11 @@ class Loop_Braid_Graph:
         if right_loop not in self:
             return []
         else:
-            return [l for l in self.loop_crossing_graph.predecessors(right_loop)
-                    if self.get_crossing(l, right_loop) is not Crossing_Direction.No_Cross]
+            return [
+                l
+                for l in self.loop_crossing_graph.predecessors(right_loop)
+                if self.get_crossing(l, right_loop) is not Crossing_Direction.No_Cross
+            ]
 
     def get_crossing(self, left_loop: Loop, right_loop: Loop) -> Crossing_Direction:
         """Get the crossing direction between two loops, creating a no-cross edge if none exists.
@@ -92,4 +110,7 @@ class Loop_Braid_Graph:
         """
         if not self.loop_crossing_graph.has_edge(left_loop, right_loop):
             self.add_crossing(left_loop, right_loop, Crossing_Direction.No_Cross)
-        return cast(Crossing_Direction, self.loop_crossing_graph[left_loop][right_loop]['crossing'])
+        return cast(
+            Crossing_Direction,
+            self.loop_crossing_graph[left_loop][right_loop][self._CROSSING],
+        )

knit_graphs/artin_wale_braids/Wale.py

@@ -2,15 +2,20 @@
 
 This module defines the Wale class which represents a vertical column of stitches in a knitted structure, maintaining the sequence and relationships between loops in that column.
 """
+
 from __future__ import annotations
 
-from typing import Iterator, cast
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, cast
 
 from networkx import DiGraph, dfs_preorder_nodes
 
 from knit_graphs.Loop import Loop
 from knit_graphs.Pull_Direction import Pull_Direction
 
+if TYPE_CHECKING:
+    from knit_graphs.Knit_Graph import Knit_Graph
+
 
 class Wale:
     """A data structure representing stitch relationships between loops in a vertical column of a knitted structure.
@@ -24,48 +29,46 @@ class Wale:
         stitches (DiGraph): Stores the directed graph of stitch connections within this wale.
     """
 
-    def __init__(self, first_loop: Loop | None = None) -> None:
+    _PULL_DIRECTION: str = "pull_direction"
+
+    def __init__(self, first_loop: Loop, knit_graph: Knit_Graph, end_loop: Loop | None = None) -> None:
         """Initialize a wale optionally starting with a specified loop.
 
         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.
+            first_loop (Loop): The initial loop to start the wale with.
+            knit_graph (Knit_Graph): The knit graph that owns this wale.
+            end_loop (Loop, optional):
+                The loop to terminate the wale with.
+                If no loop is provided or this loop is not found, the wale will terminate at the first loop with no child.
         """
         self.stitches: DiGraph = DiGraph()
-        self.first_loop: None | Loop = first_loop
-        self.last_loop: None | Loop = None
-        if isinstance(self.first_loop, Loop):
-            self.add_loop_to_end(self.first_loop, pull_direction=None)
-
-    def add_loop_to_end(self, loop: Loop, pull_direction: Pull_Direction | None = Pull_Direction.BtF) -> None:
-        """Add a loop to the end (top) of the wale with the specified pull direction.
-
-        Args:
-            loop (Loop): The loop to add to the end of the wale.
-            pull_direction (Pull_Direction | None, optional): The direction to pull the loop through its parent loop. Defaults to Pull_Direction.BtF. Can be None only for the first loop in the wale.
+        self.stitches.add_node(first_loop)
+        self._knit_graph: Knit_Graph = knit_graph
+        self.first_loop: Loop = first_loop
+        self.last_loop: Loop = first_loop
+        self._build_wale_from_first_loop(end_loop)
+
+    def _build_wale_from_first_loop(self, end_loop: Loop | None) -> None:
+        while self._knit_graph.has_child_loop(self.last_loop):
+            child = self._knit_graph.get_child_loop(self.last_loop)
+            assert isinstance(child, Loop)
+            self.add_loop_to_end(child)
+            if end_loop is not None and child is end_loop:
+                return  # found the end loop, so wrap up the wale
+
+    def add_loop_to_end(self, loop: Loop) -> None:
         """
-        if self.last_loop is None:
-            self.stitches.add_node(loop)
-            self.first_loop = loop
-            self.last_loop = loop
-        else:
-            assert isinstance(pull_direction, Pull_Direction)
-            self.stitches.add_edge(self.last_loop, loop, pull_direction=pull_direction)
-            self.last_loop = loop
-
-    def add_loop_to_beginning(self, loop: Loop, pull_direction: Pull_Direction = Pull_Direction.BtF) -> None:
-        """Add a loop to the beginning (bottom) of the wale with the specified pull direction.
+        Add a loop to the end (top) of the wale with the specified pull direction.
 
         Args:
-            loop (Loop): The loop to add to the beginning of the wale.
-            pull_direction (Pull_Direction, optional): The direction to pull the existing first loop through this new loop. Defaults to Pull_Direction.BtF.
+            loop (Loop): The loop to add to the end of the wale.
         """
-        if self.first_loop is None:
-            self.stitches.add_node(loop)
-            self.first_loop = loop
-            self.last_loop = loop
-        else:
-            self.stitches.add_edge(loop, self.first_loop, pull_direction=pull_direction)
-            self.first_loop = loop
+        self.stitches.add_edge(
+            self.last_loop,
+            loop,
+            pull_direction=self._knit_graph.get_pull_direction(self.last_loop, loop),
+        )
+        self.last_loop = loop
 
     def get_stitch_pull_direction(self, u: Loop, v: Loop) -> Pull_Direction:
         """Get the pull direction of the stitch edge between two loops in this wale.
@@ -77,10 +80,11 @@ class Wale:
         Returns:
             Pull_Direction: The pull direction of the stitch between loops u and v.
         """
-        return cast(Pull_Direction, self.stitches.edges[u, v]["pull_direction"])
+        return cast(Pull_Direction, self.stitches.edges[u, v][self._PULL_DIRECTION])
 
     def split_wale(self, split_loop: Loop) -> tuple[Wale, Wale | None]:
-        """Split this wale at the specified loop into two separate wales.
+        """
+        Split this wale at the specified loop into two separate wales.
 
         The split loop becomes the last loop of the first wale and the first loop of the second wale.
 
@@ -93,19 +97,25 @@ class Wale:
                 * The first wale (from start to split_loop). This will be the whole wale if the split_loop is not found.
                 * The second wale (from split_loop to end). This will be None if the split_loop is not found.
         """
-        first_wale = Wale(self.first_loop)
-        growing_wale = first_wale
-        found_loop = False
-        for l in cast(list[Loop], self[1:]):
-            if l is split_loop:
-                growing_wale.add_loop_to_end(l, self.get_stitch_pull_direction(cast(Loop, growing_wale.last_loop), l))
-                growing_wale = Wale(split_loop)
-                found_loop = True
-            else:
-                growing_wale.add_loop_to_end(l, self.get_stitch_pull_direction(cast(Loop, growing_wale.last_loop), l))
-        if not found_loop:
+        if split_loop in self:
+            return (
+                Wale(self.first_loop, self._knit_graph, end_loop=split_loop),
+                Wale(split_loop, self._knit_graph, end_loop=self.last_loop),
+            )
+        else:
             return self, None
-        return first_wale, growing_wale
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Args:
+            other (Wale): The wale to compare.
+
+        Returns:
+            bool: True if all the loops in both wales are present and in the same order. False, otherwise.
+        """
+        if not isinstance(other, Wale) or len(self) != len(other):
+            return False
+        return not any(l != o for l, o in zip(self, other, strict=False))
 
     def __len__(self) -> int:
         """Get the number of loops in this wale.
@@ -149,13 +159,28 @@ class Wale:
         return bool(self.stitches.has_node(item))
 
     def __hash__(self) -> int:
-        """Get the hash value of this wale based on its first loop.
+        """
+        Get the hash value of this wale based on its first loop.
 
         Returns:
             int: Hash value based on the first loop in this wale.
         """
         return hash(self.first_loop)
 
+    def __str__(self) -> str:
+        """
+        Returns:
+            str: The string representation of this wale.
+        """
+        return f"Wale({self.first_loop}->{self.last_loop})"
+
+    def __repr__(self) -> str:
+        """
+        Returns:
+            str: The string representation of this wale.
+        """
+        return str(self)
+
     def overlaps(self, other: Wale) -> bool:
         """Check if this wale has any loops in common with another wale.
 

knit_graphs/artin_wale_braids/Wale_Braid.py

@@ -3,6 +3,7 @@
 This module provides the Wale_Braid class which represents complex cable knitting patterns as mathematical braid structures,
 using concepts from algebraic topology to model how wales cross over and under each other.
 """
+
 from knit_graphs.artin_wale_braids.Wale_Braid_Word import Wale_Braid_Word
 from knit_graphs.artin_wale_braids.Wale_Group import Wale_Group
 

knit_graphs/artin_wale_braids/Wale_Braid_Word.py

@@ -2,6 +2,7 @@
 
 This module provides the Wale_Braid_Word class which represents a single step in a braid operation, describing how loops cross over each other within a course of knitting.
 """
+
 from __future__ import annotations
 
 from knit_graphs.artin_wale_braids.Crossing_Direction import Crossing_Direction
@@ -59,7 +60,7 @@ class Wale_Braid_Word:
         new_crossings = {i: ~c for i, c in self.crossings.items()}
         return Wale_Braid_Word(new_loops, new_crossings)
 
-    def __eq__(self, other: Wale_Braid_Word) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Check equality with another wale braid word.
 
         Two braid words are equal if they have the same loops in the same order and the same crossing operations at the same indices.
@@ -70,13 +71,13 @@ class Wale_Braid_Word:
         Returns:
             bool: True if both braid words have identical loops, loop ordering, and crossing operations, False otherwise.
         """
-        if (len(self) != len(other)
-                or any(l != o for l, o in zip(self.loops, other.loops))
-                or any(i not in other.crossings for i in self.crossings)
-                or any(other.crossings[i] != cd for i, cd in self.crossings.items())):
-            return False
-        else:
-            return True
+        return (
+            isinstance(other, Wale_Braid_Word)
+            and len(self) == len(other)
+            and all(l == o for l, o in zip(self.loops, other.loops, strict=False))
+            and all(i in other.crossings for i in self.crossings)
+            and all(other.crossings[i] == cd for i, cd in self.crossings.items())
+        )
 
     def is_inversion(self, other: Wale_Braid_Word) -> bool:
         """Check if another braid word is the inverse of this braid word.