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

knit_graphs/artin_wale_braids/Wale_Group.py

@@ -1,88 +1,136 @@
-"""Module containing the Wale_Group class and its methods."""
-import networkx
-
-from knit_graphs.Loop import Loop
-from knit_graphs.artin_wale_braids.Wale import Wale
-
-
-class Wale_Group:
-    """
-        A graphs structure maintaining the relationship between connected wales through decreases
-    """
-
-    def __init__(self, terminal_wale: Wale, knit_graph):
-        self.wale_graph: networkx.DiGraph = networkx.DiGraph()
-        self.stitch_graph: networkx.DiGraph = networkx.DiGraph()
-        self.terminal_wale: Wale | None = terminal_wale
-        self.top_loops: dict[Loop, Wale] = {}
-        self.bottom_loops: dict[Loop, Wale] = {}
-        self.build_group_from_top_wale(terminal_wale, knit_graph)
-
-    def add_wale(self, wale: Wale):
-        """
-        :param wale: Adds wale to group and connects by di-graph by position of shared loops.
-        """
-        self.wale_graph.add_node(wale)
-        for u, v in wale.stitches.edges:
-            self.stitch_graph.add_edge(u, v, pull_direction=wale.stitches.get_edge_data(u, v, "pull_direction"))
-        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)
-        self.top_loops[wale.last_loop] = wale
-        self.bottom_loops[wale.first_loop] = wale
-
-    def add_parent_wales(self, wale: Wale, knit_graph) -> list[Wale]:
-        """
-        Add parent wales that created the given wale to a wale group.
-        :param wale: Wale to find parents from.
-        :param knit_graph: Knit graph used to derive stitch relationships.
-        :return: List of wales that were added.
-        """
-        added_wales = []
-        for parent_loop in wale.first_loop.parent_loops:
-            parent_wales = 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, knit_graph):
-        """
-        Builds out a wale group by finding parent wales from top wale provided
-        :param top_wale: top of a wale tree.
-        :param knit_graph: Knit graph used to derive stitch relationships.
-        """
-        self.add_wale(top_wale)
-        added_wales = self.add_parent_wales(top_wale, knit_graph)
-        while len(added_wales) > 0:
-            next_wale = added_wales.pop()
-            more_wales = self.add_parent_wales(next_wale, knit_graph)
-            added_wales.extend(more_wales)
-
-    def get_loops_over_courses(self) -> list[list[Loop]]:
-        """
-        :return: List of lists of loops that are in the same course by wales
-        """
-        top_loop = self.terminal_wale.last_loop
-        courses = []
-        cur_course = [top_loop]
-        while len(cur_course) > 0:
-            courses.append(cur_course)
-            next_course = []
-            for loop in cur_course:
-                next_course.extend(self.stitch_graph.predecessors(loop))
-            cur_course = next_course
-        return courses
-
-    def __len__(self):
-        """
-        :return: height of the wale group from base loop to the tallest terminal
-        """
-        max_len = 0
-        for bot_loop, wale in self.bottom_loops.items():
-            path_len = sum(len(successor) for successor in networkx.dfs_preorder_nodes(self.wale_graph, wale))
-            max_len = max(max_len, path_len)
-        return max_len
+"""Module containing the Wale_Group class and its methods.
+
+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 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
+
+
+class Wale_Group:
+    """A graph structure maintaining relationships between connected wales through decrease operations.
+
+    This class represents a collection of wales that are connected through decrease stitches, where multiple wales merge into fewer wales as the knitting progresses upward.
+    It maintains both the wale-to-wale relationships and the individual stitch connections within the 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: _Base_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.
+            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: _Base_Knit_Graph = knit_graph
+        self.terminal_wale: Wale | None = terminal_wale
+        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.
+
+        Args:
+            wale (Wale): The wale to add to this group. Empty wales are ignored and not added.
+        """
+        if len(wale) == 0:
+            return  # This wale is empty and therefore there is nothing to add to the wale group
+        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 = cast(list[Wale], 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.
+
+        This method traces through the stitch connections starting from the terminal wale's top loop and groups loops by their vertical position (course) in the knitted structure.
+
+        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]
+        while len(cur_course) > 0:
+            courses.append(cur_course)
+            next_course = []
+            for loop in cur_course:
+                next_course.extend(self.stitch_graph.predecessors(loop))
+            cur_course = next_course
+        return courses
+
+    def __len__(self) -> int:
+        """Get the height of the wale group measured as the maximum number of loops from base to terminal.
+
+        This method calculates the total length by summing all loops in all wales that can be reached from each bottom wale, returning the maximum total length found.
+
+        Returns:
+            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():
+            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

knit_graphs/basic_knit_graph_generators.py

@@ -0,0 +1,251 @@
+"""Module of functions that generate basic knit graph swatches.
+
+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
+from knit_graphs.Pull_Direction import Pull_Direction
+from knit_graphs.Yarn import Yarn
+
+
+def co_loops(width: int) -> tuple[Knit_Graph, Yarn]:
+    """Create a cast-on row of loops forming the foundation for knitting patterns.
+
+    Args:
+        width (int): The number of loops to create in the cast-on row.
+
+    Returns:
+        tuple[Knit_Graph, Yarn]: A tuple containing the knit graph with one course of the specified width and the yarn used to create it.
+    """
+    knit_graph = Knit_Graph()
+    yarn = Yarn(knit_graph=knit_graph)
+    for _ in range(0, width):
+        _loop = yarn.make_loop_on_end()
+    return knit_graph, yarn
+
+
+def jersey_swatch(width: int, height: int) -> Knit_Graph:
+    """Generate a rectangular knit swatch with all knit stitches in a flat sheet structure.
+
+    This creates a basic stockinette/jersey pattern where all stitches are worked as knit stitches from back to front.
+
+    Args:
+        width (int): The number of stitches per course (horizontal row).
+        height (int): The number of courses (vertical rows) in the swatch.
+
+    Returns:
+        Knit_Graph: A knit graph representing a flat rectangular swatch with all knit stitches.
+    """
+    knit_graph, yarn = co_loops(width)
+    last_course = list(knit_graph.get_courses()[0])
+    for _ in range(0, height):
+        next_course = []
+        for parent_loop in reversed(last_course):
+            child_loop = yarn.make_loop_on_end()
+            knit_graph.connect_loops(parent_loop, child_loop, pull_direction=Pull_Direction.BtF)
+            next_course.append(child_loop)
+        last_course = next_course
+    return knit_graph
+
+
+def jersey_tube(tube_width: int, height: int) -> Knit_Graph:
+    """Generate a tubular knit structure with all knit stitches worked in the round.
+
+    This creates a seamless tube by knitting in the round, where the front and back sections are connected by floats to maintain the circular structure.
+
+    Args:
+        tube_width (int): The number of stitches per course on the front side of the tube.
+        height (int): The number of courses (vertical rows) in the tube.
+
+    Returns:
+        Knit_Graph: A knit graph representing a seamless tube with all knit stitches.
+    """
+    knit_graph, yarn = co_loops(tube_width * 2)
+    last_course = [*knit_graph.get_courses()[0]]
+
+    def _set_tube_floats() -> None:
+        """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)):
+            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)):
+            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):
+            knit_graph.connect_loops(parent_loop, child_loop, pull_direction=Pull_Direction.BtF)
+        last_course = next_course
+        _set_tube_floats()
+    return knit_graph
+
+
+def kp_rib_swatch(width: int, height: int) -> Knit_Graph:
+    """Generate a knit-purl ribbing swatch with alternating wales of knit and purl stitches.
+
+    This creates a 1x1 ribbing pattern where knit and purl wales alternate, maintaining their stitch type throughout the height of the swatch for a stretchy, textured fabric.
+
+    Args:
+        width (int): The number of stitches per course (horizontal row).
+        height (int): The number of courses (vertical rows) in the swatch.
+
+    Returns:
+        Knit_Graph: A knit graph representing a ribbed swatch with alternating knit and purl wales.
+    """
+    knit_graph, yarn = co_loops(width)
+    last_course = knit_graph.get_courses()[0]
+    next_course = []
+    next_pull = Pull_Direction.BtF
+    for parent_loop in reversed(last_course):
+        child_loop = yarn.make_loop_on_end()
+        knit_graph.connect_loops(parent_loop, child_loop, pull_direction=next_pull)
+        next_pull = next_pull.opposite()
+        next_course.append(child_loop)
+    last_course = next_course
+    for _ in range(1, height):
+        next_course = []
+        for parent_loop in reversed(last_course):
+            grand_parent = parent_loop.parent_loops[0]
+            parent_pull = knit_graph.get_pull_direction(grand_parent, parent_loop)
+            assert isinstance(parent_pull, Pull_Direction)
+            child_loop = yarn.make_loop_on_end()
+            knit_graph.connect_loops(parent_loop, child_loop, pull_direction=parent_pull)
+            next_course.append(child_loop)
+        last_course = next_course
+    return knit_graph
+
+
+def seed_swatch(width: int, height: int) -> Knit_Graph:
+    """Generate a seed stitch swatch with a checkerboard pattern of knit and purl stitches.
+
+    This creates a textured fabric where each stitch alternates between knit and purl both horizontally and vertically, creating a bumpy, non-curling fabric texture.
+
+    Args:
+        width (int): The number of stitches per course (horizontal row).
+        height (int): The number of courses (vertical rows) in the swatch.
+
+    Returns:
+        Knit_Graph: A knit graph representing a seed stitch swatch with checkerboard knit-purl pattern.
+    """
+    knit_graph, yarn = co_loops(width)
+    last_course = knit_graph.get_courses()[0]
+    next_course = []
+    next_pull = Pull_Direction.BtF
+    for parent_loop in reversed(last_course):
+        child_loop = yarn.make_loop_on_end()
+        knit_graph.connect_loops(parent_loop, child_loop, pull_direction=next_pull)
+        next_pull = next_pull.opposite()
+        next_course.append(child_loop)
+    last_course = next_course
+    for _ in range(1, height):
+        next_course = []
+        for parent_loop in reversed(last_course):
+            grand_parent = parent_loop.parent_loops[0]
+            parent_pull = knit_graph.get_pull_direction(grand_parent, parent_loop)
+            assert isinstance(parent_pull, Pull_Direction)
+            child_loop = yarn.make_loop_on_end()
+            knit_graph.connect_loops(parent_loop, child_loop, pull_direction=parent_pull.opposite())
+            next_course.append(child_loop)
+        last_course = next_course
+    return knit_graph
+
+
+def lace_mesh(width: int, height: int) -> Knit_Graph:
+    """Generate a mesh pattern with alternating left and right leaning decrease paired to yarn-overs.
+    These pairings create a basic lace pattern with eyelets formed around the increases.
+
+    Args:
+        width (int): The number of stitches per course (horizontal row).
+        height (int): The number of courses (vertical rows) in the swatch.
+
+    Returns:
+        Knit_Graph: A knit graph representing a mesh swatch.
+    """
+    knit_graph, yarn = co_loops(width)
+    last_course = knit_graph.get_courses()[0]
+    next_course = []
+    for parent_loop in reversed(last_course):
+        child_loop = yarn.make_loop_on_end()
+        knit_graph.connect_loops(parent_loop, child_loop, pull_direction=Pull_Direction.BtF)
+        next_course.append(child_loop)
+    last_course = next_course
+    for _ in range(1, height):
+        # Make the lace course
+        next_course = []
+        yo_parent = None
+        prior_child = None
+        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)
+            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)
+                assert isinstance(yo_parent, Loop)
+                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)
+                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)
+            next_course.append(child_loop)
+        last_course = next_course
+        # Make a basic jersey course
+        next_course = []
+        for parent_loop in reversed(last_course):
+            child_loop = yarn.make_loop_on_end()
+            knit_graph.connect_loops(parent_loop, child_loop, pull_direction=Pull_Direction.BtF)
+            next_course.append(child_loop)
+        last_course = next_course
+    return knit_graph
+
+
+def twist_cable(width: int, height: int) -> Knit_Graph:
+    """Generate a twisted cable pattern with alternating crossing directions and purl separators.
+
+    This creates a cable pattern with 1x1 twists that alternate direction every two rows, separated by purl wales to make the cable structure more prominent.
+
+    Args:
+        width (int): The number of stitches per course (horizontal row).
+        height (int): The number of courses (vertical rows) in the swatch.
+
+    Returns:
+        Knit_Graph: A knit graph representing a twisted cable pattern with alternating crossing directions.
+    """
+    # p k\k p ->: 3-4
+    # p k k p <-: 2-3
+    # p k/k p ->: 1-2
+    # p k k p <-: 0-1
+    # 0 1 2 3
+    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]
+    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])
+        next_course.append(child_loop)
+    last_course = next_course
+    crossing = Crossing_Direction.Over_Right
+    for r in range(1, height):
+        next_course = [yarn.make_loop_on_end() for _ in last_course]
+        for i, parent_loop in enumerate(reversed(last_course)):
+            if r % 2 == 0 or i % 4 == 0 or i % 4 == 3:  # not cable row (even) or in purl wale
+                child_loop = next_course[i]
+            elif i % 4 == 1:
+                child_loop = next_course[i + 1]
+            else:
+                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]):
+                knit_graph.add_crossing(left_loop, right_loop, crossing)
+            crossing = ~crossing
+        last_course = next_course
+    return knit_graph

knit_graphs-0.0.8.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Megan Hofmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -1,23 +1,29 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: knit-graphs
-Version: 0.0.6
+Version: 0.0.8
 Summary: A graph representation of knitted structures where each loop is a node and edges represent yarn and stitch relationships.
-Project-URL: Documentation, https://github.com/mhofmann-Khoury/knit_graph#readme
-Project-URL: Issues, https://github.com/mhofmann-Khoury/knit_graph/issues
-Project-URL: Source, https://github.com/mhofmann-Khoury/knit_graph
-Author-email: Megan Hofmann <m.hofmann@northeastern.edu>
-License-File: LICENSE
-Keywords: ACT Lab,Northeastern,fabrication,knit,machine knit,textile
-Classifier: Development Status :: 2 - Pre-Alpha
+Home-page: https://mhofmann-Khoury.github.io/knit-graphs/
+License: MIT
+Keywords: ACT Lab,Northeastern University,knit,machine knit,fabrication,textile
+Author: Megan Hofmann
+Author-email: m.hofmann@northeastern.edu
+Maintainer: Megan Hofmann
+Maintainer-email: m.hofmann@northeastern.edu
+Requires-Python: >=3.11,<3.14
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
-Classifier: Programming Language :: Python
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.11
-Requires-Dist: networkx~=3.2.1
-Requires-Dist: plotly~=5.22.0
+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
 Description-Content-Type: text/markdown
 
 # knit_graphs
@@ -27,9 +33,9 @@ Description-Content-Type: text/markdown
 
 -----
 ## Description
-The knit-graphs packaged provides a data structure for representing knitted structures formed of loops of yarn (nodes) connected by various edge structures. Loops are connected by: floats (yarn-edges) in a yarn graph structure, stitch edges (loops pulled through loops), and crossed over each other in a wale-braid structure. 
+The knit-graphs packaged provides a data structure for representing knitted structures formed of loops of yarn (nodes) connected by various edge structures. Loops are connected by: floats (yarn-edges) in a yarn graph structure, stitch edges (loops pulled through loops), and crossed over each other in a wale-braid structure.
 
-Knit graphs provide a powerful tool for representing knitted structures for digital fabrication systems such as knitting machine programming languages and design tools. 
+Knit graphs provide a powerful tool for representing knitted structures for digital fabrication systems such as knitting machine programming languages and design tools.
 
 Additional details about this knit-graph construction are available in the ACM publication:
 ["KnitPicking Texture: Programming and Modifying Complex Knitted Textures for Machine and Hand Knitting"](https://doi.org/10.1145/3332165.3347886)
@@ -54,25 +60,27 @@ pip install knit-graphs
 ## Usage
 
 ### Knit Graph Generators
-The [knit-graph-generators subpackage](https://github.com/mhofmann-Khoury/knit_graph/tree/main/src/knit_graphs/knit_graph_generators) provides a library of basic knit graphs to generate such as casting on loops of a knitted structure, creating Jersey (aka Stockinette) tubes and swatches, and other basic textures. 
+The [knit-graph-generators subpackage](https://github.com/mhofmann-Khoury/knit_graph/tree/main/src/knit_graphs/knit_graph_generators) provides a library of basic knit graphs to generate such as casting on loops of a knitted structure, creating Jersey (aka Stockinette) tubes and swatches, and other basic textures.
 For example, to generate a swatch of knit-purl ribbing use the following:
+
 ```python
-from knit_graphs.knit_graph_generators.basic_knit_graph_generators import kp_rib_swatch
+from knit_graphs.basic_knit_graph_generators import kp_rib_swatch
+
 width = 10
 height = 10
 kp_rib_swatch = kp_rib_swatch(width, height)
 ```
 Additional examples of knitgraph generator usage can be found in the [Knit_Graph test module](https://github.com/mhofmann-Khoury/knit_graph/blob/main/tests/test_Knit_Graph.py).
 
-Knitgraphs can be created without generators. We encourage users to review the generators as simple examples on creating a knit graph programmatically. 
+Knitgraphs can be created without generators. We encourage users to review the generators as simple examples on creating a knit graph programmatically.
 
 ### Visualizing Knit Graphs
-We provide simple support for visualizing knit graphs. This is primarily used to debugging simple knit graph programs. 
+We provide simple support for visualizing knit graphs. This is primarily used to debugging simple knit graph programs.
 
 For example, we can visualize a swatch of seed stitch (checkered knit and purl stitches) with the following code.
 
 ```python
-from knit_graphs.knit_graph_generators.basic_knit_graph_generators import seed_swatch
+from knit_graphs.basic_knit_graph_generators import seed_swatch
 from knit_graphs.knit_graph_visualizer.Stitch_Visualizer import visualize_stitches
 
 width = 4
@@ -80,16 +88,17 @@ height = 4
 swatch = seed_swatch(width, height)
 visualize_stitches(swatch)
 ```
-The visualizer shows knit stitches (loops pulled from the back of the fabric to the front) as blue edges and purl stitches (loops pulled from the front to back) (aka back-knits) as red edges. Loop nodes are circles labeled with their time-ordered index and colored to match their yarn (defaults to dark green). The yarn edges (aka floats) connecting them are made of thin edges the same color as the loop nodes. 
+The visualizer shows knit stitches (loops pulled from the back of the fabric to the front) as blue edges and purl stitches (loops pulled from the front to back) (aka back-knits) as red edges. Loop nodes are circles labeled with their time-ordered index and colored to match their yarn (defaults to dark green). The yarn edges (aka floats) connecting them are made of thin edges the same color as the loop nodes.
 
 Additional examples of using the visualizer are available in the [Stitch Visualizer Tests Module](https://github.com/mhofmann-Khoury/knit_graph/blob/main/tests/test_Stitch_Visualizer.py)
 
 ## Credits
-The design of this data scructure was completed by the authors of 
+The design of this data scructure was completed by the authors of
 ["KnitPicking Texture: Programming and Modifying Complex Knitted Textures for Machine and Hand Knitting"](https://doi.org/10.1145/3332165.3347886).
 
 The inclusion of the Artin-Braide wale crossing construction was inspired by ["An Artin Braid Group Representation of Knitting Machine State with Applications to Validation and Optimization of Fabrication Plans"](https://doi.org/10.1109/ICRA48506.2021.9562113) by Jenny Lin and James McCann.
 
 ## License
 
-`knit-graphs` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+`knit-graphs` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+