topologicpy 0.8.59__py3-none-any.whl → 0.8.61__py3-none-any.whl

topologicpy/Cell.py

@@ -226,7 +226,7 @@ class Cell():
         return new_cell
     
     @staticmethod
-    def ByShell(shell, planarize: bool = False, tolerance: float = 0.0001):
+    def ByShell(shell, planarize: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a cell from the input shell.
 
@@ -238,6 +238,8 @@ class Cell():
             If set to True, the input faces of the input shell are planarized before building the cell. Otherwise, they are not. Default is False.
         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
         -------
@@ -248,7 +250,8 @@ class Cell():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(shell, "Shell"):
-            print("Cell.ByShell - Error: The input shell parameter is not a valid topologic shell. Returning None.")
+            if not silent:
+                print("Cell.ByShell - Error: The input shell parameter is not a valid topologic shell. Returning None.")
             return None
         faces = Topology.SubTopologies(shell, subTopologyType="face")
         return Cell.ByFaces(faces, planarize=planarize, tolerance=tolerance)

topologicpy/Graph.py

@@ -64,20 +64,6 @@ except:
         print("Graph - tqdm library installed correctly.")
     except:
         warnings.warn("Graph - Error: Could not import tqdm.")
-
-try:
-    from graphviz import Digraph
-except:
-    print("Graph - Installing required graphviz library.")
-    try:
-        os.system("pip install graphviz")
-    except:
-        os.system("pip install graphviz --user")
-    try:
-        from graphviz import Digraph
-        print("Graph - graphviz library installed correctly.")
-    except:
-        warnings.warn("Graph - Error: Could not import graphviz.")
     
 GraphQueueItem = namedtuple('GraphQueueItem', ['edges'])
 
@@ -4060,6 +4046,380 @@ class Graph:
                                removeCoplanarFaces=removeCoplanarFaces,
                                xMin=xMin, yMin=yMin, zMin=zMin, xMax=xMax, yMax=yMax, zMax=zMax)
 
+    @staticmethod
+    def ByJSONDictionary(
+        jsonDictionary: dict,
+        xKey: str = "x",
+        yKey: str = "y",
+        zKey: str = "z",
+        vertexIDKey: str = None,
+        edgeSourceKey: str = "source",
+        edgeTargetKey: str = "target",
+        edgeIDKey: str = None,
+        graphPropsKey: str = "properties",
+        verticesKey: str = "vertices",
+        edgesKey: str = "edges",
+        mantissa: int = 6,
+        tolerance: float = 0.0001,
+        silent: bool = False,
+    ):
+        """
+        Loads a Graph from a JSON file and attaches graph-, vertex-, and edge-level dictionaries.
+
+        Parameters
+        ----------
+        path : str
+            Path to a JSON file containing:
+            - graph-level properties under `graphPropsKey` (default "properties"),
+            - a vertex dict under `verticesKey` (default "vertices") keyed by vertex IDs,
+            - an edge dict under `edgesKey` (default "edges") keyed by edge IDs.
+        xKey: str , optional
+            JSON key used to read vertex's x coordinate. Default is "x".
+        yKey: str , optional
+            JSON key used to read vertex's y coordinate. Default is "y".
+        zKey: str , optional
+            JSON key used to read vertex's z coordinate. Default is "z".
+        vertexIDKey : str , optional
+            If not None, the vertex dictionary key under which to store the JSON vertex id. Default is "id".
+        edgeSourceKey: str , optional
+            JSON key used to read edge's start vertex. Default is "source".
+        edgeTargetKey: str , optional
+            JSON key used to read edge's end vertex. Default is "target".
+        edgeIDKey : str , optional
+            If not None, the edge dictionary key under which to store the JSON edge id. Default is "id".
+        graphPropsKey: str , optional
+            JSON key for the graph properties section. Default is "properties".
+        verticesKey: str , optional
+            JSON key for the vertices section. Default is "vertices".
+        edgesKey: str , optional
+            JSON key for the edges section. Default is "edges".
+        mantissa : int , optional
+            The desired length of the mantissa. Default is 6.
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, no warnings or error messages are displayed. Default is False.
+
+        Returns
+        -------
+        topologic_core.Graph
+        """
+        # --- Imports kept local by request ---
+        import json
+        import math
+        from typing import Any, Iterable
+
+        # TopologicPy imports
+        from topologicpy.Graph import Graph
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        # --- Helper functions kept local by request ---
+        def _to_plain(value: Any) -> Any:
+            "Convert numpy/pandas-ish scalars/arrays and nested containers to plain Python."
+            try:
+                import numpy as _np  # optional
+                if isinstance(value, _np.generic):
+                    return value.item()
+                if isinstance(value, _np.ndarray):
+                    return [_to_plain(v) for v in value.tolist()]
+            except Exception:
+                pass
+            if isinstance(value, (list, tuple)):
+                return [_to_plain(v) for v in value]
+            if isinstance(value, dict):
+                return {str(k): _to_plain(v) for k, v in value.items()}
+            if isinstance(value, float):
+                if not math.isfinite(value):
+                    return 0.0
+                # normalize -0.0
+                return 0.0 if abs(value) < tolerance else float(value)
+            return value
+
+        def _round_num(x: Any, m: int) -> float:
+            "Safe float conversion + rounding + tolerance clamp."
+            try:
+                xf = float(x)
+            except Exception:
+                return 0.0
+            if not math.isfinite(xf):
+                return 0.0
+            # clamp tiny values to zero to avoid -0.0 drift and floating trash
+            if abs(xf) < tolerance:
+                xf = 0.0
+            return round(xf, max(0, int(m)))
+
+        def _dict_from(obj: dict, drop_keys: Iterable[str] = ()):
+            "Create a Topologic Dictionary from a Python dict (optionally dropping some keys)."
+            data = {k: _to_plain(v) for k, v in obj.items() if k not in drop_keys}
+            if not data:
+                return None
+            keys = list(map(str, data.keys()))
+            vals = list(data.values())
+            try:
+                return Dictionary.ByKeysValues(keys, vals)
+            except Exception:
+                # As a last resort, stringify nested types
+                import json as _json
+                vals2 = [_json.dumps(v) if isinstance(v, (list, dict)) else v for v in vals]
+                return Dictionary.ByKeysValues(keys, vals2)
+
+        # --- Load JSON ---
+        if not isinstance(jsonDictionary, dict):
+            if not silent:
+                print(f"Graph.ByJSONDictionary - Error: The input JSON Dictionary parameter is not a valid python dictionary. Returning None.")
+            return None
+
+        gprops = jsonDictionary.get(graphPropsKey, {}) or {}
+        verts = jsonDictionary.get(verticesKey, {}) or {}
+        edges = jsonDictionary.get(edgesKey, {}) or {}
+
+        # --- Build vertices ---
+        id_to_vertex = {}
+        vertex_list = []
+        for v_id, v_rec in verts.items():
+            x = _round_num(v_rec.get(xKey, 0.0), mantissa)
+            y = _round_num(v_rec.get(yKey, 0.0), mantissa)
+            z = _round_num(v_rec.get(zKey, 0.0), mantissa)
+            try:
+                v = Vertex.ByCoordinates(x, y, z)
+            except Exception as e:
+                if not silent:
+                    print(f"Graph.ByJSONDictionary - Warning: failed to create Vertex {v_id} at ({x},{y},{z}): {e}")
+                continue
+
+            # Attach vertex dictionary with all attributes except raw coords
+            v_dict_py = dict(v_rec)
+            if vertexIDKey:
+                v_dict_py[vertexIDKey] = v_id
+            v_dict = _dict_from(v_dict_py, drop_keys={xKey, yKey, zKey})
+            if v_dict:
+                v = Topology.SetDictionary(v, v_dict)
+
+            id_to_vertex[str(v_id)] = v
+            vertex_list.append(v)
+
+        # --- Build edges ---
+        edge_list = []
+        for e_id, e_rec in edges.items():
+            s_id = e_rec.get(edgeSourceKey)
+            t_id = e_rec.get(edgeTargetKey)
+            if s_id is None or t_id is None:
+                if not silent:
+                    print(f"Graph.ByJSONDictionary - Warning: skipping Edge {e_id}: missing '{edgeSourceKey}' or '{edgeTargetKey}'.")
+                continue
+            s_id = str(s_id)
+            t_id = str(t_id)
+            if s_id not in id_to_vertex or t_id not in id_to_vertex:
+                if not silent:
+                    print(f"Graph.ByJSONDictionary - Warning: skipping Edge {e_id}: unknown endpoint(s) {s_id}->{t_id}.")
+                continue
+            u = id_to_vertex[s_id]
+            v = id_to_vertex[t_id]
+            try:
+                e = Edge.ByVertices(u, v)
+            except Exception as ee:
+                if not silent:
+                    print(f"Graph.ByJSONDictionary - Warning: failed to create Edge {e_id}: {ee}")
+                continue
+
+            # Attach full edge record as dictionary (including source/target keys)
+            e_dict = _dict_from(dict(e_rec), drop_keys=())
+            if edgeIDKey:
+                Dictionary.SetValueAtKey(e_dict, edgeIDKey, e_id)
+            if e_dict:
+                e = Topology.SetDictionary(e, e_dict)
+            edge_list.append(e)
+
+        # --- Assemble graph ---
+        try:
+            g = Graph.ByVerticesEdges(vertex_list, edge_list)
+        except Exception:
+            # Fallback: create empty, then add
+            g = Graph.ByVerticesEdges([], [])
+            for v in vertex_list:
+                try:
+                    g = Graph.AddVertex(g, v)
+                except Exception:
+                    pass
+            for e in edge_list:
+                try:
+                    g = Graph.AddEdge(g, e)
+                except Exception:
+                    pass
+
+        # --- Graph-level dictionary ---
+        g_dict = _dict_from(dict(gprops), drop_keys=())
+        if g_dict:
+            g = Topology.SetDictionary(g, g_dict)
+
+        return g
+
+    @staticmethod
+    def ByJSONFile(file,
+                   xKey: str = "x",
+                   yKey: str = "y",
+                   zKey: str = "z",
+                   vertexIDKey: str = "id",
+                   edgeSourceKey: str = "source",
+                   edgeTargetKey: str = "target",
+                   edgeIDKey: str = "id",
+                   graphPropsKey: str = "properties",
+                   verticesKey: str = "vertices",
+                   edgesKey: str = "edges",
+                   mantissa: int = 6,
+                   tolerance: float = 0.0001,
+                   silent: bool = False):
+        """
+        Imports the graph from a JSON file.
+
+        Parameters
+        ----------
+        file : file object
+            The input JSON file.
+        xKey: str , optional
+            JSON key used to read vertex's x coordinate. Default is "x".
+        yKey: str , optional
+            JSON key used to read vertex's y coordinate. Default is "y".
+        zKey: str , optional
+            JSON key used to read vertex's z coordinate. Default is "z".
+        vertexIDKey : str , optional
+            If not None, the vertex dictionary key under which to store the JSON vertex id. Default is "id".
+        edgeSourceKey: str , optional
+            JSON key used to read edge's start vertex. Default is "source".
+        edgeTargetKey: str , optional
+            JSON key used to read edge's end vertex. Default is "target".
+        edgeIDKey : str , optional
+            If not None, the edge dictionary key under which to store the JSON edge id. Default is "id".
+        graphPropsKey: str , optional
+            JSON key for the graph properties section. Default is "properties".
+        verticesKey: str , optional
+            JSON key for the vertices section. Default is "vertices".
+        edgesKey: str , optional
+            JSON key for the edges section. Default is "edges".
+        mantissa : int , optional
+            The desired length of the mantissa. Default is 6.
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, no warnings or error messages are displayed. Default is False.
+
+        Returns
+        -------
+        topologic_graph
+            the imported graph.
+
+        """
+        import json
+        if not file:
+            if not silent:
+                print("Topology.ByJSONFile - Error: the input file parameter is not a valid file. Returning None.")
+            return None
+        try:
+            json_dict = json.load(file)
+        except Exception as e:
+            if not silent:
+                print("Graph.ByJSONFile - Error: Could not load the JSON file: {e}. Returning None.")
+            return None
+        return Graph.ByJSONDictionary(json_dict,
+                                      xKey=xKey,
+                                      yKey=yKey,
+                                      zKey=zKey,
+                                      vertexIDKey=vertexIDKey,
+                                      edgeSourceKey=edgeSourceKey,
+                                      edgeTargetKey=edgeTargetKey,
+                                      edgeIDKey=edgeIDKey,
+                                      graphPropsKey=graphPropsKey,
+                                      verticesKey=verticesKey,
+                                      edgesKey=edgesKey,
+                                      mantissa=mantissa,
+                                      tolerance=tolerance,
+                                      silent=silent)
+    
+    @staticmethod
+    def ByJSONPath(path,
+                   xKey: str = "x",
+                   yKey: str = "y",
+                   zKey: str = "z",
+                   vertexIDKey: str = "id",
+                   edgeSourceKey: str = "source",
+                   edgeTargetKey: str = "target",
+                   edgeIDKey: str = "id",
+                   graphPropsKey: str = "properties",
+                   verticesKey: str = "vertices",
+                   edgesKey: str = "edges",
+                   mantissa: int = 6,
+                   tolerance: float = 0.0001,
+                   silent: bool = False):
+        """
+        Imports the graph from a JSON file.
+
+        Parameters
+        ----------
+        path : str
+            The file path to the json file.
+        xKey: str , optional
+            JSON key used to read vertex's x coordinate. Default is "x".
+        yKey: str , optional
+            JSON key used to read vertex's y coordinate. Default is "y".
+        zKey: str , optional
+            JSON key used to read vertex's z coordinate. Default is "z".
+        vertexIDKey : str , optional
+            If not None, the vertex dictionary key under which to store the JSON vertex id. Default is "id".
+        edgeSourceKey: str , optional
+            JSON key used to read edge's start vertex. Default is "source".
+        edgeTargetKey: str , optional
+            JSON key used to read edge's end vertex. Default is "target".
+        edgeIDKey : str , optional
+            If not None, the edge dictionary key under which to store the JSON edge id. Default is "id".
+        graphPropsKey: str , optional
+            JSON key for the graph properties section. Default is "properties".
+        verticesKey: str , optional
+            JSON key for the vertices section. Default is "vertices".
+        edgesKey: str , optional
+            JSON key for the edges section. Default is "edges".
+        mantissa : int , optional
+            The desired length of the mantissa. Default is 6.
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, no warnings or error messages are displayed. Default is False.
+
+        Returns
+        -------
+        list
+            The list of imported topologies.
+
+        """
+        import json
+        if not path:
+            if not silent:
+                print("Graph.ByJSONPath - Error: the input path parameter is not a valid path. Returning None.")
+            return None
+        try:
+            with open(path) as file:
+                json_dict = json.load(file)
+        except Exception as e:
+            if not silent:
+                print(f"Graph.ByJSONPath - Error: Could not load file: {e}. Returning None.")
+            return None
+        return Graph.ByJSONDictionary(json_dict,
+                                      xKey=xKey,
+                                      yKey=yKey,
+                                      zKey=zKey,
+                                      vertexIDKey=vertexIDKey,
+                                      edgeSourceKey=edgeSourceKey,
+                                      edgeTargetKey=edgeTargetKey,
+                                      edgeIDKey=edgeIDKey,
+                                      graphPropsKey=graphPropsKey,
+                                      verticesKey=verticesKey,
+                                      edgesKey=edgesKey,
+                                      mantissa=mantissa,
+                                      tolerance=tolerance,
+                                      silent=silent)
+
     @staticmethod
     def ByMeshData(vertices, edges, vertexDictionaries=None, edgeDictionaries=None, tolerance=0.0001):
         """
@@ -4119,7 +4479,7 @@ class Graph:
         return Graph.ByVerticesEdges(g_vertices, g_edges)
 
     @staticmethod
-    def ByNetworkXGraph(nxGraph, xKey="x", yKey="y", zKey="z", range=(-1, 1), mantissa: int = 6, tolerance: float = 0.0001):
+    def ByNetworkXGraph(nxGraph, xKey="x", yKey="y", zKey="z", coordsKey='coords', randomRange=(-1, 1), mantissa: int = 6, tolerance: float = 0.0001):
         """
         Converts the input NetworkX graph into a topologic Graph. See http://networkx.org
 
@@ -4133,8 +4493,10 @@ class Graph:
             The dictionary key under which to find the Y-Coordinate of the vertex. Default is 'y'.
         zKey : str , optional
             The dictionary key under which to find the Z-Coordinate of the vertex. Default is 'z'.
-        range : tuple , optional
-            The range to use for position coordinates if no values are found in the dictionaries. Default is (-1,1)
+        coordsKey : str , optional
+            The dictionary key under which to find the list of the coordinates vertex. Default is 'coords'.
+        randomRange : tuple , optional
+            The range to use for random position coordinates if no values are found in the dictionaries. Default is (-1,1)
         mantissa : int , optional
             The number of decimal places to round the result to. Default is 6.
         tolerance : float , optional
@@ -4153,38 +4515,221 @@ class Graph:
 
         import random
         import numpy as np
+        import math
+        import torch
+        from collections.abc import Mapping, Sequence
+
+        def _is_iterable_but_not_str(x):
+            return isinstance(x, Sequence) and not isinstance(x, (str, bytes, bytearray))
+
+        def _to_python_scalar(x):
+            """Return a plain Python scalar if x is a numpy/pandas/Decimal/torch scalar; otherwise return x."""
+            # numpy scalar
+            if np is not None and isinstance(x, np.generic):
+                return x.item()
+            # pandas NA
+            if pd is not None and x is pd.NA:
+                return None
+            # pandas Timestamp/Timedelta
+            if pd is not None and isinstance(x, (pd.Timestamp, pd.Timedelta)):
+                return x.isoformat()
+            # torch scalar tensor
+            if torch is not None and isinstance(x, torch.Tensor) and x.dim() == 0:
+                return _to_python_scalar(x.item())
+            # decimal
+            try:
+                from decimal import Decimal
+                if isinstance(x, Decimal):
+                    return float(x)
+            except Exception:
+                pass
+            return x
+
+        def _to_python_list(x):
+            """Convert arrays/series/tensors/sets/tuples to Python lists (recursively)."""
+            if torch is not None and isinstance(x, torch.Tensor):
+                x = x.detach().cpu().tolist()
+            elif np is not None and isinstance(x, (np.ndarray,)):
+                x = x.tolist()
+            elif pd is not None and isinstance(x, (pd.Series, pd.Index)):
+                x = x.tolist()
+            elif isinstance(x, (set, tuple)):
+                x = list(x)
+            return x
+
+        def _round_number(x, mantissa):
+            """Round finite floats; keep ints; sanitize NaNs/Infs to None."""
+            if isinstance(x, bool):  # bool is int subclass; keep as bool
+                return x
+            if isinstance(x, int):
+                return x
+            # try float conversion
+            try:
+                xf = float(x)
+            except Exception:
+                return x  # not a number
+            if math.isfinite(xf):
+                return round(xf, mantissa)
+            return None  # NaN/Inf -> None
+
+        def clean_value(value, mantissa):
+            """
+            Recursively convert value into TopologicPy-friendly types:
+            - numbers rounded to mantissa
+            - sequences -> lists (cleaned)
+            - mappings -> dicts (cleaned)
+            - datetime -> isoformat
+            - other objects -> str(value)
+            """
+            # First, normalize common library wrappers
+            value = _to_python_scalar(value)
+
+            # Datetime from stdlib
+            import datetime
+            if isinstance(value, (datetime.datetime, datetime.date, datetime.time)):
+                try:
+                    return value.isoformat()
+                except Exception:
+                    return str(value)
+
+            # Mapping (dict-like)
+            if isinstance(value, Mapping):
+                return {str(k): clean_value(v, mantissa) for k, v in value.items()}
+
+            # Sequences / arrays / tensors -> list
+            if _is_iterable_but_not_str(value) or (
+                (np is not None and isinstance(value, (np.ndarray,))) or
+                (torch is not None and isinstance(value, torch.Tensor)) or
+                (pd is not None and isinstance(value, (pd.Series, pd.Index)))
+            ):
+                value = _to_python_list(value)
+                return [clean_value(v, mantissa) for v in value]
+
+            # Strings stay as-is
+            if isinstance(value, (str, bytes, bytearray)):
+                return value.decode() if isinstance(value, (bytes, bytearray)) else value
+
+            # Numbers (or things that can be safely treated as numbers)
+            out = _round_number(value, mantissa)
+            # If rounder didn't change type and it's still a weird object, stringify it
+            if out is value and not isinstance(out, (type(None), bool, int, float, str)):
+                return str(out)
+            return out
+
+        def coerce_xyz(val, mantissa, default=0.0):
+            """
+            Coerce a candidate XYZ value into a float:
+            - if mapping with 'x' or 'value' -> try those
+            - if sequence -> use first element
+            - if string -> try float
+            - arrays/tensors -> first element
+            - fallback to default
+            """
+            if val is None:
+                return round(float(default), mantissa)
+            # library scalars
+            val = _to_python_scalar(val)
+
+            # Mapping with common keys
+            if isinstance(val, Mapping):
+                for k in ("x", "value", "val", "coord", "0"):
+                    if k in val:
+                        return coerce_xyz(val[k], mantissa, default)
+                # otherwise try to take first value
+                try:
+                    first = next(iter(val.values()))
+                    return coerce_xyz(first, mantissa, default)
+                except Exception:
+                    return round(float(default), mantissa)
+
+            # Sequence / array / tensor
+            if _is_iterable_but_not_str(val) or \
+            (np is not None and isinstance(val, (np.ndarray,))) or \
+            (torch is not None and isinstance(val, torch.Tensor)) or \
+            (pd is not None and isinstance(val, (pd.Series, pd.Index))):
+                lst = _to_python_list(val)
+                if len(lst) == 0:
+                    return round(float(default), mantissa)
+                return coerce_xyz(lst[0], mantissa, default)
+
+            # String
+            if isinstance(val, str):
+                try:
+                    return round(float(val), mantissa)
+                except Exception:
+                    return round(float(default), mantissa)
+
+            # Numeric
+            try:
+                return _round_number(val, mantissa)
+            except Exception:
+                return round(float(default), mantissa)
 
-        # Create a mapping from NetworkX nodes to TopologicPy vertices
-        nx_to_topologic_vertex = {}
+                # Create a mapping from NetworkX nodes to TopologicPy vertices
+                nx_to_topologic_vertex = {}
 
         # Create TopologicPy vertices for each node in the NetworkX graph
         vertices = []
         for node, data in nxGraph.nodes(data=True):
-            # Attempt to get X, Y, Z from the node data
-            x = round(data.get(xKey, random.uniform(*range)), mantissa)
-            y = round(data.get(yKey, random.uniform(*range)), mantissa)
-            z = round(data.get(zKey, 0), mantissa) # If there are no Z values, this is probably a flat graph.
-            # Create a TopologicPy vertex with the node data dictionary
-            vertex = Vertex.ByCoordinates(x,y,z)
+            # Clean the node dictionary
             cleaned_values = []
-            for value in data.values():
-                if isinstance(value, np.ndarray):
-                    value = list(value)
-                cleaned_values.append(value)
-                
-            node_dict = Dictionary.ByKeysValues(list(data.keys()), cleaned_values)
+            cleaned_keys = []
+            for k, v in data.items():
+                cleaned_keys.append(str(k))
+                cleaned_values.append(clean_value(v, mantissa))
+            data = dict(zip(cleaned_keys, cleaned_values))
+            # Defensive defaults for coordinates
+            x_raw = y_raw = z_raw = None
+            try:
+                x_raw = data.get(xKey, None)
+                y_raw = data.get(yKey, None)
+                z_raw = data.get(zKey, None)
+            except Exception:
+                x_raw = y_raw = z_raw = None
+            
+            if x_raw == None:
+                coords = data.get(coordsKey, None)
+                if coords:
+                    coords = clean_value(coords, mantissa)
+                    if isinstance(coords, list):
+                        if len(coords) == 2:
+                            x_raw = coords[0]
+                            y_raw = coords[1]
+                            z_raw = 0
+                        elif len(coords) == 3:
+                            x_raw = coords[0]
+                            y_raw = coords[1]
+                            z_raw = coords[2]
+
+            # Fall back to random only if missing / invalid
+            x = coerce_xyz(x_raw, mantissa, default=random.uniform(*randomRange))
+            y = coerce_xyz(y_raw, mantissa, default=random.uniform(*randomRange))
+            z = coerce_xyz(z_raw, mantissa, default=0.0)
+
+            # Create vertex
+            vertex = Vertex.ByCoordinates(x, y, z)
+
+            # Build and attach TopologicPy dictionary
+            node_dict = Dictionary.ByKeysValues(cleaned_keys, cleaned_values)
             vertex = Topology.SetDictionary(vertex, node_dict)
-            nx_to_topologic_vertex[node] = vertex
+
+            #nx_to_topologic_vertex[node] = vertex
             vertices.append(vertex)
 
         # Create TopologicPy edges for each edge in the NetworkX graph
         edges = []
         for u, v, data in nxGraph.edges(data=True):
-            start_vertex = nx_to_topologic_vertex[u]
-            end_vertex = nx_to_topologic_vertex[v]
+            start_vertex = vertices[u]
+            end_vertex = vertices[v]
 
             # Create a TopologicPy edge with the edge data dictionary
-            edge_dict = Dictionary.ByKeysValues(list(data.keys()), list(data.values()))
+             # Clean the node dictionary
+            cleaned_values = []
+            cleaned_keys = []
+            for k, v in data.items():
+                cleaned_keys.append(str(k))
+                cleaned_values.append(clean_value(v, mantissa))
+            edge_dict = Dictionary.ByKeysValues(cleaned_keys, cleaned_values)
             edge = Edge.ByVertices([start_vertex, end_vertex], tolerance=tolerance)
             edge = Topology.SetDictionary(edge, edge_dict)
             edges.append(edge)
@@ -8015,13 +8560,13 @@ class Graph:
             1 for validate, and 2 for test. If no key is found, the ratio of train/validate/test will be used. Default is "mask".
         nodeTrainRatio : float , optional
             The desired ratio of the node data to use for training. The number must be between 0 and 1. Default is 0.8 which means 80% of the data will be used for training.
-            This value is ignored if an nodeMaskKey is foud.
+            This value is ignored if an nodeMaskKey is found.
         nodeValidateRatio : float , optional
             The desired ratio of the node data to use for validation. The number must be between 0 and 1. Default is 0.1 which means 10% of the data will be used for validation.
-            This value is ignored if an nodeMaskKey is foud.
+            This value is ignored if an nodeMaskKey is found.
         nodeTestRatio : float , optional
             The desired ratio of the node data to use for testing. The number must be between 0 and 1. Default is 0.1 which means 10% of the data will be used for testing.
-            This value is ignored if an nodeMaskKey is foud.
+            This value is ignored if an nodeMaskKey is found.
         mantissa : int , optional
             The number of decimal places to round the result to. Default is 6.
         tolerance : float , optional
@@ -8888,7 +9433,7 @@ class Graph:
             return False
 
     @staticmethod
-    def ExportToJSON(graph, path, verticesKey="vertices", edgesKey="edges", vertexLabelKey="", edgeLabelKey="", xKey="x", yKey="y", zKey="z", indent=4, sortKeys=False, mantissa=6, overwrite=False):
+    def ExportToJSON(graph, path, propertiesKey="properties", verticesKey="vertices", edgesKey="edges", vertexLabelKey="", edgeLabelKey="", xKey="x", yKey="y", zKey="z", indent=4, sortKeys=False, mantissa=6, overwrite=False):
         """
         Exports the input graph to a JSON file.
 
@@ -8898,6 +9443,8 @@ class Graph:
             The input graph.
         path : str
             The path to the JSON file.
+        propertiesKey : str , optional
+            The desired key name to call graph properties. Default is "properties".
         verticesKey : str , optional
             The desired key name to call vertices. Default is "vertices".
         edgesKey : str , optional
@@ -8947,7 +9494,7 @@ class Graph:
         except:
             raise Exception("Graph.ExportToJSON - Error: Could not create a new file at the following location: "+path)
         if (f):
-            jsondata = Graph.JSONData(graph, verticesKey=verticesKey, edgesKey=edgesKey, vertexLabelKey=vertexLabelKey, edgeLabelKey=edgeLabelKey, xKey=xKey, yKey=yKey, zKey=zKey, mantissa=mantissa)
+            jsondata = Graph.JSONData(graph, propertiesKey=propertiesKey, verticesKey=verticesKey, edgesKey=edgesKey, vertexLabelKey=vertexLabelKey, edgeLabelKey=edgeLabelKey, xKey=xKey, yKey=yKey, zKey=zKey, mantissa=mantissa)
             if jsondata != None:
                 json.dump(jsondata, f, indent=indent, sort_keys=sortKeys)
                 f.close()
@@ -10467,8 +11014,26 @@ class Graph:
             The created GraphViz graph.
         """
 
-        from graphviz import Digraph
-        from graphviz import Graph as Udgraph
+        import os
+        import warnings
+
+        try:
+            from graphviz import Digraph
+            from graphviz import Graph as Udgraph
+
+        except:
+            print("Graph - Installing required graphviz library.")
+            try:
+                os.system("pip install graphviz")
+            except:
+                os.system("pip install graphviz --user")
+            try:
+                from graphviz import Digraph
+                from graphviz import Graph as Udgraph
+                print("Graph - graphviz library installed correctly.")
+            except:
+                warnings.warn("Graph - Error: Could not import graphviz.")
+
         from topologicpy.Graph import Graph
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
@@ -11662,6 +12227,7 @@ class Graph:
 
     @staticmethod
     def JSONData(graph,
+                 propertiesKey: str = "properties",
                  verticesKey: str = "vertices",
                  edgesKey: str = "edges",
                  vertexLabelKey: str = "",
@@ -11681,6 +12247,8 @@ class Graph:
         ----------
         graph : topologic_core.Graph
             The input graph.
+        propertiesKey : str , optional
+            The desired key name to call the graph properties. Default is "properties".
         verticesKey : str , optional
             The desired key name to call vertices. Default is "vertices".
         edgesKey : str , optional
@@ -11720,8 +12288,10 @@ class Graph:
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
 
+        graph_d = Dictionary.PythonDictionary(Topology.Dictionary(graph))
         vertices = Graph.Vertices(graph)
         j_data = {}
+        j_data[propertiesKey] = graph_d
         j_data[verticesKey] = {}
         j_data[edgesKey] = {}
         n = max(len(str(len(vertices))), 4)
@@ -14266,6 +14836,54 @@ class Graph:
         _ = graph.RemoveEdges([edge], tolerance) # Hook to Core
         return graph
     
+    @staticmethod
+    def RemoveIsolatedEdges(graph, removeVertices: bool = True, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Removes all isolated edges from the input graph.
+        Isolated edges are those whose vertices are not connected to any other edges.
+        That is, they have a degree of 1.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        removeVertices : bool , optional
+            If set to True, the end vertices of the edges are also removed. 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.Graph
+            The input graph with all isolated vertices removed.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Edge import Edge
+
+        
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.RemoveIsolatedEdges - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        
+        edges = Graph.Edges(graph)
+        if removeVertices == True:
+            for edge in edges:
+                va, vb = Edge.Vertices(edge)
+                if Graph.VertexDegree(graph, va, tolerance=tolerance, silent=silent) == 1 and Graph.VertexDegree(graph, vb, tolerance=tolerance, silent=silent) == 1:
+                    graph = Graph.RemoveEdge(graph, edge, tolerance=tolerance)
+                    graph = Graph.RemoveVertex(graph, va, tolerance=tolerance)
+                    graph = Graph.RemoveVertex(graph, vb, tolerance=tolerance)
+        else:
+            for edge in edges:
+                va, vb = Edge.Vertices(edge)
+                if Graph.VertexDegree(graph, va, tolerance=tolerance, silent=silent) == 1 and Graph.VertexDegree(graph, vb, tolerance=tolerance, silent=silent) == 1:
+                    graph = Graph.RemoveEdge(graph, edge, tolerance=tolerance)
+        return graph
+
     @staticmethod
     def RemoveIsolatedVertices(graph, tolerance=0.0001):
         """

topologicpy/Kuzu.py

@@ -476,7 +476,7 @@ class Kuzu:
     def GraphsByQuery(
         manager,
         query: str,
-        params: dict | None = None,
+        params: dict = None,
         silent: bool = False,
     ):
         """

topologicpy/Topology.py

@@ -2390,7 +2390,7 @@ class Topology():
         return topology
     '''
     @staticmethod
-    def ByJSONFile(file, tolerance=0.0001):
+    def ByJSONFile(file, tolerance: float = 0.0001, silent: bool = False):
         """
         Imports the topology from a JSON file.
 
@@ -2400,6 +2400,8 @@ class Topology():
             The input JSON file.
         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
         -------
@@ -2407,14 +2409,21 @@ class Topology():
             The list of imported topologies (Warning: the list could contain 0, 1, or many topologies, but this method will always return a list)
 
         """
+        import json
         if not file:
-            print("Topology.ByJSONFile - Error: the input file parameter is not a valid file. Returning None.")
+            if not silent:
+                print("Topology.ByJSONFile - Error: the input file parameter is not a valid file. Returning None.")
+            return None
+        try:
+            json_dict = json.load(file)
+        except Exception as e:
+            if not silent:
+                print("Topology.ByJSONFile - Error: Could not load the JSON file: {e}. Returning None.")
             return None
-        json_dict = json.load(file)
-        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance)
+        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def ByJSONPath(path, tolerance=0.0001):
+    def ByJSONPath(path, tolerance: float = 0.0001, silent: bool = False):
         """
         Imports the topology from a JSON file.
 
@@ -2424,6 +2433,8 @@ class Topology():
             The file path to the json file.
         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
         -------
@@ -2433,15 +2444,20 @@ class Topology():
         """
         import json
         if not path:
-            print("Topology.ByJSONPath - Error: the input path parameter is not a valid path. Returning None.")
+            if not silent:
+                print("Topology.ByJSONPath - Error: the input path parameter is not a valid path. Returning None.")
             return None
-        with open(path) as file:
-            json_dict = json.load(file)
-        entities = Topology.ByJSONDictionary(json_dict, tolerance=tolerance)
-        return entities
+        try:
+            with open(path) as file:
+                json_dict = json.load(file)
+        except Exception as e:
+            if not silent:
+                print("Topology.ByJSONPath - Error: Could not load file: {e}. Returning None.")
+            return None
+        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def ByJSONDictionary(jsonDictionary, tolerance=0.0001):
+    def ByJSONDictionary(jsonDictionary: dict, tolerance: float = 0.0001, silent: bool = False):
         """
         Imports the topology from a JSON dictionary.
 
@@ -2451,6 +2467,8 @@ class Topology():
             The input JSON dictionary.
         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
         -------
@@ -2489,41 +2507,41 @@ class Topology():
             # Create basic topological entities
             if entity_type == 'Vertex':
                 parent_entity = Vertex.ByCoordinates(*entity['coordinates'])
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 vertices[entity['uuid']] = parent_entity
 
             elif entity_type == 'Edge':
                 vertex1 = vertices[entity['vertices'][0]]
                 vertex2 = vertices[entity['vertices'][1]]
-                parent_entity = Edge.ByVertices([vertex1, vertex2])
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                parent_entity = Edge.ByVertices([vertex1, vertex2], tolerance=tolerance, silent=silent)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 edges[entity['uuid']] = parent_entity
 
             elif entity_type == 'Wire':
                 wire_edges = [edges[uuid] for uuid in entity['edges']]
-                parent_entity = Wire.ByEdges(wire_edges)
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                parent_entity = Wire.ByEdges(wire_edges, tolerance=tolerance, silent=silent)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 wires[entity['uuid']] = parent_entity
 
             elif entity_type == 'Face':
                 face_wires = [wires[uuid] for uuid in entity['wires']]
                 if len(face_wires) > 1:
-                    parent_entity = Face.ByWires(face_wires[0], face_wires[1:])
+                    parent_entity = Face.ByWires(face_wires[0], face_wires[1:], tolerance=tolerance, silent=silent)
                 else:
-                    parent_entity = Face.ByWire(face_wires[0])
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                    parent_entity = Face.ByWire(face_wires[0], tolerance=tolerance, silent=silent)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 faces[entity['uuid']] = parent_entity
 
             elif entity_type == 'Shell':
                 shell_faces = [faces[uuid] for uuid in entity['faces']]
-                parent_entity = Shell.ByFaces(shell_faces)
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                parent_entity = Shell.ByFaces(shell_faces, tolerance=tolerance, silent=silent)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 shells[entity['uuid']] = parent_entity
 
             elif entity_type == 'Cell':
                 cell_shells = [shells[uuid] for uuid in entity['shells']]
                 if len(cell_shells) > 1:
-                    parent_entity = Cell.ByShells(cell_shells[0], cell_shells[1:])
+                    parent_entity = Cell.ByShells(cell_shells[0], cell_shells[1:], tolerance=tolerance, silent=silent)
                 else:
                     parent_entity = Cell.ByShell(cell_shells[0])
                 parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
@@ -2649,7 +2667,7 @@ class Topology():
         return top_level_list
     
     @staticmethod
-    def ByJSONString(string, tolerance=0.0001):
+    def ByJSONString(string: str, tolerance: float = 0.0001, silent: bool = False):
         """
         Imports the topology from a JSON string.
 
@@ -2659,6 +2677,8 @@ class Topology():
             The input JSON string.
         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
         -------
@@ -2666,9 +2686,13 @@ class Topology():
             The list of imported topologies (Warning: the list could contain 0, 1, or many topologies, but this method will always return a list)
 
         """
-
-        json_dict = json.loads(string)
-        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance)
+        try:
+            json_dict = json.loads(string)
+        except Exception as e:
+            if not silent:
+                print(f"Topology.ByJSONString - Error: Could not read the input string: {e}. Returning None.")
+            return None 
+        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance, silent=silent)
 
     @staticmethod
     def ByMeshData(dictionary, transferDictionaries: bool = False, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.59'
+__version__ = '0.8.61'

{topologicpy-0.8.59.dist-info → topologicpy-0.8.61.dist-info}/METADATA

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

@@ -2,7 +2,7 @@ topologicpy/ANN.py,sha256=gpflv4lFypOW789vO7mSkMLaMF_ZftVOCqCvtGr6-JA,47873
 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=ndrfovjwEEQTJ0B5DuthuCBDdVg9-1i_MX8Dtj-wD4E,177330
+topologicpy/Cell.py,sha256=xkt9lfutgSwr_1lah1U5n48UnrLIggznNKUmEe2FA2g,177505
 topologicpy/CellComplex.py,sha256=Kbz63rGeE08bJfMXFvB-AptoKHiaCK5OtiV1wz8Y-Fk,68081
 topologicpy/Cluster.py,sha256=G49AuhJHQ1s819cB5MtVdmAGgkag19IC3dRP1ub1Wh4,58608
 topologicpy/Color.py,sha256=hzSmgBWhiuYc55RSipkQNIgGtgyhC5BqY8AakNYEK-U,24486
@@ -12,11 +12,11 @@ topologicpy/Dictionary.py,sha256=Z4YQ88tONWd-0X0dENQ8IZqIOa9mbBqhJkTBsHmft2g,446
 topologicpy/Edge.py,sha256=DifItuyabFDUFC7CVMlt2DeMFMNaGOqCg43iU9CPP0A,74029
 topologicpy/EnergyModel.py,sha256=hB1aiJe45gdDMFm1AhkBr-1djjtXSzn24iRpQMk43-4,57749
 topologicpy/Face.py,sha256=aX9EcR3JGbLITElhd25J0Z8m9U8KkmbYivGg3oZN-Uw,202296
-topologicpy/Graph.py,sha256=LMK-YceKCPP4-8s32mTF2QPRaxbUiKSwytV3WcpQJIE,756629
+topologicpy/Graph.py,sha256=ytXl9VLj243o9LhY0A8P_gp4_Ce_VrHW5oaC2WK6Mbc,782718
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
 topologicpy/Helper.py,sha256=Nr6pyzl0sZm4Cu11wOqoYKu6yYal5N6A9jErXnaZBJc,31765
 topologicpy/Honeybee.py,sha256=DzaG9wpkJdcDWcjOGXhuN5X0gCqypmZGBa1y5E2MkjU,48964
-topologicpy/Kuzu.py,sha256=THmXfImCVTZhvt0fH0M2-PJeFNyTnmBCf_sjXDxOraE,36305
+topologicpy/Kuzu.py,sha256=fxaDPWM5Xam7Tot0olPZsazS_7xgE_Vo-jf0Sbv3VZE,36298
 topologicpy/Matrix.py,sha256=bOofT34G3YHu9aMIWx60YHAJga4R0GbDjsZBUD4Hu_k,22706
 topologicpy/Neo4j.py,sha256=J8jU_mr5-mWC0Lg_D2dMjMlx1rY_eh8ks_aubUuTdWw,22319
 topologicpy/Plotly.py,sha256=OQvCzAXqu_QYn8iY0rjc8ZB4XwwK70pWjnnoMzDdcc0,123167
@@ -26,14 +26,14 @@ topologicpy/ShapeGrammar.py,sha256=KYsKDLXWdflAcYMAIz84AUF-GMkbTmaBDd2-ovbilqU,2
 topologicpy/Shell.py,sha256=ioO4raCJfXtYldQg-adpcLVeJPEA6od6cAA5ro7t6r4,96792
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=8S6dhCKfOhUGVny-jEk87Q08anLYMB1JEBKRGCklvbQ,36670
-topologicpy/Topology.py,sha256=_D1E8c8lnbu4Eii4YjkJhWoNb-q2ELdnLIE-xQFloPg,472580
+topologicpy/Topology.py,sha256=O3K4B47K0ic4jMj4OC9ZuqDPV6I7QRZ6r7Q9SHPEqaI,474206
 topologicpy/Vector.py,sha256=pEC8YY3TeHGfGdeNgvdHjgMDwxGabp5aWjwYC1HSvMk,42236
 topologicpy/Vertex.py,sha256=r_3cicgpino96ymm1ANptfOuqE59b99YWwksxyPOYK4,85914
 topologicpy/Wire.py,sha256=gjgQUGHdBdXUIijgZc_VIW0E39w-smaVhhdl0jF63fQ,230466
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=JBWmeYi_9RclzA_WCIMX3fzJxg3vh3eyKLFiq90X2mA,23
-topologicpy-0.8.59.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.59.dist-info/METADATA,sha256=hEPFnN0ZWkV_YPvQ5wemo_9nnmV9H6qW42XErgpUvSs,10535
-topologicpy-0.8.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.59.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.59.dist-info/RECORD,,
+topologicpy/version.py,sha256=v9RYfeFVriaSopTI1WMyzj0QSU9vvxnXtU_efzx9Iek,23
+topologicpy-0.8.61.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.61.dist-info/METADATA,sha256=AUdc_jfqI7o0MlB6Izlr_BIUcpjbN71DLKCHBY1UYsA,10535
+topologicpy-0.8.61.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.61.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.61.dist-info/RECORD,,