topologicpy 0.8.28__py3-none-any.whl → 0.8.29__py3-none-any.whl

topologicpy/Plotly.py

@@ -592,6 +592,7 @@ class Plotly:
             mode = "markers+text"
         else:
             mode = "markers"
+
         vData2 = go.Scatter3d(x=x,
                             y=y,
                             z=z,
@@ -603,11 +604,13 @@ class Plotly:
                                         opacity=1,
                                         sizemode="diameter"),
                             mode=mode,
+                            customdata = labels,
                             legendgroup=legendGroup,
                             legendrank=legendRank,
                             text=labels,
                             hoverinfo='text',
-                            hovertext=labels
+                            hovertext=labels,
+                            hovertemplate=["Click "+label for label in labels]
                             )
         if borderWidth > 0 or borderWidthKey:
             vData1 = go.Scatter3d(x=x,
@@ -676,14 +679,13 @@ class Plotly:
             labels = []
             for j, elements_cluster in enumerate(elements_clusters):
                 d_color = color
-                labels.append("Edge_"+str(j+1).zfill(n))
                 d = dict_clusters[j][0] # All dicitonaries have same values in dictionaries, so take first one.
                 if d:
                     if not colorKey == None:
                         d_color = Dictionary.ValueAtKey(d, key=colorKey) or color
                         d_color = Color.AnyToHex(d_color)
                     if not labelKey == None:
-                        label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
+                        labels.append(str(Dictionary.ValueAtKey(d, labelKey, "")))
                     if not widthKey == None:
                         e_width = Dictionary.ValueAtKey(d, key=widthKey)
                         if not e_width == None:
@@ -727,8 +729,10 @@ class Plotly:
                                     line=dict(color=d_color, width=width),
                                     legendgroup=legendGroup,
                                     legendrank=legendRank,
-                                    text=label,
-                                    hoverinfo='text')
+                                    text=labels,
+                                    customdata=labels,
+                                    hoverinfo='text',
+                                    hovertext=labels)
                 traces.append(trace)
         else:
             x = []

topologicpy/ShapeGrammar.py

@@ -0,0 +1,492 @@
+# Copyright (C) 2025
+# Wassim Jabi <wassim.jabi@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along with
+# this program. If not, see <https://www.gnu.org/licenses/>.
+
+import topologic_core as topologic
+
+class ShapeGrammar:
+    def __init__(self):
+        self.title = "Untitled" # Stores the title of the topology grammar.
+        self.description = "" # Stores the description of the grammar.
+        self.rules = []  # Stores transformation rules of the topology grammar.
+        # Operations
+        # Replace
+        replace = {"title": "Replace",
+                   "description": "Replaces the input topology with the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Transform
+        transform = {"title": "Transform",
+                   "description": "Transforms the input topology using the specified matrix.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Union
+        union = {"title": "Union",
+                   "description": "Unions the input topology and the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Difference
+        difference = {"title": "Difference",
+                   "description": "Subtracts the output topology from the input topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Difference
+        symdif = {"title": "Symmetric Difference",
+                   "description": "Calculates the symmetrical difference of the input topology and the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Intersect
+        intersect = {"title": "Intersect",
+                   "description": "Intersects the input topology and the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Merge
+        merge = {"title": "Merge",
+                   "description": "Merges the input topology and the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Slice
+        slice = {"title": "Slice",
+                   "description": "Slices the input topology using the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Impose
+        impose = {"title": "Impose",
+                   "description": "Imposes the output topology on the input topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Imprint
+        imprint = {"title": "Imprint",
+                   "description": "Imposes the output topology on the input topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Divide
+        divide = {"title": "Divide",
+                   "description": "Divides the input topology along the x, y, and z axes using the specified number of sides (uSides, vSides, wSides)",
+                   "uSides": 2,
+                   "vSides": 2,
+                   "wSides": 2}
+        self.operations = [replace, transform, union, difference, symdif, intersect, merge, slice, impose, imprint, divide]
+
+    def OperationTitles(self):
+        """
+        Returns the list of available operation titles.
+
+        Parameters
+        ----------
+        
+        Returns
+        -------
+        list
+            The requested list of operation titles
+        """
+        return [op["title"] for op in self.operations]
+    
+    def OperationByTitle(self, title):
+        """
+        Returns the operation given the input title string
+
+        Parameters
+        ----------
+        title : str
+            The input operation str. See OperationTitles for list of operations.
+        
+        Returns
+        -------
+        ShapeGrammar.Operation
+            The requested operation
+        """
+        for op in self.operations:
+            op_title = op["title"]
+            if title.lower() in op_title.lower():
+                return op
+        return None
+
+    def AddRule(self,
+                input,
+                output,
+                title : str = "Untitled Rule",
+                description: str = "",
+                operation : dict = None,
+                matrix: list = None,
+                silent: bool = False):
+        """
+        Adds a rule to the topology grammar.
+
+        Parameters
+        ----------
+        input : topologic_core.Topology
+            The linput topology of the rule.
+        output : topologic_core.Topology
+            The output topology of the rule.
+        title : str , optional
+            The title of the rule. The default is "Untitled Rule"
+        description : str, optional
+            The description of the rule. The default is "".
+        operation : dict , optional
+            The desired rule operation. See Rule Operations. If set to None, the replacement rule is applied. The default is None.
+        matrix : list
+            The 4x4 transformation matrix that tranforms the output topology to the input topology. If set to None, no transformation is applied. The default is None.
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        None
+            This method does not return a value.
+        """
+        from topologicpy.Topology import Topology
+
+        def is_4x4_matrix(matrix):
+            return (
+                isinstance(matrix, list) and
+                len(matrix) == 4 and
+                all(isinstance(row, list) and len(row) == 4 for row in matrix)
+            )
+
+        if not Topology.IsInstance(input, "Topology"):
+            if not silent:
+                print("ShapeGrammar.AddRule - Error: The input input parameter is not a valid topology. Returning None.")
+            return None
+        if not output == None:
+            if not Topology.IsInstance(output, "Topology"):
+                if not silent:
+                    print("ShapeGrammar.AddRule - Error: The input output parameter is not a valid topology. Returning None.")
+                return None
+        if not operation == None:
+            if not operation in self.operations:
+                if not silent:
+                    print("ShapeGrammar.AddRule - Error: The input operation parameter is not a valid operation. Returning None.")
+                return None
+        if not matrix == None:
+            if not is_4x4_matrix(matrix):
+                if not silent:
+                    print("ShapeGrammar.AddRule - Error: The input matrix parameter is not a valid matrix. Returning None.")
+                return None
+        
+        self.rules.append({"input":input,
+                           "output": output,
+                           "title": title,
+                           "description": description,
+                           "operation": operation,
+                           "matrix": matrix
+                           })
+
+    def ApplicableRules(self, topology, keys: list = None, silent: bool = False):
+        """
+        Returns rules applicable to the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology
+        keys : list , optional
+            The list of dictionary keys to semantically match the rules. The default is None which means dictionaries are not considered.
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        list
+            The list of applicable rules.
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("ShapeGrammar.ApplicableRules - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        
+        ap_rules = []
+        ap_trans = []
+        d = Topology.Dictionary(topology)
+        for i, rule in enumerate(self.rules):
+            dict_status = True
+            input = rule["input"]
+            # If there is a list of keys specified, check that the values match
+            if isinstance(keys, list):
+                d_input = Topology.Dictionary(input)
+                for j, key in enumerate(keys):
+                    if not Dictionary.ValueAtKey(d, key, None) == Dictionary.ValueAtKey(d_input, key, None):
+                        dict_status = False
+                        break
+            #If it passed the dictionary key test, then check topology similarity
+            if dict_status:
+                topology_status, mat = Topology.IsSimilar(rule["input"], topology)
+                if topology_status:
+                    ap_rules.append(rule)
+                    ap_trans.append(mat)
+        return ap_rules, ap_trans
+
+    def ApplyRule(self, topology, rule: dict = None, matrix: list = None, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns rules applicable to the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology
+        rule : dict , optional
+            The desired rule to apply. The default is None.
+        matrix : list
+            The 4x4 transformation matrix that tranforms the output topology to the input topology. If set to None, no transformation is applied. The default is None.
+        mantissa : int, optional
+            Decimal precision. Default is 6.
+        tolerance : float, optional
+            The desired Tolerance. Not used here but included for API compatibility. Default is 0.0001.
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        topologic_core.Topology
+            The transformed topology
+        """
+
+        from topologicpy.Topology import Topology
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Face import Face
+        from topologicpy.Vertex import Vertex
+
+        def is_4x4_matrix(matrix):
+            return (
+                isinstance(matrix, list) and
+                len(matrix) == 4 and
+                all(isinstance(row, list) and len(row) == 4 for row in matrix)
+            )
+        
+        def bb(topology):
+            vertices = Topology.Vertices(topology)
+            x = []
+            y = []
+            z = []
+            for aVertex in vertices:
+                x.append(Vertex.X(aVertex, mantissa=mantissa))
+                y.append(Vertex.Y(aVertex, mantissa=mantissa))
+                z.append(Vertex.Z(aVertex, mantissa=mantissa))
+            x_min = min(x)
+            y_min = min(y)
+            z_min = min(z)
+            maxX = max(x)
+            maxY = max(y)
+            maxZ = max(z)
+            return [x_min, y_min, z_min, maxX, maxY, maxZ]
+        
+        def slice(topology, uSides, vSides, wSides):
+            x_min, y_min, z_min, maxX, maxY, maxZ = bb(topology)
+            centroid = Vertex.ByCoordinates(x_min+(maxX-x_min)*0.5, y_min+(maxY-y_min)*0.5, z_min+(maxZ-z_min)*0.5)
+            wOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), Vertex.Y(centroid, mantissa=mantissa), z_min)
+            wFace = Face.Rectangle(origin=wOrigin, width=(maxX-x_min)*1.1, length=(maxY-y_min)*1.1)
+            wFaces = []
+            wOffset = (maxZ-z_min)/wSides
+            for i in range(wSides-1):
+                wFaces.append(Topology.Translate(wFace, 0,0,wOffset*(i+1)))
+            uOrigin = Vertex.ByCoordinates(x_min, Vertex.Y(centroid, mantissa=mantissa), Vertex.Z(centroid, mantissa=mantissa))
+            uFace = Face.Rectangle(origin=uOrigin, width=(maxZ-z_min)*1.1, length=(maxY-y_min)*1.1, direction=[1,0,0])
+            uFaces = []
+            uOffset = (maxX-x_min)/uSides
+            for i in range(uSides-1):
+                uFaces.append(Topology.Translate(uFace, uOffset*(i+1),0,0))
+            vOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), y_min, Vertex.Z(centroid, mantissa=mantissa))
+            vFace = Face.Rectangle(origin=vOrigin, width=(maxX-x_min)*1.1, length=(maxZ-z_min)*1.1, direction=[0,1,0])
+            vFaces = []
+            vOffset = (maxY-y_min)/vSides
+            for i in range(vSides-1):
+                vFaces.append(Topology.Translate(vFace, 0,vOffset*(i+1),0))
+            all_faces = uFaces+vFaces+wFaces
+            if len(all_faces) > 0:
+                f_clus = Cluster.ByTopologies(uFaces+vFaces+wFaces)
+                return Topology.Slice(topology, f_clus, tolerance=tolerance)
+            else:
+                return topology
+
+        if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("ShapeGrammar.ApplyRule - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        if not matrix == None:
+            if not is_4x4_matrix(matrix):
+                if not silent:
+                    print("ShapeGrammar.ApplyRule - Error: The input matrix parameter is not a valid matrix. Returning None.")
+                return None
+        
+        if not rule == None:
+            input = rule["input"]
+            output = rule["output"]
+            r_matrix = rule["matrix"]
+            operation = rule["operation"]
+            if not operation == None:
+                op_title = operation["title"]
+            else:
+                op_title = "None"
+
+            result_output = topology
+            temp_output = None
+            if not output == None:
+                temp_output = output
+            # Transform the output topology to the input topology to prepare it for final transformation
+            if not r_matrix == None and not output == None:
+                    temp_output = Topology.Transform(output, r_matrix)
+
+            if "replace" in op_title.lower():
+                result_output = temp_output
+            elif "transform" in op_title.lower():
+                result_output = Topology.Transform(topology, r_matrix)
+            elif "union" in op_title.lower():
+                result_output = Topology.Union(input, temp_output)
+            elif "difference" in op_title.lower():
+                result_output = Topology.Difference(input, temp_output)
+            elif "symmetric difference" in op_title.lower():
+                result_output = Topology.SymmetricDifference(input, temp_output)
+            elif "intersect" in op_title.lower():
+                result_output = Topology.Intersect(input, temp_output)
+            elif "merge" in op_title.lower():
+                result_output = Topology.Merge(input, temp_output)
+            elif "slice" in op_title.lower():
+                result_output = Topology.Slice(input, temp_output)
+            elif "impose" in op_title.lower():
+                result_output = Topology.Impose(input, temp_output)
+            elif "imprint" in op_title.lower():
+                result_output = Topology.Imprint(input, temp_output)
+            elif "divide" in op_title.lower():
+                uSides = operation["uSides"]
+                vSides = operation["vSides"]
+                wSides = operation["wSides"]
+                if not uSides == None and not vSides == None and not wSides == None:
+                    result_output = slice(input, uSides, vSides, wSides)
+        
+        # Finally, transform the result to the input topology
+        if not matrix == None:
+            result_output = Topology.Transform(result_output, matrix)
+        
+        return result_output
+
+    def FigureByInputOutput(self, input, output, silent: bool = False):
+        """
+        Returns the Plotly figure of the input and output topologies as a rule.
+
+        Parameters
+        ----------
+        input : topologic_core.Topology
+            The input topology
+        output : topologic_core.Topology
+            The output topology
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        This function does not return a value
+        """
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Plotly import Plotly
+
+        if not Topology.IsInstance(input, "Topology"):
+            if not silent:
+                print("ShapeGrammar.DrawInputOutput - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        if not Topology.IsInstance(output, "Topology"):
+            if not silent:
+                print("ShapeGrammar.DrawInputOutput - Error: The output topology parameter is not a valid topology. Returning None.")
+            return None
+
+        input_bb = Topology.BoundingBox(input)
+        input_centroid = Topology.Centroid(input_bb)
+        input_d = Topology.Dictionary(input_bb)
+        xmin = Dictionary.ValueAtKey(input_d, "xmin")
+        ymin = Dictionary.ValueAtKey(input_d, "ymin")
+        zmin = Dictionary.ValueAtKey(input_d, "zmin")
+        xmax = Dictionary.ValueAtKey(input_d, "xmax")
+        ymax = Dictionary.ValueAtKey(input_d, "ymax")
+        zmax = Dictionary.ValueAtKey(input_d, "zmax")
+        input_width = xmax-xmin
+        input_length = ymax-ymin
+        input_height = zmax-zmin
+        input_max = max(input_width, input_length, input_height)
+        sf = 1/input_max
+        temp_input = Topology.Translate(input, -Vertex.X(input_centroid), -Vertex.Y(input_centroid), -Vertex.Z(input_centroid))
+        temp_input = Topology.Scale(temp_input, x=sf, y=sf, z=sf)
+        temp_input = Topology.Translate(temp_input, 0.5, 0, 0)
+
+        output_bb = Topology.BoundingBox(output)
+        output_centroid = Topology.Centroid(output_bb)
+        output_d = Topology.Dictionary(output_bb)
+        xmin = Dictionary.ValueAtKey(output_d, "xmin")
+        ymin = Dictionary.ValueAtKey(output_d, "ymin")
+        zmin = Dictionary.ValueAtKey(output_d, "zmin")
+        xmax = Dictionary.ValueAtKey(output_d, "xmax")
+        ymax = Dictionary.ValueAtKey(output_d, "ymax")
+        zmax = Dictionary.ValueAtKey(output_d, "zmax")
+        output_width = xmax-xmin
+        output_length = ymax-ymin
+        output_height = zmax-zmin
+        output_max = max(output_width, output_length, output_height)
+        sf = 1/output_max
+        temp_output = Topology.Translate(output, -Vertex.X(output_centroid), -Vertex.Y(output_centroid), -Vertex.Z(output_centroid))
+        temp_output = Topology.Scale(temp_output, x=sf, y=sf, z=sf)
+        temp_output = Topology.Translate(temp_output, 2.5, 0, 0)
+
+        cyl = Cell.Cylinder(radius=0.04, height=0.4, placement="bottom")
+        cyl=Topology.Rotate(cyl, axis=[0,1,0], angle=90)
+        cyl = Topology.Translate(cyl, 1.25, 0, 0)
+
+        cone = Cell.Cone(baseRadius=0.1, topRadius=0, height=0.15, placement="bottom")
+        cone=Topology.Rotate(cone, axis=[0,1,0], angle=90)
+        cone = Topology.Translate(cone, 1.65, 0, 0)
+        cluster = Cluster.ByTopologies([temp_input, temp_output, cyl, cone])
+        cluster = Topology.Place(cluster, originA=Topology.Centroid(cluster), originB=Vertex.Origin())
+        data = Plotly.DataByTopology(cluster)
+        fig = Plotly.FigureByData(data)
+        return fig
+    
+    def FigureByRule(self, rule, silent: bool = False):
+        """
+        Returns the Plotly figure of the input rule.
+
+        Parameters
+        ----------
+        rule : dict
+            The input rule
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        This function does not return a value
+        """
+        from topologicpy.Topology import Topology
+        if not isinstance(rule, dict):
+            if not silent:
+                print("ShapeGrammar.DrawRule - Error: The input rule parameter is not a valid rule. Returning None.")
+            return None
+        input = rule["input"]
+        output = self.ApplyRule(input, rule)
+        return self.FigureByInputOutput(input, output)

topologicpy/Topology.py

@@ -9949,7 +9949,6 @@ class Topology():
             
             # Extract translation (last column of the matrix)
             translation = [m[3] for m in matrix[:3]]
-            print("translation", translation)
             x_translate, y_translate, z_translate = translation
             
             # Extract rotation (top-left 3x3 part of the matrix)
@@ -9957,7 +9956,6 @@ class Topology():
             
             # Extract scaling (diagonal of the matrix)
             scaling_factors = [matrix[m][m] for m in [0,1,2]]  # scaling is stored in the diagonal of the rotation matrix
-            print(scaling_factors)
             x_scale, y_scale, z_scale = scaling_factors
             
             # Step 1: Apply Scaling

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.28'
+__version__ = '0.8.29'

{topologicpy-0.8.28.dist-info → topologicpy-0.8.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.28
+Version: 0.8.29
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.8.28.dist-info → topologicpy-0.8.29.dist-info}/RECORD

@@ -18,20 +18,21 @@ topologicpy/Helper.py,sha256=JdvC30WMrla46mTj5TdwCV_bRv-6y8vK5Bkx0prluy4,29100
 topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
 topologicpy/Matrix.py,sha256=BHGDRkBn1pf5DkRoY8feAhDGHTF3bjFM4jluiEb_A0w,22779
 topologicpy/Neo4j.py,sha256=vNMaqTWerwr-3luLjYEXNhf8T97aFee6x5sIKBHY73s,22392
-topologicpy/Plotly.py,sha256=s0fC_eNsgJN8zkkY_EomZi6jnKCIdtrVYsgnS51MWkU,119271
+topologicpy/Plotly.py,sha256=FIFahDnWhvbQ--VJjy3lQGl5735w8hDzZNrVkCkpZFE,119455
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
+topologicpy/ShapeGrammar.py,sha256=JwE__VcKum5X3r33WwToEWtpJdFuhzZYyNhU2ob15ss,21194
 topologicpy/Shell.py,sha256=h8S2nP1e0JtMxeOdAFZVhOYTJWTW8vlZRM5lxK0gu2o,89577
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
-topologicpy/Topology.py,sha256=3wTW_C3lquA7lc5sLMxxoBj53Ygc--6hLl5LGvnv3NI,478412
+topologicpy/Topology.py,sha256=UN1BnwS4G0DN5oLb6rLFUHEPxTj7PR6KzH-AnJQ0NHQ,478331
 topologicpy/Vector.py,sha256=mx7fgABdioikPWM9HzXKzmqfx3u_XBcU_jlLD4qK2x8,42407
 topologicpy/Vertex.py,sha256=UMDhERrLH6b4WOu4pl0UgYzcfp9-NvmASLtKXwetO_4,84687
 topologicpy/Wire.py,sha256=eRs4PM7h4yU5v6umPh0oBJR4cN8BwsqlVroaFdnvK4w,228499
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=YRGDu9QPaNPQlZcx7MJLLUrv2aIEpppZ8LAIiyZvW00,23
-topologicpy-0.8.28.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.28.dist-info/METADATA,sha256=W4Rje6xhqAy7LxQUXrv0Q5yY97BFPOKC0iWuZDqjjJM,10535
-topologicpy-0.8.28.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-topologicpy-0.8.28.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.28.dist-info/RECORD,,
+topologicpy/version.py,sha256=c72Y0CCfU5Qgxq7demxoD7bRlDWidTBPnLUByhWGtHU,23
+topologicpy-0.8.29.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.29.dist-info/METADATA,sha256=ahE6eaRHVYotJtOLSidVqD3l81GOrkKbBhlSnJauDsk,10535
+topologicpy-0.8.29.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+topologicpy-0.8.29.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.29.dist-info/RECORD,,