topologicpy 0.4.11__tar.gz → 0.4.13__tar.gz

{topologicpy-0.4.11/src/topologicpy.egg-info → topologicpy-0.4.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.4.11
+Version: 0.4.13
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 Project-URL: Homepage, https://github.com/wassimj/TopologicPy

{topologicpy-0.4.11 → topologicpy-0.4.13}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "topologicpy"
-version = "0.4.11"
+version = "0.4.13"
 authors = [
   { name="Wassim Jabi", email="wassim.jabi@gmail.com" },
 ]
@@ -17,7 +17,6 @@ classifiers = [
 ]
 dependencies = [
     "numpy",
-    "scipy",
     "tqdm",
     "plotly",
 ]

{topologicpy-0.4.11 → topologicpy-0.4.13}/src/topologicpy/DGL.py

@@ -1901,7 +1901,7 @@ class DGL:
         hl_widths : list , optional
             The list of hidden layer widths. A list of [16, 32, 16] means that the model will have 3 hidden layers with number of neurons in each being 16, 32, 16 respectively from input to output. The default is [32].
         conv_layer_type : str , optional
-            THe desired type of the convultion layer. The options are "Classic", "GraphConv", "GINConv", "SAGEConv", "TAGConv", "DGN". It is case insensitive. The default is "SAGEConv".
+            The desired type of the convolution layer. The options are "Classic", "GraphConv", "GINConv", "SAGEConv", "TAGConv", "DGN". It is case insensitive. The default is "SAGEConv".
         pooling : str , optional
             The desired type of pooling. The options are "AvgPooling", "MaxPooling", or "SumPooling". It is case insensitive. The default is "AvgPooling".
         batch_size : int , optional
@@ -1911,7 +1911,7 @@ class DGL:
         use_gpu : bool , optional
             If set to True, the model will attempt to use the GPU. The default is False.
         loss_function : str , optional
-            The desired loss function. The optionals are "Cross-Entropy" or "Negative Log Likelihood". It is case insensitive. The default is "Cross-Entropy".
+            The desired loss function. The options are "Cross-Entropy" or "Negative Log Likelihood". It is case insensitive. The default is "Cross-Entropy".
 
         Returns
         -------
@@ -2334,7 +2334,7 @@ class DGL:
         yTitle : str , optional
             The Y-axis title. The default is "Accuracy and Loss".
         ySpacing : float , optional
-            THe Y-axis spacing. The default is 0.1.
+            The Y-axis spacing. The default is 0.1.
         useMarkers : bool , optional
             If set to True, markers will be displayed. The default is False.
         chartType : str , optional
@@ -2512,7 +2512,29 @@ class DGL:
         Returns
         -------
         dict
-            A dictionary containing the model data.
+            A dictionary containing the model data. The keys in the dictionary are:
+            'Model Type'
+            'Optimizer'
+            'CV Type'
+            'Split'
+            'K-Folds'
+            'HL Widths'
+            'Conv Layer Type'
+            'Pooling'
+            'Learning Rate'
+            'Batch Size'
+            'Epochs'
+            'Training Accuracy'
+            'Validation Accuracy'
+            'Testing Accuracy'
+            'Training Loss'
+            'Validation Loss'
+            'Testing Loss'
+            'Accuracies' (Classifier and K-Fold only)
+            'Max Accuracy' (Classifier and K-Fold only)
+            'Losses' (Regressor and K-fold only)
+            'min Loss' (Regressor and K-fold only)
+
 
         """
         from topologicpy.Helper import Helper
@@ -2578,7 +2600,7 @@ class DGL:
         labelKey : str , optional
             The label key to use. The default is "value".
         key : str , optional
-            The node attributes key. THe default is 'node_attr'.
+            The node attributes key. The default is 'node_attr'.
 
         Returns
         -------

{topologicpy-0.4.11 → topologicpy-0.4.13}/src/topologicpy/Dictionary.py

@@ -74,6 +74,19 @@ class Dictionary(topologic.Dictionary):
                 stl_values.append(topologic.DoubleAttribute(value))
             elif isinstance(value, str):
                 stl_values.append(topologic.StringAttribute(value))
+            elif isinstance(value, tuple):
+                value = list(value)
+                l = []
+                for v in value:
+                    if isinstance(v, bool):
+                        l.append(topologic.IntAttribute(v))
+                    elif isinstance(v, int):
+                        l.append(topologic.IntAttribute(v))
+                    elif isinstance(v, float):
+                        l.append(topologic.DoubleAttribute(v))
+                    elif isinstance(v, str):
+                        l.append(topologic.StringAttribute(v))
+                stl_values.append(topologic.ListAttribute(l))
             elif isinstance(value, list):
                 l = []
                 for v in value:

{topologicpy-0.4.11 → topologicpy-0.4.13}/src/topologicpy/EnergyModel.py

@@ -3,6 +3,7 @@ import topologic
 from topologicpy.Topology import Topology
 from topologicpy.Dictionary import Dictionary
 
+import shutil
 import math
 from collections import OrderedDict
 import os
@@ -664,7 +665,7 @@ class EnergyModel:
         return list(OrderedDict( (x,1) for x in columnNames ).keys()) #Making a unique list and keeping its order
 
     @staticmethod
-    def Run(model, weatherFilePath: str = None, osBinaryPath : str = None, outputFolder : str = None):
+    def Run(model, weatherFilePath: str = None, osBinaryPath : str = None, outputFolder : str = None, removeFiles : bool = False):
         """
             Runs an energy simulation.
         
@@ -678,6 +679,8 @@ class EnergyModel:
             The path to the openstudio binary.
         outputFolder : str
             The path to the output folder.
+        removeFiles : bool , optional
+            If set to True, the working files are removed at the end of the process. The default is False.
 
         Returns
         -------
@@ -686,8 +689,22 @@ class EnergyModel:
 
         """
         import os
+        import time
+        def deleteOldFiles(path):
+            onemonth = (time.time()) - 30 * 86400
+            try:
+                for filename in os.listdir(path):
+                    if os.path.getmtime(os.path.join(path, filename)) < onemonth:
+                        if os.path.isfile(os.path.join(path, filename)):
+                            os.remove(os.path.join(path, filename))
+                        elif os.path.isdir(os.path.join(path, filename)):
+                            shutil.rmtree((os.path.join(path, filename)))
+            except:
+                pass
         if not weatherFilePath:
             weatherFilePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "GBR_London.Gatwick.037760_IWEC.epw")
+        if removeFiles:
+            deleteOldFiles(outputFolder)
         pbar = tqdm(desc='Running Simulation', total=100, leave=False)
         utcnow = datetime.utcnow()
         timestamp = utcnow.strftime("UTC-%Y-%m-%d-%H-%M-%S")

{topologicpy-0.4.11 → topologicpy-0.4.13}/src/topologicpy/Graph.py

@@ -1953,7 +1953,6 @@ class Graph:
             The created graph.
 
         """
-
         if not isinstance(vertices, list):
             return None
         if not isinstance(edges, list):

topologicpy-0.4.13/src/topologicpy/Neo4j.py

@@ -0,0 +1,499 @@
+import topologic
+import time
+import random
+import sys, subprocess
+
+try:
+    import py2neo
+    from py2neo import NodeMatcher,RelationshipMatcher
+    from py2neo.data import spatial as sp
+except:
+    call = [sys.executable, '-m', 'pip', 'install', 'py2neo', '-t', sys.path[0]]
+    subprocess.run(call)
+    try:
+        import py2neo
+        from py2neo import NodeMatcher,RelationshipMatcher
+        from py2neo.data import spatial as sp
+    except:
+        print("Neo4j - Error: Could not import pandas")
+
+class Neo4j:
+
+    @staticmethod
+    def NodeToVertex(node):
+        """
+        Converts the input neo4j node to a topologic vertex.
+
+        Parameters
+        ----------
+        node : Neo4j.Node
+            The input neo4j node.
+
+        Returns
+        -------
+        topologic.Vertex
+            The output topologic vertex.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        
+        if ('x' in node.keys()) and ('y' in node.keys()) and ('z' in node.keys()) or ('X' in node.keys()) and ('Y' in node.keys()) and ('Z' in node.keys()):
+            x = node['x']
+            y = node['y']
+            z = node['z']
+            vertex = Vertex.ByCoordinates(x, y, z)
+        else:
+            x = random.uniform(0, 1000)
+            y = random.uniform(0, 1000)
+            z = random.uniform(0, 1000)
+            vertex = Vertex.ByCoordinates(x, y, z)
+        keys = list(node.keys())
+        values = list(node.values())
+        d = Dictionary.ByKeysValues(keys, values)
+        vertex = Topology.SetDictionary(vertex, d)
+        return vertex
+        
+
+    @staticmethod
+    def NodesByCypher(neo4jGraph, cypher):
+        dataList = neo4jGraph.run(cypher).data()
+        nodes = []
+        for data in dataList:
+            path = data['p']
+            nodes += list(path.nodes)
+        return nodes
+
+    @staticmethod
+    def NodesBySubGraph(subGraph):
+        data = subGraph.data()
+        nodes = []
+        for data in subGraph:
+            path = data['p']
+            nodes += list(path.nodes)
+        return nodes
+
+    @staticmethod
+    def SubGraphByCypher(neo4jGraph, cypher):
+        return neo4jGraph.run(cypher).to_subgraph()
+
+    @staticmethod
+    def SubGraphExportToGraph(subGraph):
+        """
+        Exports the input neo4j graph to a topologic graph.
+
+        Parameters
+        ----------
+        subGraph : Neo4j.SubGraph
+            The input neo4j subgraph.
+
+        Returns
+        -------
+        topologic.Graph
+            The output topologic graph.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Graph import Graph
+
+        def randomVertex(vertices, minDistance):
+            flag = True
+            while flag:
+                x = random.uniform(0, 1000)
+                y = random.uniform(0, 1000)
+                z = random.uniform(0, 1000)
+                v = Vertex.ByCoordinates(x, y, z)
+                test = False
+                if len(vertices) < 1:
+                    return v
+                for vertex in vertices:
+                    d = Vertex.Distance(v, vertex)
+                    if d < minDistance:
+                        test = True
+                        break
+                if test == False:
+                    return v
+                else:
+                    continue
+        
+        nodes = subGraph.nodes
+        relationships = list(subGraph.relationships)
+        vertices = []
+        edges = []
+        for node in nodes:
+            #Check if they have X, Y, Z coordinates
+            if ('x' in node.keys()) and ('y' in node.keys()) and ('z' in node.keys()) or ('X' in node.keys()) and ('Y' in node.keys()) and ('Z' in node.keys()):
+                x = node['x']
+                y = node['y']
+                z = node['z']
+                vertex = Vertex.ByCoordinates(x, y, z)
+            else:
+                vertex = randomVertex(vertices, 1)
+            keys = list(node.keys())
+            keys.append("identity")
+            values = [node.identity]
+            for key in keys:
+                values.append(node[key])
+            d = Dictionary.ByKeysValues(keys, values)
+            vertex = Topology.SetDictionary(vertex, d)
+            vertices.append(vertex)
+        for relationship in relationships:
+            keys = list(relationship.keys())
+            keys.append("identity")
+            values = [relationship.identity]
+            for key in keys:
+                values.append(node[key])
+            sv = vertices[nodes.index(relationship.start_node)]
+            ev = vertices[nodes.index(relationship.end_node)]
+            edge = Edge.ByVertices([sv, ev])
+            if relationship.start_node['name']:
+                sv_name = relationship.start_node['name']
+            else:
+                sv_name = 'None'
+            if relationship.end_node['name']:
+                ev_name = relationship.end_node['name']
+            else:
+                ev_name = 'None'
+            d = Dictionary.ByKeysValues(["relationship_type", "from", "to"], [relationship.__class__.__name__, sv_name, ev_name])
+            if d:
+                _ = Topology.SetDictionary(edge, d)
+            edges.append(edge)
+        return Graph.ByVerticesEdges(vertices,edges)
+    
+    @staticmethod
+    def ExportToGraph(neo4jGraph):
+        """
+        Exports the input neo4j graph to a topologic graph.
+
+        Parameters
+        ----------
+        neo4jGraph : Neo4j.Graph
+            The input neo4j graph.
+
+        Returns
+        -------
+        topologic.Graph
+            The output topologic graph.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Graph import Graph
+
+        def randomVertex(vertices, minDistance):
+            flag = True
+            while flag:
+                x = random.uniform(0, 1000)
+                y = random.uniform(0, 1000)
+                z = random.uniform(0, 1000)
+                v = Vertex.ByCoordinates(x, y, z)
+                test = False
+                if len(vertices) < 1:
+                    return v
+                for vertex in vertices:
+                    d = Vertex.Distance(v, vertex)
+                    if d < minDistance:
+                        test = True
+                        break
+                if test == False:
+                    return v
+                else:
+                    continue
+        
+        node_labels =  neo4jGraph.schema.node_labels
+        relationship_types = neo4jGraph.schema.relationship_types
+        node_matcher = NodeMatcher(neo4jGraph)
+        relationship_matcher = RelationshipMatcher(neo4jGraph)
+        vertices = []
+        edges = []
+        nodes = []
+        for node_label in node_labels:
+            nodes = nodes + (list(node_matcher.match(node_label)))
+        for node in nodes:
+            #Check if they have X, Y, Z coordinates
+            if ('x' in node.keys()) and ('y' in node.keys()) and ('z' in node.keys()) or ('X' in node.keys()) and ('Y' in node.keys()) and ('Z' in node.keys()):
+                x = node['x']
+                y = node['y']
+                z = node['z']
+                vertex = Vertex.ByCoordinates(x, y, z)
+            else:
+                vertex = randomVertex(vertices, 1)
+            keys = list(node.keys())
+            values = []
+            for key in keys:
+                values.append(node[key])
+            d = Dictionary.ByKeysValues(keys, values)
+            vertex = Topology.SetDictionary(vertex, d)
+            vertices.append(vertex)
+        for node in nodes:
+            for relationship_type in relationship_types:
+                relationships = list(relationship_matcher.match([node], r_type=relationship_type))
+                for relationship in relationships:
+                    sv = vertices[nodes.index(relationship.start_node)]
+                    ev = vertices[nodes.index(relationship.end_node)]
+                    edge = Edge.ByVertices([sv, ev])
+                    if relationship.start_node['name']:
+                        sv_name = relationship.start_node['name']
+                    else:
+                        sv_name = 'None'
+                    if relationship.end_node['name']:
+                        ev_name = relationship.end_node['name']
+                    else:
+                        ev_name = 'None'
+                    d = Dictionary.ByKeysValues(["relationship_type", "from", "to"], [relationship_type, sv_name, ev_name])
+                    if d:
+                        _ = Topology.SetDictionary(edge, d)
+                    edges.append(edge)
+        return Graph.ByVerticesEdges(vertices,edges)
+    
+    @staticmethod
+    def AddGraph(neo4jGraph, graph, labelKey=None, relationshipKey=None, bidirectional=True, deleteAll=True, tolerance=0.0001):
+        """
+        Adds the input topologic graph to the input neo4j graph
+
+        Parameters
+        ----------
+        neo4jGraph : Neo4j.Graph
+            The input neo4j graph.
+        graph : topologic.Graph
+            The input topologic graph.
+        categoryKey : str
+            The category key in the dictionary under which to look for the category value.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        Neo4j.Graph
+            The input neo4j graph with the input topologic graph added to it.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        from topologicpy.Graph import Graph
+        from topologicpy.Dictionary import Dictionary
+        gmt = time.gmtime()
+        timestamp =  str(gmt.tm_zone)+"_"+str(gmt.tm_year)+"_"+str(gmt.tm_mon)+"_"+str(gmt.tm_wday)+"_"+str(gmt.tm_hour)+"_"+str(gmt.tm_min)+"_"+str(gmt.tm_sec)
+        vertices = Graph.Vertices(graph)
+        edges = Graph.Edges(graph)
+        tx = neo4jGraph.begin()
+        nodes = []
+        for  i in range(len(vertices)):
+            vDict = Topology.Dictionary(vertices[i])
+            keys = Dictionary.Keyus(vDict)
+            values = Dictionary.Values(vDict)
+            keys.append("x")
+            keys.append("y")
+            keys.append("z")
+            keys.append("timestamp")
+            keys.append("location")
+            values.append(vertices[i].X())
+            values.append(vertices[i].Y())
+            values.append(vertices[i].Z())
+            values.append(timestamp)
+            values.append(sp.CartesianPoint([vertices[i].X(),vertices[i].Y(),vertices[i].Z()]))
+            zip_iterator = zip(keys, values)
+            pydict = dict(zip_iterator)
+            if labelKey == 'None':
+                nodeName = "TopologicGraphVertex"
+            else:
+                nodeName = str(values[keys.index(labelKey)])
+            n = py2neo.Node(nodeName, **pydict)
+            neo4jGraph.cypher.execute("CREATE INDEX FOR (n:%s) on (n.name)" %
+                    n.nodelabel)
+            tx.create(n)
+            nodes.append(n)
+        for i in range(len(edges)):
+            e = edges[i]
+            sv = e.StartVertex()
+            ev = e.EndVertex()
+            sn = nodes[Vertex.Index(sv, vertices, tolerance)]
+            en = nodes[Vertex.Index(ev, vertices, tolerance)]
+            relationshipType = Dictionary.ValueAtKey(ed, relationshipKey)
+            if not (relationshipType):
+                relationshipType = "Connected To"
+            snen = py2neo.Relationship(sn, relationshipType, en)
+            tx.create(snen)
+            snen = py2neo.Relationship(en, relationshipType, sn)
+            tx.create(snen)
+        neo4jGraph.commit(tx)
+        return neo4jGraph
+
+    
+    @staticmethod
+    def ByParameters(url, username, password):
+        """
+        Returns a Neo4j graph by the input parameters.
+
+        Parameters
+        ----------
+        url : str
+            The URL of the server.
+        username : str
+            The username to use for logging in.
+        password : str
+            The password to use for logging in.
+
+        Returns
+        -------
+        Neo4j.Graph
+            The returned Neo4j graph.
+
+        """
+        return py2neo.Graph(url, auth=(username, password))
+    
+    @staticmethod
+    def DeleteAll(neo4jGraph):
+        """
+        Deletes all entities in the input Neo4j graph.
+
+        Parameters
+        ----------
+        neo4jGraph : Neo4j Graph
+            The input Neo4jGraph.
+
+        Returns
+        -------
+        Neo4J Graph
+            The returned empty graph.
+
+        """
+        neo4jGraph.delete_all()
+        return neo4jGraph
+    
+    @staticmethod
+    def NodeLabels(neo4jGraph):
+        """
+        Returns all the node labels used in the input neo4j graph.
+        
+        Parameters
+        ----------
+        neo4jGraph : Newo4j.Graph
+            The input neo4j graph.
+
+        Returns
+        -------
+        list
+            The list of node labels used in the input neo4j graph.
+
+        """
+        return list(neo4jGraph.schema.node_labels)
+    
+    @staticmethod
+    def RelationshipTypes(neo4jGraph):
+        """
+        Returns all the relationship types used in the input neo4j graph.
+        
+        Parameters
+        ----------
+        neo4jGraph : Newo4j.Graph
+            The input neo4j graph.
+
+        Returns
+        -------
+        list
+            The list of relationship types used in the input neo4j graph.
+
+        """
+        return list(neo4jGraph.schema.relationship_types)
+    
+    @staticmethod
+    def SetGraph(neo4jGraph, graph, labelKey=None, relationshipKey=None, bidirectional=True, deleteAll=True, tolerance=0.0001):
+        """
+        Sets the input topologic graph to the input neo4jGraph.
+
+        Parameters
+        ----------
+        neo4jGraph : Neo4j.Graph
+            The input neo4j graph.
+        graph : topologic.Graph
+            The input topologic graph.
+        labelKey : str , optional
+            The dictionary key under which to find the vertex's label value. The default is None which means the vertex gets the name 'TopologicGraphVertex'.
+        relationshipKey : str , optional
+            The dictionary key under which to find the edge's relationship value. The default is None which means the edge gets the relationship type 'Connected To'.
+        bidirectional : bool , optional
+            If set to True, the edges in the neo4j graph are set to be bi-drectional.
+        deleteAll : bool , optional
+            If set to True, all previous entities are deleted before adding the new entities.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        neo4jGraph : TYPE
+            The input neo4j graph with the input topologic graph added to it.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Graph import Graph
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        
+        import time
+        gmt = time.gmtime()
+        timestamp =  str(gmt.tm_zone)+"_"+str(gmt.tm_year)+"_"+str(gmt.tm_mon)+"_"+str(gmt.tm_wday)+"_"+str(gmt.tm_hour)+"_"+str(gmt.tm_min)+"_"+str(gmt.tm_sec)
+
+        vertices = Graph.Vertices(graph)
+        edges = Graph.Edges(graph)
+        tx = neo4jGraph.begin()
+        nodes = []
+        for  i in range(len(vertices)):
+            vDict = Topology.Dictionary(vertices[i])
+            if not vDict:
+                keys = []
+                values = []
+            else:
+                keys = Dictionary.Keys(vDict)
+                if not keys:
+                    keys = []
+                values = Dictionary.Values(vDict)
+                if not values:
+                    values = []
+            keys.append("x")
+            keys.append("y")
+            keys.append("z")
+            keys.append("timestamp")
+            keys.append("location")
+            values.append(vertices[i].X())
+            values.append(vertices[i].Y())
+            values.append(vertices[i].Z())
+            values.append(timestamp)
+            values.append(sp.CartesianPoint([vertices[i].X(),vertices[i].Y(),vertices[i].Z()]))
+            zip_iterator = zip(keys, values)
+            pydict = dict(zip_iterator)
+            if (labelKey == 'None') or (not (labelKey)):
+                nodeName = "TopologicGraphVertex"
+            else:
+                nodeName = str(Dictionary.ValueAtKey(vDict, labelKey))
+            n = py2neo.Node(nodeName, **pydict)
+            tx.create(n)
+            nodes.append(n)
+        for i in range(len(edges)):
+            e = edges[i]
+            sv = e.StartVertex()
+            ev = e.EndVertex()
+            sn = nodes[Vertex.Index(vertex=sv, vertices=vertices, strict=False, tolerance=tolerance)]
+            en = nodes[Vertex.Index(vertex=ev, vertices=vertices, strict=False, tolerance=tolerance)]
+            ed = Topology.Dictionary(e)
+            if relationshipKey:
+                relationshipType = Dictionary.ValueAtKey(ed, relationshipKey)
+            else:
+                relationshipType = "Connected To"
+            if not (relationshipType):
+                relationshipType = "Connected To"
+            snen = py2neo.Relationship(sn, relationshipType, en)
+            tx.create(snen)
+            if bidirectional:
+                snen = py2neo.Relationship(en, relationshipType, sn)
+                tx.create(snen)
+        if deleteAll:
+            neo4jGraph.delete_all()
+        neo4jGraph.commit(tx)
+        return neo4jGraph