merge with upstream master

helix/Services/dxf_helper.py

@@ -234,24 +234,43 @@ class DXFHelper(object):
 
             node_store.add_node(node)
 
+        # Optimization: avoid creating thousands of replicated objects
+        graph_directions_cache = {}
+        for x in (0, 1, -1):
+            for y in (0, 1, -1):
+                if x == y == 0:
+                    continue
+                graph_directions_cache[(x, y)] = GraphDirection((x, y))
+
         for node in nodes:
             if len(node.neighboring_nodes()) == 8:
                 continue
+
+            rotation = math.radians(node.coordinate.rotation)
+            # Optimization: Avoid replicate calculations thousands of times
+            x_spacing_cos_rotation = (node.x_spacing * math.cos(rotation))
+            y_spacing_sin_rotation = (node.y_spacing * math.sin(rotation))
+            x_spacing_sin_rotation = (node.x_spacing * math.sin(rotation))
+            y_spacing_cos_rotation = (node.y_spacing * math.cos(rotation))
+
             for x in (0, 1, -1):
                 for y in (0, 1, -1):
                     if x == y == 0:
                         continue
-                    rotation = math.radians(node.coordinate.rotation)
-                    x_spacing = (x * node.x_spacing * math.cos(rotation)) - (y * node.y_spacing * math.sin(rotation))
-                    y_spacing = (x * node.x_spacing * math.sin(rotation)) + (y * node.y_spacing * math.cos(rotation))
+                    x_spacing = (x * x_spacing_cos_rotation) - (y * y_spacing_sin_rotation)
+                    y_spacing = (x * x_spacing_sin_rotation) + (y * y_spacing_cos_rotation)
 
                     coordinate = Coordinate(node.coordinate.x + x_spacing, node.coordinate.y + y_spacing, node.coordinate.rotation)
                     if coordinate.x < 0 or coordinate.y < 0:
                         continue
-                    direction = GraphDirection((x, y))
+
+                    # Optimization for `direction = GraphDirection((x, y))`
+                    direction = graph_directions_cache[(x, y)]
                     if node.has_existing_neighbor(direction):
                         continue
 
+                    # FIXME: This is the bottleneck of the loop
+                    # Calling this ~10000 times needs ~20 seconds
                     neighbor = node_store.find_coordinate(coordinate)
                     if neighbor:
                         node.add_neighbor(neighbor, direction)
@@ -417,7 +436,7 @@ class DXFHelper(object):
     def __compute_segment_direction(p1, p2):
         """
         Computes direction of a segment. Points taken from building outline are assumed to be in counterclockwise order.
-        
+
         :param p1: first point
         :param p2: second point
         :return: tuple representing orientation ('north', 'south', 'east', 'west') and variation in degrees from ideally
@@ -438,7 +457,7 @@ class DXFHelper(object):
     def compute_corner_directions(vertex, prev, next, angle_correction):
         """
         Determines if point is located in north/east corner
-        
+
         :param vertex: point located in the corner
         :param prev: point previous to vertex, assuming counterclockwise order
         :param next: point next to vertex, assuming counterclockwise order
@@ -510,7 +529,7 @@ class DXFHelper(object):
     @staticmethod
     def __generate_wind_zone__(buildings, scaling_factor, points_callback, panel_orientation):
         """
-        Important: polygons representing buildings are expected to have points in counterclockwise order 
+        Important: polygons representing buildings are expected to have points in counterclockwise order
         """
 
         wind_zones = []

helix/Services/dxf_service.py

@@ -2,9 +2,6 @@ import io
 
 import dxfgrabber
 
-from helix.constants.file_validation_error import FileValidationMessage
-from helix.models.dxf.dxf_error import OldDxfFormatException
-
 
 class DXFService(object):
     """
@@ -51,6 +48,7 @@ class DXFService(object):
 
 
         panels = dxf_helper.generate_panels(modules, translated_modules)
+        # FIXME: Building a graph with many entities is very slow
         node_graph = dxf_helper.build_node_graph(panels, module_constants.panel_spacing)
         subarrays = dxf_helper.detect_subarrays(node_graph, panels)
         for subarray in subarrays:

helix/Services/s3_helper.py

@@ -0,0 +1,26 @@
+import boto3
+import os
+import uuid
+
+
+def s3_upload(bytes_or_file_like, filename=None, file_extension=None):
+    '''
+    @bytes_or_file_like: bytes(), open('filepath') or io.StringIO('')
+    '''
+    if filename is None:
+        filename = uuid.uuid4().hex
+        if file_extension:
+            filename += file_extension
+
+    s3 = boto3.resource('s3',
+        aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
+        aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY'))
+
+    # Default: test environment
+    bucket_name = os.getenv('AWS_S3_BUCKET', 'sunpower-test-dgplatform-spectrum')
+
+    # Assuming bucket already exists
+    s3.Bucket(bucket_name).put_object(Key=filename, Body=bytes_or_file_like.read(), ACL='public-read')
+    file_url = 'https://s3.amazonaws.com/{}/{}'.format(bucket_name, filename)
+    print('Uploaded filename {} to S3: {}'.format(filename, file_url))
+    return file_url