topologicpy 0.8.47__py3-none-any.whl → 0.8.49__py3-none-any.whl

topologicpy/CellComplex.py

@@ -193,6 +193,153 @@ class CellComplex():
         cells = Topology.Cells(cluster)
         return CellComplex.ByCells(cells, tolerance=tolerance)
 
+    @staticmethod
+    def ByDisjointedFaces(faces: list,
+                        minOffset: float = 0,
+                        maxOffset: float = 1.0,
+                        minCells: float = 2,
+                        maxCells: float = 10,
+                        maxAttempts: int = 100,
+                        patience: int = 5,
+                        transferDictionaries: bool = False,
+                        exclusive: bool = True,
+                        tolerance: float = 0.0001,
+                        silent: bool = False):
+        """
+        Creates a CellComplex from a list of disjointed faces. The algorithm expands the faces by an offset to find intersections before building cells.
+
+        Parameters
+        ----------
+        faces : list of topologic_core.Face
+            The linput ist of faces.
+        minOffset : float , optional
+            The minimum initial face offset to try. Default is 0.
+        maxOffset : float , optional
+            The final maximum face offset to try. Default is 1.0.
+        minCells : int , optional
+            The minimum number of cells to create. A CellComplex cannot have less than 2 cells. Default is 2.
+        maxCells : int , optional
+            The maximum number of cells to create. Default is 10.
+        maxAttempts : int , optional
+            The desired maximum number of attempts. Default is 100.
+        patience : int , optional
+            The desired number of attempts to wait with no change in the created number of cells. Default is 5.
+        transferDictionaries : bool , optional
+            If set to True, face dictionaries are inhertied. Default is False.
+        exclusive : bool , optional
+            Applies only if transferDictionaries is set to True. If set to True, only one source face contributes its dictionary to a target face. Default is True.
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+        
+        Returns
+        -------
+        topologic_core.CellComplex
+            The created CellComplex
+
+        """
+
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
+        def trim(cells, n):
+            volumes = [Cell.Volume(c) for c in cells]
+            return_cc = Helper.Sort(cells, volumes)
+            return_cc.reverse()
+            return return_cc[:n]
+
+        faces = [f for f in faces if Topology.IsInstance(f, "Face")]
+        if len(faces) == 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input list of faces does not contain any valid topologic faces. Returning None.")
+            return None
+        if len(faces) < 3:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input list of faces contains less than three topologic faces. Returning None.")
+            return None
+        if minOffset < 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input minOffset parameter is less than 0. Returning None.")
+            return None
+        if minOffset > maxOffset:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input minOffset parameter is greater than the input maxOffset parameter. Returning None.")
+            return None
+        if minCells < 2:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input minCells parameter is less than 2. Returning None.")
+            return None
+        if minCells > maxCells:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input minCells parameter is greater than the input maxCells parameter. Returning None.")
+            return None
+        if maxAttempts <= 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input maxAttempts parameter is not greater than 0. Returning None.")
+            return None
+        if patience < 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input patience parameter is not greater than or equal to 0. Returning None.")
+            return None
+        if patience > maxAttempts:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input patience parameter is greater than the input maxAttempts parameter. Returning None.")
+            return None
+        cc = None
+        attempts = 0
+        increment = float(maxOffset) / float(maxAttempts)
+        cellComplexes = [] # List of all possible cellComplexes
+        patience_list = []
+        offset = minOffset
+        
+        while attempts < maxAttempts:
+            expanded_faces = [Face.ByOffset(f, offset=-offset, silent=silent) for f in faces]
+            try:
+                cc = CellComplex.ByFaces(expanded_faces, silent=True)
+                if Topology.IsInstance(cc, "cellComplex"):
+                    cells = Topology.Cells(cc)
+                    n_cells = len(cells)
+                    if minCells <= n_cells <= maxCells:
+                        cellComplexes.append(cc)
+                    elif n_cells > maxCells:
+                        cells = trim(cells, maxCells)
+                        try:
+                            new_cc = CellComplex.ByCells(cells)
+                            if Topology.IsInstance(new_cc, "CellComplex"):
+                                cellComplexes.append(new_cc)
+                        except:
+                            pass
+                    patience_list.append(n_cells)
+            except:
+                patience_list.append(0)
+            
+            if len(patience_list) >= patience:
+                if len(set(patience_list)) == 1 and not patience_list[0] == 0:
+                    if not silent:
+                        print("CellComplex.ByDisjointedFaces - Warning: Ran out of patience.")
+                    break
+                else:
+                    patience_list = []
+            attempts += 1
+            offset += increment
+
+        if len(cellComplexes) == 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: Could not create a CellComplex. Consider revising the input parameters. Returning None.")
+            return None
+        n_cells = [len(Topology.Cells(c)) for c in cellComplexes] # Get the number of cells in each cellComplex
+        cellComplexes = Helper.Sort(cellComplexes, n_cells) # Sort the cellComplexes by their number of cells
+        for cc in cellComplexes:
+            cells = Topology.Cells(cc)
+        cc = cellComplexes[-1] # Choose the last cellComplex (the one with the most number of cells)
+        if transferDictionaries == True:
+            cc_faces = Topology.Faces(cc)
+            cc_faces = Topology.Inherit(targets=cc_faces, sources=faces, exclusive=exclusive, tolerance=tolerance, silent=silent)
+        return cc
+
     @staticmethod
     def ByFaces(faces: list, tolerance: float = 0.0001, silent: bool = False):
         """

topologicpy/Graph.py

@@ -8159,24 +8159,28 @@ class Graph:
             Returns:
                 A numpy array representing the adjacency matrix.
             """
+
             
+
             # Get the number of nodes from the edge list.
-            flat_list = Helper.Flatten(edge_list)
-            flat_list = [x for x in flat_list if not x == None]
-            num_nodes = max(flat_list) + 1
+            if len(edge_list) > 0:
+                flat_list = Helper.Flatten(edge_list)
+                flat_list = [x for x in flat_list if not x == None]
+                num_nodes = max(flat_list) + 1
 
-            # Create an adjacency matrix.
-            adjacency_matrix = np.zeros((num_nodes, num_nodes))
+                # Create an adjacency matrix.
+                adjacency_matrix = np.zeros((num_nodes, num_nodes))
 
-            # Fill in the adjacency matrix.
-            for edge in edge_list:
-                adjacency_matrix[edge[0], edge[1]] = 1
-                adjacency_matrix[edge[1], edge[0]] = 1
+                # Fill in the adjacency matrix.
+                for edge in edge_list:
+                    adjacency_matrix[edge[0], edge[1]] = 1
+                    adjacency_matrix[edge[1], edge[0]] = 1
 
-            return adjacency_matrix
+                return adjacency_matrix
+            else:
+                return None
 
         def tree_from_edge_list(edge_list, root_index=0):
-            
             adj_matrix = edge_list_to_adjacency_matrix(edge_list)
             num_nodes = adj_matrix.shape[0]
             root = _Tree(str(root_index))
@@ -12457,7 +12461,238 @@ class Graph:
         net.show_buttons()
         net.show(path, notebook=notebook)
         return None
+
+    @staticmethod
+    def Quotient(topology,
+                topologyType: str = None,
+                key: str = None,
+                groupLabelKey: str = None,
+                groupCountKey: str = "count",
+                weighted: bool = False,
+                edgeWeightKey: str = "weight",
+                idKey: str = None,
+                silent: bool = False):
+        """
+        Construct the quotient graph induced by grouping sub-topologies (Cells/Faces/Edges/Vertices)
+        by a dictionary value. Two groups are connected if any member of one is adjacent to any member
+        of the other via Topology.AdjacentTopologies. If weighted=True, edge weights count the number
+        of distinct member-level adjacencies across groups. See https://en.wikipedia.org/wiki/Quotient_graph
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        topologyType : str
+            The type of subtopology for which to search. This can be one of "vertex", "edge", "face", "cell". It is case-insensitive.
+        key : str , optional
+            Dictionary key used to form groups. If None, all items fall into one group.
+        groupLabelKey : str , optional
+            Vertex-dictionary key storing the group label. Default is "group_label".
+        groupCountKey : str , optional
+            Vertex-dictionary key storing the group size. Default is "count".
+        weighted : bool , optional
+            If True, store counts of cross-group adjacencies on edges under edgeWeightKey. Default is False.
+        edgeWeightKey : str , optional
+            Edge-dictionary key storing the weight when weighted=True. Default "weight".
+        idKey : str , optional
+            Optional dictionary key that uniquely identifies each sub-topology. If provided and present
+            on both members, lookup is O(1) without calling Topology.IsSame. If missing, falls back to Topology.IsSame. Default is None.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+
+        Returns
+        -------
+        topologic_core.Graph
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Graph import Graph
+
+        if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("Graph.Quotient - Error: The input topology parameter is not a valid Topology. Returning None.")
+            return None
+        if topologyType.lower() not in {"vertex", "edge", "face", "cell"}:
+            if not silent:
+                print("Graph.Quotient - Error: topologyType must be one of 'Cell','Face','Edge','Vertex'. Returning None.")
+            return None
+        if not isinstance(key, str):
+            if not silent:
+                print("Graph.Quotient - Error: The input key parameter is not a valid string. Returning None.")
+            return None
+        if groupLabelKey == None:
+            groupLabelKey = key
+        if not isinstance(groupLabelKey, str):
+            if not silent:
+                print("Graph.Quotient - Error: The input groupLabelKey parameter is not a valid string. Returning None.")
+            return None
+        if not isinstance(groupCountKey, str):
+            if not silent:
+                print("Graph.Quotient - Error: The input groupCountKey parameter is not a valid string. Returning None.")
+            return None
+        if not isinstance(weighted, bool):
+            if not silent:
+                print("Graph.Quotient - Error: The input weighted parameter is not a valid boolean. Returning None.")
+            return None
+        if not isinstance(edgeWeightKey, str):
+            if not silent:
+                print("Graph.Quotient - Error: The input edgeWeightKey parameter is not a valid string. Returning None.")
+            return None
         
+        # 1) Collect sub-topologies
+        getters = {
+            "vertex": Topology.Vertices,
+            "edge": Topology.Edges,
+            "face": Topology.Faces,
+            "cell": Topology.Cells,
+        }
+        subs = getters[topologyType.lower()](topology)
+        if not subs:
+            if not silent:
+                print("Graph.Quotient - Error: No subtopologies found. Returning None.")
+            return None
+
+        # 2) Optional O(1) index via a unique idKey in dictionaries
+        def _get_dict(st):
+            try:
+                return Topology.Dictionary(st)
+            except Exception:
+                return None
+
+        id_index = {}
+        if idKey is not None:
+            for i, st in enumerate(subs):
+                d = _get_dict(st)
+                if d is None:
+                    continue
+                try:
+                    uid = Dictionary.ValueAtKey(d, idKey)
+                except Exception:
+                    uid = None
+                if uid is not None and uid not in id_index:
+                    id_index[uid] = i  # first seen wins
+
+        # 3) Labels for grouping
+        def _label(st):
+            if key is None:
+                return None
+            d = _get_dict(st)
+            if d is None:
+                return None
+            try:
+                return Dictionary.ValueAtKey(d, key)
+            except Exception:
+                return None
+
+        labels = [_label(st) for st in subs]
+
+        # 4) Partition indices by label
+        groups = {}
+        for i, lbl in enumerate(labels):
+            groups.setdefault(lbl, []).append(i)
+
+        group_labels = list(groups.keys())
+        label_to_group_idx = {lbl: gi for gi, lbl in enumerate(group_labels)}
+        item_to_group_idx = {i: label_to_group_idx[lbl] for lbl, idxs in groups.items() for i in idxs}
+
+        # Helper to resolve neighbor index j for a given neighbor topology nb
+        def _neighbor_index(nb):
+            # Try idKey shortcut
+            if idKey is not None:
+                d = _get_dict(nb)
+                if d is not None:
+                    try:
+                        uid = Dictionary.ValueAtKey(d, idKey)
+                    except Exception:
+                        uid = None
+                    if uid is not None:
+                        j = id_index.get(uid)
+                        if j is not None:
+                            return j
+            # Fallback: linear scan using Topology.IsSame
+            for j, st in enumerate(subs):
+                try:
+                    if Topology.IsSame(nb, st):
+                        return j
+                except Exception:
+                    continue
+            return None
+
+        # 5) Group adjacency with optional weights
+        # Use a set to ensure each unordered member-pair is counted once
+        seen_member_pairs = set()
+        group_edges = {}  # (a,b) -> weight
+
+        for i, st in enumerate(subs):
+            try:
+                neighs = Topology.AdjacentTopologies(st, topology, topologyType)
+            except Exception:
+                neighs = []
+            gi = item_to_group_idx[i]
+            for nb in neighs:
+                j = _neighbor_index(nb)
+                if j is None or j == i:
+                    continue
+                aij = (i, j) if i < j else (j, i)
+                if aij in seen_member_pairs:
+                    continue
+                seen_member_pairs.add(aij)
+
+                gj = item_to_group_idx[j]
+                if gi == gj:
+                    continue
+                a, b = (gi, gj) if gi < gj else (gj, gi)
+                group_edges[(a, b)] = group_edges.get((a, b), 0) + 1
+
+        # 6) One vertex per group at mean of member centroids
+        group_vertices = []
+        for lbl in group_labels:
+            idxs = groups[lbl]
+            pts = []
+            for i in idxs:
+                try:
+                    c = Topology.Centroid(subs[i])
+                    pts.append(c)
+                except Exception:
+                    pass
+            if pts:
+                try:
+                    xs = [Vertex.X(p) for p in pts]
+                    ys = [Vertex.Y(p) for p in pts]
+                    zs = [Vertex.Z(p) for p in pts]
+                    v = Vertex.ByCoordinates(sum(xs)/len(xs), sum(ys)/len(ys), sum(zs)/len(zs))
+                except Exception:
+                    v = Vertex.ByCoordinates(0, 0, 0)
+            else:
+                v = Vertex.ByCoordinates(0, 0, 0)
+
+            try:
+                d = Dictionary.ByKeysValues([groupLabelKey, groupCountKey], [lbl, len(idxs)])
+                v = Topology.SetDictionary(v, d)
+            except Exception:
+                pass
+
+            group_vertices.append(v)
+
+        # 7) Edges, with optional weights
+        edges = []
+        for (a, b), w in group_edges.items():
+            try:
+                e = Edge.ByStartVertexEndVertex(group_vertices[a], group_vertices[b])
+                if weighted:
+                    try:
+                        d = Dictionary.ByKeysValues([edgeWeightKey], [w])
+                        e = Topology.SetDictionary(e, d)
+                    except Exception:
+                        pass
+                edges.append(e)
+            except Exception:
+                continue
+
+        return Graph.ByVerticesEdges(group_vertices, edges)
+
     @staticmethod
     def RemoveEdge(graph, edge, tolerance=0.0001):
         """

topologicpy/Plotly.py

@@ -558,7 +558,7 @@ class Plotly:
                             if not temp_color == None:
                                 colors[m] = Color.AnyToHex(temp_color)
                         if not labelKey == None:
-                            labels[m] = Dictionary.ValueAtKey(d, key=labelKey, defaultValue=" ")
+                            labels[m] = str(Dictionary.ValueAtKey(d, key=labelKey, defaultValue=" "))
                         if not sizeKey == None:
                             sizes[m] = float(Dictionary.ValueAtKey(d, key=sizeKey, defaultValue=sizes[m]))
                             if sizes[m] == None:

topologicpy/Shell.py

@@ -1097,6 +1097,143 @@ class Shell():
                 return True
         return False
 
+    @staticmethod
+    def MobiusStrip(origin = None,
+                    radius: float=0.5,
+                    height: float=1,
+                    uSides=32,
+                    vSides=1,
+                    twists: int = 1,
+                    direction: list = [0, 0, 1],
+                    placement: str = "center",
+                    tolerance: float = 0.0001,
+                    silent: bool = False):
+
+
+        """
+        Creates a Möbius strip. See: https://en.wikipedia.org/wiki/M%C3%B6bius_strip
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the Möbius strip. Default is None which results in the Möbius strip being placed at (0, 0, 0).
+        radius : float , optional
+            The radius of the Möbius strip. Default is 0.5.
+        height : float , optional
+            The height of the Möbius strip. Default is 1.
+        uSides : int , optional
+            The number of circle segments of the Möbius strip. Default is 16.
+        vSides : int , optional
+            The number of vertical segments of the Möbius strip. Default is 1.
+        twists : int , optional
+            The number of twists (multiples of a 180 degree rotation) of the Möbius strip. Default is 1.
+        direction : list , optional
+            The vector representing the up direction of the Möbius strip. Default is [0, 0, 1].
+        placement : str , optional
+            Not implemented. The description of the placement of the origin of the Möbius strip. This can be "bottom", "center", or "lowerleft". It is case insensitive. Default is "bottom".
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+
+        Returns
+        -------
+        topologic_core.Cell
+            The created cell.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+        
+        if not isinstance(radius, int) and not isinstance(radius, float):
+            if not silent:
+                print("Shell.MobiusStrip - Error: The radius input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(height, int) and not isinstance(height, float):
+            if not silent:
+                print("Shell.MobiusStrip - Error: The height input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(uSides, int):
+            if not silent:
+                print("Shell.MobiusStrip - Error: The uSides input parameter is not a valid integer. Returning None.")
+            return None
+        if not isinstance(vSides, int):
+            if not silent:
+                print("Shell.MobiusStrip - Error: The vSides input parameter is not a valid integer. Returning None.")
+            return None
+        if not isinstance(twists, int):
+            if not silent:
+                print("Shell.MobiusStrip - Error: The twists input parameter is not a valid integer. Returning None.")
+            return None
+        if radius <= tolerance:
+            if not silent:
+                print("Shell.MobiusStrip - Error: The radius input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if height <= tolerance:
+            if not silent:
+                print("Shell.MobiusStrip - Error: The height input parameter must be a positive number  greater than the tolerance input parameter. Returning None.")
+            return None
+        if uSides <= 3:
+            if not silent:
+                print("Shell.MobiusStrip - Error: The uSides input parameter must be a positive integer greater than 2. Returning None.")
+            return None
+        if vSides < 1:
+            if not silent:
+                print("Shell.MobiusStrip - Error: The vSides input parameter must be a positive integer greater than 0. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "Vertex"):
+            if not silent:
+                print("Shell.MobiusStrip - Error: The origin input parameter is not a valid topologic Vertex. Returning None.")
+            return None
+        if not isinstance(direction, list):
+            if not silent:
+                print("Shell.MobiusStrip - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Shell.MobiusStrip - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        
+        total_angle = 180*twists
+        cir = Wire.Circle(origin=origin, radius=radius, sides=uSides)
+        c_verts = Topology.Vertices(cir)
+        wires = []
+        for i, v in enumerate(c_verts):
+            vb = Vertex.ByCoordinates(Vertex.X(v), Vertex.Y(v), -height*0.5)
+            vt = Vertex.ByCoordinates(Vertex.X(v), Vertex.Y(v), height*0.5)
+            e = Edge.ByVertices([vb, vt])
+            d = Edge.Normal(Edge.ByVertices(Vertex.Origin(), v))
+            angle = float(total_angle)/float(uSides)*float(i)
+            e = Topology.Rotate(e, origin=v, axis=d, angle=angle)
+            verts = []
+            for j in range(vSides+1):
+                vp = Edge.VertexByParameter(e, float(j)/float(vSides))
+                verts.append(vp)
+            w = Wire.ByVertices(verts, close=False, silent=True)
+            wires.append(w)
+            # Create the last wire
+            if i == 0:
+                e = Edge.ByVertices([vb, vt])
+                e = Topology.Rotate(e, origin=v, axis=d, angle=total_angle)
+                verts = []
+                for j in range(vSides+1):
+                    vp = Edge.VertexByParameter(e, float(j)/float(vSides))
+                    verts.append(vp)
+                last_wire = Wire.ByVertices(verts, close=False, silent=True)
+
+        wires.append(last_wire)
+        m = Shell.ByWires(wires, silent=silent, tolerance=tolerance)
+        if not Topology.IsInstance(m, "Shell"):
+            if not silent:
+                print("Shell.MobiusStrip - Error: Could not create a mobius strip. Returning None.")
+            return None
+        m = Topology.Orient(m, origin=origin, dirA=[0, 0, 1], dirB=direction)
+        return m
+
     @staticmethod
     def Paraboloid(origin= None, focalLength=0.125, width: float = 1, length: float = 1, uSides: int = 16, vSides: int = 16,
                     direction: list = [0, 0, 1], placement: str ="center", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):

topologicpy/Wire.py

@@ -870,6 +870,7 @@ class Wire():
                 edges.append(e)
             else:
                 if not silent:
+                    print("Wire.ByVertices - Warning: Degenerate edge. Skipping.")
                     curframe = inspect.currentframe()
                     calframe = inspect.getouterframes(curframe, 2)
                     print('caller name:', calframe[1][3])
@@ -885,6 +886,7 @@ class Wire():
                     curframe = inspect.currentframe()
                     calframe = inspect.getouterframes(curframe, 2)
                     print('caller name:', calframe[1][3])
+        
         if len(edges) < 1:
             if not silent:
                 print("Wire.ByVertices - Error: The number of edges is less than 1. Returning None.")
@@ -893,9 +895,21 @@ class Wire():
                 print('caller name:', calframe[1][3])
             return None
         elif len(edges) == 1:
+            if not silent:
+                print("Wire.ByVertices - Warning: The wire is made of only one edge.")
             wire = Wire.ByEdges(edges, orient=False, silent=silent)
         else:
             wire = Topology.SelfMerge(Cluster.ByTopologies(edges), tolerance=tolerance)
+            if Topology.IsInstance(wire, "Edge"):
+                wire = Wire.ByEdges([wire], orient=False, silent=silent)
+        # Final Check
+        if not Topology.IsInstance(wire, "Wire"):
+            if not silent:
+                print("Wire.ByVertices - Error: Could not create a wire. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
+            return None
         return wire
 
     @staticmethod
@@ -2989,7 +3003,7 @@ class Wire():
         for i in range(1, sides):
             vertices.append(Edge.VertexByParameter(edge, i*unitDistance))
         vertices.append(Edge.EndVertex(edge))
-        return Wire.ByVertices(vertices, closed=False, tolerance=tolerance)
+        return Wire.ByVertices(vertices, close=False, tolerance=tolerance)
 
     @staticmethod
     def LShape(origin=None,

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.47'
+__version__ = '0.8.49'

{topologicpy-0.8.47.dist-info → topologicpy-0.8.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.47
+Version: 0.8.49
 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.47.dist-info → topologicpy-0.8.49.dist-info}/RECORD

@@ -3,7 +3,7 @@ topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
 topologicpy/BVH.py,sha256=JA4bb-9hgMfVZ_syzmSmTL3ueCq-0vMUGMPZxNcawAY,13023
 topologicpy/CSG.py,sha256=09la1-xzS9vr-WnV7tpJ0I-mkZ-XY0MRSd5iB50Nfgw,15556
 topologicpy/Cell.py,sha256=gldsBl3LnrvTRS4SnK9aAM8k_kS1aNovTjUNHxQRNKk,175319
-topologicpy/CellComplex.py,sha256=TOnMnhBX4eXypKjDdkyhNesEDc9yRetPSDUNIi2eqU0,60948
+topologicpy/CellComplex.py,sha256=Kbz63rGeE08bJfMXFvB-AptoKHiaCK5OtiV1wz8Y-Fk,68081
 topologicpy/Cluster.py,sha256=G49AuhJHQ1s819cB5MtVdmAGgkag19IC3dRP1ub1Wh4,58608
 topologicpy/Color.py,sha256=hzSmgBWhiuYc55RSipkQNIgGtgyhC5BqY8AakNYEK-U,24486
 topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
@@ -12,27 +12,27 @@ topologicpy/Dictionary.py,sha256=Z4YQ88tONWd-0X0dENQ8IZqIOa9mbBqhJkTBsHmft2g,446
 topologicpy/Edge.py,sha256=DifItuyabFDUFC7CVMlt2DeMFMNaGOqCg43iU9CPP0A,74029
 topologicpy/EnergyModel.py,sha256=IiBJNx7F9-8TPMaQn1iQON1ZtTv2nT5kbZHxM_gBCTQ,53773
 topologicpy/Face.py,sha256=aX9EcR3JGbLITElhd25J0Z8m9U8KkmbYivGg3oZN-Uw,202296
-topologicpy/Graph.py,sha256=9uzTa0uTJrwrUHW4ObG4iERFwOQQjWKuAMK6yV-h74Q,675782
+topologicpy/Graph.py,sha256=vK5mj90cc_cwC5suodSuYDrXCX3njp_SV4SiTyQzvuE,685271
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
 topologicpy/Helper.py,sha256=aGmndgmEztjVNU-wW9OoHDel7wzapprM0TjA7f2AoS8,31188
 topologicpy/Honeybee.py,sha256=C7Am0kCK3a5rt7Jpu2EIgqeR114ZJWtsx4_DBcr5hQA,21716
 topologicpy/Matrix.py,sha256=bOofT34G3YHu9aMIWx60YHAJga4R0GbDjsZBUD4Hu_k,22706
 topologicpy/Neo4j.py,sha256=J8jU_mr5-mWC0Lg_D2dMjMlx1rY_eh8ks_aubUuTdWw,22319
-topologicpy/Plotly.py,sha256=X5iNs8nRSVgHns6rbXHWgEzLPCxvwPgOkNWS1TwdSLM,122919
+topologicpy/Plotly.py,sha256=RXGeEBwVs8unJaT9vv_FBmAFfKd-1Z5x3V8oeKE43Bs,122924
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=wOsoBFxMgwZYWjj86OMkz_PJuQ02locV_djhSDD6dVc,109644
 topologicpy/ShapeGrammar.py,sha256=KYsKDLXWdflAcYMAIz84AUF-GMkbTmaBDd2-ovbilqU,23336
-topologicpy/Shell.py,sha256=IugTb5tWmEx-QqUX_FOEOKB_iCX5eImHCLbsjlrhaLY,90187
+topologicpy/Shell.py,sha256=e6R7JdzYL1ubO0xXJs5P_UiiNHccN5SjQhQfGPPgHBg,96793
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=8S6dhCKfOhUGVny-jEk87Q08anLYMB1JEBKRGCklvbQ,36670
 topologicpy/Topology.py,sha256=x6NTJ8AFIeFq3emZRT7FA_6NgNd-aavd4i9ws704AAU,470541
 topologicpy/Vector.py,sha256=pEC8YY3TeHGfGdeNgvdHjgMDwxGabp5aWjwYC1HSvMk,42236
 topologicpy/Vertex.py,sha256=0f6HouARKaCuxhdxsUEYi8T9giJycnWhQ8Cn70YILBA,84885
-topologicpy/Wire.py,sha256=u1q8SA5m5jtcoCTRd9cCizPo7nUOqpdtN9k_ju7QyWc,229757
+topologicpy/Wire.py,sha256=gjgQUGHdBdXUIijgZc_VIW0E39w-smaVhhdl0jF63fQ,230466
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=tn529OlBICnQHhkm_PSnCq9jyPIoFccHmsIrezWqemo,23
-topologicpy-0.8.47.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.47.dist-info/METADATA,sha256=FJ5bz-y-rgUKcMp5vKMPN6_lyG9158OcT-nPhOfrXxs,10535
-topologicpy-0.8.47.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.47.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.47.dist-info/RECORD,,
+topologicpy/version.py,sha256=QtAkT5hlIePCtadXLl4JDdKbyvuiJ4-dBo60LPK6aDE,23
+topologicpy-0.8.49.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.49.dist-info/METADATA,sha256=xrO1G5MVgzF8yZXxfihp6syuWrK7z_aBao9_chfUw6U,10535
+topologicpy-0.8.49.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.49.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.49.dist-info/RECORD,,