topologicpy 0.8.52__py3-none-any.whl → 0.8.55__py3-none-any.whl

topologicpy/Cell.py

@@ -1552,7 +1552,6 @@ class Cell():
         cluster = Cluster.ByTopologies(pentagons)
         
         cluster2 = Topology.Rotate(cluster, origin=Vertex.Origin(), axis=[1, 0, 0], angle=180)
-        #cluster2 = Topology.Rotate(cluster2, origin=Vertex.Origin(), axis=[0, 0, 1], angle=36)
         vertices = Topology.Vertices(cluster)
         zList = [Vertex.Z(v) for v in vertices]
         zList = list(set(zList))
@@ -1566,9 +1565,8 @@ class Cell():
         dodecahedron = Topology.Translate(dodecahedron, -Vertex.X(centroid), -Vertex.Y(centroid), -Vertex.Z(centroid))
         vertices = Topology.Vertices(dodecahedron)
         d = Vertex.Distance(Vertex.Origin(), vertices[0])
+        # Make sure the distance from the origin to the vertices is equal to the radius.
         dodecahedron = Topology.Scale(dodecahedron, origin=Vertex.Origin(), x=radius/d, y=radius/d, z=radius/d)
-        verts = Topology.Vertices(dodecahedron)
-        print("Dodec: Distance", Vertex.Distance(Vertex.Origin(), verts[0]))
         if placement == "bottom":
             dodecahedron = Topology.Translate(dodecahedron, 0, 0, radius)
         elif placement == "lowerleft":

topologicpy/EnergyModel.py

@@ -201,6 +201,51 @@ class EnergyModel:
                 warnings.warn("EnergyModel.ByTopology - Error: Could not import openstudio.Please try to install openstudio manually. Returning None.")
                 return None
 
+
+        def load_openstudio_model(osm_path: str, allow_newer: bool = True):
+            """
+            Load an OpenStudio .osm file and return an openstudio.model.Model.
+            Uses loadModelFromString to avoid SWIG path overload issues.
+            """
+            import os
+
+            if not os.path.exists(osm_path):
+                raise FileNotFoundError(osm_path)
+
+            vt = openstudio.osversion.VersionTranslator()
+            if allow_newer:
+                vt.setAllowNewerVersions(True)
+
+            # 1) Robust path-agnostic route: read text and load from string
+            with open(osm_path, "r", encoding="utf-8") as f:
+                txt = f.read()
+            model_opt = vt.loadModelFromString(txt)  # <- avoids path type mismatches
+
+            # 2) Fallback: try the filesystem-path overloads if needed
+            if (not model_opt) or (not model_opt.is_initialized()):
+                os_path = None
+                for maker in (
+                    lambda s: getattr(openstudio, "path")(s),
+                    lambda s: getattr(openstudio, "toPath")(s),
+                    lambda s: getattr(openstudio.openstudioutilitiescore, "toPath")(s),
+                ):
+                    try:
+                        os_path = maker(osm_path)
+                        break
+                    except Exception:
+                        pass
+                if os_path is not None:
+                    try:
+                        model_opt = vt.loadModel(os_path)
+                    except TypeError:
+                        model_opt = openstudio.model.Model.load(os_path)
+
+            if (not model_opt) or (not model_opt.is_initialized()):
+                raise RuntimeError(f"Failed to load OpenStudio model from: {osm_path}")
+
+            model = model_opt.get()
+            return model
+    
         def getKeyName(d, keyName):
             keys = d.Keys()
             for key in keys:
@@ -243,21 +288,23 @@ class EnergyModel:
         
         if not osModelPath:
             import os
-            osModelPath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "OSMTemplate-OfficeBuilding-3.5.0.osm")
+            osModelPath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "OSMTemplate-OfficeBuilding-3.10.0.osm")
         if not weatherFilePath or not designDayFilePath:
             import os
             weatherFilePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "GBR_London.Gatwick.037760_IWEC.epw")
             designDayFilePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "GBR_London.Gatwick.037760_IWEC.ddy")
-        translator = openstudio.osversion.VersionTranslator()
+
+        #translator = openstudio.osversion.VersionTranslator()
         # DEBUGGING
         #osmFile = openstudio.openstudioutilitiescore.toPath(osModelPath)
         #osModel = translator.loadModel(osmFile)
-        osModel = translator.loadModel(osModelPath)
-        if osModel.isNull():
-            print("EnergyModel.ByTopology - Error: The openstudio model is null. Returning None.")
-            return None
-        else:
-            osModel = osModel.get()
+        #osModel = translator.loadModel(osModelPath)
+        osModel = load_openstudio_model(osModelPath, allow_newer=True)
+        # if osModel.isNull():
+        #     print("EnergyModel.ByTopology - Error: The openstudio model is null. Returning None.")
+        #     return None
+        # else:
+        #     osModel = osModel.get()
         # DEBUGGING
         #osEPWFile = openstudio.openstudioutilitiesfiletypes.EpwFile.load(openstudio.toPath(weatherFilePath))
         osEPWFile = openstudio.openstudioutilitiesfiletypes.EpwFile.load(weatherFilePath)
@@ -265,8 +312,8 @@ class EnergyModel:
             osEPWFile = osEPWFile.get()
             openstudio.model.WeatherFile.setWeatherFile(osModel, osEPWFile)
         # DEBUGGING
-        #ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(openstudio.toPath(designDayFilePath))
-        ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(designDayFilePath)
+        ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(openstudio.toPath(designDayFilePath))
+        #ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(designDayFilePath)
         if ddyModel.is_initialized():
             ddyModel = ddyModel.get()
             for ddy in ddyModel.getObjectsByType(openstudio.IddObjectType("OS:SizingPeriod:DesignDay")):
@@ -1195,3 +1242,57 @@ class EnergyModel:
             return None
         return units
     
+    @staticmethod
+    def Version(check: bool = True, silent: bool = False):
+        """
+        Returns the OpenStudio SDK version number.
+
+        Parameters
+        ----------
+        check : bool , optional
+            if set to True, the version number is checked with the latest version on PyPi. Default is True.
+        
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+        
+        Returns
+        -------
+        str
+            The OpenStudio SDK version number.
+
+        """
+        from topologicpy.Helper import Helper
+        try:
+            import openstudio
+            openstudio.Logger.instance().standardOutLogger().setLogLevel(openstudio.Fatal)
+        except:
+            if not silent:
+                print("EnergyModel.Version - Information: Installing required openstudio library.")
+            try:
+                os.system("pip install openstudio")
+            except:
+                os.system("pip install openstudio --user")
+            try:
+                import openstudio
+                openstudio.Logger.instance().standardOutLogger().setLogLevel(openstudio.Fatal)
+                if not silent:
+                    print("EnergyModel.Version - Information: openstudio library installed correctly.")
+            except:
+                if not silent:
+                    print("EnergyModel.Version - Error: Could not import openstudio.Please try to install openstudio manually. Returning None.")
+                return None
+        import requests
+        from packaging import version
+
+        result = getattr(openstudio, "openStudioVersion", None)
+        if callable(result):
+            result = result()
+        else:
+            if not silent:
+                print("EnergyModel.Version - Error: Could not retrieve the openstudio SDK version number. Returning None.")
+            return None
+        if check == True:
+            result = Helper.CheckVersion("openstudio", result, silent=silent)
+        return result
+        
+        

topologicpy/Graph.py

@@ -784,7 +784,291 @@ class Graph:
             return csv_buffer.getvalue()
         except Exception as e:
             return ""
-        
+
+    @staticmethod
+    def AdjacencyMatrixFigure(graph,
+                            vertexKey: str = None,
+                            showZero: bool = False,
+                            zeroChar: str = "·",
+                            zeroColor: str = 'rgba(0,0,0,0)',
+                            valueColor: str = 'rgba(0,0,0,0.05)',
+                            diagonalHighlight: bool = True,
+                            diagonalColor: str = 'rgba(0,0,0,0)',
+                            title: str = None,
+                            cellSize: int = 24,
+                            fontFamily: str = "Arial",
+                            fontSize: int = 12,
+                            fontColor: str = 'rgba(0,0,0,0)',
+                            backgroundColor: str = 'rgba(0,0,0,0)',
+                            headerColor: str = 'rgba(0,0,0,0)',
+                            reverse=False,
+                            edgeKeyFwd=None,
+                            edgeKeyBwd=None,
+                            bidirKey=None,
+                            bidirectional=True,
+                            useEdgeIndex=False,
+                            useEdgeLength=False,
+                            mantissa: int = 6,
+                            tolerance=0.0001,
+                            silent: bool = False):
+        """
+        Returns a Plotly table figure visualizing the adjacency matrix of a Graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexKey : str , optional
+            If set, the returned list of vertices is sorted according to the dictionary values stored under this key. Default is None.
+        showZero : bool, optional
+            If True, show zeros as "0"; if False, show a subtle glyph (zero_char) or blank. Default is False.
+        zeroChar : str, optional
+            Character to display for zero entries when show_zero is False. Default is "·".
+        zeroColor : list or str , optional
+            The desired color to display for zero-valued cells. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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).
+        valueColor : list or str , optional
+            The desired color to display for non-zero-valued cells. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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.35)' (slight highlight).
+        diagonalHighlight : bool, optional
+            If True, lightly highlight diagonal cells. Default is True.
+        diagonalColor : list or str , optional
+            The desired diagonal highlight color. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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).
+        title : str, optional
+            Optional figure title.
+        cellSize : int, optional
+            Approximate pixel height of each table row. Default is 24.
+        fontFamily : str, optional
+            Font family for table text. Default is "Arial".
+        fontSize : int, optional
+            Font size for table text. Default is 12.
+        fontColor : list or str , optional
+            The desired font color. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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).
+        backgroundColor : list or str , optional
+            The desired background color. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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).
+        headerColor : list or str , optional
+            The desired header color. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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).
+        reverse : bool , optional
+            If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. Default is False.
+        edgeKeyFwd : str , optional
+            If set, the value at this key in the connecting edge from start vertex to end vertex (forward) will be used instead of the value 1. Default is None. useEdgeIndex and useEdgeLength override this setting.
+        edgeKeyBwd : str , optional
+            If set, the value at this key in the connecting edge from end vertex to start vertex (backward) will be used instead of the value 1. Default is None. useEdgeIndex and useEdgeLength override this setting.
+        bidirKey : bool , optional
+            If set to True or False, this key in the connecting edge will be used to determine is the edge is supposed to be bidirectional or not. If set to None, the input variable bidrectional will be used instead. Default is None
+        bidirectional : bool , optional
+            If set to True, the edges in the graph that do not have a bidireKey in their dictionaries will be treated as being bidirectional. Otherwise, the start vertex and end vertex of the connecting edge will determine the direction. Default is True.
+        useEdgeIndex : bool , optional
+            If set to True, the adjacency matrix values will the index of the edge in Graph.Edges(graph). Default is False. Both useEdgeIndex, useEdgeLength should not be True at the same time. If they are, useEdgeLength will be used.
+        useEdgeLength : bool , optional
+            If set to True, the adjacency matrix values will the length of the edge in Graph.Edges(graph). Default is False. Both useEdgeIndex, useEdgeLength should not be True at the same time. If they are, useEdgeLength will be used.
+        mantissa : int , optional
+            The number of decimal places to round the result to. Default is 6.
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool, optional
+            If True, suppresses warning messages. Default is False.
+
+        Returns
+        -------
+        plotly.graph_objs._figure.Figure
+            A Plotly table figure containing the adjacency matrix table.
+        """
+
+        from topologicpy.Topology import Topology
+        from topologicpy.Graph import Graph
+        from topologicpy.Dictionary import Dictionary
+        import plotly.graph_objects as go
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Plotly.AdjacencyMatrixTable - Error: The input is not a valid Graph. Returning None.")
+            return None
+
+        # Build adjacency matrix
+        adj = Graph.AdjacencyMatrix(graph,
+                                    vertexKey=vertexKey,
+                                    reverse=reverse,
+                                    edgeKeyFwd=edgeKeyFwd,
+                                    edgeKeyBwd=edgeKeyBwd,
+                                    bidirKey=bidirKey,
+                                    bidirectional=bidirectional,
+                                    useEdgeIndex=useEdgeIndex,
+                                    useEdgeLength=useEdgeLength,
+                                    mantissa=mantissa,
+                                    tolerance=tolerance)
+
+        if adj is None or not isinstance(adj, list) or len(adj) == 0:
+            if not silent:
+                print("Plotly.AdjacencyMatrixTable - Warning: Empty adjacency matrix. Returning None.")
+            return None
+
+        n = len(adj)
+        # Validate squareness
+        if any((not isinstance(row, list) or len(row) != n) for row in adj):
+            if not silent:
+                print("Plotly.AdjacencyMatrixTable - Error: Adjacency matrix must be square. Returning None.")
+            return None
+
+        # Derive labels
+        verts = Graph.Vertices(graph)
+        labels = [Dictionary.ValueAtKey(Topology.Dictionary(v), vertexKey, str(i)) for i, v in enumerate(verts)]
+        if len(labels) > 0 and not vertexKey == None:
+            labels.sort()
+            if reverse == True:
+                labels.reverse()
+        # Build display matrix (strings) while keeping a parallel style mask for diagonal
+        display_matrix = []
+        diag_mask = []
+        for r in range(n):
+            row_vals = []
+            row_diag = []
+            for c in range(n):
+                v = adj[r][c]
+                if v == 0:
+                    row_vals.append("0" if showZero else (zeroChar if zeroChar else ""))
+                else:
+                    # Keep integers unpadded for clarity; cast others nicely
+                    row_vals.append(str(int(v)) if isinstance(v, (int, float)) and float(v).is_integer() else str(v))
+                row_diag.append(r == c)
+            display_matrix.append(row_vals)
+            diag_mask.append(row_diag)
+
+        # Construct header and cells for Plotly Table
+        # Header: blank corner + column labels
+        header_values = [""] + labels
+
+        # Body: first column is row labels, then matrix cells as strings
+        # Plotly Table expects columns as lists; we need to transpose
+        columns = []
+        # Column 0: row labels
+        columns.append(labels)
+        # Subsequent columns: for each c, collect display_matrix[r][c]
+        for c in range(n):
+            columns.append([display_matrix[r][c] for r in range(n)])
+
+        # Flatten cell fill_colors to highlight diagonal subtly.
+        # Plotly Table allows per-cell fillcolor via a 2D list matching the table shape for 'cells'.
+        # Our cells shape is n rows x (n+1) cols (including row label column).
+
+        fill_colors = []
+        # Column 0: row labels (no highlight)
+        fill_colors.append([headerColor] * n)
+
+        # Columns 1..n: highlight diagonal where row index r == (column_index-1)
+        for c in range(1, n + 1):
+            col_colors = []
+            for r in range(n):
+                if diagonalHighlight and r == (c - 1):
+                    col_colors.append(diagonalColor)
+                elif columns[c][r] == "0" or columns[c][r] == zeroChar:
+                    col_colors.append(zeroColor)
+                else:
+                    col_colors.append(valueColor)
+            fill_colors.append(col_colors)
+
+        # Minimal line style
+        line_color = "rgba(0,0,0,0.12)"
+        # --- Sizing to prevent cropped text ---
+        # Heuristic widths (pixels)
+        max_label_len = max(len(str(x)) for x in labels) if labels else 1
+        row_label_px = max(120, min(320, 8 * max_label_len))  # scale with label length
+        cell_px = 36 if n <= 30 else (30 if n <= 50 else 24)   # narrower cells for very wide matrices
+
+        # Adaptive cell font size for many columns
+        fontSize = max(fontSize, 3)
+        cell_font_size = fontSize if n <= 35 else (fontSize-1 if n <= 60 else fontSize-2)
+
+        # Figure width: row label column + all matrix columns
+        fig_width = row_label_px + n * cell_px
+        fig_width = max(600, min(2400, fig_width))  # clamp to reasonable bounds
+
+        # Increase row height a bit for readability
+        cellSize = max(cellSize, 26)
+
+        # Column widths in px (Plotly Table accepts pixel widths)
+        columnwidth = [row_label_px] + [cell_px] * n
+        fig = go.Figure(
+            data=[
+                go.Table(
+                    header=dict(
+                        values=header_values,
+                        align="center",
+                        font=dict(family=fontFamily, size=cell_font_size, color=fontColor),
+                        fill_color=headerColor,
+                        line_color=line_color,
+                        height=cellSize + 4  # a touch taller for the header
+                    ),
+                    cells=dict(
+                        values=columns,
+                        align=["right"] + ["center"] * n,
+                        font=dict(family=fontFamily, size=cell_font_size, color=fontColor),
+                        fill_color=fill_colors,
+                        line_color=line_color,
+                        height=cellSize
+                    ),
+                    columnorder=list(range(n + 1)),
+                    columnwidth=columnwidth
+                )
+            ]
+        )
+
+        # Layout: generous margins, white background, optional title
+        fig.update_layout(
+            title=dict(text=title, x=0.5, xanchor="center") if title else None,
+            paper_bgcolor="white",
+            plot_bgcolor=backgroundColor,
+            margin=dict(l=20, r=20, t=40 if title else 10, b=20)
+        )
+
+        return fig
+
     @staticmethod
     def AdjacencyList(graph, vertexKey=None, reverse=True, tolerance=0.0001):
         """

topologicpy/Helper.py

@@ -90,6 +90,53 @@ class Helper:
 
         return sorted(bin_averages)
     
+    def CheckVersion(library: str = None, version: str = None, silent: bool = False):
+        """
+        Compare an input version with the latest version of a Python library on PyPI.
+
+        Parameters
+        ----------
+        library : str
+            The input software library name. Default is None.
+        version : str
+            The input software version number to compare. Default is None.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+
+        Returns:
+            str: A message indicating whether the input version is less than,
+                equal to, or greater than the latest version on PyPI.
+        """
+        import requests
+        from packaging import version as ver
+
+        try:
+            # Fetch library data from PyPI
+            url = f"https://pypi.org/pypi/{library}/json"
+            response = requests.get(url)
+            response.raise_for_status()
+
+            # Extract the latest version from the JSON response
+            data = response.json()
+            latest_version = data['info']['version']
+
+            # Compare versions using the packaging library
+            if ver.parse(version) < ver.parse(latest_version):
+                return (f"The version that you are using ({version}) is OLDER than the latest version ({latest_version}) from PyPI. Please consider upgrading to the latest version.")
+            elif ver.parse(version) == ver.parse(latest_version):
+                return (f"The version that you are using ({version}) is EQUAL TO the latest version available on PyPI.")
+            else:
+                return (f"The version that you are using ({version}) is NEWER than the latest version ({latest_version}) available from PyPI.")
+
+        except requests.exceptions.RequestException as e:
+            if not silent:
+                print("Helper.CheckVersion - Error: Could not fetch data from PyPI. Returning None")
+            return None
+        except KeyError:
+            if not silent:
+                print("Helper.CheckVersion - Error: Could not fetch data from PyPI. Returning None")
+            return None
+    
     @staticmethod
     def ClosestMatch(item, listA):
         """
@@ -788,58 +835,25 @@ class Helper:
         return returnList
     
     @staticmethod
-    def Version():
+    def Version(check: bool = True, silent: bool = False):
         """
         Returns the current version of the software.
 
         Parameters
         ----------
-
+        check : bool , optional
+            if set to True, the version number is checked with the latest version on PyPi. Default is True.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+        
         Returns
         -------
         str
-            The current version of the software.
+            The current version of the software. Optionally, includes a check with PyPi.
 
         """
         
-        import requests
-        from packaging import version
-
-        def compare_version_with_pypi(library_name, input_version):
-            """
-            Compare an input version with the latest version of a Python library on PyPI.
-
-            Args:
-                library_name (str): The name of the Python library on PyPI.
-                input_version (str): The version number to compare (e.g., "0.7.58").
-
-            Returns:
-                str: A message indicating whether the input version is less than,
-                    equal to, or greater than the latest version on PyPI.
-            """
-            try:
-                # Fetch library data from PyPI
-                url = f"https://pypi.org/pypi/{library_name}/json"
-                response = requests.get(url)
-                response.raise_for_status()
-
-                # Extract the latest version from the JSON response
-                data = response.json()
-                latest_version = data['info']['version']
-
-                # Compare versions using the packaging library
-                if version.parse(input_version) < version.parse(latest_version):
-                    return (f"The version that you are using ({input_version}) is OLDER than the latest version {latest_version} from PyPI. Please consider upgrading to the latest version.")
-                elif version.parse(input_version) == version.parse(latest_version):
-                    return (f"The version that you are using ({input_version}) is the latest version available on PyPI.")
-                else:
-                    return (f"The version that you are using ({input_version}) is NEWER than the latest version ({latest_version}) available from PyPI.")
-
-            except requests.exceptions.RequestException as e:
-                return f"Error fetching data from PyPI: {e}"
-            except KeyError:
-                return "Error: Unable to find the latest version in the PyPI response."
-        
-        current_version = topologicpy.__version__
-        result = compare_version_with_pypi("topologicpy", current_version)
+        result = topologicpy.__version__
+        if check == True:
+            result = Helper.CheckVersion("topologicpy", result, silent=silent)
         return result

topologicpy/Honeybee.py

@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU Affero General Public License along with
 # this program. If not, see <https://www.gnu.org/licenses/>.
 
+from __future__ import annotations
 import os
 import warnings
 
@@ -112,6 +113,530 @@ import json
 import topologic_core as topologic
 
 class Honeybee:
+    @staticmethod
+    def ByHBJSONDictionary(
+        dictionary,
+        includeRooms: bool = True,
+        includeFaces: bool = True,
+        includeShades: bool = True,
+        includeApertures: bool = True,
+        includeDoors: bool = True,
+        includeOrphanedRooms: bool = True,
+        includeOrphanedFaces: bool = True,
+        includeOrphanedShades: bool = True,
+        includeOrphanedApertures: bool = True,
+        includeOrphanedDoors: bool = True,
+        tolerance: float = 0.0001,
+        silent: bool = False):
+        """
+        Import an HBJSON model from a python dictionary and return a python dictionary. See: https://github.com/ladybug-tools/honeybee-schema/wiki/1.1-Model-Schema
+        
+        Parameters
+        ----------
+        dictionary : dict
+            The HBJSON model as a Python dictionary (e.g., loaded via ``json.load``).
+        includeRooms : bool, optional
+            If True, parse rooms and attempt to create one ``Cell`` per room. Default is True.
+        includeFaces : bool, optional
+            If True, include top-level planar faces found outside rooms (e.g., at root "faces"). Default is True.
+        includeShades : bool, optional
+            If True, include context/standalone shades (e.g., ``context_geometry.shades``). Default is True.
+        includeApertures : bool, optional
+            If True, include **room** apertures (e.g., windows) as separate ``Face`` objects (not cut from hosts). Default is True.
+        includeDoors : bool, optional
+            If True, include **room** doors as separate ``Face`` objects (not cut from hosts). Default is True.
+        includeOrphanedRooms : bool, optional
+            If True, include the topology of the room when a room fails to close as a ``Cell``. This may be a ``Shell`` or a ``Cluster``. Default is True.
+        includeOrphanedFaces : bool, optional
+            If True, include planar faces listed at the HBJSON root (e.g., "faces"). Default is True.
+        includeOrphanedShades : bool, optional
+            If True, include shades listed at the HBJSON root (e.g., "orphaned_shades"). Default is True.
+        includeOrphanedApertures : bool, optional
+            If True, include apertures listed at the HBJSON root (e.g., "orphaned_apertures"). Default is True.
+        includeOrphanedDoors : bool, optional
+            If True, include doors listed at the HBJSON root (e.g., "orphaned_doors"). 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
+        -------
+        dict
+            The created cluster of vertices, edges, faces, and cells.
+            - 'rooms': list of Cells (one per successfully closed room)
+            - 'faces': list of Faces (all faces that make up the rooms)
+            - 'shades': list of Faces (all shade faces)
+            - 'apertures': list of Faces (all apertures, never cut from hosts)
+            - 'doors': list of Faces (all doors, never cut from hosts)
+            - 'orphanedRooms': list of Topologies (context/top-level topologies (e.g. Shells or Clustser) that failed to form a Cell)
+            - 'orphanedFaces': list of Faces (context/top-level faces + host faces of rooms that failed to form a Cell)
+            - 'orphanedShades': list of Faces (context/top-level shade faces that failed to have a parent cell)
+            - 'orphanedApertures': list of Faces (apertures that failed to have a parent face)
+            - 'orphanedDoors': list of Faces (doors that failed to have a parent face)
+            - 'properties': hierarchical dict copied verbatim from HBJSON['properties']
+        """
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Shell import Shell
+        from topologicpy.Cell import Cell
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+        from typing import Any, Dict, List, Optional, Tuple
+
+        if not isinstance(dictionary, dict):
+            if not silent:
+                print("Honeybee.ByHBJSONDictionary - Error: The input dictionary parameter is not a valid python dictionary. Returning None.")
+            return None
+
+        # ---------------------- helpers ----------------------
+        def _close(points: List[List[float]]) -> List[List[float]]:
+            if not points:
+                return points
+            p0, pN = points[0], points[-1]
+            if (abs(p0[0]-pN[0]) > tolerance or
+                abs(p0[1]-pN[1]) > tolerance or
+                abs(p0[2]-pN[2]) > tolerance):
+                return points + [p0]
+            return points
+
+        def _V(p: List[float]) -> Vertex:
+            return Vertex.ByCoordinates(float(p[0]), float(p[1]), float(p[2]))
+
+        # Tolerance-filtered wire (your spec)
+        def _wire(points: List[List[float]], tolerance: float = 1e-6) -> Wire:
+            pts = _close(points)
+            verts = [_V(x) for x in pts]
+            edges = [
+                Edge.ByVertices(verts[i], verts[i+1], tolerance=tolerance, silent=True)
+                for i in range(len(verts)-1)
+                if Vertex.Distance(verts[i], verts[i+1]) > tolerance
+            ]
+            w = None
+            try:
+                w = Wire.ByEdges(edges, tolerance=tolerance, silent=True)
+            except:
+                w = Topology.SelfMerge(Cluster.ByTopologies(edges), tolerance=tolerance)
+            if w == None:
+                if not silent:
+                    print("Honeybee.ByHBSJONDictionary - Error: Could not build wire. Returning None.")
+            return w
+
+        def _face_from_boundary(boundary: List[List[float]]) -> Face:
+            w = _wire(boundary, tolerance)
+            if w:
+                f = Face.ByWire(w, tolerance=tolerance, silent=True)
+                if not f:
+                    if not silent:
+                        print("Honeybee.ByHBSJONDictionary - Error: Could not build face. Returning the wire")
+                    return w
+                return f
+            if not silent:
+                print("Honeybee.ByHBSJONDictionary - Error: Could not build face. Returning None")
+            return None
+
+        def _attach_all(top: Topology, full_py_dict: Dict[str, Any]) -> Topology:
+            # Attach the entire available dict (no filtering)
+            try:
+                keys = list(full_py_dict.keys())
+                values = [full_py_dict[k] for k in keys]
+                d = Dictionary.ByKeysValues(keys, values)
+                return Topology.SetDictionary(top, d)
+            except Exception:
+                return top  # be robust to non-serializable values
+
+        def _build_host_face_cut_holes(fobj: Dict[str, Any]) -> Optional[Face]:
+            """
+            Build host face from outer boundary and cut ONLY explicit 'holes' (NOT apertures/doors).
+            Attach the full fobj dict.
+            """
+            geom = fobj.get("geometry") or {}
+            boundary = geom.get("boundary") or fobj.get("boundary")
+            holes = geom.get("holes") or fobj.get("holes") or []
+
+            if not boundary or len(boundary) < 3:
+                return None
+
+            hosts = _face_from_boundary(boundary)
+            if Topology.IsInstance(hosts, "face") or Topology.IsInstance(hosts, "wire"):
+                hosts = [hosts]
+
+            for host in hosts:
+                # Subtract explicit hole loops (if any)
+                hole_faces: List[Face] = []
+                for h in holes:
+                    if h and len(h) >= 3:
+                        hole_faces.append(_face_from_boundary(h))
+
+                if hole_faces:
+                    hole_cluster = Cluster.ByTopologies(hole_faces)
+                    try:
+                        host = Topology.Difference(host, hole_cluster)
+                    except Exception as e:
+                        if not silent:
+                            name = fobj.get("identifier") or fobj.get("name") or "unnamed"
+                            print(f"HBJSON Import: Hole cutting failed on face '{name}'. Keeping uncut. Error: {e}")
+                _attach_all(host, fobj)
+            return hosts
+
+        def _aperture_faces_from(fobj: Dict[str, Any], kind: str) -> List[Face]:
+            """
+            Build separate faces for apertures/doors on a host (DO NOT cut from host).
+            'kind' ∈ {'apertures','doors'}. Attach full dict for each.
+            """
+            out: List[Face] = []
+            ap_list = fobj.get(kind) or []
+            for ap in ap_list:
+                g = ap.get("geometry") or {}
+                boundary = g.get("boundary") or ap.get("boundary")
+                if not boundary or len(boundary) < 3:
+                    continue
+                f = _face_from_boundary(boundary)
+                out.append(_attach_all(f, ap))
+            return out
+
+        def _orphaned_aperture_faces(ap_list: List[Dict[str, Any]]) -> List[Face]:
+            out: List[Face] = []
+            for ap in ap_list or []:
+                g = ap.get("geometry") or {}
+                boundary = g.get("boundary") or ap.get("boundary")
+                if not boundary or len(boundary) < 3:
+                    continue
+                f = _face_from_boundary(boundary)
+                out.append(_attach_all(f, ap))
+            return out
+
+        def _room_to_cell_and_apertures(room: Dict[str, Any]) -> Tuple[Optional[Cell], List[Face], List[Face]]:
+            """
+            Build host faces (cut 'holes' only) and aperture faces for a room.
+            Return (cell_or_none, host_faces, aperture_faces).
+            """
+            hb_faces = room.get("faces") or room.get("Faces") or []
+            rm_faces: List[Face] = []
+            sh_faces = room.get("shades") or room.get("Shades") or []
+            ap_faces: List[Face] = []
+            dr_faces: List[Face] = []
+
+
+            for fobj in hb_faces:
+                hosts = _build_host_face_cut_holes(fobj)
+                if hosts:
+                    rm_faces.extend(hosts)
+                ap_faces.extend(_aperture_faces_from(fobj, "apertures"))
+                dr_faces.extend(_aperture_faces_from(fobj, "doors"))
+            
+            # Room Shades
+            for sh in sh_faces:
+                shades = _build_host_face_cut_holes(sh)
+                if shades:
+                    sh_faces.extend(shades)
+            # Try to make a Cell. If it fails, we DO NOT return a Shell/Cluster in rooms;
+            # instead we will salvage host faces into the 'faces' bucket.
+            if rm_faces:
+                selectors = []
+                for rm_face in rm_faces:
+                    s = Topology.InternalVertex(rm_face)
+                    face_d = Topology.Dictionary(rm_face)
+                    s = Topology.SetDictionary(s, face_d)
+                    selectors.append(s)
+                cell = Cell.ByFaces(Helper.Flatten(rm_faces), tolerance=0.001, silent=True)
+                if Topology.IsInstance(cell, "cell"):
+                    cell = _attach_all(cell, room)  # attach full room dict
+                else:
+                    cell = Shell.ByFaces(Helper.Flatten(rm_faces), tolerance=0.001, silent=True)
+                    if not cell:
+                        cell = Cluster.ByTopologies(Helper.Flatten(rm_faces), silent=True)
+                if Topology.IsInstance(cell, "topology"):
+                    cell = _attach_all(cell, room)  # attach full room dict
+                
+                if Topology.IsInstance(cell, "Topology"):
+                    cell = Topology.TransferDictionariesBySelectors(cell, selectors,tranFaces=True, numWorkers=1)
+                return cell, rm_faces, sh_faces, ap_faces, dr_faces
+            # No host faces -> no cell
+            return None, [], sh_faces, ap_faces, dr_faces
+
+        rooms: List[Cell] = []
+        faces: List[Face] = []
+        shades: List[Face] = []
+        apertures: List[Face] = []
+        doors: List[Face] = []
+        orphaned_rooms: List[Cell] = []
+        orphaned_faces: List[Face] = []
+        orphaned_shades: List[Face] = []
+        orphaned_apertures: List[Face] = []
+        orphaned_doors: List[Face] = []
+
+        # Rooms → Cells (when possible) + collect apertures. If a Cell cannot be made,
+        # the room goes to the orphaned_rooms list.
+        for room in (dictionary.get("rooms") or dictionary.get("Rooms") or []):
+            cell, host_faces, sh_faces, ap_faces, dr_faces = _room_to_cell_and_apertures(room)
+
+            if includeRooms and Topology.IsInstance(cell, "cell"):
+                rooms.append(cell)
+            elif includeOrphanedRooms and Topology.IsInstance(cell, "topology"):
+                orphaned_rooms.append(cell)
+            if cell:
+                if includeFaces and host_faces:
+                    faces.extend(host_faces)
+                if includeShades and sh_faces:
+                    shades.extend(sh_faces)
+                if includeApertures and ap_faces:
+                    apertures.extend(ap_faces)
+                if includeDoors and dr_faces:
+                    doors.extend(dr_faces)
+
+        # Explicit orphaned faces → 'orphaned_faces'
+        if includeOrphanedFaces:
+            explicit_orphaned_faces = dictionary.get("orphaned_faces") or dictionary.get("OrphanedFaces") or []
+            for f in explicit_orphaned_faces:
+                hf = _build_host_face_cut_holes(f)
+                if hf:
+                    orphaned_faces.extend(hf)
+            # Some files also place planar surfaces at top-level 'faces'
+            for fobj in (dictionary.get("faces") or dictionary.get("Faces") or []):
+                hf = _build_host_face_cut_holes(fobj)
+                if hf:
+                    orphaned_faces.extend(hf)
+        
+        # Explicit orphaned shades (and/or context shades)
+        if includeOrphanedShades:
+            explicit_orphaned_shades = dictionary.get("orphaned_shades") or dictionary.get("OrphanedShades") or []
+            for s in explicit_orphaned_shades:
+                hf = _build_host_face_cut_holes(s)
+                if hf:
+                    orphaned_shades.extend(hf)
+
+            ctx = dictionary.get("context_geometry") or dictionary.get("Context") or {}
+            shade_list = []
+            if isinstance(ctx, dict):
+                shade_list = ctx.get("shades") or ctx.get("Shades") or []
+            elif isinstance(ctx, list):
+                shade_list = ctx
+            for s in shade_list:
+                hf = _build_host_face_cut_holes(s)
+                if hf:
+                    orphaned_shades.extend(hf)
+            # Some files might also place planar shade surfaces at top-level 'shades'
+            for fobj in (dictionary.get("shades") or dictionary.get("Shades") or []):
+                hf = _build_host_face_cut_holes(fobj)
+                if hf:
+                    orphaned_shades.extend(hf)
+
+        # Explicit orphaned apertures → 'orphaned_apertures'
+        if includeOrphanedApertures:
+            orphaned_ap_list = dictionary.get("orphaned_apertures") or dictionary.get("OrphanedApertures") or []
+            if orphaned_ap_list:
+                orphaned_apertures.extend(_orphaned_aperture_faces(orphaned_ap_list))
+        
+         # Explicit orphaned doors → 'orphaned_doors'
+        if includeOrphanedDoors:
+            orphaned_dr_list = dictionary.get("orphaned_doors") or dictionary.get("OrphanedDoors") or []
+            if orphaned_dr_list:
+                orphaned_doors.extend(_orphaned_aperture_faces(orphaned_dr_list)) #You can use the same function as apertures.
+
+        # Properties → hierarchical dict verbatim
+        props_root = dictionary.get("properties") or dictionary.get("Properties") or {}
+        properties = {
+            "radiance": props_root.get("radiance") or props_root.get("Radiance") or {},
+            "energy": props_root.get("energy") or props_root.get("Energy") or {},
+        }
+
+        return {
+            "rooms": rooms,
+            "faces": faces,
+            "shades": shades,
+            "apertures": apertures,
+            "doors": doors,
+            "orphanedRooms": orphaned_rooms,
+            "orphanedFaces": orphaned_faces,
+            "orphanedShades": orphaned_shades,
+            "orphanedApertures": orphaned_apertures,
+            "orphanedDoors": orphaned_doors,
+            "properties": properties
+        }
+    
+    @staticmethod
+    def ByHBJSONPath(
+        path: str,
+        includeRooms: bool = True,
+        includeFaces: bool = True,
+        includeShades: bool = True,
+        includeApertures: bool = True,
+        includeDoors: bool = True,
+        includeOrphanedRooms: bool = True,
+        includeOrphanedFaces: bool = True,
+        includeOrphanedShades: bool = True,
+        includeOrphanedApertures: bool = True,
+        includeOrphanedDoors: bool = True,
+        tolerance: float = 0.0001,
+        silent: bool = False):
+        """
+        Import an HBJSON model from a file path and return a python dictionary. See: https://github.com/ladybug-tools/honeybee-schema/wiki/1.1-Model-Schema
+        
+        Parameters
+        ----------
+        dictionary : dict
+            The HBJSON model as a Python dictionary (e.g., loaded via ``json.load``).
+        includeRooms : bool, optional
+            If True, parse rooms and attempt to create one ``Cell`` per room. Default is True.
+        includeFaces : bool, optional
+            If True, include top-level planar faces found outside rooms (e.g., at root "faces"). Default is True.
+        includeShades : bool, optional
+            If True, include context/standalone shades (e.g., ``context_geometry.shades``). Default is True.
+        includeApertures : bool, optional
+            If True, include **room** apertures (e.g., windows) as separate ``Face`` objects (not cut from hosts). Default is True.
+        includeDoors : bool, optional
+            If True, include **room** doors as separate ``Face`` objects (not cut from hosts). Default is True.
+        includeOrphanedRooms : bool, optional
+            If True, include the topology of the room when a room fails to close as a ``Cell``. This may be a ``Shell`` or a ``Cluster``. Default is True.
+        includeOrphanedFaces : bool, optional
+            If True, include planar faces listed at the HBJSON root (e.g., "faces"). Default is True.
+        includeOrphanedShades : bool, optional
+            If True, include shades listed at the HBJSON root (e.g., "orphaned_shades"). Default is True.
+        includeOrphanedApertures : bool, optional
+            If True, include apertures listed at the HBJSON root (e.g., "orphaned_apertures"). Default is True.
+        includeOrphanedDoors : bool, optional
+            If True, include doors listed at the HBJSON root (e.g., "orphaned_doors"). 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
+        -------
+        dict
+            The created cluster of vertices, edges, faces, and cells.
+            - 'rooms': list of Cells (one per successfully closed room)
+            - 'faces': list of Faces (all faces that make up the rooms)
+            - 'shades': list of Faces (all shade faces)
+            - 'apertures': list of Faces (all apertures, never cut from hosts)
+            - 'doors': list of Faces (all doors, never cut from hosts)
+            - 'orphanedRooms': list of Topologies (context/top-level topologies (e.g. Shells or Clustser) that failed to form a Cell)
+            - 'orphanedFaces': list of Faces (context/top-level faces + host faces of rooms that failed to form a Cell)
+            - 'orphanedShades': list of Faces (context/top-level shade faces that failed to have a parent cell)
+            - 'orphanedApertures': list of Faces (apertures that failed to have a parent face)
+            - 'orphanedDoors': list of Faces (doors that failed to have a parent face)
+            - 'properties': hierarchical dict copied verbatim from HBJSON['properties']
+        """
+
+        import json
+        if not path:
+            if not silent:
+                print("Honeybee.ByHBJSONPath - Error: the input path parameter is not a valid path. Returning None.")
+            return None
+        with open(path) as file:
+            try:
+                hbjson_dict = json.load(file)
+            except:
+                if not silent:
+                    print("Honeybee.ByHBJSONPath - Error: Could not open the HBJSON file. Returning None.")
+                    return None
+        return Honeybee.ByHBJSONDictionary(hbjson_dict,
+                                             includeRooms = includeRooms,
+                                             includeFaces = includeFaces,
+                                             includeShades = includeShades,
+                                             includeApertures = includeApertures,
+                                             includeDoors = includeDoors,
+                                             includeOrphanedRooms = includeOrphanedRooms,
+                                             includeOrphanedFaces = includeOrphanedFaces,
+                                             includeOrphanedShades = includeOrphanedShades,
+                                             includeOrphanedApertures = includeOrphanedApertures,
+                                             includeOrphanedDoors = includeOrphanedDoors,
+                                             tolerance = tolerance,
+                                             silent = silent)
+    
+    @staticmethod
+    def ByHBJSONString(
+        string,
+        includeRooms: bool = True,
+        includeFaces: bool = True,
+        includeShades: bool = True,
+        includeApertures: bool = True,
+        includeDoors: bool = True,
+        includeOrphanedRooms: bool = True,
+        includeOrphanedFaces: bool = True,
+        includeOrphanedShades: bool = True,
+        includeOrphanedApertures: bool = True,
+        includeOrphanedDoors: bool = True,
+        tolerance: float = 0.0001,
+        silent: bool = False):
+        """
+        Import an HBJSON model from a file path and return a python dictionary. See: https://github.com/ladybug-tools/honeybee-schema/wiki/1.1-Model-Schema
+        
+        Parameters
+        ----------
+        string : str
+            The HBJSON model as a string.
+        includeRooms : bool, optional
+            If True, parse rooms and attempt to create one ``Cell`` per room. Default is True.
+        includeFaces : bool, optional
+            If True, include top-level planar faces found outside rooms (e.g., at root "faces"). Default is True.
+        includeShades : bool, optional
+            If True, include context/standalone shades (e.g., ``context_geometry.shades``). Default is True.
+        includeApertures : bool, optional
+            If True, include **room** apertures (e.g., windows) as separate ``Face`` objects (not cut from hosts). Default is True.
+        includeDoors : bool, optional
+            If True, include **room** doors as separate ``Face`` objects (not cut from hosts). Default is True.
+        includeOrphanedRooms : bool, optional
+            If True, include the topology of the room when a room fails to close as a ``Cell``. This may be a ``Shell`` or a ``Cluster``. Default is True.
+        includeOrphanedFaces : bool, optional
+            If True, include planar faces listed at the HBJSON root (e.g., "faces"). Default is True.
+        includeOrphanedShades : bool, optional
+            If True, include shades listed at the HBJSON root (e.g., "orphaned_shades"). Default is True.
+        includeOrphanedApertures : bool, optional
+            If True, include apertures listed at the HBJSON root (e.g., "orphaned_apertures"). Default is True.
+        includeOrphanedDoors : bool, optional
+            If True, include doors listed at the HBJSON root (e.g., "orphaned_doors"). 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
+        -------
+        dict
+            The created cluster of vertices, edges, faces, and cells.
+            - 'rooms': list of Cells (one per successfully closed room)
+            - 'faces': list of Faces (all faces that make up the rooms)
+            - 'shades': list of Faces (all shade faces)
+            - 'apertures': list of Faces (all apertures, never cut from hosts)
+            - 'doors': list of Faces (all doors, never cut from hosts)
+            - 'orphanedRooms': list of Topologies (context/top-level topologies (e.g. Shells or Clustser) that failed to form a Cell)
+            - 'orphanedFaces': list of Faces (context/top-level faces + host faces of rooms that failed to form a Cell)
+            - 'orphanedShades': list of Faces (context/top-level shade faces that failed to have a parent cell)
+            - 'orphanedApertures': list of Faces (apertures that failed to have a parent face)
+            - 'orphanedDoors': list of Faces (doors that failed to have a parent face)
+            - 'properties': hierarchical dict copied verbatim from HBJSON['properties']
+        """
+
+        if not isinstance(string, str):
+            if not silent:
+                print("Honeybee.ByHBJSONString - Error: The input string parameter is not a valid string. Returning None.")
+            return None
+        hbjson_dict = json.loads(string)
+        if not isinstance(hbjson_dict, dict):
+            if not silent:
+                print("Honeybee.ByHBJSONString - Error: Could not convert the input string into a valid HBJSON dictionary. Returning None.")
+            return None
+        return Honeybee.ByHBJSONDictionary(hbjson_dict,
+                                           includeRooms = includeRooms,
+                                           includeFaces = includeFaces,
+                                           includeShades = includeShades,
+                                           includeApertures = includeApertures,
+                                           includeDoors = includeDoors,
+                                           includeOrphanedRooms = includeOrphanedRooms,
+                                           includeOrphanedFaces = includeOrphanedFaces,
+                                           includeOrphanedShades = includeOrphanedShades,
+                                           includeOrphanedApertures = includeOrphanedApertures,
+                                           includeOrphanedDoors = includeOrphanedDoors,
+                                           tolerance = tolerance,
+                                           silent = silent)
+    
     @staticmethod
     def ConstructionSetByIdentifier(id):
         """
@@ -175,7 +700,7 @@ class Honeybee:
             path = path+".hbjson"
         
         if not overwrite and exists(path):
-            print("DGL.ExportToHBJSON - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
+            print("Honeybee.ExportToHBJSON - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
             return None
         f = None
         try:
@@ -184,7 +709,7 @@ class Honeybee:
             else:
                 f = open(path, "x") # Try to create a new File
         except:
-            print("DGL.ExportToHBJSON - Error: Could not create a new file at the following location: "+path+". Returning None.")
+            print("Honeybee.ExportToHBJSON - Error: Could not create a new file at the following location: "+path+". Returning None.")
             return None
         if (f):
             json.dump(model.to_dict(), f, indent=4)

topologicpy/Plotly.py

@@ -1447,8 +1447,10 @@ class Plotly:
         ----------
         matrix : list or numpy.array
             The matrix to display.
-        categories : list
-            The list of categories to use on the X and Y axes.
+        xCategories : list
+            The list of categories to use on the X axis.
+        yCategories : list
+            The list of categories to use on the Y axis.
         minValue : float , optional
             The desired minimum value to use for the color scale. If set to None, the minmum value found in the input matrix will be used. Default is None.
         maxValue : float , optional

topologicpy/Topology.py

@@ -8699,6 +8699,23 @@ class Topology():
         if showFigure:
             Plotly.Show(figure=figure, renderer=renderer, camera=camera, center=center, up=up, projection=projection)
             return None
+        if "ortho" in projection.lower():
+            camera_settings = dict(eye=dict(x=camera[0], y=camera[1], z=camera[2]),
+                                center=dict(x=center[0], y=center[1], z=center[2]),
+                                up=dict(x=up[0], y=up[1], z=up[2]),
+                                projection=dict(type="orthographic"))
+        else:
+            camera_settings = dict(eye=dict(x=camera[0], y=camera[1], z=camera[2]),
+                                center=dict(x=center[0], y=center[1], z=center[2]),
+                                up=dict(x=up[0], y=up[1], z=up[2]),
+                                projection=dict(type="perspective"))
+
+        figure.update_layout(
+            scene_camera = camera_settings,
+            scene=dict(aspectmode="data"),
+            autosize=True,
+            margin=dict(l=40, r=40, t=40, b=40)
+            )
         return figure
 
     @staticmethod

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.52'
+__version__ = '0.8.55'

{topologicpy-0.8.52.dist-info → topologicpy-0.8.55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.52
+Version: 0.8.55
 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.52.dist-info → topologicpy-0.8.55.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=-QoKvAsLjKp4xXO1bXCIpKdKNrPF7o232QTj60WCADE,177462
+topologicpy/Cell.py,sha256=ndrfovjwEEQTJ0B5DuthuCBDdVg9-1i_MX8Dtj-wD4E,177330
 topologicpy/CellComplex.py,sha256=Kbz63rGeE08bJfMXFvB-AptoKHiaCK5OtiV1wz8Y-Fk,68081
 topologicpy/Cluster.py,sha256=G49AuhJHQ1s819cB5MtVdmAGgkag19IC3dRP1ub1Wh4,58608
 topologicpy/Color.py,sha256=hzSmgBWhiuYc55RSipkQNIgGtgyhC5BqY8AakNYEK-U,24486
@@ -10,29 +10,29 @@ topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
 topologicpy/DGL.py,sha256=O7r22ss0tgak4kWaACkyExhR_rZ46O_bqIBpxAcwJkw,138918
 topologicpy/Dictionary.py,sha256=Z4YQ88tONWd-0X0dENQ8IZqIOa9mbBqhJkTBsHmft2g,44619
 topologicpy/Edge.py,sha256=DifItuyabFDUFC7CVMlt2DeMFMNaGOqCg43iU9CPP0A,74029
-topologicpy/EnergyModel.py,sha256=IiBJNx7F9-8TPMaQn1iQON1ZtTv2nT5kbZHxM_gBCTQ,53773
+topologicpy/EnergyModel.py,sha256=hB1aiJe45gdDMFm1AhkBr-1djjtXSzn24iRpQMk43-4,57749
 topologicpy/Face.py,sha256=aX9EcR3JGbLITElhd25J0Z8m9U8KkmbYivGg3oZN-Uw,202296
-topologicpy/Graph.py,sha256=o6aK18tCTkfzsNFOTAU-wIPG2p3g_vpm6n7YHc44bYU,691239
+topologicpy/Graph.py,sha256=Oa0oOrPoOSUGL5fvJYHBH_r6kRZ944wk-P828GyAjk4,705757
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
-topologicpy/Helper.py,sha256=aGmndgmEztjVNU-wW9OoHDel7wzapprM0TjA7f2AoS8,31188
-topologicpy/Honeybee.py,sha256=C7Am0kCK3a5rt7Jpu2EIgqeR114ZJWtsx4_DBcr5hQA,21716
+topologicpy/Helper.py,sha256=Nr6pyzl0sZm4Cu11wOqoYKu6yYal5N6A9jErXnaZBJc,31765
+topologicpy/Honeybee.py,sha256=DzaG9wpkJdcDWcjOGXhuN5X0gCqypmZGBa1y5E2MkjU,48964
 topologicpy/Matrix.py,sha256=bOofT34G3YHu9aMIWx60YHAJga4R0GbDjsZBUD4Hu_k,22706
 topologicpy/Neo4j.py,sha256=J8jU_mr5-mWC0Lg_D2dMjMlx1rY_eh8ks_aubUuTdWw,22319
-topologicpy/Plotly.py,sha256=RXGeEBwVs8unJaT9vv_FBmAFfKd-1Z5x3V8oeKE43Bs,122924
+topologicpy/Plotly.py,sha256=kF7JwBMWJQAuGezaJYI6Cq7ErNwEtcKzaExOfdGPIMc,123003
 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=ioO4raCJfXtYldQg-adpcLVeJPEA6od6cAA5ro7t6r4,96792
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=8S6dhCKfOhUGVny-jEk87Q08anLYMB1JEBKRGCklvbQ,36670
-topologicpy/Topology.py,sha256=Oz6I0jerzgXJaOEAS-WZVko5wj4_PYq67UH707jpwE0,471685
+topologicpy/Topology.py,sha256=R5Ac3V_ADDRDZjhpcNvhM3AvDOLU6ORvB3yILyEkxnI,472559
 topologicpy/Vector.py,sha256=pEC8YY3TeHGfGdeNgvdHjgMDwxGabp5aWjwYC1HSvMk,42236
 topologicpy/Vertex.py,sha256=0f6HouARKaCuxhdxsUEYi8T9giJycnWhQ8Cn70YILBA,84885
 topologicpy/Wire.py,sha256=gjgQUGHdBdXUIijgZc_VIW0E39w-smaVhhdl0jF63fQ,230466
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=KGLw5DoKAzuYOCwcR3luB2Dw4oq0tDBaQ67alLPVna8,23
-topologicpy-0.8.52.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.52.dist-info/METADATA,sha256=haOTIpPxEwBfVeLm4SOIow_qanvOQ-4bzWRFNCGnWPg,10535
-topologicpy-0.8.52.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.52.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.52.dist-info/RECORD,,
+topologicpy/version.py,sha256=EKCMooHLmkTpTBR1XTlkHxj-YkXZosf7ysuCeCcjiR8,23
+topologicpy-0.8.55.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.55.dist-info/METADATA,sha256=BIWmEWd275UZuMnl423fCxI3Bv6-vZpot8niPNApQAE,10535
+topologicpy-0.8.55.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.55.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.55.dist-info/RECORD,,