topologicpy 0.7.42__py3-none-any.whl → 0.7.43__py3-none-any.whl

topologicpy/Plotly.py

@@ -994,8 +994,8 @@ class Plotly:
              minValue=None,
              maxValue=None,
              title="Confusion Matrix",
-             xTitle = "Actual",
-             yTitle = "Predicted",
+             xTitle = "Actual Categories",
+             yTitle = "Predicted Categories",
              width=950,
              height=500,
              showScale = True,
@@ -1022,9 +1022,9 @@ class Plotly:
         title : str , optional
             The desired title to display. The default is "Confusion Matrix".
         xTitle : str , optional
-            The desired X-axis title to display. The default is "Actual".
+            The desired X-axis title to display. The default is "Actual Categories".
         yTitle : str , optional
-            The desired Y-axis title to display. The default is "Predicted".
+            The desired Y-axis title to display. The default is "Predicted Categories".
         width : int , optional
             The desired width of the figure. The default is 950.
         height : int , optional
@@ -1051,7 +1051,11 @@ class Plotly:
             The desired top margin in pixels. The default is 40.
         marginBottom : int , optional
             The desired bottom margin in pixels. The default is 0.
-
+        
+        Returns
+        -------
+        plotly.Figure
+            The created plotly figure.
         """
         try:
             import numpy as np
@@ -1265,7 +1269,158 @@ class Plotly:
         fig.update_xaxes( tickvals=xCategories)
         fig.update_yaxes( tickvals=yCategories)
         return fig
+    
+    @staticmethod
+    def FigureByCorrelation(actual,
+                        predicted,
+                        title="Correlation between Actual and Predicted Values",
+                        xTitle = "Actual Values",
+                        yTitle = "Predicted Values",
+                        dotColor = "blue",
+                        lineColor = "red",
+                        width=800,
+                        height=600,
+                        theme='default',
+                        backgroundColor='rgba(0,0,0,0)',
+                        marginLeft=0,
+                        marginRight=0,
+                        marginTop=40,
+                        marginBottom=0):
+        """
+        Returns a Plotly Figure showing the correlation between the input actual and predicted values. Actual values are displayed on the X-Axis, Predicted values are displayed on the Y-Axis.
+
+        Parameters
+        ----------
+        actual : list
+            The actual values to display.
+        predicted : list
+            The predicted values to display.
+        title : str , optional
+            The desired title to display. The default is "Correlation between Actual and Predicted Values".
+        xTitle : str , optional
+            The desired X-axis title to display. The default is "Actual Values".
+        yTitle : str , optional
+            The desired Y-axis title to display. The default is "Predicted Values".
+        dotColor : str , optional
+            The desired color of the dots. This can be any plotly color string and may be specified as:
+            - A hex string (e.g. '#ff0000')
+            - An rgb/rgba string (e.g. 'rgb(255,0,0)')
+            - An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
+            - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
+            - A named CSS color.
+            The default is 'blue'.
+        lineColor : str , optional
+            The desired color of the best fit line. This can be any plotly color string and may be specified as:
+            - A hex string (e.g. '#ff0000')
+            - An rgb/rgba string (e.g. 'rgb(255,0,0)')
+            - An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
+            - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
+            - A named CSS color.
+            The default is 'red'.
+        width : int , optional
+            The desired width of the figure. The default is 800.
+        height : int , optional
+            The desired height of the figure. The default is 600.
+        theme : str , optional
+            The plotly color scheme to use. The options are "dark", "light", "default". The default is "default".
+        backgroundColor : str , optional
+            The desired background color. This can be any plotly color string and may be specified as:
+            - A hex string (e.g. '#ff0000')
+            - An rgb/rgba string (e.g. 'rgb(255,0,0)')
+            - An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
+            - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
+            - A named CSS color.
+            The default is 'rgba(0,0,0,0)' (transparent).
+        marginLeft : int , optional
+            The desired left margin in pixels. The default is 0.
+        marginRight : int , optional
+            The desired right margin in pixels. The default is 0.
+        marginTop : int , optional
+            The desired top margin in pixels. The default is 40.
+        marginBottom : int , optional
+            The desired bottom margin in pixels. The default is 0.
+        
+        Returns
+        -------
+        plotly.Figure
+            The created plotly figure.
         
+        """
+
+        import numpy as np
+        import plotly.graph_objs as go
+        from sklearn.linear_model import LinearRegression
+        import plotly.io as pio
+        actual_values = np.array(actual)
+        predicted_values = np.array(predicted)
+
+        # Validate the theme input
+        if theme == 'light':
+            pio.templates.default = "plotly_white"
+            backgroundColor='white'
+        elif theme == 'dark':
+            pio.templates.default = "plotly_dark"
+            backgroundColor='black'
+        else:
+            pio.templates.default = None  # Use default Plotly theme
+        
+        # Calculate the best-fit line using linear regression
+        regressor = LinearRegression()
+        regressor.fit(np.array(actual_values).reshape(-1, 1), np.array(predicted_values))
+        line = regressor.predict(np.array(actual_values).reshape(-1, 1))
+
+        # Determine the range and tick step
+        combined_values = np.concatenate([actual_values, predicted_values])
+        min_value = np.min(combined_values)
+        max_value = np.max(combined_values)
+        margin = 0.1 * (max_value - min_value)
+        tick_range = [min_value - margin, max_value + margin]
+        tick_step = (max_value - min_value) / 10  # Adjust as needed for a different number of ticks
+
+        # Create the scatter plot for actual vs predicted values
+        scatter_trace = go.Scatter(
+            x=actual_values,
+            y=predicted_values,
+            mode='markers',
+            name='Actual vs. Predicted',
+            marker=dict(color=dotColor)
+        )
+
+        # Create the line of best fit
+        line_trace = go.Scatter(
+            x=actual_values,
+            y=line,
+            mode='lines',
+            name='Best Fit Line',
+            line=dict(color=lineColor)
+        )
+
+        # Create the 45-degree line
+        line_45_trace = go.Scatter(
+            x=tick_range,
+            y=tick_range,
+            mode='lines',
+            name='45-Degree Line',
+        line=dict(color='green', dash='dash')
+        )
+
+        # Combine the traces into a single figure
+        layout = {
+            "title": title,
+            "width": width,
+            "height": height,
+            "xaxis": {"title": xTitle, "range":tick_range, "dtick":tick_step},
+            "yaxis": {"title": yTitle, "range":tick_range, "dtick":tick_step},
+            "showlegend": True,
+            "paper_bgcolor": backgroundColor,
+            "plot_bgcolor": backgroundColor,
+            "margin":dict(l=marginLeft, r=marginRight, t=marginTop, b=marginBottom)
+        }
+
+        fig = go.Figure(data=[scatter_trace, line_trace, line_45_trace], layout=layout)
+
+        return fig
+
     @staticmethod
     def FigureByDataFrame(dataFrame,
              labels=[],

topologicpy/PyG.py

@@ -73,10 +73,35 @@ class CustomGraphDataset(Dataset):
             else:
                 edge_attr = None
 
+
+
             if self.graph_level:
-                y = torch.tensor([self.graph_df[self.graph_df['graph_id'] == graph_id]['label'].values[0]], dtype=torch.long)
+                label_value = self.graph_df[self.graph_df['graph_id'] == graph_id]['label'].values[0]
+                
+                # Check if the label is an integer or a float and cast accordingly
+                if isinstance(label_value, int):
+                    y = torch.tensor([label_value], dtype=torch.long)
+                elif isinstance(label_value, float):
+                    y = torch.tensor([label_value], dtype=torch.float)
+                else:
+                    raise ValueError(f"Unexpected label type: {type(label_value)}. Expected int or float.")
+                    
             elif self.node_level:
-                y = torch.tensor(graph_nodes['label'].values, dtype=torch.long)
+                label_values = graph_nodes['label'].values
+                
+                # Check if the labels are integers or floats and cast accordingly
+                if issubclass(label_values.dtype.type, int):
+                    y = torch.tensor(label_values, dtype=torch.long)
+                elif issubclass(label_values.dtype.type, float):
+                    y = torch.tensor(label_values, dtype=torch.float)
+                else:
+                    raise ValueError(f"Unexpected label types: {label_values.dtype}. Expected int or float.")
+
+
+            # if self.graph_level:
+            #     y = torch.tensor([self.graph_df[self.graph_df['graph_id'] == graph_id]['label'].values[0]], dtype=torch.long)
+            # elif self.node_level:
+            #     y = torch.tensor(graph_nodes['label'].values, dtype=torch.long)
 
             data = Data(x=x, edge_index=edge_index, y=y)
             if edge_attr is not None:
@@ -1411,6 +1436,82 @@ class PyG:
         
         return CustomGraphDataset(root=path, node_level=node_level, graph_level=graph_level, node_attr_key=nodeATTRKey, edge_attr_key=edgeATTRKey)
     
+    @staticmethod
+    def DatasetGraphLabels(dataset, graphLabelHeader="label"):
+        """
+        Returns the labels of the graphs in the input dataset
+
+        Parameters
+        ----------
+        dataset : CustomDataset
+            The input dataset
+        graphLabelHeader: str , optional
+            The key string under which the graph labels are stored. The default is "label".
+        
+        Returns
+        -------
+        list
+            The list of graph labels.
+        """
+        import torch
+
+        graph_labels = []
+        for g in dataset:
+            # Get the label of the graph
+            label = g.y
+            graph_labels.append(label.item())
+        return graph_labels
+
+    @staticmethod
+    def DatasetSplit(dataset, split=[0.8,0.1,0.1], shuffle=True, randomState=42):
+        """
+        Splits the dataset into three subsets.
+
+        Parameters
+        ----------
+        dataset : CustomDataset
+            The input dataset
+        split: list , optional
+            The list of ratios. This list must be made out of three numbers adding to 1.
+        shuffle: boolean , optional
+            If set to True, the subsets are created from random indices. Otherwise, they are split sequentially. The default is True.
+        randomState : int , optional
+            The random seed to use for reproducibility. The default is 42.
+                
+        Returns
+        -------
+        list
+            The list of three subset datasets.
+        """
+
+        import torch
+        from torch.utils.data import random_split, Subset
+        train_ratio, val_ratio, test_ratio = split
+        assert abs(train_ratio + val_ratio + test_ratio - 1.0) < 1e-6, "Ratios must add up to 1."
+        
+        # Calculate the number of samples for each split
+        dataset_len = len(dataset)
+        train_len = int(train_ratio * dataset_len)
+        val_len = int(val_ratio * dataset_len)
+        test_len = dataset_len - train_len - val_len  # Ensure it adds up correctly
+
+        ## Generate indices for the split
+        indices = list(range(dataset_len))
+        if shuffle:
+            torch.manual_seed(randomState)  # For reproducibility
+            indices = torch.randperm(dataset_len).tolist()  # Shuffled indices
+
+        # Create splits
+        train_indices = indices[:train_len]
+        val_indices = indices[train_len:train_len + val_len]
+        test_indices = indices[train_len + val_len:train_len + val_len + test_len]
+
+        train_dataset = Subset(dataset, train_indices)
+        val_dataset = Subset(dataset, val_indices)
+        test_dataset = Subset(dataset, test_indices)
+
+        return train_dataset, val_dataset, test_dataset
+
     @staticmethod
     def Optimizer(name="Adam", amsgrad=True, betas=(0.9,0.999), eps=0.000001, lr=0.001, maximize=False, weightDecay=0.0, rho=0.9, lr_decay=0.0):
         """
@@ -1529,11 +1630,11 @@ class PyG:
         ----------
         hparams : HParams
             The input hyperparameters 
-        trainingDataset : DGLDataset
+        trainingDataset : CustomDataset
             The input training dataset.
-        validationDataset : DGLDataset
+        validationDataset : CustomDataset
             The input validation dataset. If not specified, a portion of the trainingDataset will be used for validation according the to the split list as specified in the hyper-parameters.
-        testingDataset : DGLDataset
+        testingDataset : CustomDataset
             The input testing dataset. If not specified, a portion of the trainingDataset will be used for testing according the to the split list as specified in the hyper-parameters.
 
         Returns
@@ -1635,13 +1736,13 @@ class PyG:
         import os
 
         if model == None:
-            print("DGL.ModelSave - Error: The input model parameter is invalid. Returning None.")
+            print("PyG.ModelSave - Error: The input model parameter is invalid. Returning None.")
             return None
         if path == None:
-            print("DGL.ModelSave - Error: The input path parameter is invalid. Returning None.")
+            print("PyG.ModelSave - Error: The input path parameter is invalid. Returning None.")
             return None
         if not overwrite and os.path.exists(path):
-            print("DGL.ModelSave - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
+            print("PyG.ModelSave - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
             return None
         if overwrite and os.path.exists(path):
             os.remove(path)
@@ -1893,7 +1994,7 @@ class PyG:
             from sklearn import metrics
             from sklearn.metrics import accuracy_score
         except:
-            print("DGL - Installing required scikit-learn (sklearn) library.")
+            print("PyG - Installing required scikit-learn (sklearn) library.")
             try:
                 os.system("pip install scikit-learn")
             except:
@@ -1901,19 +2002,19 @@ class PyG:
             try:
                 from sklearn import metrics
                 from sklearn.metrics import accuracy_score
-                print("DGL - scikit-learn (sklearn) library installed correctly.")
+                print("PyG - scikit-learn (sklearn) library installed correctly.")
             except:
-                warnings.warn("DGL - Error: Could not import scikit-learn (sklearn). Please try to install scikit-learn manually. Returning None.")
+                warnings.warn("PyG - Error: Could not import scikit-learn (sklearn). Please try to install scikit-learn manually. Returning None.")
                 return None
             
         if not isinstance(actual, list):
-            print("DGL.ConfusionMatrix - ERROR: The actual input is not a list. Returning None")
+            print("PyG.ConfusionMatrix - ERROR: The actual input is not a list. Returning None")
             return None
         if not isinstance(predicted, list):
-            print("DGL.ConfusionMatrix - ERROR: The predicted input is not a list. Returning None")
+            print("PyG.ConfusionMatrix - ERROR: The predicted input is not a list. Returning None")
             return None
         if len(actual) != len(predicted):
-            print("DGL.ConfusionMatrix - ERROR: The two input lists do not have the same length. Returning None")
+            print("PyG.ConfusionMatrix - ERROR: The two input lists do not have the same length. Returning None")
             return None
         if normalize:
             cm = np.transpose(metrics.confusion_matrix(y_true=actual, y_pred=predicted, normalize="true"))
@@ -2065,3 +2166,58 @@ class PyG:
         size = len(predicted)
 
         return {"mse": mse, "size": size}
+
+    @staticmethod
+    def Performance(actual, predicted, mantissa: int = 6):
+        """
+        Computes regression model performance measures. This is to be used only with regression not with classification.
+
+        Parameters
+        ----------
+        actual : list
+            The input list of actual values.
+        predicted : list
+            The input list of predicted values.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        
+        Returns
+        -------
+        dict
+            The dictionary containing the performance measures. The keys in the dictionary are: 'mae', 'mape', 'mse', 'r', 'r2', 'rmse'.
+        """
+        
+        if not isinstance(actual, list):
+            print("PyG.Performance - ERROR: The actual input is not a list. Returning None")
+            return None
+        if not isinstance(predicted, list):
+            print("PyG.Performance - ERROR: The predicted input is not a list. Returning None")
+            return None
+        if not (len(actual) == len(predicted)):
+            print("PyG.Performance - ERROR: The actual and predicted input lists have different lengths. Returning None")
+            return None
+        
+        predicted = np.array(predicted)
+        actual = np.array(actual)
+
+        mae = np.mean(np.abs(predicted - actual))
+        mape = np.mean(np.abs((actual - predicted) / actual))*100
+        mse = np.mean((predicted - actual)**2)
+        correlation_matrix = np.corrcoef(predicted, actual)
+        r = correlation_matrix[0, 1]
+        r2 = r**2
+        absolute_errors = np.abs(predicted - actual)
+        mean_actual = np.mean(actual)
+        if mean_actual == 0:
+            rae = None
+        else:
+            rae = np.mean(absolute_errors) / mean_actual
+        rmse = np.sqrt(mse)
+        return {'mae': round(mae, mantissa),
+                'mape': round(mape, mantissa),
+                'mse': round(mse, mantissa),
+                'r': round(r, mantissa),
+                'r2': round(r2, mantissa),
+                'rae': round(rae, mantissa),
+                'rmse': round(rmse, mantissa)
+                }

topologicpy/Shell.py

@@ -1056,6 +1056,110 @@ class Shell():
         """
         return shell.IsClosed()
 
+
+    @staticmethod
+    def ParabolicSurface(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):
+        """
+            Creates a parabolic surface.
+
+            Parameters
+            ----------
+            origin : topologic_core.Vertex , optional
+                The origin location of the parabolic surface. The default is None which results in the parabolic surface being placed at (0, 0, 0).
+            focalLength : float , optional
+                The focal length of the parabola. The default is 1.
+            width : float , optional
+                The width of the parabolic surface. The default is 1.
+            length : float , optional
+                The length of the parabolic surface. The default is 1.
+            uSides : int , optional
+                The number of sides along the width. The default is 16.
+            vSides : int , optional
+                The number of sides along the length. The default is 16.
+            direction : list , optional
+                The vector representing the up direction of the parabolic surface. The default is [0, 0, 1].
+            placement : str , optional
+                The description of the placement of the origin of the parabolic surface. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+            mantissa : int , optional
+                The desired length of the mantissa. The default is 6.
+            tolerance : float , optional
+                The desired tolerance. The default is 0.0001.
+            
+            Returns
+            -------
+            topologic_core.Shell
+                The created parabolic surface.
+
+            """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+
+        def create_triangulated_mesh(vertices, uSides, vSides):
+            faces = []
+
+            # Iterate over the grid of vertices to form triangular faces
+            for i in range(uSides - 1):
+                for j in range(vSides - 1):
+                    # Get the indices of the vertices forming the current grid cell
+                    v1 = vertices[i * vSides + j]
+                    v2 = vertices[i * vSides + (j + 1)]
+                    v3 = vertices[(i + 1) * vSides + j]
+                    v4 = vertices[(i + 1) * vSides + (j + 1)]
+
+                    # Create two triangles for each grid cell
+                    # Triangle 1: (v1, v2, v3)
+                    wire1 = Wire.ByVertices([v1, v2, v3])
+                    face1 = Face.ByWire(wire1)
+                    faces.append(face1)
+
+                    # Triangle 2: (v3, v2, v4)
+                    wire2 = Wire.ByVertices([v3, v2, v4])
+                    face2 = Face.ByWire(wire2)
+                    faces.append(face2)
+
+            # Create the mesh (Shell) from the list of faces
+            mesh = Shell.ByFaces(faces)
+            return mesh
+        
+        if not Topology.IsInstance(origin, "Vertex"):
+            origin = Vertex.Origin()
+        
+        x_range = [-width*0.5, width*0.5]
+        y_range = [-length*0.5, length*0.5]
+        # Generate x and y values
+        x_values = [x_range[0] + i * (x_range[1] - x_range[0]) / (uSides - 1) for i in range(uSides)]
+        y_values = [y_range[0] + i * (y_range[1] - y_range[0]) / (vSides - 1) for i in range(vSides)]
+        
+        # Create the grid and calculate Z values
+        vertices = []
+        
+        for x in x_values:
+            for y in y_values:
+                z = ((x)**2 + (y)**2) / (4 * focalLength)
+                vertices.append(Vertex.ByCoordinates(x, y, z))
+        
+        mesh = create_triangulated_mesh(vertices=vertices, uSides=uSides, vSides=vSides)
+        if not placement.lower() == "bottom":
+            x_list = [Vertex.X(v) for v in vertices]
+            y_list = [Vertex.Y(v) for v in vertices]
+            z_list = [Vertex.Z(v) for v in vertices]
+            x_list.sort()
+            y_list.sort()
+            z_list.sort()
+            width = abs(x_list[-1] - x_list[0])
+            length = abs(y_list[-1] - y_list[0])
+            height = abs(z_list[-1] - z_list[0])
+            if placement.lower() == "center":
+                mesh = Topology.Translate(mesh, 0, 0, -height*0.5)
+            elif placement.lower() == "lowerleft":
+                mesh = Topology.Translate(mesh, width*0.5, length*0.5, 0)
+
+        mesh = Topology.Orient(mesh, origin=origin, dirA=[0, 0, 1], dirB=direction, tolerance=tolerance)
+        return mesh
+    
     @staticmethod
     def Pie(origin= None, radiusA: float = 0.5, radiusB: float = 0.0, sides: int = 32, rings: int = 1, fromAngle: float = 0.0, toAngle: float = 360.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.42'
+__version__ = '0.7.43'

{topologicpy-0.7.42.dist-info → topologicpy-0.7.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.42
+Version: 0.7.43
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: MIT License

{topologicpy-0.7.42.dist-info → topologicpy-0.7.43.dist-info}/RECORD

@@ -16,10 +16,10 @@ topologicpy/Helper.py,sha256=i-AfI29NMsZXBaymjilfvxQbuS3wpYbpPw4RWu1YCHs,16358
 topologicpy/Honeybee.py,sha256=vcBECJlgWVjNNdD9ZmjNik_pA1Y_ZNoOorsQb2CiyGA,21965
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=YvtF7RYUMATEZ8iHwFwK_MOxEDyARby2DTI2CCK6-cI,19694
-topologicpy/Plotly.py,sha256=qMhBMAYoNMsc-cKdNpqM2p9rqAVXWvBNTzmTKw7iU_0,98963
+topologicpy/Plotly.py,sha256=U6Lo7hyDoStRKQXqlhb2LM-rR_bfBulxetRT2wMBmhI,105391
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
-topologicpy/PyG.py,sha256=mDEYYGKv-q1B7GI_J7b3pAbJhF0hqMnITZNMzhHycg4,96097
-topologicpy/Shell.py,sha256=etLWt2VsKOYE-2N0InKdQxLDHEZWsp59DeToSggrjF0,79914
+topologicpy/PyG.py,sha256=Dd0fiEbM_KR-sEHKCodmURBFFvckB6j7x4oBcCC5Q2o,102171
+topologicpy/Shell.py,sha256=NZyHYTvV0pXx18AoMbVs8y-7if8teETItv5ZOJq6gzE,84672
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
 topologicpy/Sun.py,sha256=InnKtX8eKwtAgcScuABH6yp0ljmWh5m_fDR4-n3jJMY,36869
 topologicpy/Topology.py,sha256=5KGQ8jSiURMk9syoMLc3mrIONCfj_pfvCfHTKgPcLOM,366047
@@ -27,9 +27,9 @@ topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
 topologicpy/Vertex.py,sha256=EQdVYHmW85_pZdHZB3N8pEi0GiadCCkF3z_oqohA7B0,71161
 topologicpy/Wire.py,sha256=9EJE0Iq3nGz5X7Suy6xxjmuOpfV49By6WH98UAL_7m4,153532
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=UWZPE9jgOKgWiu1NjdF3GjtgYjFTqvDvq_t-y5kjb-s,23
-topologicpy-0.7.42.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.42.dist-info/METADATA,sha256=NSPc5BzWU_sOnE--u-EnHbDLze91ki3OV6LRtAyEc1k,10916
-topologicpy-0.7.42.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-topologicpy-0.7.42.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.42.dist-info/RECORD,,
+topologicpy/version.py,sha256=7JOl9BjjPK0ib5M5rAuj9I5xjEoYF6YsFAS_dvAYEzg,23
+topologicpy-0.7.43.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.43.dist-info/METADATA,sha256=NCprd1lCZf1afHBHxA5uol5btFYvJFZeiIdoIJtQ5aI,10916
+topologicpy-0.7.43.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+topologicpy-0.7.43.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.43.dist-info/RECORD,,

{topologicpy-0.7.42.dist-info → topologicpy-0.7.43.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (72.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any