autopep8, round 1

etjones-erisyon · etjones-erisyon · commit 7d7cb062e1dc · 2015-05-23T11:10:48.000-07:00
diff --git a/Doc/conf.py b/Doc/conf.py
@@ -188,22 +188,22 @@
 # -- Options for LaTeX output ---------------------------------------------
 
 latex_elements = {
-# The paper size ('letterpaper' or 'a4paper').
-#'papersize': 'letterpaper',
+    # The paper size ('letterpaper' or 'a4paper').
+    #'papersize': 'letterpaper',
 
-# The font size ('10pt', '11pt' or '12pt').
-#'pointsize': '10pt',
+    # The font size ('10pt', '11pt' or '12pt').
+    #'pointsize': '10pt',
 
-# Additional stuff for the LaTeX preamble.
-#'preamble': '',
+    # Additional stuff for the LaTeX preamble.
+    #'preamble': '',
 }
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-  ('index', 'SolidPython.tex', 'SolidPython Documentation',
-   'Evan Jones', 'manual'),
+    ('index', 'SolidPython.tex', 'SolidPython Documentation',
+     'Evan Jones', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -246,9 +246,9 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  ('index', 'SolidPython', 'SolidPython Documentation',
-   'Evan Jones', 'SolidPython', 'One line description of project.',
-   'Miscellaneous'),
+    ('index', 'SolidPython', 'SolidPython Documentation',
+     'Evan Jones', 'SolidPython', 'One line description of project.',
+     'Miscellaneous'),
 ]
 
 # Documents to append as an appendix to all manuals.
diff --git a/setup.py b/setup.py
@@ -1,4 +1,4 @@
-# from distutils.core import setup 
+# from distutils.core import setup
 from setuptools import setup, find_packages
 
 setup(
@@ -23,6 +23,3 @@
     packages=find_packages(),
     install_requires=['euclid', 'PyPNG'],
 )
-
-
-
diff --git a/solid/patch_euclid.py b/solid/patch_euclid.py
@@ -3,40 +3,41 @@
 
 from solid.utils import *  # Only needed for EPSILON. Tacky.
 
-# NOTE: The PyEuclid on PyPi doesn't include several elements added to 
+# NOTE: The PyEuclid on PyPi doesn't include several elements added to
 # the module as of 13 Feb 2013.  Add them here until euclid supports them
 
+
 def as_arr_local(self):
-    return [ self.x, self.y, self.z]
+    return [self.x, self.y, self.z]
+
 
 def set_length_local(self, length):
     d = self.magnitude()
     if d:
-        factor = length/d
+        factor = length / d
         self.x *= factor
         self.y *= factor
-    
-    return self            
+
+    return self
+
 
 def _intersect_line3_line3(A, B):
     # Connect A & B
     # If the length of the connecting segment  is 0, they intersect
     # at the endpoint(s) of the connecting segment
     sol = euclid._connect_line3_line3(A, B)
-    # TODO: Ray3 and LineSegment3 would like to be able to know 
+    # TODO: Ray3 and LineSegment3 would like to be able to know
     # if their intersection points fall within the segment.
     if sol.magnitude_squared() < EPSILON:
         return sol.p
     else:
-        return None 
-
+        return None
 
 
-def run_patch():       
+def run_patch():
     if 'as_arr' not in dir(Vector3):
         Vector3.as_arr = as_arr_local
     if 'set_length' not in dir(Vector3):
         Vector3.set_length = set_length_local
     if '_intersect_line3' not in dir(Line3):
         Line3._intersect_line3 = _intersect_line3_line3
-
diff --git a/solid/screw_thread.py b/solid/screw_thread.py
@@ -1,21 +1,24 @@
 #! /usr/bin/env python
 # -*- coding: utf-8 -*-
-import os, sys, re
+import os
+import sys
+import re
 
 from solid import *
 from solid.utils import *
 from euclid import *
-# NOTE: The PyEuclid on PyPi doesn't include several elements added to 
+# NOTE: The PyEuclid on PyPi doesn't include several elements added to
 # the module as of 13 Feb 2013.  Add them here until euclid supports them
 # TODO: when euclid updates, remove this cruft. -ETJ 13 Feb 2013
 import solid.patch_euclid
 solid.patch_euclid.run_patch()
 
-def thread(outline_pts, inner_rad, pitch, length, external=True, segments_per_rot=32,neck_in_degrees=0, neck_out_degrees=0):
+
+def thread(outline_pts, inner_rad, pitch, length, external=True, segments_per_rot=32, neck_in_degrees=0, neck_out_degrees=0):
     '''
     Sweeps outline_pts (an array of points describing a closed polygon in XY)
     through a spiral. 
-    
+
     This is done by creating and returning one huge polyhedron, with potentially
     thousands of faces.  An alternate approach would make one single polyhedron,
     then repeat it over and over in the spiral shape, unioning them all together.  
@@ -24,10 +27,10 @@ def thread(outline_pts, inner_rad, pitch, length, external=True, segments_per_ro
     in the python, as here.  Also would take some doing to make the neck-in work
     as well.  Not sure how the two approaches compare in terms of render-time. 
     -ETJ 16 Mar 2011     
-    
+
     outline_pts: a list of points (NOT an OpenSCAD polygon) that define the cross 
             section of the thread
-            
+
     inner_rad: radius of cylinder the screw will wrap around
     pitch: height for one revolution; must be <= the height of outline_pts 
                     bounding box to avoid self-intersection
@@ -40,35 +43,35 @@ def thread(outline_pts, inner_rad, pitch, length, external=True, segments_per_ro
                     a thickness of zero (inner_rad) to its full thickness
     neck_out_degrees: degrees through which outer edge of the screw thread will move from 
                     full thickness back to zero
-                    
+
     NOTE: if pitch is less than the or equal to the height of each tooth (outline_pts), 
     OpenSCAD will likely crash, since the resulting screw would self-intersect 
     all over the place.  For screws with essentially no space between 
     threads, (i.e., pitch=tooth_height), I use pitch= tooth_height+EPSILON, 
     since pitch=tooth_height will self-intersect for rotations >=1
     '''
     a = union()
-    rotations = float(length)/pitch
-    
-    total_angle = 360.0*rotations
-    up_step = float(length) / (rotations*segments_per_rot)
+    rotations = float(length) / pitch
+
+    total_angle = 360.0 * rotations
+    up_step = float(length) / (rotations * segments_per_rot)
     # Add one to total_steps so we have total_steps *segments*
     total_steps = int(ceil(rotations * segments_per_rot)) + 1
-    step_angle = total_angle/ (total_steps -1)
-    
+    step_angle = total_angle / (total_steps - 1)
+
     all_points = []
     all_tris = []
-    euc_up = Vector3( *UP_VEC)
+    euc_up = Vector3(*UP_VEC)
     poly_sides = len(outline_pts)
-    
+
     # Figure out how wide the tooth profile is
     min_bb, max_bb = bounding_box(outline_pts)
     outline_w = max_bb[0] - min_bb[0]
     outline_h = max_bb[1] - min_bb[1]
-    
-    min_rad = max(0, inner_rad-outline_w-EPSILON)    
+
+    min_rad = max(0, inner_rad - outline_w - EPSILON)
     max_rad = inner_rad + outline_w + EPSILON
-    
+
     # outline_pts, since they were created in 2D , are in the XY plane.
     # But spirals move a profile in XZ around the Z-axis.  So swap Y and Z
     # co-ords... and hope users know about this
@@ -80,92 +83,95 @@ def thread(outline_pts, inner_rad, pitch, length, external=True, segments_per_ro
             p.append(0)
         # [x, y, z] => [ x+inner_rad, z, y]
         external_mult = 1 if external else -1
-        s =  Point3(external_mult*p[0], p[2], p[1]) # adding inner_rad, swapping Y & Z
+        # adding inner_rad, swapping Y & Z
+        s = Point3(external_mult * p[0], p[2], p[1])
         euc_points.append(s)
-        
+
     for i in range(total_steps):
-        angle = i*step_angle
-        
-        elevation = i*up_step
+        angle = i * step_angle
+
+        elevation = i * up_step
         if angle > total_angle:
             angle = total_angle
             elevation = length
-        
+
         # Handle the neck-in radius for internal and external threads
         rad = inner_rad
         int_ext_mult = 1 if external else -1
         neck_in_rad = min_rad if external else max_rad
-        
+
         if angle < neck_in_degrees:
             rad = neck_in_rad + int_ext_mult * angle / neck_in_degrees * outline_w
         elif angle > total_angle - neck_in_degrees:
-            rad = neck_in_rad + int_ext_mult * (total_angle - angle)/neck_out_degrees * outline_w
-        
+            rad = neck_in_rad + int_ext_mult * (total_angle - angle) / neck_out_degrees * outline_w
+
         elev_vec = Vector3(rad, 0, elevation)
-        
+
         # create new points
         for p in euc_points:
-            pt = (p + elev_vec).rotate_around(axis=euc_up, theta=radians(angle))
+            pt = (
+                p + elev_vec).rotate_around(axis=euc_up, theta=radians(angle))
             all_points.append(pt.as_arr())
-        
+
         # Add the connectivity information
-        if i < total_steps -1:
-            ind = i*poly_sides
+        if i < total_steps - 1:
+            ind = i * poly_sides
             for j in range(ind, ind + poly_sides - 1):
-                all_tris.append( [ j, j+1,   j+poly_sides])
-                all_tris.append( [ j+1, j+poly_sides+1, j+poly_sides])
-            all_tris.append( [ ind, ind + poly_sides-1+poly_sides, ind + poly_sides-1])
-            all_tris.append( [ ind, ind + poly_sides, ind +poly_sides-1+poly_sides])       
-        
+                all_tris.append([j, j + 1,   j + poly_sides])
+                all_tris.append([j + 1, j + poly_sides + 1, j + poly_sides])
+            all_tris.append(
+                [ind, ind + poly_sides - 1 + poly_sides, ind + poly_sides - 1])
+            all_tris.append(
+                [ind, ind + poly_sides, ind + poly_sides - 1 + poly_sides])
+
     # End triangle fans for beginning and end
     last_loop = len(all_points) - poly_sides
-    for i in range(poly_sides -2):
-        all_tris.append( [ 0,  i+2, i+1])
-        all_tris.append( [ last_loop, last_loop + i+1, last_loop + i + 2])
-        
-        
+    for i in range(poly_sides - 2):
+        all_tris.append([0,  i + 2, i + 1])
+        all_tris.append([last_loop, last_loop + i + 1, last_loop + i + 2])
+
     # Make the polyhedron
     a = polyhedron(points=all_points, faces=all_tris)
-    
+
     if external:
         # Intersect with a cylindrical tube to make sure we fit into
         # the correct dimensions
-        tube = cylinder(r=inner_rad+outline_w+EPSILON, h=length, segments=segments_per_rot) 
+        tube = cylinder(
+            r=inner_rad + outline_w + EPSILON, h=length, segments=segments_per_rot)
         tube -= cylinder(r=inner_rad, h=length, segments=segments_per_rot)
     else:
-        # If the threading is internal, intersect with a central cylinder 
+        # If the threading is internal, intersect with a central cylinder
         # to make sure nothing else remains
-        tube = cylinder(r=inner_rad, h=length, segments=segments_per_rot)        
+        tube = cylinder(r=inner_rad, h=length, segments=segments_per_rot)
     a *= tube
     return render()(a)
 
 
-
 def default_thread_section(tooth_height, tooth_depth):
     # An isoceles triangle, tooth_height vertically, tooth_depth wide:
-    res = [ [ 0, -tooth_height/2],
-             [ tooth_depth, 0],
-             [ 0, tooth_height/2]
-            ]
+    res = [[0, -tooth_height / 2],
+           [tooth_depth, 0],
+           [0, tooth_height / 2]
+           ]
     return res
 
 
 def assembly():
     # Scad code here
     a = union()
-    
+
     rad = 5
-    pts = [ [ 0, -1, 0],
-            [ 1,  0, 0],
-            [ 0,  1, 0],
-            [ -1, 0, 0],
-            [ -1, -1, 0]    ]
-            
-    a = thread(pts, inner_rad=10, pitch= 6, length=2, segments_per_rot=31, 
-                            neck_in_degrees=30, neck_out_degrees=30)
-    
-    return a + cylinder(10+EPSILON, 2)
+    pts = [[0, -1, 0],
+           [1,  0, 0],
+           [0,  1, 0],
+           [-1, 0, 0],
+           [-1, -1, 0]]
+
+    a = thread(pts, inner_rad=10, pitch=6, length=2, segments_per_rot=31,
+               neck_in_degrees=30, neck_out_degrees=30)
+
+    return a + cylinder(10 + EPSILON, 2)
 
 if __name__ == '__main__':
-    a = assembly()    
-    scad_render_to_file(a)
+    a = assembly()
+    scad_render_to_file(a)
diff --git a/solid/solidpython.py b/solid/solidpython.py
