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

knit_graphs/artin_wale_braids/Wale_Group.py

@@ -2,6 +2,7 @@
 
 This module provides the Wale_Group class which represents a collection of interconnected wales that are joined through decrease operations, forming a tree-like structure of vertical stitch columns.
 """
+
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, cast
@@ -24,84 +25,68 @@ class Wale_Group:
     Attributes:
         wale_graph (DiGraph): A directed graph representing the relationships between wales in this group.
         stitch_graph (DiGraph): A directed graph of all individual stitch connections within this wale group.
-        terminal_wale (Wale | None): The topmost wale in this group, typically where multiple wales converge.
         top_loops (dict[Loop, Wale]): Mapping from the last (top) loop of each wale to the wale itself.
         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: Knit_Graph):
+    def __init__(self, terminal_loop: Loop, knit_graph: Knit_Graph):
         """Initialize a wale group starting from a terminal wale and building downward.
 
         Args:
-            terminal_wale (Wale): The topmost wale in the group, used as the starting point for building the complete group structure.
+            terminal_loop (Loop): The terminal loop of this wale-group. All the wales in the group connect up to this loop.
             knit_graph (Knit_Graph): The parent knit graph that contains this wale group.
         """
         self.wale_graph: DiGraph = DiGraph()
         self.stitch_graph: DiGraph = DiGraph()
         self._knit_graph: Knit_Graph = knit_graph
-        self.terminal_wale: Wale | None = terminal_wale
+        self._terminal_loop: Loop = terminal_loop
         self.top_loops: dict[Loop, Wale] = {}
         self.bottom_loops: dict[Loop, Wale] = {}
-        self.build_group_from_top_wale(terminal_wale)
-
-    def add_wale(self, wale: Wale) -> None:
-        """Add a wale to the group and connect it to existing wales through shared loops.
-
-        This method adds the wale to the group's graphs and establishes connections with other wales based on shared loops at their endpoints.
+        self._build_wale_group()
 
-        Args:
-            wale (Wale): The wale to add to this group. Empty wales are ignored and not added.
+    @property
+    def terminal_loop(self) -> Loop:
         """
-        if len(wale) == 0:
-            return  # This wale is empty and therefore there is nothing to add to the wale group
+        Returns:
+            Loop: The loop that terminates all wales in this group.
+        """
+        return self._terminal_loop
+
+    def _build_wale_group(self) -> None:
+        full_wales = self._knit_graph.get_wales_ending_with_loop(self._terminal_loop)
+        # Build up the stitch graph.
+        for wale in full_wales:
+            u_loops: list[Loop] = cast(list[Loop], wale[:-1])
+            v_loops: list[Loop] = cast(list[Loop], wale[1:])
+            for u, v in zip(u_loops, v_loops, strict=False):
+                self.stitch_graph.add_edge(u, v, pull_direction=self._knit_graph.get_pull_direction(u, v))
+        wales_to_split = full_wales
+        while len(wales_to_split) > 0:
+            wale_to_split = wales_to_split.pop()
+            split = False
+            upper_loops = cast(list[Loop], wale_to_split[1:])
+            for (
+                loop
+            ) in upper_loops:  # skip first loop in each wale as it may be already connected to a discovered decrease.
+                if len(loop.parent_loops) > 1:  # Focal of a decrease.
+                    clean_wale, remaining_wale = wale_to_split.split_wale(loop)
+                    if not self.wale_graph.has_node(clean_wale):
+                        self._add_wale(clean_wale)
+                    if isinstance(remaining_wale, Wale):
+                        wales_to_split.add(remaining_wale)
+                    split = True
+                    break
+            if not split:
+                self._add_wale(wale_to_split)
+        for _bot_loop, lower_wale in self.bottom_loops.items():
+            if lower_wale.last_loop in self.bottom_loops:
+                self.wale_graph.add_edge(lower_wale, self.bottom_loops[lower_wale.last_loop])
+
+    def _add_wale(self, wale: Wale) -> None:
         self.wale_graph.add_node(wale)
-        for u, v in wale.stitches.edges:
-            self.stitch_graph.add_edge(u, v, pull_direction=wale.get_stitch_pull_direction(u, v))
-        for top_loop, other_wale in self.top_loops.items():
-            if top_loop == wale.first_loop:
-                self.wale_graph.add_edge(other_wale, wale)
-        for bot_loop, other_wale in self.bottom_loops.items():
-            if bot_loop == wale.last_loop:
-                self.wale_graph.add_edge(wale, other_wale)
-        assert isinstance(wale.last_loop, Loop)
         self.top_loops[wale.last_loop] = wale
-        assert isinstance(wale.first_loop, Loop)
         self.bottom_loops[wale.first_loop] = wale
 
-    def add_parent_wales(self, wale: Wale) -> list[Wale]:
-        """Find and add all parent wales that created the given wale through decrease operations.
-
-        This method identifies wales that end at the loops that are parents of this wale's first loop, representing the wales that were decreased together to form the given wale.
-
-        Args:
-            wale (Wale): The wale to find and add parent wales for.
-
-        Returns:
-            list[Wale]: The list of parent wales that were found and added to the group.
-        """
-        added_wales = []
-        for parent_loop in cast(Loop, wale.first_loop).parent_loops:
-            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)
-        return added_wales
-
-    def build_group_from_top_wale(self, top_wale: Wale) -> None:
-        """Build the complete wale group by recursively finding all parent wales from the terminal wale.
-
-        This method starts with the terminal wale and recursively adds all parent wales, building the complete tree structure of wales that contribute to the terminal wale through decrease operations.
-
-        Args:
-            top_wale (Wale): The terminal wale at the top of the group structure.
-        """
-        self.add_wale(top_wale)
-        added_wales = self.add_parent_wales(top_wale)
-        while len(added_wales) > 0:
-            next_wale = added_wales.pop()
-            more_wales = self.add_parent_wales(next_wale)
-            added_wales.extend(more_wales)
-
     def get_loops_over_courses(self) -> list[list[Loop]]:
         """Get loops organized by their course (horizontal row) within this wale group.
 
@@ -110,11 +95,8 @@ class Wale_Group:
         Returns:
             list[list[Loop]]: A list where each inner list contains all loops that belong to the same course, ordered from top to bottom courses. Returns empty list if there is no terminal wale.
         """
-        if self.terminal_wale is None:
-            return []
-        top_loop: Loop = cast(Loop, self.terminal_wale.last_loop)
         courses: list[list[Loop]] = []
-        cur_course: list[Loop] = [top_loop]
+        cur_course: list[Loop] = [self._terminal_loop]
         while len(cur_course) > 0:
             courses.append(cur_course)
             next_course = []
@@ -132,7 +114,41 @@ class Wale_Group:
             int: The height of the wale group from the base loops to the tallest terminal, measured in total number of loops.
         """
         max_len = 0
-        for bot_loop, wale in self.bottom_loops.items():
+        for _bot_loop, wale in self.bottom_loops.items():
             path_len = sum(len(successor) for successor in dfs_preorder_nodes(self.wale_graph, wale))
             max_len = max(max_len, path_len)
         return max_len
+
+    def __hash__(self) -> int:
+        """
+        Returns:
+            int: Hash value of the terminal loop of this group.
+        """
+        return hash(self._terminal_loop)
+
+    def __contains__(self, item: Loop | int | Wale) -> bool:
+        """
+        Args:
+            item (Loop | int | Wale): The item to check for in the wale group.
+
+        Returns:
+            bool: True if the given loop, loop_id (int), or wale is in this group.
+        """
+        if isinstance(item, (Loop, int)):
+            return item in self.stitch_graph.nodes
+        else:  # isinstance(item, Wale):
+            return item in self.wale_graph
+
+    def __str__(self) -> str:
+        """
+        Returns:
+            str: The string representation of this wale group.
+        """
+        return f"WG({self.terminal_loop})"
+
+    def __repr__(self) -> str:
+        """
+        Returns:
+            str: The string representation of this wale group.
+        """
+        return str(self)

knit_graphs/basic_knit_graph_generators.py

@@ -3,6 +3,7 @@
 This module provides utility functions for creating common knitting patterns and structures as knit graphs.
 These functions serve as building blocks for testing and demonstration purposes.
 """
+
 from knit_graphs.artin_wale_braids.Crossing_Direction import Crossing_Direction
 from knit_graphs.Knit_Graph import Knit_Graph
 from knit_graphs.Loop import Loop
@@ -69,15 +70,19 @@ def jersey_tube(tube_width: int, height: int) -> Knit_Graph:
         """Internal helper function to set up float connections between front and back of tube."""
         front_loops = last_course[0:tube_width]
         back_loops = last_course[tube_width:]
-        for first_front, second_front, back in zip(front_loops[0:-1], front_loops[1:], reversed(back_loops)):
+        for first_front, second_front, back in zip(
+            front_loops[0:-1], front_loops[1:], reversed(back_loops), strict=False
+        ):
             yarn.add_loop_behind_float(back, first_front, second_front)
-        for (first_back, second_back, front) in zip(back_loops[0:-1], back_loops[1:], reversed(front_loops)):
+        for first_back, second_back, front in zip(
+            back_loops[0:-1], back_loops[1:], reversed(front_loops), strict=False
+        ):
             yarn.add_loop_in_front_of_float(front, first_back, second_back)
 
     _set_tube_floats()
     for _ in range(0, height):
         next_course = [yarn.make_loop_on_end() for _p in last_course]
-        for parent_loop, child_loop in zip(last_course, next_course):
+        for parent_loop, child_loop in zip(last_course, next_course, strict=False):
             knit_graph.connect_loops(parent_loop, child_loop, pull_direction=Pull_Direction.BtF)
         last_course = next_course
         _set_tube_floats()
@@ -181,19 +186,44 @@ def lace_mesh(width: int, height: int) -> Knit_Graph:
         for i, parent_loop in enumerate(reversed(last_course)):
             child_loop = yarn.make_loop_on_end()
             if i % 3 == 0:  # Just knit every third stitch
-                knit_graph.connect_loops(parent_loop, child_loop, pull_direction=Pull_Direction.BtF, stack_position=0)
+                knit_graph.connect_loops(
+                    parent_loop,
+                    child_loop,
+                    pull_direction=Pull_Direction.BtF,
+                    stack_position=0,
+                )
             elif i % 6 == 1:  # Second of every 6 stitches (0 indexed) is yarn over before a decrease.
                 yo_parent = parent_loop
             elif i % 6 == 2:  # Third of every 6 stitches is bottom of decrease with prior yarn-over's parent
-                knit_graph.connect_loops(parent_loop, child_loop, pull_direction=Pull_Direction.BtF, stack_position=0)
+                knit_graph.connect_loops(
+                    parent_loop,
+                    child_loop,
+                    pull_direction=Pull_Direction.BtF,
+                    stack_position=0,
+                )
                 assert isinstance(yo_parent, Loop)
-                knit_graph.connect_loops(yo_parent, child_loop, pull_direction=Pull_Direction.BtF, stack_position=1)
+                knit_graph.connect_loops(
+                    yo_parent,
+                    child_loop,
+                    pull_direction=Pull_Direction.BtF,
+                    stack_position=1,
+                )
             elif i % 6 == 4:  # Fifth of every six stitches is bottom of decrease with next yarn-over's parent
-                knit_graph.connect_loops(parent_loop, child_loop, pull_direction=Pull_Direction.BtF, stack_position=0)
+                knit_graph.connect_loops(
+                    parent_loop,
+                    child_loop,
+                    pull_direction=Pull_Direction.BtF,
+                    stack_position=0,
+                )
                 prior_child = child_loop
             elif i % 6 == 5:  # The last of six stitches is the top of the prior decrease and new yarn-over
                 assert isinstance(prior_child, Loop)
-                knit_graph.connect_loops(parent_loop, prior_child, pull_direction=Pull_Direction.BtF, stack_position=1)
+                knit_graph.connect_loops(
+                    parent_loop,
+                    prior_child,
+                    pull_direction=Pull_Direction.BtF,
+                    stack_position=1,
+                )
             next_course.append(child_loop)
         last_course = next_course
         # Make a basic jersey course
@@ -226,7 +256,12 @@ def twist_cable(width: int, height: int) -> Knit_Graph:
     knit_graph, yarn = co_loops(width)
     last_course = knit_graph.get_courses()[0]
     next_course = []
-    pull_directions = [Pull_Direction.FtB, Pull_Direction.BtF, Pull_Direction.BtF, Pull_Direction.FtB]
+    pull_directions = [
+        Pull_Direction.FtB,
+        Pull_Direction.BtF,
+        Pull_Direction.BtF,
+        Pull_Direction.FtB,
+    ]
     for i, parent_loop in enumerate(reversed(last_course)):
         child_loop = yarn.make_loop_on_end()
         knit_graph.connect_loops(parent_loop, child_loop, pull_direction=pull_directions[i % 4])
@@ -244,7 +279,7 @@ def twist_cable(width: int, height: int) -> Knit_Graph:
                 child_loop = next_course[i - 1]
             knit_graph.connect_loops(parent_loop, child_loop, pull_direction=pull_directions[i % 4])
         if r % 2 == 1:  # cable row
-            for left_loop, right_loop in zip(next_course[1::4], next_course[2::4]):
+            for left_loop, right_loop in zip(next_course[1::4], next_course[2::4], strict=False):
                 knit_graph.add_crossing(left_loop, right_loop, crossing)
             crossing = ~crossing
         last_course = next_course

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: knit-graphs
-Version: 0.0.9
+Version: 0.0.11
 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_graph/
 License: MIT
@@ -20,8 +20,9 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
 Requires-Dist: networkx (>=3.5)
-Requires-Dist: plotly (>=6.3.0,<7.0.0)
+Requires-Dist: plotly (>=6.3.0)
 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-0.0.9.dist-info → knit_graphs-0.0.11.dist-info}/RECORD

@@ -17,25 +17,26 @@ docs/source/api/knit_graphs.artin_wale_braids.Wale_Group.rst,sha256=bAGHs3s8dW6l
 docs/source/api/knit_graphs.artin_wale_braids.rst,sha256=ESKgE9gg830yJ6w5mKuv3MHgH3tMZ-Ee2y3b-bSnU4Y,547
 docs/source/api/knit_graphs.basic_knit_graph_generators.rst,sha256=OgV2jkEMY0LfRq8v0cNhJUk3fbUOS9VcP8zRv4VBvC4,213
 docs/source/api/knit_graphs.rst,sha256=w9HIhWI8P0_gG0H_efRUMHYBtWbgCprcS9moclgM_3I,499
-docs/source/conf.py,sha256=TZK8Rz0JNgQs2J_cUhVX5_4tmMBvRdGtILJsnAnAFWo,13350
-docs/source/index.rst,sha256=D4KmCX1_d2-WrPgxSeggHHsc9-TeQwSUGYOkehRQWrw,1462
+docs/source/conf.py,sha256=qfKxtgms3gNDSoXGpOzWEDMzKJH20ovRMqTC57LkYF4,13282
+docs/source/index.rst,sha256=E82Y_wpDU2hR8w6bSt2k6ZstslCe7u63Ld6ZFgT70RY,1284
 docs/source/installation.rst,sha256=GyNRk_oXKVgOZ4KFLAgkXLwjHYzDYsx8gcokLRrS0ZI,1247
-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=WQh9ag1lv7_cJndZLGhhoGx1msdLEGixpahdXd2PhGk,7189
-knit_graphs/Pull_Direction.py,sha256=8xRLN-j7V1mExgmt3YjcJcTDa5rLedA2bF4wI8gd-DE,2334
-knit_graphs/Yarn.py,sha256=Stm-_1SRJTdN1hFPjtuBPyY0Ln55zC15FKGu5vyqerA,16000
+knit_graphs/Course.py,sha256=dcJvWtTYc66iiVpxtYzULDD2ttWuvuGnlahWpWs1wAY,6308
+knit_graphs/Knit_Graph.py,sha256=ys4-oeu23_8yZ8yjun-QngeiErUK0l3F8lnNlg7cB70,12442
+knit_graphs/Knit_Graph_Visualizer.py,sha256=R-iSEEq5_hDi3NLDjP0hVrArrynKUASHs7vA7MAccJg,42108
+knit_graphs/Loop.py,sha256=B1YU6bjTsGYZ8QrBZN52vg1btf7jvzeviCAH-Exrmw8,9747
+knit_graphs/Pull_Direction.py,sha256=3QW_TKEF3fb-Y7I8xDOHHTe6vCYK-ADi3_SDtqr5uSU,2336
+knit_graphs/Yarn.py,sha256=RaU0_At-V6Yk0TGgrRbsKeWJsI4WMoHkZHzUfs7txAE,18391
 knit_graphs/__init__.py,sha256=qzZAOxTqjgLkhoGnKNZwOkuYbKEyzfWKkKpKkV6lVfk,111
-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=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=JJXR5TvLuoC2LXvNfmwbHhvBObn0MONUVE9ZsBcSmUc,6867
+knit_graphs/artin_wale_braids/Crossing_Direction.py,sha256=qQCxgsI5L_PMY16bX7_W_C0YG2SKTVcq05RO5eNcZDA,2822
+knit_graphs/artin_wale_braids/Loop_Braid_Graph.py,sha256=A4KoqjBBw8mqvUyzXwCZcwSDDIePtUqgnVVKAWXTa-w,4997
+knit_graphs/artin_wale_braids/Wale.py,sha256=G7Uci5wkE5y7gHGK2bbTpRyswGRSWhVXFxyIUYOprlo,7259
+knit_graphs/artin_wale_braids/Wale_Braid.py,sha256=p2SsFQW6nQZTO89TtCnFSWTWkYAFDm6kykvhb9G7chg,2663
+knit_graphs/artin_wale_braids/Wale_Braid_Word.py,sha256=rY1cB_PpAfz4vFGPh2qUaLf0yNDczk2l6pgxtYA6Sqg,4593
+knit_graphs/artin_wale_braids/Wale_Group.py,sha256=Px-3yxKAUCeqI52IE6t6L2aSCFwgTTsVbN0bWdhQ518,6696
 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.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/basic_knit_graph_generators.py,sha256=x1zHC2PYbzkmjE40xe5_3k2vDsT749L9iufUIfC2QUw,12353
+knit_graphs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+knit_graphs-0.0.11.dist-info/LICENSE,sha256=Oazk3oiRu5ZN7b-EdYNYh0vu-I3Av2uIPQ-9L_cZ6Oo,1070
+knit_graphs-0.0.11.dist-info/METADATA,sha256=I8Kkhsuu02YB0UX9W7Gzwzrq5Y9PrXmWvqo1j8JwUJA,5215
+knit_graphs-0.0.11.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+knit_graphs-0.0.11.dist-info/RECORD,,