BoltFactory: Cleanup, Remove star imports

Bumped version to 0.3.2
Fix star imports
Replace the star import of the createMesh
with importlib reload in init

Pep8 cleanup

Fix crash with the Cap head type -
props.DIV_COUNT was non existing

3 files changed, 1258 insertions, 1258 deletions

diff --git a/add_mesh_BoltFactory/Boltfactory.py b/add_mesh_BoltFactory/Boltfactory.py
index be0ba617..89af117c 100644
--- a/add_mesh_BoltFactory/Boltfactory.py
+++ b/add_mesh_BoltFactory/Boltfactory.py
@@ -18,199 +18,248 @@
 
 
 import bpy
-import mathutils
-from bpy.props import *
-from add_mesh_BoltFactory.createMesh import *
-
-##------------------------------------------------------------
-# calculates the matrix for the new object
-# depending on user pref
+from mathutils import Matrix
+from bpy.props import (
+        BoolProperty,
+        EnumProperty,
+        FloatProperty,
+        IntProperty,
+        )
+from . import createMesh
+
+
+# ------------------------------------------------------------
+# calculates the matrix for the new object depending on user pref
 def align_matrix(context):
-    loc = mathutils.Matrix.Translation(context.scene.cursor_location)
+    loc = Matrix.Translation(context.scene.cursor_location)
     obj_align = context.user_preferences.edit.object_align
-    if (context.space_data.type == 'VIEW_3D'
-        and obj_align == 'VIEW'):
+    if (context.space_data.type == 'VIEW_3D' and obj_align == 'VIEW'):
         rot = context.space_data.region_3d.view_matrix.to_3x3().inverted().to_4x4()
     else:
-        rot = mathutils.Matrix()
+        rot = Matrix()
     align_matrix = loc * rot
     return align_matrix
 
 
-
 class add_mesh_bolt(bpy.types.Operator):
-    """"""
     bl_idname = "mesh.bolt_add"
     bl_label = "Add Bolt"
     bl_options = {'REGISTER', 'UNDO', 'PRESET'}
-    bl_description = "adds many types of Bolts"
+    bl_description = "Construct many types of Bolts"
 
-    align_matrix = mathutils.Matrix()
+    align_matrix = Matrix()
     MAX_INPUT_NUMBER = 50
 
-  # edit - Whether to add or update.
-    edit = BoolProperty(name="",
+    # edit - Whether to add or update
+    edit = BoolProperty(
+        name="",
         description="",
         default=False,
-        options={'HIDDEN'})
-
-
-    #Model Types
-    Model_Type_List = [('bf_Model_Bolt','BOLT','Bolt Model'),
-                        ('bf_Model_Nut','NUT','Nut Model')]
-    bf_Model_Type = EnumProperty( attr='bf_Model_Type',
+        options={'HIDDEN'}
+        )
+    # Model Types
+    Model_Type_List = [('bf_Model_Bolt', 'BOLT', 'Bolt Model'),
+                       ('bf_Model_Nut', 'NUT', 'Nut Model')]
+    bf_Model_Type = EnumProperty(
+            attr='bf_Model_Type',
             name='Model',
             description='Choose the type off model you would like',
-            items = Model_Type_List, default = 'bf_Model_Bolt')
-
-    #Head Types
-    Model_Type_List = [('bf_Head_Hex','HEX','Hex Head'),
-                        ('bf_Head_Cap','CAP','Cap Head'),
-                        ('bf_Head_Dome','DOME','Dome Head'),
-                        ('bf_Head_Pan','PAN','Pan Head'),
-                        ('bf_Head_CounterSink','COUNTER SINK','Counter Sink Head')]
-    bf_Head_Type = EnumProperty( attr='bf_Head_Type',
+            items=Model_Type_List, default='bf_Model_Bolt'
+            )
+    # Head Types
+    Model_Type_List = [('bf_Head_Hex', 'HEX', 'Hex Head'),
+                        ('bf_Head_Cap', 'CAP', 'Cap Head'),
+                        ('bf_Head_Dome', 'DOME', 'Dome Head'),
+                        ('bf_Head_Pan', 'PAN', 'Pan Head'),
+                        ('bf_Head_CounterSink', 'COUNTER SINK', 'Counter Sink Head')]
+    bf_Head_Type = EnumProperty(
+            attr='bf_Head_Type',
             name='Head',
             description='Choose the type off Head you would like',
-            items = Model_Type_List, default = 'bf_Head_Hex')
-
-    #Bit Types
-    Bit_Type_List = [('bf_Bit_None','NONE','No Bit Type'),
-                    ('bf_Bit_Allen','ALLEN','Allen Bit Type'),
-                    ('bf_Bit_Philips','PHILLIPS','Phillips Bit Type')]
-    bf_Bit_Type = EnumProperty( attr='bf_Bit_Type',
+            items=Model_Type_List, default='bf_Head_Hex'
+            )
+    # Bit Types
+    Bit_Type_List = [('bf_Bit_None', 'NONE', 'No Bit Type'),
+                    ('bf_Bit_Allen', 'ALLEN', 'Allen Bit Type'),
+                    ('bf_Bit_Philips', 'PHILLIPS', 'Phillips Bit Type')]
+    bf_Bit_Type = EnumProperty(
+            attr='bf_Bit_Type',
             name='Bit Type',
             description='Choose the type of bit to you would like',
-            items = Bit_Type_List, default = 'bf_Bit_None')
-
-    #Nut Types
-    Nut_Type_List = [('bf_Nut_Hex','HEX','Hex Nut'),
-                    ('bf_Nut_Lock','LOCK','Lock Nut')]
-    bf_Nut_Type = EnumProperty( attr='bf_Nut_Type',
+            items=Bit_Type_List, default='bf_Bit_None'
+            )
+    # Nut Types
+    Nut_Type_List = [('bf_Nut_Hex', 'HEX', 'Hex Nut'),
+                    ('bf_Nut_Lock', 'LOCK', 'Lock Nut')]
+    bf_Nut_Type = EnumProperty(
+            attr='bf_Nut_Type',
             name='Nut Type',
             description='Choose the type of nut you would like',
-            items = Nut_Type_List, default = 'bf_Nut_Hex')
-
-    #Shank Types
-    bf_Shank_Length = FloatProperty(attr='bf_Shank_Length',
-            name='Shank Length', default = 0,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Length of the unthreaded shank')
-
-    bf_Shank_Dia = FloatProperty(attr='bf_Shank_Dia',
-            name='Shank Dia', default = 3,
-            min = 0, soft_min = 0,max = MAX_INPUT_NUMBER,
-            description='Diameter of the shank')
-
-    bf_Phillips_Bit_Depth = FloatProperty(attr='bf_Phillips_Bit_Depth',
-            name='Bit Depth', default = 1.1431535482406616,
-            min = 0, soft_min = 0,max = MAX_INPUT_NUMBER,
-            description='Depth of the Phillips Bit')
-
-    bf_Allen_Bit_Depth = FloatProperty(attr='bf_Allen_Bit_Depth',
-            name='Bit Depth', default = 1.5,
-            min = 0, soft_min = 0,max = MAX_INPUT_NUMBER,
-            description='Depth of the Allen Bit')
-
-    bf_Allen_Bit_Flat_Distance = FloatProperty( attr='bf_Allen_Bit_Flat_Distance',
-            name='Flat Dist', default = 2.5,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Flat Distance of the Allen Bit')
-
-    bf_Hex_Head_Height = FloatProperty( attr='bf_Hex_Head_Height',
-            name='Head Height', default = 2,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Height of the Hex Head')
-
-    bf_Hex_Head_Flat_Distance = FloatProperty( attr='bf_Hex_Head_Flat_Distance',
-            name='Flat Dist', default = 5.5,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Flat Distance of the Hex Head')
-
-    bf_CounterSink_Head_Dia = FloatProperty( attr='bf_CounterSink_Head_Dia',
-            name='Head Dia', default = 5.5,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Diameter of the Counter Sink Head')
-
-    bf_Cap_Head_Height = FloatProperty( attr='bf_Cap_Head_Height',
-            name='Head Height', default = 5.5,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Height of the Cap Head')
-
-    bf_Cap_Head_Dia = FloatProperty( attr='bf_Cap_Head_Dia',
-            name='Head Dia', default = 3,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Diameter of the Cap Head')
-
-    bf_Dome_Head_Dia = FloatProperty( attr='bf_Dome_Head_Dia',
-            name='Dome Head Dia', default = 5.6,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Length of the unthreaded shank')
-
-    bf_Pan_Head_Dia = FloatProperty( attr='bf_Pan_Head_Dia',
-            name='Pan Head Dia', default = 5.6,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
+            items=Nut_Type_List, default='bf_Nut_Hex'
+            )
+    # Shank Types
+    bf_Shank_Length = FloatProperty(
+            attr='bf_Shank_Length',
+            name='Shank Length', default=0,
+            min=0, soft_min=0, max=MAX_INPUT_NUMBER,
+            description='Length of the unthreaded shank'
+            )
+    bf_Shank_Dia = FloatProperty(
+            attr='bf_Shank_Dia',
+            name='Shank Dia', default=3,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Diameter of the shank'
+            )
+    bf_Phillips_Bit_Depth = FloatProperty(
+            attr='bf_Phillips_Bit_Depth',
+            name='Bit Depth', default=1.1431535482406616,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Depth of the Phillips Bit'
+            )
+    bf_Allen_Bit_Depth = FloatProperty(
+            attr='bf_Allen_Bit_Depth',
+            name='Bit Depth', default=1.5,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Depth of the Allen Bit'
+            )
+    bf_Allen_Bit_Flat_Distance = FloatProperty(
+            attr='bf_Allen_Bit_Flat_Distance',
+            name='Flat Dist', default=2.5,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Flat Distance of the Allen Bit'
+            )
+    bf_Hex_Head_Height = FloatProperty(
+            attr='bf_Hex_Head_Height',
+            name='Head Height', default=2,
+            min=0, soft_min=0, max=MAX_INPUT_NUMBER,
+            description='Height of the Hex Head'
+            )
+    bf_Hex_Head_Flat_Distance = FloatProperty(
+            attr='bf_Hex_Head_Flat_Distance',
+            name='Flat Dist', default=5.5,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Flat Distance of the Hex Head'
+            )
+    bf_CounterSink_Head_Dia = FloatProperty(
+            attr='bf_CounterSink_Head_Dia',
+            name='Head Dia', default=5.5,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Diameter of the Counter Sink Head'
+            )
+    bf_Cap_Head_Height = FloatProperty(
+            attr='bf_Cap_Head_Height',
+            name='Head Height', default=5.5,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Height of the Cap Head'
+            )
+    bf_Cap_Head_Dia = FloatProperty(
+            attr='bf_Cap_Head_Dia',
+            name='Head Dia', default=3,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Diameter of the Cap Head'
+            )
+    bf_Dome_Head_Dia = FloatProperty(
+            attr='bf_Dome_Head_Dia',
+            name='Dome Head Dia', default=5.6,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Length of the unthreaded shank'
+            )
+    bf_Pan_Head_Dia = FloatProperty(
+            attr='bf_Pan_Head_Dia',
+            name='Pan Head Dia', default=5.6,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
             description='Diameter of the Pan Head')
 
-    bf_Philips_Bit_Dia = FloatProperty(attr='bf_Philips_Bit_Dia',
-            name='Bit Dia', default = 1.8199999332427979,
-            min = 0, soft_min = 0,max = MAX_INPUT_NUMBER,
+    bf_Philips_Bit_Dia = FloatProperty(
+            attr='bf_Philips_Bit_Dia',
+            name='Bit Dia', default=1.8199999332427979,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
             description='Diameter of the Philips Bit')
 
-    bf_Thread_Length = FloatProperty( attr='bf_Thread_Length',
-            name='Thread Length', default = 6,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
+    bf_Thread_Length = FloatProperty(
+            attr='bf_Thread_Length',
+            name='Thread Length', default=6,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
             description='Length of the Thread')
 
-    bf_Major_Dia = FloatProperty( attr='bf_Major_Dia',
-            name='Major Dia', default = 3,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
+    bf_Major_Dia = FloatProperty(
+            attr='bf_Major_Dia',
+            name='Major Dia', default=3,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
             description='Outside diameter of the Thread')
 
-    bf_Pitch = FloatProperty( attr='bf_Pitch',
-            name='Pitch', default = 0.35,
-            min = 0.1, soft_min = 0.1, max = 7.0,
-            description='Pitch if the thread')
-
-    bf_Minor_Dia = FloatProperty( attr='bf_Minor_Dia',
-            name='Minor Dia', default = 2.6211137771606445,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Inside diameter of the Thread')
-
-    bf_Crest_Percent = IntProperty( attr='bf_Crest_Percent',
-            name='Crest Percent', default = 10,
-            min = 1, soft_min = 1, max = 90,
-            description='Percent of the pitch that makes up the Crest')
-
-    bf_Root_Percent = IntProperty( attr='bf_Root_Percent',
-            name='Root Percent', default = 10,
-            min = 1, soft_min = 1, max = 90,
-            description='Percent of the pitch that makes up the Root')
-
-    bf_Div_Count = IntProperty( attr='bf_Div_Count',
-            name='Div count', default = 36,
-            min = 4, soft_min = 4, max = 4096,
-            description='Div count determine circle resolution')
-
-    bf_Hex_Nut_Height = FloatProperty( attr='bf_Hex_Nut_Height',
-            name='Hex Nut Height', default = 2.4,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Height of the Hex Nut')
-
-    bf_Hex_Nut_Flat_Distance = FloatProperty( attr='bf_Hex_Nut_Flat_Distance',
-            name='Hex Nut Flat Dist', default = 5.5,
-            min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
-            description='Flat distance of the Hex Nut')
+    bf_Pitch = FloatProperty(
+            attr='bf_Pitch',
+            name='Pitch', default=0.35,
+            min=0.1, soft_min=0.1,
+            max=7.0,
+            description='Pitch if the thread'
+            )
+    bf_Minor_Dia = FloatProperty(
+            attr='bf_Minor_Dia',
+            name='Minor Dia', default=2.6211137771606445,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Inside diameter of the Thread'
+            )
+    bf_Crest_Percent = IntProperty(
+            attr='bf_Crest_Percent',
+            name='Crest Percent', default=10,
+            min=1, soft_min=1,
+            max=90,
+            description='Percent of the pitch that makes up the Crest'
+            )
+    bf_Root_Percent = IntProperty(
+            attr='bf_Root_Percent',
+            name='Root Percent', default=10,
+            min=1, soft_min=1,
+            max=90,
+            description='Percent of the pitch that makes up the Root'
+            )
+    bf_Div_Count = IntProperty(
+            attr='bf_Div_Count',
+            name='Div count', default=36,
+            min=4, soft_min=4,
+            max=4096,
+            description='Div count determine circle resolution'
+            )
+    bf_Hex_Nut_Height = FloatProperty(
+            attr='bf_Hex_Nut_Height',
+            name='Hex Nut Height', default=2.4,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Height of the Hex Nut'
+            )
+    bf_Hex_Nut_Flat_Distance = FloatProperty(
+            attr='bf_Hex_Nut_Flat_Distance',
+            name='Hex Nut Flat Dist', default=5.5,
+            min=0, soft_min=0,
+            max=MAX_INPUT_NUMBER,
+            description='Flat distance of the Hex Nut'
+            )
 
     def draw(self, context):
         layout = self.layout
         col = layout.column()
 
-        #ENUMS
+        # ENUMS
         col.prop(self, 'bf_Model_Type')
         col.separator()
 
-        #Bit
+        # Bit
         if self.bf_Model_Type == 'bf_Model_Bolt':
             col.prop(self, 'bf_Bit_Type')
             if self.bf_Bit_Type == 'bf_Bit_None':
@@ -222,8 +271,7 @@ class add_mesh_bolt(bpy.types.Operator):
                 col.prop(self, 'bf_Phillips_Bit_Depth')
                 col.prop(self, 'bf_Philips_Bit_Dia')
             col.separator()
-
-        #Head
+        # Head
         if self.bf_Model_Type == 'bf_Model_Bolt':
             col.prop(self, 'bf_Head_Type')
             if self.bf_Head_Type == 'bf_Head_Hex':
@@ -239,18 +287,18 @@ class add_mesh_bolt(bpy.types.Operator):
             elif self.bf_Head_Type == 'bf_Head_CounterSink':
                 col.prop(self, 'bf_CounterSink_Head_Dia')
             col.separator()
-        #Shank
+        # Shank
         if self.bf_Model_Type == 'bf_Model_Bolt':
             col.label(text='Shank')
             col.prop(self, 'bf_Shank_Length')
             col.prop(self, 'bf_Shank_Dia')
             col.separator()
-        #Nut
+        # Nut
         if self.bf_Model_Type == 'bf_Model_Nut':
             col.prop(self, 'bf_Nut_Type')
             col.prop(self, 'bf_Hex_Nut_Height')
             col.prop(self, 'bf_Hex_Nut_Flat_Distance')
-        #Thread
+        # Thread
         col.label(text='Thread')
         if self.bf_Model_Type == 'bf_Model_Bolt':
             col.prop(self, 'bf_Thread_Length')
@@ -261,23 +309,17 @@ class add_mesh_bolt(bpy.types.Operator):
         col.prop(self, 'bf_Root_Percent')
         col.prop(self, 'bf_Div_Count')
 
-
-
-    ##### POLL #####
     @classmethod
     def poll(cls, context):
         return context.scene is not None
 
-    ##### EXECUTE #####
     def execute(self, context):
-
-        #print('EXECUTING...')
-        Create_New_Mesh(self, context, self.align_matrix)
+        # print('EXECUTING...')
+        createMesh.Create_New_Mesh(self, context, self.align_matrix)
         return {'FINISHED'}
 
-    ##### INVOKE #####
     def invoke(self, context, event):
-        #print('\n___________START_____________')
+        # print('\n___________START_____________')
         # store creation_matrix
         self.align_matrix = align_matrix(context)
         self.execute(context)
diff --git a/add_mesh_BoltFactory/__init__.py b/add_mesh_BoltFactory/__init__.py
index 16dd9a9c..8c94ec35 100644
--- a/add_mesh_BoltFactory/__init__.py
+++ b/add_mesh_BoltFactory/__init__.py
@@ -19,11 +19,11 @@
 bl_info = {
     "name": "BoltFactory",
     "author": "Aaron Keith",
-    "version": (0, 3, 1),
+    "version": (0, 3, 2),
     "blender": (2, 78, 0),
     "location": "View3D > Add > Mesh",
     "description": "Add a bolt or nut",
-    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
+    "wiki_url": "https://wiki.blender.org/index.php/Extensions:2.6/Py/"
                 "Scripts/Add_Mesh/BoltFactory",
     "category": "Add Mesh",
 }
@@ -32,13 +32,15 @@ bl_info = {
 if "bpy" in locals():
     import importlib
     importlib.reload(Boltfactory)
+    importlib.reload(createMesh)
 else:
-    from add_mesh_BoltFactory import Boltfactory
+    from . import Boltfactory
+    from . import createMesh
 
 import bpy
 
-################################################################################
-##### REGISTER #####
+
+# ### REGISTER ###
 
 def add_mesh_bolt_button(self, context):
     self.layout.operator(Boltfactory.add_mesh_bolt.bl_idname, text="Bolt", icon="MOD_SCREW")
@@ -48,13 +50,15 @@ def register():
     bpy.utils.register_module(__name__)
 
     bpy.types.INFO_MT_mesh_add.append(add_mesh_bolt_button)
-    #bpy.types.VIEW3D_PT_tools_objectmode.prepend(add_mesh_bolt_button) #just for testing
+    # bpy.types.VIEW3D_PT_tools_objectmode.prepend(add_mesh_bolt_button)  # just for testing
+
 
 def unregister():
     bpy.utils.unregister_module(__name__)
 
     bpy.types.INFO_MT_mesh_add.remove(add_mesh_bolt_button)
-    #bpy.types.VIEW3D_PT_tools_objectmode.remove(add_mesh_bolt_button) #just for testing
+    # bpy.types.VIEW3D_PT_tools_objectmode.remove(add_mesh_bolt_button)  # just for testing
+
 
 if __name__ == "__main__":
     register()
diff --git a/add_mesh_BoltFactory/createMesh.py b/add_mesh_BoltFactory/createMesh.py
index 58470c01..fcdefdc1 100644
--- a/add_mesh_BoltFactory/createMesh.py
+++ b/add_mesh_BoltFactory/createMesh.py
@@ -17,19 +17,23 @@
 # ##### END GPL LICENSE BLOCK #####
 
 import bpy
-import mathutils
-
-from math import *
-from itertools import *
+from mathutils import (
+        Matrix,
+        Vector,
+        )
+from math import (
+        sin,
+        cos,
+        tan,
+        radians,
+        )
 
 NARROW_UI = 180
 MAX_INPUT_NUMBER = 50
 
-#Global_Scale = 0.001    #1 blender unit = X mm
-GLOBAL_SCALE = 0.1    #1 blender unit = X mm
-#Global_Scale = 1.0    #1 blender unit = X mm
-
-
+# Global_Scale = 0.001   # 1 blender unit = X mm
+GLOBAL_SCALE = 0.1       # 1 blender unit = X mm
+# Global_Scale = 1.0     # 1 blender unit = X mm
 
 
 # next two utility functions are stolen from import_obj.py
@@ -40,6 +44,7 @@ def unpack_list(list_of_tuples):
         l.extend(t)
     return l
 
+
 def unpack_face_list(list_of_tuples):
     l = []
     for t in list_of_tuples:
@@ -59,6 +64,7 @@ def unpack_face_list(list_of_tuples):
 
     return l
 
+
 """
 Remove Doubles takes a list on Verts and a list of Faces and
 removes the doubles, much like Blender does in edit mode.
@@ -70,7 +76,7 @@ disadvantage of not being able to interactively change the properties.
 """
 
 
-def RemoveDoubles(verts,faces,Decimal_Places = 4):
+def RemoveDoubles(verts, faces, Decimal_Places=4):
 
     new_verts = []
     new_faces = []
@@ -78,7 +84,9 @@ def RemoveDoubles(verts,faces,Decimal_Places = 4):
     Rounded_Verts = []
 
     for v in verts:
-        Rounded_Verts.append([round(v[0],Decimal_Places),round(v[1],Decimal_Places),round(v[2],Decimal_Places)])
+        Rounded_Verts.append([round(v[0], Decimal_Places),
+                              round(v[1], Decimal_Places),
+                              round(v[2], Decimal_Places)])
 
     for face in faces:
         new_face = []
@@ -94,24 +102,19 @@ def RemoveDoubles(verts,faces,Decimal_Places = 4):
         if len(new_face) == 3 or len(new_face) == 4:
             new_faces.append(new_face)
 
-    return new_verts,new_faces
-
+    return new_verts, new_faces
 
 
-
-def Scale_Mesh_Verts(verts,scale_factor):
+def Scale_Mesh_Verts(verts, scale_factor):
     Ret_verts = []
     for v in verts:
-        Ret_verts.append([v[0]*scale_factor,v[1]*scale_factor,v[2]*scale_factor])
+        Ret_verts.append([v[0] * scale_factor, v[1] * scale_factor, v[2] * scale_factor])
     return Ret_verts
 
 
-
-
-
-#Create a matrix representing a rotation.
+# Create a matrix representing a rotation.
 #
-#Parameters:
+# Parameters:
 #
 #        * angle (float) - The angle of rotation desired.
 #        * matSize (int) - The size of the rotation matrix to construct. Can be 2d, 3d, or 4d.
@@ -122,49 +125,46 @@ def Scale_Mesh_Verts(verts,scale_factor):
 #              o "r - arbitrary rotation around vector"
 #        * axis (Vector object. (optional)) - The arbitrary axis of rotation used with "R"
 #
-#Returns: Matrix object.
+# Returns: Matrix object.
 #    A new rotation matrix.
+
 def Simple_RotationMatrix(angle, matSize, axisFlag):
-    if matSize != 4 :
-        print ("Simple_RotationMatrix can only do 4x4")
+    if matSize != 4:
+        print("Simple_RotationMatrix can only do 4x4")
 
-    q = radians(angle)  #make the rotation go clockwise
+    q = radians(angle)  # make the rotation go clockwise
 
     if axisFlag == 'x':
-        matrix = mathutils.Matrix.Rotation(q, 4, 'X')
-    elif  axisFlag == 'y':
-        matrix = mathutils.Matrix.Rotation(q, 4, 'Y')
+        matrix = Matrix.Rotation(q, 4, 'X')
+    elif axisFlag == 'y':
+        matrix = Matrix.Rotation(q, 4, 'Y')
     elif axisFlag == 'z':
-        matrix = mathutils.Matrix.Rotation(q, 4, 'Z')
+        matrix = Matrix.Rotation(q, 4, 'Z')
     else:
-        print   ("Simple_RotationMatrix can only do x y z axis")
+        print("Simple_RotationMatrix can only do x y z axis")
     return matrix
 
 
-##########################################################################################
-##########################################################################################
-##                    Converter Functions For Bolt Factory
-##########################################################################################
-##########################################################################################
-
+# ####################################################################
+#              Converter Functions For Bolt Factory
+# ####################################################################
 
 def Flat_To_Radius(FLAT):
-    h = (float(FLAT)/2)/cos(radians(30))
+    h = (float(FLAT) / 2) / cos(radians(30))
     return h
 
+
 def Get_Phillips_Bit_Height(Bit_Dia):
-    Flat_Width_half = (Bit_Dia*(0.5/1.82))/2.0
+    Flat_Width_half = (Bit_Dia * (0.5 / 1.82)) / 2.0
     Bit_Rad = Bit_Dia / 2.0
     x = Bit_Rad - Flat_Width_half
-    y = tan(radians(60))*x
+    y = tan(radians(60)) * x
     return float(y)
 
 
-##########################################################################################
-##########################################################################################
-##                    Miscellaneous Utilities
-##########################################################################################
-##########################################################################################
+# ####################################################################
+#                    Miscellaneous Utilities
+# ####################################################################
 
 # Returns a list of verts rotated by the given matrix. Used by SpinDup
 def Rot_Mesh(verts, matrix):
@@ -173,271 +173,258 @@ def Rot_Mesh(verts, matrix):
 
 
 # Returns a list of faces that has there index incremented by offset
-def Copy_Faces(faces,offset):
+def Copy_Faces(faces, offset):
     return [[(i + offset) for i in f] for f in faces]
 
 
-# Much like Blenders built in SpinDup.
-def SpinDup(VERTS,FACES,DEGREE,DIVISIONS,AXIS):
-    verts=[]
-    faces=[]
+# Much like Blenders built in SpinDup
+def SpinDup(VERTS, FACES, DEGREE, DIVISIONS, AXIS):
+    verts = []
+    faces = []
 
     if DIVISIONS == 0:
         DIVISIONS = 1
 
-    step = DEGREE/DIVISIONS # set step so pieces * step = degrees in arc
+    step = DEGREE / DIVISIONS  # set step so pieces * step = degrees in arc
 
     for i in range(int(DIVISIONS)):
-        rotmat = Simple_RotationMatrix(step*i, 4, AXIS) # 4x4 rotation matrix, 30d about the x axis.
-        Rot = Rot_Mesh(VERTS,rotmat)
-        faces.extend(Copy_Faces(FACES,len(verts)))
+        rotmat = Simple_RotationMatrix(step * i, 4, AXIS)  # 4x4 rotation matrix, 30d about the x axis.
+        Rot = Rot_Mesh(VERTS, rotmat)
+        faces.extend(Copy_Faces(FACES, len(verts)))
         verts.extend(Rot)
-    return verts,faces
-
+    return verts, faces
 
 
 # Returns a list of verts that have been moved up the z axis by DISTANCE
-def Move_Verts_Up_Z(VERTS,DISTANCE):
+def Move_Verts_Up_Z(VERTS, DISTANCE):
     ret = []
     for v in VERTS:
-        ret.append([v[0],v[1],v[2]+DISTANCE])
+        ret.append([v[0], v[1], v[2] + DISTANCE])
     return ret
 
 
 # Returns a list of verts and faces that has been mirrored in the AXIS
-def Mirror_Verts_Faces(VERTS,FACES,AXIS,FLIP_POINT =0):
+def Mirror_Verts_Faces(VERTS, FACES, AXIS, FLIP_POINT=0):
     ret_vert = []
     ret_face = []
     offset = len(VERTS)
     if AXIS == 'y':
         for v in VERTS:
             Delta = v[0] - FLIP_POINT
-            ret_vert.append([FLIP_POINT-Delta,v[1],v[2]])
+            ret_vert.append([FLIP_POINT - Delta, v[1], v[2]])
     if AXIS == 'x':
         for v in VERTS:
             Delta = v[1] - FLIP_POINT
-            ret_vert.append([v[0],FLIP_POINT-Delta,v[2]])
+            ret_vert.append([v[0], FLIP_POINT - Delta, v[2]])
     if AXIS == 'z':
         for v in VERTS:
             Delta = v[2] - FLIP_POINT
-            ret_vert.append([v[0],v[1],FLIP_POINT-Delta])
+            ret_vert.append([v[0], v[1], FLIP_POINT - Delta])
 
     for f in FACES:
         fsub = []
         for i in range(len(f)):
-            fsub.append(f[i]+ offset)
-        fsub.reverse() # flip the order to make norm point out
+            fsub.append(f[i] + offset)
+        fsub.reverse()  # flip the order to make norm point out
         ret_face.append(fsub)
 
-    return ret_vert,ret_face
-
+    return ret_vert, ret_face
 
 
 # Returns a list of faces that
 # make up an array of 4 point polygon.
-def Build_Face_List_Quads(OFFSET,COLUM,ROW,FLIP = 0):
-    Ret =[]
-    RowStart = 0;
+def Build_Face_List_Quads(OFFSET, COLUM, ROW, FLIP=0):
+    Ret = []
+    RowStart = 0
     for j in range(ROW):
         for i in range(COLUM):
-            Res1 = RowStart + i;
-            Res2 = RowStart + i + (COLUM +1)
-            Res3 = RowStart + i + (COLUM +1) +1
-            Res4 = RowStart+i+1
+            Res1 = RowStart + i
+            Res2 = RowStart + i + (COLUM + 1)
+            Res3 = RowStart + i + (COLUM + 1) + 1
+            Res4 = RowStart + i + 1
             if FLIP:
-                Ret.append([OFFSET+Res1,OFFSET+Res2,OFFSET+Res3,OFFSET+Res4])
+                Ret.append([OFFSET + Res1, OFFSET + Res2, OFFSET + Res3, OFFSET + Res4])
             else:
-                Ret.append([OFFSET+Res4,OFFSET+Res3,OFFSET+Res2,OFFSET+Res1])
-        RowStart += COLUM+1
+                Ret.append([OFFSET + Res4, OFFSET + Res3, OFFSET + Res2, OFFSET + Res1])
+        RowStart += COLUM + 1
     return Ret
 
 
 # Returns a list of faces that makes up a fill pattern for a
 # circle
-def Fill_Ring_Face(OFFSET,NUM,FACE_DOWN = 0):
-    Ret =[]
-    Face = [1,2,0]
-    TempFace = [0,0,0]
+def Fill_Ring_Face(OFFSET, NUM, FACE_DOWN=0):
+    Ret = []
+    Face = [1, 2, 0]
+    TempFace = [0, 0, 0]
     # A = 0  # UNUSED
     B = 1
     C = 2
     if NUM < 3:
         return None
-    for i in range(NUM-2):
-        if (i%2):
-            TempFace[0] = Face[C];
-            TempFace[1] = Face[C] + 1;
-            TempFace[2] = Face[B];
+    for i in range(NUM - 2):
+        if (i % 2):
+            TempFace[0] = Face[C]
+            TempFace[1] = Face[C] + 1
+            TempFace[2] = Face[B]
             if FACE_DOWN:
-                Ret.append([OFFSET+Face[2],OFFSET+Face[1],OFFSET+Face[0]])
+                Ret.append([OFFSET + Face[2], OFFSET + Face[1], OFFSET + Face[0]])
             else:
-                Ret.append([OFFSET+Face[0],OFFSET+Face[1],OFFSET+Face[2]])
+                Ret.append([OFFSET + Face[0], OFFSET + Face[1], OFFSET + Face[2]])
         else:
-            TempFace[0] =Face[C];
+            TempFace[0] = Face[C]
             if Face[C] == 0:
-                TempFace[1] = NUM-1;
+                TempFace[1] = NUM - 1
             else:
-                TempFace[1] = Face[C] - 1;
-            TempFace[2] = Face[B];
+                TempFace[1] = Face[C] - 1
+            TempFace[2] = Face[B]
             if FACE_DOWN:
-                Ret.append([OFFSET+Face[0],OFFSET+Face[1],OFFSET+Face[2]])
+                Ret.append([OFFSET + Face[0], OFFSET + Face[1], OFFSET + Face[2]])
             else:
-                Ret.append([OFFSET+Face[2],OFFSET+Face[1],OFFSET+Face[0]])
+                Ret.append([OFFSET + Face[2], OFFSET + Face[1], OFFSET + Face[0]])
 
         Face[0] = TempFace[0]
         Face[1] = TempFace[1]
         Face[2] = TempFace[2]
     return Ret
 
-######################################################################################
-##########################################################################################
-##########################################################################################
-##                    Create Allen Bit
-##########################################################################################
-##########################################################################################
 
+# ####################################################################
+#                    Create Allen Bit
+# ####################################################################
 
-def Allen_Fill(OFFSET,FLIP= 0):
+def Allen_Fill(OFFSET, FLIP=0):
     faces = []
-    Lookup = [[19,1,0],
-              [19,2,1],
-              [19,3,2],
-              [19,20,3],
-              [20,4,3],
-              [20,5,4],
-              [20,6,5],
-              [20,7,6],
-              [20,8,7],
-              [20,9,8],
-
-              [20,21,9],
-
-              [21,10,9],
-              [21,11,10],
-              [21,12,11],
-              [21,13,12],
-              [21,14,13],
-              [21,15,14],
-
-              [21,22,15],
-              [22,16,15],
-              [22,17,16],
-              [22,18,17]
+    Lookup = [[19, 1, 0],
+              [19, 2, 1],
+              [19, 3, 2],
+              [19, 20, 3],
+              [20, 4, 3],
+              [20, 5, 4],
+              [20, 6, 5],
+              [20, 7, 6],
+              [20, 8, 7],
+              [20, 9, 8],
+
+              [20, 21, 9],
+
+              [21, 10, 9],
+              [21, 11, 10],
+              [21, 12, 11],
+              [21, 13, 12],
+              [21, 14, 13],
+              [21, 15, 14],
+
+              [21, 22, 15],
+              [22, 16, 15],
+              [22, 17, 16],
+              [22, 18, 17]
               ]
     for i in Lookup:
         if FLIP:
-            faces.append([OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
+            faces.append([OFFSET + i[2], OFFSET + i[1], OFFSET + i[0]])
         else:
-            faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2]])
+            faces.append([OFFSET + i[0], OFFSET + i[1], OFFSET + i[2]])
 
     return faces
 
+
 def Allen_Bit_Dia(FLAT_DISTANCE):
-    Flat_Radius = (float(FLAT_DISTANCE)/2.0)/cos(radians(30))
+    Flat_Radius = (float(FLAT_DISTANCE) / 2.0) / cos(radians(30))
     return (Flat_Radius * 1.05) * 2.0
 
-def Allen_Bit_Dia_To_Flat(DIA):
-    Flat_Radius = (DIA/2.0)/1.05
-    return (Flat_Radius * cos (radians(30)))* 2.0
 
+def Allen_Bit_Dia_To_Flat(DIA):
+    Flat_Radius = (DIA / 2.0) / 1.05
+    return (Flat_Radius * cos(radians(30))) * 2.0
 
 
-def Create_Allen_Bit(FLAT_DISTANCE,HEIGHT):
+def Create_Allen_Bit(FLAT_DISTANCE, HEIGHT):
     verts = []
     faces = []
     DIV_COUNT = 36
 
-    Flat_Radius = (float(FLAT_DISTANCE)/2.0)/cos(radians(30))
+    Flat_Radius = (float(FLAT_DISTANCE) / 2.0) / cos(radians(30))
     OUTTER_RADIUS = Flat_Radius * 1.05
-    Outter_Radius_Height = Flat_Radius * (0.1/5.77)
+    Outter_Radius_Height = Flat_Radius * (0.1 / 5.77)
     FaceStart_Outside = len(verts)
-    Deg_Step = 360.0 /float(DIV_COUNT)
+    Deg_Step = 360.0 / float(DIV_COUNT)
 
-    for i in range(int(DIV_COUNT/2)+1):    # only do half and mirror later
-        x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-        y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-        verts.append([x,y,0])
+    for i in range(int(DIV_COUNT / 2) + 1):  # only do half and mirror later
+        x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+        y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+        verts.append([x, y, 0])
 
     FaceStart_Inside = len(verts)
 
-    Deg_Step = 360.0 /float(6)
-    for i in range(int(6/2)+1):
-        x = sin(radians(i*Deg_Step))* Flat_Radius
-        y = cos(radians(i*Deg_Step))* Flat_Radius
-        verts.append([x,y,0-Outter_Radius_Height])
-
-    faces.extend(Allen_Fill(FaceStart_Outside,0))
+    Deg_Step = 360.0 / float(6)
+    for i in range(int(6 / 2) + 1):
+        x = sin(radians(i * Deg_Step)) * Flat_Radius
+        y = cos(radians(i * Deg_Step)) * Flat_Radius
+        verts.append([x, y, 0 - Outter_Radius_Height])
 
+    faces.extend(Allen_Fill(FaceStart_Outside, 0))
 
     FaceStart_Bottom = len(verts)
 
-    Deg_Step = 360.0 /float(6)
-    for i in range(int(6/2)+1):
-        x = sin(radians(i*Deg_Step))* Flat_Radius
-        y = cos(radians(i*Deg_Step))* Flat_Radius
-        verts.append([x,y,0-HEIGHT])
+    Deg_Step = 360.0 / float(6)
+    for i in range(int(6 / 2) + 1):
+        x = sin(radians(i * Deg_Step)) * Flat_Radius
+        y = cos(radians(i * Deg_Step)) * Flat_Radius
+        verts.append([x, y, 0 - HEIGHT])
 
-    faces.extend(Build_Face_List_Quads(FaceStart_Inside,3,1,True))
-    faces.extend(Fill_Ring_Face(FaceStart_Bottom,4))
+    faces.extend(Build_Face_List_Quads(FaceStart_Inside, 3, 1, True))
+    faces.extend(Fill_Ring_Face(FaceStart_Bottom, 4))
 
-
-    M_Verts,M_Faces = Mirror_Verts_Faces(verts,faces,'y')
+    M_Verts, M_Faces = Mirror_Verts_Faces(verts, faces, 'y')
     verts.extend(M_Verts)
     faces.extend(M_Faces)
 
-    return verts,faces,OUTTER_RADIUS * 2.0
-
+    return verts, faces, OUTTER_RADIUS * 2.0
 
-##########################################################################################
-##########################################################################################
-##                    Create Phillips Bit
-##########################################################################################
-##########################################################################################
 
+# ####################################################################
+#                    Create Phillips Bit
+# ####################################################################
 
-def Phillips_Fill(OFFSET,FLIP= 0):
+def Phillips_Fill(OFFSET, FLIP=0):
     faces = []
-    Lookup = [[0,1,10],
-              [1,11,10],
-              [1,2,11],
-              [2,12,11],
-
-              [2,3,12],
-              [3,4,12],
-              [4,5,12],
-              [5,6,12],
-              [6,7,12],
-
-              [7,13,12],
-              [7,8,13],
-              [8,14,13],
-              [8,9,14],
-
-
-              [10,11,16,15],
-              [11,12,16],
-              [12,13,16],
-              [13,14,17,16],
-              [15,16,17,18]
-
-
+    Lookup = [[0, 1, 10],
+              [1, 11, 10],
+              [1, 2, 11],
+              [2, 12, 11],
+
+              [2, 3, 12],
+              [3, 4, 12],
+              [4, 5, 12],
+              [5, 6, 12],
+              [6, 7, 12],
+
+              [7, 13, 12],
+              [7, 8, 13],
+              [8, 14, 13],
+              [8, 9, 14],
+
+              [10, 11, 16, 15],
+              [11, 12, 16],
+              [12, 13, 16],
+              [13, 14, 17, 16],
+              [15, 16, 17, 18]
               ]
     for i in Lookup:
         if FLIP:
             if len(i) == 3:
-                faces.append([OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
+                faces.append([OFFSET + i[2], OFFSET + i[1], OFFSET + i[0]])
             else:
-                faces.append([OFFSET+i[3],OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
+                faces.append([OFFSET + i[3], OFFSET + i[2], OFFSET + i[1], OFFSET + i[0]])
         else:
             if len(i) == 3:
-                faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2]])
+                faces.append([OFFSET + i[0], OFFSET + i[1], OFFSET + i[2]])
             else:
-                faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2],OFFSET+i[3]])
+                faces.append([OFFSET + i[0], OFFSET + i[1], OFFSET + i[2], OFFSET + i[3]])
     return faces
 
 
-
-def Create_Phillips_Bit(FLAT_DIA,FLAT_WIDTH,HEIGHT):
+def Create_Phillips_Bit(FLAT_DIA, FLAT_WIDTH, HEIGHT):
     verts = []
     faces = []
 
@@ -445,50 +432,46 @@ def Create_Phillips_Bit(FLAT_DIA,FLAT_WIDTH,HEIGHT):
     FLAT_RADIUS = FLAT_DIA * 0.5
     OUTTER_RADIUS = FLAT_RADIUS * 1.05
 
-    Flat_Half = float(FLAT_WIDTH)/2.0
+    Flat_Half = float(FLAT_WIDTH) / 2.0
 
     FaceStart_Outside = len(verts)
-    Deg_Step = 360.0 /float(DIV_COUNT)
-    for i in range(int(DIV_COUNT/4)+1):    # only do half and mirror later
-        x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-        y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-        verts.append([x,y,0])
-
-
-    # FaceStart_Inside = len(verts)  # UNUSED
-    verts.append([0,FLAT_RADIUS,0]) #10
-    verts.append([Flat_Half,FLAT_RADIUS,0]) #11
-    verts.append([Flat_Half,Flat_Half,0])     #12
-    verts.append([FLAT_RADIUS,Flat_Half,0])    #13
-    verts.append([FLAT_RADIUS,0,0])            #14
+    Deg_Step = 360.0 / float(DIV_COUNT)
+    for i in range(int(DIV_COUNT / 4) + 1):  # only do half and mirror later
+        x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+        y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+        verts.append([x, y, 0])
 
+    # FaceStart_Inside = len(verts)               # UNUSED
+    verts.append([0, FLAT_RADIUS, 0])             # 10
+    verts.append([Flat_Half, FLAT_RADIUS, 0])     # 11
+    verts.append([Flat_Half, Flat_Half, 0])       # 12
+    verts.append([FLAT_RADIUS, Flat_Half, 0])     # 13
+    verts.append([FLAT_RADIUS, 0, 0])             # 14
 
-    verts.append([0,Flat_Half,0-HEIGHT])        #15
-    verts.append([Flat_Half,Flat_Half,0-HEIGHT])    #16
-    verts.append([Flat_Half,0,0-HEIGHT])            #17
+    verts.append([0, Flat_Half, 0 - HEIGHT])          # 15
+    verts.append([Flat_Half, Flat_Half, 0 - HEIGHT])  # 16
+    verts.append([Flat_Half, 0, 0 - HEIGHT])          # 17
 
-    verts.append([0,0,0-HEIGHT])            #18
+    verts.append([0, 0, 0 - HEIGHT])            # 18
 
-    faces.extend(Phillips_Fill(FaceStart_Outside,True))
+    faces.extend(Phillips_Fill(FaceStart_Outside, True))
 
-    Spin_Verts,Spin_Face = SpinDup(verts,faces,360,4,'z')
+    Spin_Verts, Spin_Face = SpinDup(verts, faces, 360, 4, 'z')
 
-    return Spin_Verts,Spin_Face,OUTTER_RADIUS * 2
+    return Spin_Verts, Spin_Face, OUTTER_RADIUS * 2
 
 
-##########################################################################################
-##########################################################################################
-##                    Create Head Types
-##########################################################################################
-##########################################################################################
+# ####################################################################
+#                    Create Head Types
+# ####################################################################
 
 def Max_Pan_Bit_Dia(HEAD_DIA):
     HEAD_RADIUS = HEAD_DIA * 0.5
     XRad = HEAD_RADIUS * 1.976
-    return (sin(radians(10))*XRad) * 2.0
+    return (sin(radians(10)) * XRad) * 2.0
 
 
-def Create_Pan_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET,DIV_COUNT):
+def Create_Pan_Head(HOLE_DIA, HEAD_DIA, SHANK_DIA, HEIGHT, RAD1, RAD2, FACE_OFFSET, DIV_COUNT):
 
     HOLE_RADIUS = HOLE_DIA * 0.5
     HEAD_RADIUS = HEAD_DIA * 0.5
@@ -504,61 +487,58 @@ def Create_Pan_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET,DIV
     EndZOffset = HEAD_RADIUS * 0.432
     HEIGHT = HEAD_RADIUS * 0.59
 
-#    Dome_Rad =  5.6
-#    RAD_Offset = 4.9
-#    OtherRad = 0.8
-#    OtherRad_X_Offset = 4.2
-#    OtherRad_Z_Offset = 2.52
-#    XRad = 9.88
-#    ZRad = 8.84
-#    EndRad = 1.42
-#    EndZOffset = 2.16
-#    HEIGHT = 2.95
-
+    """
+    Dome_Rad =  5.6
+    RAD_Offset = 4.9
+    OtherRad = 0.8
+    OtherRad_X_Offset = 4.2
+    OtherRad_Z_Offset = 2.52
+    XRad = 9.88
+    ZRad = 8.84
+    EndRad = 1.42
+    EndZOffset = 2.16
+    HEIGHT = 2.95
+    """
     FaceStart = FACE_OFFSET
 
-    z = cos(radians(10))*ZRad
-    verts.append([HOLE_RADIUS,0.0,(0.0-ZRad)+z])
-    Start_Height = 0 - ((0.0-ZRad)+z)
+    z = cos(radians(10)) * ZRad
+    verts.append([HOLE_RADIUS, 0.0, (0.0 - ZRad) + z])
+    Start_Height = 0 - ((0.0 - ZRad) + z)
     Row += 1
 
-    #for i in range(0,30,10):  was 0 to 30 more work needed to make this look good.
-    for i in range(10,30,10):
-        x = sin(radians(i))*XRad
-        z = cos(radians(i))*ZRad
-        verts.append([x,0.0,(0.0-ZRad)+z])
+    # for i in range(0,30,10):  was 0 to 30 more work needed to make this look good.
+    for i in range(10, 30, 10):
+        x = sin(radians(i)) * XRad
+        z = cos(radians(i)) * ZRad
+        verts.append([x, 0.0, (0.0 - ZRad) + z])
         Row += 1
 
-    for i in range(20,140,10):
-        x = sin(radians(i))*EndRad
-        z = cos(radians(i))*EndRad
-        if ((0.0 - EndZOffset)+z) < (0.0-HEIGHT):
-            verts.append([(HEAD_RADIUS -EndRad)+x,0.0,0.0 - HEIGHT])
+    for i in range(20, 140, 10):
+        x = sin(radians(i)) * EndRad
+        z = cos(radians(i)) * EndRad
+        if ((0.0 - EndZOffset) + z) < (0.0 - HEIGHT):
+            verts.append([(HEAD_RADIUS - EndRad) + x, 0.0, 0.0 - HEIGHT])
         else:
-            verts.append([(HEAD_RADIUS -EndRad)+x,0.0,(0.0 - EndZOffset)+z])
+            verts.append([(HEAD_RADIUS - EndRad) + x, 0.0, (0.0 - EndZOffset) + z])
         Row += 1
 
-
-    verts.append([SHANK_RADIUS,0.0,(0.0-HEIGHT)])
+    verts.append([SHANK_RADIUS, 0.0, (0.0 - HEIGHT)])
     Row += 1
 
-    verts.append([SHANK_RADIUS,0.0,(0.0-HEIGHT)-Start_Height])
+    verts.append([SHANK_RADIUS, 0.0, (0.0 - HEIGHT) - Start_Height])
     Row += 1
 
+    sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+    sVerts.extend(verts)  # add the start verts to the Spin verts to complete the loop
 
-    sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
-    sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
-
-    faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT))
+    faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT))
 
     # Global_Head_Height = HEIGHT  # UNUSED
 
-
-    return Move_Verts_Up_Z(sVerts,Start_Height),faces,HEIGHT
-
+    return Move_Verts_Up_Z(sVerts, Start_Height), faces, HEIGHT
 
 
-def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET,DIV_COUNT):
+def Create_Dome_Head(HOLE_DIA, HEAD_DIA, SHANK_DIA, HEIGHT, RAD1, RAD2, FACE_OFFSET, DIV_COUNT):
     HOLE_RADIUS = HOLE_DIA * 0.5
     HEAD_RADIUS = HEAD_DIA * 0.5
     SHANK_RADIUS = SHANK_DIA * 0.5
@@ -567,106 +547,95 @@ def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET,DI
     faces = []
     Row = 0
     # BEVEL = HEIGHT * 0.01  # UNUSED
-    #Dome_Rad =  HEAD_RADIUS * (1.0/1.75)
+    # Dome_Rad =  HEAD_RADIUS * (1.0/1.75)
 
-    Dome_Rad =  HEAD_RADIUS * 1.12
-    #Head_Height = HEAD_RADIUS * 0.78
+    Dome_Rad = HEAD_RADIUS * 1.12
+    # Head_Height = HEAD_RADIUS * 0.78
     RAD_Offset = HEAD_RADIUS * 0.98
     Dome_Height = HEAD_RADIUS * 0.64
     OtherRad = HEAD_RADIUS * 0.16
     OtherRad_X_Offset = HEAD_RADIUS * 0.84
     OtherRad_Z_Offset = HEAD_RADIUS * 0.504
 
-
-#    Dome_Rad =  5.6
-#    RAD_Offset = 4.9
-#    Dome_Height = 3.2
-#    OtherRad = 0.8
-#    OtherRad_X_Offset = 4.2
-#    OtherRad_Z_Offset = 2.52
-#
+    """
+    Dome_Rad =  5.6
+    RAD_Offset = 4.9
+    Dome_Height = 3.2
+    OtherRad = 0.8
+    OtherRad_X_Offset = 4.2
+    OtherRad_Z_Offset = 2.52
+   """
 
     FaceStart = FACE_OFFSET
 
-    verts.append([HOLE_RADIUS,0.0,0.0])
+    verts.append([HOLE_RADIUS, 0.0, 0.0])
     Row += 1
 
-
-    for i in range(0,60,10):
-        x = sin(radians(i))*Dome_Rad
-        z = cos(radians(i))*Dome_Rad
-        if ((0.0-RAD_Offset)+z) <= 0:
-            verts.append([x,0.0,(0.0-RAD_Offset)+z])
+    for i in range(0, 60, 10):
+        x = sin(radians(i)) * Dome_Rad
+        z = cos(radians(i)) * Dome_Rad
+        if ((0.0 - RAD_Offset) + z) <= 0:
+            verts.append([x, 0.0, (0.0 - RAD_Offset) + z])
             Row += 1
 
-
-    for i in range(60,160,10):
-        x = sin(radians(i))*OtherRad
-        z = cos(radians(i))*OtherRad
-        z = (0.0-OtherRad_Z_Offset)+z
-        if z < (0.0-Dome_Height):
-            z = (0.0-Dome_Height)
-        verts.append([OtherRad_X_Offset+x,0.0,z])
+    for i in range(60, 160, 10):
+        x = sin(radians(i)) * OtherRad
+        z = cos(radians(i)) * OtherRad
+        z = (0.0 - OtherRad_Z_Offset) + z
+        if z < (0.0 - Dome_Height):
+            z = (0.0 - Dome_Height)
+        verts.append([OtherRad_X_Offset + x, 0.0, z])
         Row += 1
 
-    verts.append([SHANK_RADIUS,0.0,(0.0-Dome_Height)])
+    verts.append([SHANK_RADIUS, 0.0, (0.0 - Dome_Height)])
     Row += 1
 
+    sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+    sVerts.extend(verts)   # add the start verts to the Spin verts to complete the loop
 
-    sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
-    sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
-
-    faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT))
+    faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT))
 
-    return sVerts,faces,Dome_Height
+    return sVerts, faces, Dome_Height
 
 
-
-def Create_CounterSink_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,DIV_COUNT):
+def Create_CounterSink_Head(HOLE_DIA, HEAD_DIA, SHANK_DIA, HEIGHT, RAD1, DIV_COUNT):
 
     HOLE_RADIUS = HOLE_DIA * 0.5
     HEAD_RADIUS = HEAD_DIA * 0.5
     SHANK_RADIUS = SHANK_DIA * 0.5
 
-
     verts = []
     faces = []
     Row = 0
 
-#    HEAD_RADIUS = (HEIGHT/tan(radians(60))) + SHANK_RADIUS
+    # HEAD_RADIUS = (HEIGHT/tan(radians(60))) + SHANK_RADIUS
     HEIGHT = tan(radians(60)) * (HEAD_RADIUS - SHANK_RADIUS)
-    #print (RAD1)
+    # print(RAD1)
 
     FaceStart = len(verts)
 
-    verts.append([HOLE_RADIUS,0.0,0.0])
+    verts.append([HOLE_RADIUS, 0.0, 0.0])
     Row += 1
 
-    #rad
-
-    for i in range(0,100,10):
-        x = sin(radians(i))*RAD1
-        z = cos(radians(i))*RAD1
-        verts.append([(HEAD_RADIUS-RAD1)+x,0.0,(0.0-RAD1)+z])
+    # rad
+    for i in range(0, 100, 10):
+        x = sin(radians(i)) * RAD1
+        z = cos(radians(i)) * RAD1
+        verts.append([(HEAD_RADIUS - RAD1) + x, 0.0, (0.0 - RAD1) + z])
         Row += 1
 
-
-    verts.append([SHANK_RADIUS,0.0,0.0-HEIGHT])
+    verts.append([SHANK_RADIUS, 0.0, 0.0 - HEIGHT])
     Row += 1
 
+    sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+    sVerts.extend(verts)    # add the start verts to the Spin verts to complete the loop
 
-    sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
-    sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
-
-
-    faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT,1))
+    faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT, 1))
 
-    return sVerts,faces,HEIGHT
+    return sVerts, faces, HEIGHT
 
 
-
-
-def Create_Cap_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,DIV_COUNT):
+def Create_Cap_Head(HOLE_DIA, HEAD_DIA, SHANK_DIA, HEIGHT, RAD1, RAD2, DIV_COUNT):
 
     HOLE_RADIUS = HOLE_DIA * 0.5
     HEAD_RADIUS = HEAD_DIA * 0.5
@@ -677,613 +646,580 @@ def Create_Cap_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,DIV_COUNT):
     Row = 0
     BEVEL = HEIGHT * 0.01
 
-
     FaceStart = len(verts)
 
-    verts.append([HOLE_RADIUS,0.0,0.0])
+    verts.append([HOLE_RADIUS, 0.0, 0.0])
     Row += 1
 
-    #rad
-
-    for i in range(0,100,10):
-        x = sin(radians(i))*RAD1
-        z = cos(radians(i))*RAD1
-        verts.append([(HEAD_RADIUS-RAD1)+x,0.0,(0.0-RAD1)+z])
+    # rad
+    for i in range(0, 100, 10):
+        x = sin(radians(i)) * RAD1
+        z = cos(radians(i)) * RAD1
+        verts.append([(HEAD_RADIUS - RAD1) + x, 0.0, (0.0 - RAD1) + z])
         Row += 1
 
-
-    verts.append([HEAD_RADIUS,0.0,0.0-HEIGHT+BEVEL])
+    verts.append([HEAD_RADIUS, 0.0, 0.0 - HEIGHT + BEVEL])
     Row += 1
 
-    verts.append([HEAD_RADIUS-BEVEL,0.0,0.0-HEIGHT])
+    verts.append([HEAD_RADIUS - BEVEL, 0.0, 0.0 - HEIGHT])
     Row += 1
 
-    #rad2
-
-    for i in range(0,100,10):
-        x = sin(radians(i))*RAD2
-        z = cos(radians(i))*RAD2
-        verts.append([(SHANK_RADIUS+RAD2)-x,0.0,(0.0-HEIGHT-RAD2)+z])
+    # rad2
+    for i in range(0, 100, 10):
+        x = sin(radians(i)) * RAD2
+        z = cos(radians(i)) * RAD2
+        verts.append([(SHANK_RADIUS + RAD2) - x, 0.0, (0.0 - HEIGHT - RAD2) + z])
         Row += 1
 
+    sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+    sVerts.extend(verts)    # add the start verts to the Spin verts to complete the loop
 
-    sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
-    sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
-
-
-    faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT))
+    faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT))
 
-    return sVerts,faces,HEIGHT+RAD2
+    return sVerts, faces, HEIGHT + RAD2
 
 
-def Create_Hex_Head(FLAT,HOLE_DIA,SHANK_DIA,HEIGHT):
+def Create_Hex_Head(FLAT, HOLE_DIA, SHANK_DIA, HEIGHT):
 
     verts = []
     faces = []
     HOLE_RADIUS = HOLE_DIA * 0.5
-    Half_Flat = FLAT/2
-    TopBevelRadius = Half_Flat - (Half_Flat* (0.05/8))
-    Undercut_Height = (Half_Flat* (0.05/8))
-    Shank_Bevel = (Half_Flat* (0.05/8))
+    Half_Flat = FLAT / 2
+    TopBevelRadius = Half_Flat - (Half_Flat * (0.05 / 8))
+    Undercut_Height = (Half_Flat * (0.05 / 8))
+    Shank_Bevel = (Half_Flat * (0.05 / 8))
     Flat_Height = HEIGHT - Undercut_Height - Shank_Bevel
-    #Undercut_Height = 5
-    SHANK_RADIUS = SHANK_DIA/2
-    Row = 0;
-
-    verts.append([0.0,0.0,0.0])
+    # Undercut_Height = 5
+    SHANK_RADIUS = SHANK_DIA / 2
+    Row = 0
 
+    verts.append([0.0, 0.0, 0.0])
 
     FaceStart = len(verts)
-    #inner hole
 
-    x = sin(radians(0))*HOLE_RADIUS
-    y = cos(radians(0))*HOLE_RADIUS
-    verts.append([x,y,0.0])
+    # inner hole
+    x = sin(radians(0)) * HOLE_RADIUS
+    y = cos(radians(0)) * HOLE_RADIUS
+    verts.append([x, y, 0.0])
 
+    x = sin(radians(60 / 6)) * HOLE_RADIUS
+    y = cos(radians(60 / 6)) * HOLE_RADIUS
+    verts.append([x, y, 0.0])
 
-    x = sin(radians(60/6))*HOLE_RADIUS
-    y = cos(radians(60/6))*HOLE_RADIUS
-    verts.append([x,y,0.0])
+    x = sin(radians(60 / 3)) * HOLE_RADIUS
+    y = cos(radians(60 / 3)) * HOLE_RADIUS
+    verts.append([x, y, 0.0])
 
-
-    x = sin(radians(60/3))*HOLE_RADIUS
-    y = cos(radians(60/3))*HOLE_RADIUS
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/2))*HOLE_RADIUS
-    y = cos(radians(60/2))*HOLE_RADIUS
-    verts.append([x,y,0.0])
+    x = sin(radians(60 / 2)) * HOLE_RADIUS
+    y = cos(radians(60 / 2)) * HOLE_RADIUS
+    verts.append([x, y, 0.0])
     Row += 1
 
-    #bevel
-
-    x = sin(radians(0))*TopBevelRadius
-    y = cos(radians(0))*TopBevelRadius
-    vec1 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/6))*TopBevelRadius
-    y = cos(radians(60/6))*TopBevelRadius
-    vec2 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/3))*TopBevelRadius
-    y = cos(radians(60/3))*TopBevelRadius
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/2))*TopBevelRadius
-    y = cos(radians(60/2))*TopBevelRadius
-    vec4 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,0.0])
+    # bevel
+    x = sin(radians(0)) * TopBevelRadius
+    y = cos(radians(0)) * TopBevelRadius
+    vec1 = Vector([x, y, 0.0])
+    verts.append([x, y, 0.0])
+
+    x = sin(radians(60 / 6)) * TopBevelRadius
+    y = cos(radians(60 / 6)) * TopBevelRadius
+    vec2 = Vector([x, y, 0.0])
+    verts.append([x, y, 0.0])
+
+    x = sin(radians(60 / 3)) * TopBevelRadius
+    y = cos(radians(60 / 3)) * TopBevelRadius
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, 0.0])
+
+    x = sin(radians(60 / 2)) * TopBevelRadius
+    y = cos(radians(60 / 2)) * TopBevelRadius
+    vec4 = Vector([x, y, 0.0])
+    verts.append([x, y, 0.0])
     Row += 1
 
-    #Flats
-
-    x = tan(radians(0))*Half_Flat
-    dvec = vec1 - mathutils.Vector([x,Half_Flat,0.0])
-    verts.append([x,Half_Flat,-dvec.length])
+    # Flats
+    x = tan(radians(0)) * Half_Flat
+    dvec = vec1 - Vector([x, Half_Flat, 0.0])
+    verts.append([x, Half_Flat, -dvec.length])
 
+    x = tan(radians(60 / 6)) * Half_Flat
+    dvec = vec2 - Vector([x, Half_Flat, 0.0])
+    verts.append([x, Half_Flat, -dvec.length])
 
-    x = tan(radians(60/6))*Half_Flat
-    dvec = vec2 - mathutils.Vector([x,Half_Flat,0.0])
-    verts.append([x,Half_Flat,-dvec.length])
-
-
-    x = tan(radians(60/3))*Half_Flat
-    dvec = vec3 - mathutils.Vector([x,Half_Flat,0.0])
+    x = tan(radians(60 / 3)) * Half_Flat
+    dvec = vec3 - Vector([x, Half_Flat, 0.0])
     Lowest_Point = -dvec.length
-    verts.append([x,Half_Flat,-dvec.length])
-
+    verts.append([x, Half_Flat, -dvec.length])
 
-    x = tan(radians(60/2))*Half_Flat
-    dvec = vec4 - mathutils.Vector([x,Half_Flat,0.0])
+    x = tan(radians(60 / 2)) * Half_Flat
+    dvec = vec4 - Vector([x, Half_Flat, 0.0])
     Lowest_Point = -dvec.length
-    verts.append([x,Half_Flat,-dvec.length])
+    verts.append([x, Half_Flat, -dvec.length])
     Row += 1
 
-    #down Bits Tri
-    x = tan(radians(0))*Half_Flat
-    verts.append([x,Half_Flat,Lowest_Point])
+    # down Bits Tri
+    x = tan(radians(0)) * Half_Flat
+    verts.append([x, Half_Flat, Lowest_Point])
 
-    x = tan(radians(60/6))*Half_Flat
-    verts.append([x,Half_Flat,Lowest_Point])
+    x = tan(radians(60 / 6)) * Half_Flat
+    verts.append([x, Half_Flat, Lowest_Point])
 
-    x = tan(radians(60/3))*Half_Flat
-    verts.append([x,Half_Flat,Lowest_Point])
+    x = tan(radians(60 / 3)) * Half_Flat
+    verts.append([x, Half_Flat, Lowest_Point])
 
-    x = tan(radians(60/2))*Half_Flat
-    verts.append([x,Half_Flat,Lowest_Point])
+    x = tan(radians(60 / 2)) * Half_Flat
+    verts.append([x, Half_Flat, Lowest_Point])
     Row += 1
 
-    #down Bits
+    # down Bits
 
-    x = tan(radians(0))*Half_Flat
-    verts.append([x,Half_Flat,-Flat_Height])
+    x = tan(radians(0)) * Half_Flat
+    verts.append([x, Half_Flat, -Flat_Height])
 
-    x = tan(radians(60/6))*Half_Flat
-    verts.append([x,Half_Flat,-Flat_Height])
+    x = tan(radians(60 / 6)) * Half_Flat
+    verts.append([x, Half_Flat, -Flat_Height])
 
-    x = tan(radians(60/3))*Half_Flat
-    verts.append([x,Half_Flat,-Flat_Height])
+    x = tan(radians(60 / 3)) * Half_Flat
+    verts.append([x, Half_Flat, -Flat_Height])
 
-    x = tan(radians(60/2))*Half_Flat
-    verts.append([x,Half_Flat,-Flat_Height])
+    x = tan(radians(60 / 2)) * Half_Flat
+    verts.append([x, Half_Flat, -Flat_Height])
     Row += 1
 
-
-    #under cut
-
-    x = sin(radians(0))*Half_Flat
-    y = cos(radians(0))*Half_Flat
-    vec1 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height])
-
-    x = sin(radians(60/6))*Half_Flat
-    y = cos(radians(60/6))*Half_Flat
-    vec2 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height])
-
-    x = sin(radians(60/3))*Half_Flat
-    y = cos(radians(60/3))*Half_Flat
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height])
-
-    x = sin(radians(60/2))*Half_Flat
-    y = cos(radians(60/2))*Half_Flat
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height])
+    # Under cut
+    x = sin(radians(0)) * Half_Flat
+    y = cos(radians(0)) * Half_Flat
+    vec1 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height])
+
+    x = sin(radians(60 / 6)) * Half_Flat
+    y = cos(radians(60 / 6)) * Half_Flat
+    vec2 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height])
+
+    x = sin(radians(60 / 3)) * Half_Flat
+    y = cos(radians(60 / 3)) * Half_Flat
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height])
+
+    x = sin(radians(60 / 2)) * Half_Flat
+    y = cos(radians(60 / 2)) * Half_Flat
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height])
     Row += 1
 
-    #under cut down bit
-    x = sin(radians(0))*Half_Flat
-    y = cos(radians(0))*Half_Flat
-    vec1 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height])
-
-    x = sin(radians(60/6))*Half_Flat
-    y = cos(radians(60/6))*Half_Flat
-    vec2 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height])
-
-    x = sin(radians(60/3))*Half_Flat
-    y = cos(radians(60/3))*Half_Flat
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height])
-
-    x = sin(radians(60/2))*Half_Flat
-    y = cos(radians(60/2))*Half_Flat
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height])
+    # Under cut down bit
+    x = sin(radians(0)) * Half_Flat
+    y = cos(radians(0)) * Half_Flat
+    vec1 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height])
+
+    x = sin(radians(60 / 6)) * Half_Flat
+    y = cos(radians(60 / 6)) * Half_Flat
+    vec2 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height])
+
+    x = sin(radians(60 / 3)) * Half_Flat
+    y = cos(radians(60 / 3)) * Half_Flat
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height])
+
+    x = sin(radians(60 / 2)) * Half_Flat
+    y = cos(radians(60 / 2)) * Half_Flat
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height])
     Row += 1
 
-    #under cut to Shank BEVEAL
-    x = sin(radians(0))*(SHANK_RADIUS+Shank_Bevel)
-    y = cos(radians(0))*(SHANK_RADIUS+Shank_Bevel)
-    vec1 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height])
-
-    x = sin(radians(60/6))*(SHANK_RADIUS+Shank_Bevel)
-    y = cos(radians(60/6))*(SHANK_RADIUS+Shank_Bevel)
-    vec2 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height])
-
-    x = sin(radians(60/3))*(SHANK_RADIUS+Shank_Bevel)
-    y = cos(radians(60/3))*(SHANK_RADIUS+Shank_Bevel)
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height])
-
-    x = sin(radians(60/2))*(SHANK_RADIUS+Shank_Bevel)
-    y = cos(radians(60/2))*(SHANK_RADIUS+Shank_Bevel)
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height])
+    # Under cut to Shank BEVEL
+    x = sin(radians(0)) * (SHANK_RADIUS + Shank_Bevel)
+    y = cos(radians(0)) * (SHANK_RADIUS + Shank_Bevel)
+    vec1 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height])
+
+    x = sin(radians(60 / 6)) * (SHANK_RADIUS + Shank_Bevel)
+    y = cos(radians(60 / 6)) * (SHANK_RADIUS + Shank_Bevel)
+    vec2 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height])
+
+    x = sin(radians(60 / 3)) * (SHANK_RADIUS + Shank_Bevel)
+    y = cos(radians(60 / 3)) * (SHANK_RADIUS + Shank_Bevel)
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height])
+
+    x = sin(radians(60 / 2)) * (SHANK_RADIUS + Shank_Bevel)
+    y = cos(radians(60 / 2)) * (SHANK_RADIUS + Shank_Bevel)
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height])
     Row += 1
 
-    #under cut to Shank BEVEAL
-    x = sin(radians(0))*SHANK_RADIUS
-    y = cos(radians(0))*SHANK_RADIUS
-    vec1 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
-
-    x = sin(radians(60/6))*SHANK_RADIUS
-    y = cos(radians(60/6))*SHANK_RADIUS
-    vec2 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
-
-    x = sin(radians(60/3))*SHANK_RADIUS
-    y = cos(radians(60/3))*SHANK_RADIUS
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
-
-    x = sin(radians(60/2))*SHANK_RADIUS
-    y = cos(radians(60/2))*SHANK_RADIUS
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
+    # Under cut to Shank BEVEL
+    x = sin(radians(0)) * SHANK_RADIUS
+    y = cos(radians(0)) * SHANK_RADIUS
+    vec1 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
+
+    x = sin(radians(60 / 6)) * SHANK_RADIUS
+    y = cos(radians(60 / 6)) * SHANK_RADIUS
+    vec2 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
+
+    x = sin(radians(60 / 3)) * SHANK_RADIUS
+    y = cos(radians(60 / 3)) * SHANK_RADIUS
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
+
+    x = sin(radians(60 / 2)) * SHANK_RADIUS
+    y = cos(radians(60 / 2)) * SHANK_RADIUS
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
     Row += 1
 
+    # Global_Head_Height = 0 - (-HEIGHT-0.1)
+    faces.extend(Build_Face_List_Quads(FaceStart, 3, Row - 1))
 
-    #Global_Head_Height = 0 - (-HEIGHT-0.1)
-    faces.extend(Build_Face_List_Quads(FaceStart,3,Row - 1))
-
-
-    Mirror_Verts,Mirror_Faces = Mirror_Verts_Faces(verts,faces,'y')
+    Mirror_Verts, Mirror_Faces = Mirror_Verts_Faces(verts, faces, 'y')
     verts.extend(Mirror_Verts)
     faces.extend(Mirror_Faces)
 
-    Spin_Verts,Spin_Faces = SpinDup(verts,faces,360,6,'z')
+    Spin_Verts, Spin_Faces = SpinDup(verts, faces, 360, 6, 'z')
 
+    return Spin_Verts, Spin_Faces, 0 - (-HEIGHT)
 
-    return Spin_Verts,Spin_Faces,0 - (-HEIGHT)
 
+# ####################################################################
+#                    Create External Thread
+# ####################################################################
 
-##########################################################################################
-##########################################################################################
-##                    Create External Thread
-##########################################################################################
-##########################################################################################
 
+def Thread_Start3(verts, INNER_RADIUS, OUTTER_RADIUS, PITCH, DIV_COUNT,
+                  CREST_PERCENT, ROOT_PERCENT, Height_Offset):
 
-
-def Thread_Start3(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV_COUNT,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
-
-
-    Ret_Row = 0;
+    Ret_Row = 0
 
     # Half_Pitch = float(PITCH)/2  # UNUSED
     Height_Start = Height_Offset - PITCH
-    Height_Step = float(PITCH)/float(DIV_COUNT)
-    Deg_Step = 360.0 /float(DIV_COUNT)
+    Height_Step = float(PITCH) / float(DIV_COUNT)
+    Deg_Step = 360.0 / float(DIV_COUNT)
 
-    Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
-    Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
-    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
 
-#theard start
-
-    Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV_COUNT)
+    # thread start
+    Rank = float(OUTTER_RADIUS - INNER_RADIUS) / float(DIV_COUNT)
     for j in range(4):
 
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,z])
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, z])
         Height_Offset -= Crest_Height
         Ret_Row += 1
 
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,z ])
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, z])
         Height_Offset -= Crest_to_Root_Height
         Ret_Row += 1
 
-
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
             if j == 0:
-                x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-                y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-            verts.append([x,y,z ])
+                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+            verts.append([x, y, z])
         Height_Offset -= Root_Height
         Ret_Row += 1
 
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
 
             if j == 0:
-                x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-                y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-            verts.append([x,y,z ])
+                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+            verts.append([x, y, z])
         Height_Offset -= Root_to_Crest_Height
         Ret_Row += 1
 
-    return Ret_Row,Height_Offset
+    return Ret_Row, Height_Offset
 
 
-def Create_Shank_Verts(START_DIA,OUTTER_DIA,LENGTH,Z_LOCATION,DIV_COUNT):
+def Create_Shank_Verts(START_DIA, OUTTER_DIA, LENGTH, Z_LOCATION, DIV_COUNT):
 
     verts = []
 
-    START_RADIUS = START_DIA/2
-    OUTTER_RADIUS = OUTTER_DIA/2
+    START_RADIUS = START_DIA / 2
+    OUTTER_RADIUS = OUTTER_DIA / 2
 
     Opp = abs(START_RADIUS - OUTTER_RADIUS)
-    Taper_Lentgh = Opp/tan(radians(31));
+    Taper_Lentgh = Opp / tan(radians(31))
 
     if Taper_Lentgh > LENGTH:
         Taper_Lentgh = 0
 
     Stright_Length = LENGTH - Taper_Lentgh
 
-    Deg_Step = 360.0 /float(DIV_COUNT)
+    Deg_Step = 360.0 / float(DIV_COUNT)
 
     Row = 0
 
-    Lowest_Z_Vert = 0;
+    Lowest_Z_Vert = 0
 
     Height_Offset = Z_LOCATION
 
-
-        #ring
-    for i in range(DIV_COUNT+1):
-        x = sin(radians(i*Deg_Step))*START_RADIUS
-        y = cos(radians(i*Deg_Step))*START_RADIUS
-        z =  Height_Offset - 0
-        verts.append([x,y,z])
-        Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    # Ring
+    for i in range(DIV_COUNT + 1):
+        x = sin(radians(i * Deg_Step)) * START_RADIUS
+        y = cos(radians(i * Deg_Step)) * START_RADIUS
+        z = Height_Offset - 0
+        verts.append([x, y, z])
+        Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Height_Offset -= Stright_Length
     Row += 1
 
-    for i in range(DIV_COUNT+1):
-        x = sin(radians(i*Deg_Step))*START_RADIUS
-        y = cos(radians(i*Deg_Step))*START_RADIUS
-        z =  Height_Offset - 0
-        verts.append([x,y,z])
-        Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    for i in range(DIV_COUNT + 1):
+        x = sin(radians(i * Deg_Step)) * START_RADIUS
+        y = cos(radians(i * Deg_Step)) * START_RADIUS
+        z = Height_Offset - 0
+        verts.append([x, y, z])
+        Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Height_Offset -= Taper_Lentgh
     Row += 1
 
-
-    return verts,Row,Height_Offset
+    return verts, Row, Height_Offset
 
 
-def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION,DIV_COUNT):
+def Create_Thread_Start_Verts(INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
+                              ROOT_PERCENT, Z_LOCATION, DIV_COUNT):
 
     verts = []
 
-    INNER_RADIUS = INNER_DIA/2
-    OUTTER_RADIUS = OUTTER_DIA/2
+    INNER_RADIUS = INNER_DIA / 2
+    OUTTER_RADIUS = OUTTER_DIA / 2
 
     # Half_Pitch = float(PITCH)/2  # UNUSED
-    Deg_Step = 360.0 /float(DIV_COUNT)
-    Height_Step = float(PITCH)/float(DIV_COUNT)
+    Deg_Step = 360.0 / float(DIV_COUNT)
+    Height_Step = float(PITCH) / float(DIV_COUNT)
 
     Row = 0
 
-    Lowest_Z_Vert = 0;
+    Lowest_Z_Vert = 0
 
     Height_Offset = Z_LOCATION
 
     Height_Start = Height_Offset
 
-    Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
-    Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
-    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
 
-    Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV_COUNT)
+    Rank = float(OUTTER_RADIUS - INNER_RADIUS) / float(DIV_COUNT)
 
     Height_Offset = Z_LOCATION + PITCH
     Cut_off = Z_LOCATION
 
-
     for j in range(1):
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            z = Height_Offset - (Height_Step*i)
-            if z > Cut_off : z = Cut_off
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            z = Height_Offset - (Height_Step * i)
+            if z > Cut_off:
+                z = Cut_off
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Crest_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            z = Height_Offset - (Height_Step*i)
-            if z > Cut_off : z = Cut_off
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            z = Height_Offset - (Height_Step * i)
+            if z > Cut_off:
+                z = Cut_off
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Crest_to_Root_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            z = Height_Offset - (Height_Step*i)
-            if z > Cut_off : z = Cut_off
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            z = Height_Offset - (Height_Step * i)
+            if z > Cut_off:
+                z = Cut_off
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Root_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            z = Height_Offset - (Height_Step*i)
-            if z > Cut_off : z = Cut_off
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            z = Height_Offset - (Height_Step * i)
+            if z > Cut_off:
+                z = Cut_off
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Root_to_Crest_Height
         Row += 1
 
-
     for j in range(2):
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Crest_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,z ])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Crest_to_Root_Height
         Row += 1
 
-
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
             if j == 0:
-                x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-                y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-            verts.append([x,y,z ])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Root_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
 
             if j == 0:
-                x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-                y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-            verts.append([x,y,z ])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Root_to_Crest_Height
         Row += 1
 
-
-    return verts,Row,Height_Offset
+    return verts, Row, Height_Offset
 
 
+def Create_Thread_Verts(INNER_DIA, OUTTER_DIA, PITCH, HEIGHT,
+                        CREST_PERCENT, ROOT_PERCENT, Z_LOCATION, DIV_COUNT):
 
-def Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION,DIV_COUNT):
     verts = []
 
-
-    INNER_RADIUS = INNER_DIA/2
-    OUTTER_RADIUS = OUTTER_DIA/2
+    INNER_RADIUS = INNER_DIA / 2
+    OUTTER_RADIUS = OUTTER_DIA / 2
 
     # Half_Pitch = float(PITCH)/2  # UNUSED
-    Deg_Step = 360.0 /float(DIV_COUNT)
-    Height_Step = float(PITCH)/float(DIV_COUNT)
+    Deg_Step = 360.0 / float(DIV_COUNT)
+    Height_Step = float(PITCH) / float(DIV_COUNT)
 
     NUM_OF_START_THREADS = 4.0
     NUM_OF_END_THREADS = 3.0
-    Num = int((HEIGHT- ((NUM_OF_START_THREADS*PITCH) + (NUM_OF_END_THREADS*PITCH) ))/PITCH)
+    Num = int((HEIGHT - ((NUM_OF_START_THREADS * PITCH) + (NUM_OF_END_THREADS * PITCH))) / PITCH)
     Row = 0
 
-
-    Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
-    Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
-    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
-
+    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
 
     Height_Offset = Z_LOCATION
 
-    Lowest_Z_Vert = 0;
+    Lowest_Z_Vert = 0
 
     for j in range(Num):
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            z = Height_Offset - (Height_Step*i)
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            z = Height_Offset - (Height_Step * i)
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Crest_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            z = Height_Offset - (Height_Step*i)
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            z = Height_Offset - (Height_Step * i)
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Crest_to_Root_Height
         Row += 1
 
-
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
-            z = Height_Offset - (Height_Step*i)
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
+            z = Height_Offset - (Height_Step * i)
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Root_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
-            z = Height_Offset - (Height_Step*i)
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
+            z = Height_Offset - (Height_Step * i)
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Root_to_Crest_Height
         Row += 1
 
-    return verts,Row,Height_Offset
-
+    return verts, Row, Height_Offset
 
 
-def Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION,DIV_COUNT):
+def Create_Thread_End_Verts(INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
+                            ROOT_PERCENT, Z_LOCATION, DIV_COUNT):
     verts = []
 
-
-    INNER_RADIUS = INNER_DIA/2
-    OUTTER_RADIUS = OUTTER_DIA/2
+    INNER_RADIUS = INNER_DIA / 2
+    OUTTER_RADIUS = OUTTER_DIA / 2
 
     # Half_Pitch = float(PITCH)/2  # UNUSED
-    Deg_Step = 360.0 /float(DIV_COUNT)
-    Height_Step = float(PITCH)/float(DIV_COUNT)
+    Deg_Step = 360.0 / float(DIV_COUNT)
+    Height_Step = float(PITCH) / float(DIV_COUNT)
 
-    Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
-    Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
-    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
 
     # Col = 0  # UNUSED
     Row = 0
@@ -1294,74 +1230,72 @@ def Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCEN
 
     Max_Height = Tapper_Height_Start - PITCH
 
-    Lowest_Z_Vert = 0;
+    Lowest_Z_Vert = 0
 
     # FaceStart = len(verts)  # UNUSED
     for j in range(4):
 
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
-            z = max(z,Max_Height)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
+            z = max(z, Max_Height)
             Tapper_Radius = OUTTER_RADIUS
             if z < Tapper_Height_Start:
                 Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
 
-            x = sin(radians(i*Deg_Step))*(Tapper_Radius)
-            y = cos(radians(i*Deg_Step))*(Tapper_Radius)
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+            x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
+            y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Crest_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
-            z = max(z,Max_Height)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
+            z = max(z, Max_Height)
             Tapper_Radius = OUTTER_RADIUS
             if z < Tapper_Height_Start:
                 Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
 
-            x = sin(radians(i*Deg_Step))*(Tapper_Radius)
-            y = cos(radians(i*Deg_Step))*(Tapper_Radius)
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+            x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
+            y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Crest_to_Root_Height
         Row += 1
 
-
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
-            z = max(z,Max_Height)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
+            z = max(z, Max_Height)
             Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
             if Tapper_Radius > INNER_RADIUS:
                 Tapper_Radius = INNER_RADIUS
 
-            x = sin(radians(i*Deg_Step))*(Tapper_Radius)
-            y = cos(radians(i*Deg_Step))*(Tapper_Radius)
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+            x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
+            y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Root_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            z = Height_Offset - (Height_Step*i)
-            z = max(z,Max_Height)
+        for i in range(DIV_COUNT + 1):
+            z = Height_Offset - (Height_Step * i)
+            z = max(z, Max_Height)
             Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
             if Tapper_Radius > INNER_RADIUS:
                 Tapper_Radius = INNER_RADIUS
 
-            x = sin(radians(i*Deg_Step))*(Tapper_Radius)
-            y = cos(radians(i*Deg_Step))*(Tapper_Radius)
-            verts.append([x,y,z])
-            Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+            x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
+            y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
+            verts.append([x, y, z])
+            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Height_Offset -= Root_to_Crest_Height
         Row += 1
 
-    return verts,Row,Height_Offset,Lowest_Z_Vert
-
-
+    return verts, Row, Height_Offset, Lowest_Z_Vert
 
 
-def Create_External_Thread(SHANK_DIA,SHANK_LENGTH,INNER_DIA,OUTTER_DIA,PITCH,LENGTH,CREST_PERCENT,ROOT_PERCENT,DIV_COUNT):
+def Create_External_Thread(SHANK_DIA, SHANK_LENGTH, INNER_DIA, OUTTER_DIA,
+                           PITCH, LENGTH, CREST_PERCENT, ROOT_PERCENT, DIV_COUNT):
 
     verts = []
     faces = []
@@ -1370,202 +1304,193 @@ def Create_External_Thread(SHANK_DIA,SHANK_LENGTH,INNER_DIA,OUTTER_DIA,PITCH,LEN
     # Thread_Len = 0  # UNUSED
 
     Face_Start = len(verts)
-    Offset = 0.0;
+    Offset = 0.0
 
-
-    Shank_Verts,Shank_Row,Offset = Create_Shank_Verts(SHANK_DIA,OUTTER_DIA,SHANK_LENGTH,Offset,DIV_COUNT)
+    Shank_Verts, Shank_Row, Offset = Create_Shank_Verts(
+                                                    SHANK_DIA, OUTTER_DIA, SHANK_LENGTH,
+                                                    Offset, DIV_COUNT
+                                                    )
     Total_Row += Shank_Row
 
-    Thread_Start_Verts,Thread_Start_Row,Offset = Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Offset,DIV_COUNT)
+    Thread_Start_Verts, Thread_Start_Row, Offset = Create_Thread_Start_Verts(
+                                                    INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
+                                                    ROOT_PERCENT, Offset, DIV_COUNT
+                                                    )
     Total_Row += Thread_Start_Row
 
-
-    Thread_Verts,Thread_Row,Offset = Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,LENGTH,CREST_PERCENT,ROOT_PERCENT,Offset,DIV_COUNT)
+    Thread_Verts, Thread_Row, Offset = Create_Thread_Verts(
+                                                    INNER_DIA, OUTTER_DIA, PITCH, LENGTH,
+                                                    CREST_PERCENT, ROOT_PERCENT, Offset, DIV_COUNT
+                                                    )
     Total_Row += Thread_Row
 
-
-    Thread_End_Verts,Thread_End_Row,Offset,Lowest_Z_Vert = Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Offset,DIV_COUNT )
+    Thread_End_Verts, Thread_End_Row, Offset, Lowest_Z_Vert = Create_Thread_End_Verts(
+                                                    INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
+                                                    ROOT_PERCENT, Offset, DIV_COUNT
+                                                    )
     Total_Row += Thread_End_Row
 
-
     verts.extend(Shank_Verts)
     verts.extend(Thread_Start_Verts)
     verts.extend(Thread_Verts)
     verts.extend(Thread_End_Verts)
 
-    faces.extend(Build_Face_List_Quads(Face_Start,DIV_COUNT,Total_Row -1,0))
-    faces.extend(Fill_Ring_Face(len(verts)-DIV_COUNT,DIV_COUNT,1))
+    faces.extend(Build_Face_List_Quads(Face_Start, DIV_COUNT, Total_Row - 1, 0))
+    faces.extend(Fill_Ring_Face(len(verts) - DIV_COUNT, DIV_COUNT, 1))
 
-    return verts,faces,0.0 - Lowest_Z_Vert
+    return verts, faces, 0.0 - Lowest_Z_Vert
 
 
-##########################################################################################
-##########################################################################################
-##                    Create Nut
-##########################################################################################
-##########################################################################################
+# ####################################################################
+#                   Create Nut
+# ####################################################################
 
-def add_Hex_Nut(FLAT,HOLE_DIA,HEIGHT):
+def add_Hex_Nut(FLAT, HOLE_DIA, HEIGHT):
     global Global_Head_Height
     global Global_NutRad
 
     verts = []
     faces = []
     HOLE_RADIUS = HOLE_DIA * 0.5
-    Half_Flat = FLAT/2
-    Half_Height = HEIGHT/2
+    Half_Flat = FLAT / 2
+    Half_Height = HEIGHT / 2
     TopBevelRadius = Half_Flat - 0.05
 
-    Global_NutRad =  TopBevelRadius
-
-    Row = 0;
-    Lowest_Z_Vert = 0.0;
+    Global_NutRad = TopBevelRadius
 
-    verts.append([0.0,0.0,0.0])
+    Row = 0
+    Lowest_Z_Vert = 0.0
 
+    verts.append([0.0, 0.0, 0.0])
 
     FaceStart = len(verts)
-    #inner hole
-
-    x = sin(radians(0))*HOLE_RADIUS
-    y = cos(radians(0))*HOLE_RADIUS
-    #print ("rad 0 x;",  x,  "y:" ,y )
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/6))*HOLE_RADIUS
-    y = cos(radians(60/6))*HOLE_RADIUS
-    #print ("rad 60/6x;",  x,  "y:" ,y )
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/3))*HOLE_RADIUS
-    y = cos(radians(60/3))*HOLE_RADIUS
-    #print ("rad 60/3x;",  x,  "y:" ,y )
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/2))*HOLE_RADIUS
-    y = cos(radians(60/2))*HOLE_RADIUS
-    #print ("rad 60/2x;",  x,  "y:" ,y )
-    verts.append([x,y,0.0])
+    # inner hole
+
+    x = sin(radians(0)) * HOLE_RADIUS
+    y = cos(radians(0)) * HOLE_RADIUS
+    # print ("rad 0 x;",  x,  "y:" ,y )
+    verts.append([x, y, 0.0])
+
+    x = sin(radians(60 / 6)) * HOLE_RADIUS
+    y = cos(radians(60 / 6)) * HOLE_RADIUS
+    # print ("rad 60/6x;",  x,  "y:" ,y )
+    verts.append([x, y, 0.0])
+
+    x = sin(radians(60 / 3)) * HOLE_RADIUS
+    y = cos(radians(60 / 3)) * HOLE_RADIUS
+    # print ("rad 60/3x;",  x,  "y:" ,y )
+    verts.append([x, y, 0.0])
+
+    x = sin(radians(60 / 2)) * HOLE_RADIUS
+    y = cos(radians(60 / 2)) * HOLE_RADIUS
+    # print ("rad 60/2x;",  x,  "y:" ,y )
+    verts.append([x, y, 0.0])
     Row += 1
 
+    # Bevel
 
-    #bevel
+    x = sin(radians(0)) * TopBevelRadius
+    y = cos(radians(0)) * TopBevelRadius
+    vec1 = Vector([x, y, 0.0])
+    verts.append([x, y, 0.0])
 
-    x = sin(radians(0))*TopBevelRadius
-    y = cos(radians(0))*TopBevelRadius
-    vec1 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,0.0])
+    x = sin(radians(60 / 6)) * TopBevelRadius
+    y = cos(radians(60 / 6)) * TopBevelRadius
+    vec2 = Vector([x, y, 0.0])
+    verts.append([x, y, 0.0])
 
+    x = sin(radians(60 / 3)) * TopBevelRadius
+    y = cos(radians(60 / 3)) * TopBevelRadius
+    vec3 = Vector([x, y, 0.0])
+    verts.append([x, y, 0.0])
 
-    x = sin(radians(60/6))*TopBevelRadius
-    y = cos(radians(60/6))*TopBevelRadius
-    vec2 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/3))*TopBevelRadius
-    y = cos(radians(60/3))*TopBevelRadius
-    vec3 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,0.0])
-
-
-    x = sin(radians(60/2))*TopBevelRadius
-    y = cos(radians(60/2))*TopBevelRadius
-    vec4 = mathutils.Vector([x,y,0.0])
-    verts.append([x,y,0.0])
+    x = sin(radians(60 / 2)) * TopBevelRadius
+    y = cos(radians(60 / 2)) * TopBevelRadius
+    vec4 = Vector([x, y, 0.0])
+    verts.append([x, y, 0.0])
     Row += 1
 
-    #Flats
-
-    x = tan(radians(0))*Half_Flat
-    dvec = vec1 - mathutils.Vector([x,Half_Flat,0.0])
-    verts.append([x,Half_Flat,-dvec.length])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
+    # Flats
+    x = tan(radians(0)) * Half_Flat
+    dvec = vec1 - Vector([x, Half_Flat, 0.0])
+    verts.append([x, Half_Flat, -dvec.length])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)
 
+    x = tan(radians(60 / 6)) * Half_Flat
+    dvec = vec2 - Vector([x, Half_Flat, 0.0])
+    verts.append([x, Half_Flat, -dvec.length])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)
 
-    x = tan(radians(60/6))*Half_Flat
-    dvec = vec2 - mathutils.Vector([x,Half_Flat,0.0])
-    verts.append([x,Half_Flat,-dvec.length])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
-
-
-    x = tan(radians(60/3))*Half_Flat
-    dvec = vec3 - mathutils.Vector([x,Half_Flat,0.0])
+    x = tan(radians(60 / 3)) * Half_Flat
+    dvec = vec3 - Vector([x, Half_Flat, 0.0])
     Lowest_Point = -dvec.length
-    verts.append([x,Half_Flat,-dvec.length])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
+    verts.append([x, Half_Flat, -dvec.length])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)
 
-    x = tan(radians(60/2))*Half_Flat
-    dvec = vec4 - mathutils.Vector([x,Half_Flat,0.0])
+    x = tan(radians(60 / 2)) * Half_Flat
+    dvec = vec4 - Vector([x, Half_Flat, 0.0])
     Lowest_Point = -dvec.length
-    verts.append([x,Half_Flat,-dvec.length])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
+    verts.append([x, Half_Flat, -dvec.length])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)
     Row += 1
 
-    #down Bits Tri
-    x = tan(radians(0))*Half_Flat
-    verts.append([x,Half_Flat,Lowest_Point])
-
+    # down Bits Tri
+    x = tan(radians(0)) * Half_Flat
+    verts.append([x, Half_Flat, Lowest_Point])
 
-    x = tan(radians(60/6))*Half_Flat
-    verts.append([x,Half_Flat,Lowest_Point])
-    x = tan(radians(60/3))*Half_Flat
-    verts.append([x,Half_Flat,Lowest_Point])
+    x = tan(radians(60 / 6)) * Half_Flat
+    verts.append([x, Half_Flat, Lowest_Point])
+    x = tan(radians(60 / 3)) * Half_Flat
+    verts.append([x, Half_Flat, Lowest_Point])
 
-    x = tan(radians(60/2))*Half_Flat
-    verts.append([x,Half_Flat,Lowest_Point])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,Lowest_Point)
+    x = tan(radians(60 / 2)) * Half_Flat
+    verts.append([x, Half_Flat, Lowest_Point])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, Lowest_Point)
     Row += 1
 
-    #down Bits
+    # down Bits
 
-    x = tan(radians(0))*Half_Flat
-    verts.append([x,Half_Flat,-Half_Height])
+    x = tan(radians(0)) * Half_Flat
+    verts.append([x, Half_Flat, -Half_Height])
 
-    x = tan(radians(60/6))*Half_Flat
-    verts.append([x,Half_Flat,-Half_Height])
+    x = tan(radians(60 / 6)) * Half_Flat
+    verts.append([x, Half_Flat, -Half_Height])
 
-    x = tan(radians(60/3))*Half_Flat
-    verts.append([x,Half_Flat,-Half_Height])
+    x = tan(radians(60 / 3)) * Half_Flat
+    verts.append([x, Half_Flat, -Half_Height])
 
-    x = tan(radians(60/2))*Half_Flat
-    verts.append([x,Half_Flat,-Half_Height])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,-Half_Height)
+    x = tan(radians(60 / 2)) * Half_Flat
+    verts.append([x, Half_Flat, -Half_Height])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, -Half_Height)
     Row += 1
 
-    faces.extend(Build_Face_List_Quads(FaceStart,3,Row - 1))
+    faces.extend(Build_Face_List_Quads(FaceStart, 3, Row - 1))
 
     Global_Head_Height = HEIGHT
 
-    Tvert,tface = Mirror_Verts_Faces(verts,faces,'z',Lowest_Z_Vert)
+    Tvert, tface = Mirror_Verts_Faces(verts, faces, 'z', Lowest_Z_Vert)
     verts.extend(Tvert)
     faces.extend(tface)
 
-
-    Tvert,tface = Mirror_Verts_Faces(verts,faces,'y')
+    Tvert, tface = Mirror_Verts_Faces(verts, faces, 'y')
     verts.extend(Tvert)
     faces.extend(tface)
 
-    S_verts,S_faces = SpinDup(verts,faces,360,6,'z')
-
-    #return verts,faces,TopBevelRadius
-    return S_verts,S_faces,TopBevelRadius
+    S_verts, S_faces = SpinDup(verts, faces, 360, 6, 'z')
 
+    # return verts, faces, TopBevelRadius
+    return S_verts, S_faces, TopBevelRadius
 
 
-def add_Nylon_Head(OUTSIDE_RADIUS,Z_LOCATION,DIV_COUNT):
+def add_Nylon_Head(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
     verts = []
     faces = []
     Row = 0
 
-    INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.25/4.75))
-    EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4/4.75))
-    RAD1 = (OUTSIDE_RADIUS * (0.5/4.75))
-    OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0/4.75))
-
+    INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.25 / 4.75))
+    EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4 / 4.75))
+    RAD1 = (OUTSIDE_RADIUS * (0.5 / 4.75))
+    OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0 / 4.75))
 
     FaceStart = len(verts)
 
@@ -1575,51 +1500,48 @@ def add_Nylon_Head(OUTSIDE_RADIUS,Z_LOCATION,DIV_COUNT):
 
     x = INNER_HOLE
     z = (Height_Offset - OVER_ALL_HEIGTH) + EDGE_THICKNESS
-    verts.append([x,0.0,z])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    verts.append([x, 0.0, z])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Row += 1
 
     x = INNER_HOLE
     z = (Height_Offset - OVER_ALL_HEIGTH)
-    verts.append([x,0.0,z])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    verts.append([x, 0.0, z])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Row += 1
 
-
-    for i in range(180,80,-10):
-        x = sin(radians(i))*RAD1
-        z = cos(radians(i))*RAD1
-        verts.append([(OUTSIDE_RADIUS-RAD1)+x,0.0,((Height_Offset - OVER_ALL_HEIGTH)+RAD1)+z])
-        Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    for i in range(180, 80, -10):
+        x = sin(radians(i)) * RAD1
+        z = cos(radians(i)) * RAD1
+        verts.append([(OUTSIDE_RADIUS - RAD1) + x, 0.0, ((Height_Offset - OVER_ALL_HEIGTH) + RAD1) + z])
+        Lowest_Z_Vert = min(Lowest_Z_Vert, z)
         Row += 1
 
-
     x = OUTSIDE_RADIUS - 0
     z = Height_Offset
-    verts.append([x,0.0,z])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    verts.append([x, 0.0, z])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Row += 1
 
-    sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
-    sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
+    sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+    sVerts.extend(verts)        # add the start verts to the Spin verts to complete the loop
 
-    faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT))
+    faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT))
 
-    return Move_Verts_Up_Z(sVerts,0),faces,Lowest_Z_Vert
+    return Move_Verts_Up_Z(sVerts, 0), faces, Lowest_Z_Vert
 
 
-
-def add_Nylon_Part(OUTSIDE_RADIUS,Z_LOCATION,DIV_COUNT):
+def add_Nylon_Part(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
     verts = []
     faces = []
     Row = 0
 
-    INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.5/4.75))
-    EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4/4.75))
+    INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.5 / 4.75))
+    EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4 / 4.75))
     # RAD1 = (OUTSIDE_RADIUS * (0.5/4.75))  # UNUSED
-    OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0/4.75))
+    OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0 / 4.75))
     PART_THICKNESS = OVER_ALL_HEIGTH - EDGE_THICKNESS
-    PART_INNER_HOLE = (OUTSIDE_RADIUS * (2.5/4.75))
+    PART_INNER_HOLE = (OUTSIDE_RADIUS * (2.5 / 4.75))
 
     FaceStart = len(verts)
 
@@ -1627,275 +1549,269 @@ def add_Nylon_Part(OUTSIDE_RADIUS,Z_LOCATION,DIV_COUNT):
     Height_Offset = Z_LOCATION
     Lowest_Z_Vert = 0
 
-
     x = INNER_HOLE + EDGE_THICKNESS
     z = Height_Offset
-    verts.append([x,0.0,z])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    verts.append([x, 0.0, z])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Row += 1
 
     x = PART_INNER_HOLE
     z = Height_Offset
-    verts.append([x,0.0,z])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    verts.append([x, 0.0, z])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Row += 1
 
     x = PART_INNER_HOLE
     z = Height_Offset - PART_THICKNESS
-    verts.append([x,0.0,z])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    verts.append([x, 0.0, z])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Row += 1
 
     x = INNER_HOLE + EDGE_THICKNESS
     z = Height_Offset - PART_THICKNESS
-    verts.append([x,0.0,z])
-    Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+    verts.append([x, 0.0, z])
+    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
     Row += 1
 
+    sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+    sVerts.extend(verts)  # add the start verts to the Spin verts to complete the loop
 
-    sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
-    sVerts.extend(verts)  #add the start verts to the Spin verts to complete the loop
-
-    faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT,1))
+    faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT, 1))
 
-    return sVerts,faces,0 - Lowest_Z_Vert
+    return sVerts, faces, 0 - Lowest_Z_Vert
 
 
-##########################################################################################
-##########################################################################################
-##                    Create Internal Thread
-##########################################################################################
-##########################################################################################
+# ####################################################################
+#                   Create Internal Thread
+# ####################################################################
 
+def Create_Internal_Thread_Start_Verts(verts, INNER_RADIUS, OUTTER_RADIUS, PITCH, DIV,
+                                       CREST_PERCENT, ROOT_PERCENT, Height_Offset):
 
-def Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
-
-
-    Ret_Row = 0;
-
-    Height_Offset = Height_Offset + PITCH  #Move the offset up so that the verts start at
-                                           #at the correct place  (Height_Start)
+    Ret_Row = 0
+    # Move the offset up so that the verts start at
+    # at the correct place (Height_Start)
+    Height_Offset = Height_Offset + PITCH
 
     # Half_Pitch = float(PITCH)/2  # UNUSED
     Height_Start = Height_Offset - PITCH
-    Height_Step = float(PITCH)/float(DIV)
-    Deg_Step = 360.0 /float(DIV)
+    Height_Step = float(PITCH) / float(DIV)
+    Deg_Step = 360.0 / float(DIV)
 
-    Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
-    Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
-    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
 
+    Rank = float(OUTTER_RADIUS - INNER_RADIUS) / float(DIV)
+    for j in range(1):  # FIXME - for j in range(1) what?!
 
-    Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV)
-    for j in range(1):  #FIXME - for j in range(1) what?!
-
-        for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,z])
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, z])
         Height_Offset -= Crest_Height
         Ret_Row += 1
 
-        for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,z ])
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, z])
         Height_Offset -= Crest_to_Root_Height
         Ret_Row += 1
 
-
-        for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
             if j == 0:
-                x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-                y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-            verts.append([x,y,z ])
+                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+            verts.append([x, y, z])
         Height_Offset -= Root_Height
         Ret_Row += 1
 
-        for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV + 1):
+            z = Height_Offset - (Height_Step * i)
             if z > Height_Start:
                 z = Height_Start
 
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
 
             if j == 0:
-                x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-                y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
-            verts.append([x,y,z ])
+                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+            verts.append([x, y, z])
         Height_Offset -= Root_to_Crest_Height
         Ret_Row += 1
 
-    return Ret_Row,Height_Offset
+    return Ret_Row, Height_Offset
 
 
-def Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
+def Create_Internal_Thread_End_Verts(verts, INNER_RADIUS, OUTTER_RADIUS, PITCH,
+                                     DIV, CREST_PERCENT, ROOT_PERCENT, Height_Offset):
 
-
-    Ret_Row = 0;
+    Ret_Row = 0
 
     # Half_Pitch = float(PITCH)/2  # UNUSED
-    #Height_End = Height_Offset - PITCH - PITCH - PITCH- PITCH - PITCH- PITCH
+    # Height_End = Height_Offset - PITCH - PITCH - PITCH- PITCH - PITCH- PITCH
     Height_End = Height_Offset - PITCH
-    #Height_End = -2.1
-    Height_Step = float(PITCH)/float(DIV)
-    Deg_Step = 360.0 /float(DIV)
-
-    Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
-    Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
-    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+    # Height_End = -2.1
+    Height_Step = float(PITCH) / float(DIV)
+    Deg_Step = 360.0 / float(DIV)
 
+    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
 
-    Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV)
+    Rank = float(OUTTER_RADIUS - INNER_RADIUS) / float(DIV)
 
     Num = 0
 
     for j in range(2):
 
-        for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV + 1):
+            z = Height_Offset - (Height_Step * i)
             if z < Height_End:
                 z = Height_End
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,z])
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, z])
         Height_Offset -= Crest_Height
         Ret_Row += 1
 
-
-        for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV + 1):
+            z = Height_Offset - (Height_Step * i)
             if z < Height_End:
                 z = Height_End
 
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,z ])
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, z])
         Height_Offset -= Crest_to_Root_Height
         Ret_Row += 1
 
-
-        for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV + 1):
+            z = Height_Offset - (Height_Step * i)
             if z < Height_End:
                 z = Height_End
 
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
             if j == Num:
-                x = sin(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
-                y = cos(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
+                x = sin(radians(i * Deg_Step)) * (INNER_RADIUS + (i * Rank))
+                y = cos(radians(i * Deg_Step)) * (INNER_RADIUS + (i * Rank))
             if j > Num:
-                x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS)
-                y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS )
+                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS)
+                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS)
 
-            verts.append([x,y,z ])
+            verts.append([x, y, z])
         Height_Offset -= Root_Height
         Ret_Row += 1
 
-
-        for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i)
+        for i in range(DIV + 1):
+            z = Height_Offset - (Height_Step * i)
             if z < Height_End:
                 z = Height_End
 
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
 
             if j == Num:
-                x = sin(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
-                y = cos(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
+                x = sin(radians(i * Deg_Step)) * (INNER_RADIUS + (i * Rank))
+                y = cos(radians(i * Deg_Step)) * (INNER_RADIUS + (i * Rank))
             if j > Num:
-                x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS )
-                y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS )
+                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS)
+                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS)
 
-            verts.append([x,y,z ])
+            verts.append([x, y, z])
         Height_Offset -= Root_to_Crest_Height
         Ret_Row += 1
 
+    return Ret_Row, Height_End  # send back Height End as this is the lowest point
 
-    return Ret_Row,Height_End  # send back Height End as this is the lowest point
 
-
-def Create_Internal_Thread(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PERCENT,INTERNAL,DIV_COUNT):
+def Create_Internal_Thread(INNER_DIA, OUTTER_DIA, PITCH, HEIGHT,
+                           CREST_PERCENT, ROOT_PERCENT, INTERNAL, DIV_COUNT):
     verts = []
     faces = []
 
+    INNER_RADIUS = INNER_DIA / 2
+    OUTTER_RADIUS = OUTTER_DIA / 2
 
-    INNER_RADIUS = INNER_DIA/2
-    OUTTER_RADIUS = OUTTER_DIA/2
-
-    # Half_Pitch = float(PITCH)/2  # UNUSED
-    Deg_Step = 360.0 /float(DIV_COUNT)
-    Height_Step = float(PITCH)/float(DIV_COUNT)
+    # Half_Pitch = float(PITCH) / 2  # UNUSED
+    Deg_Step = 360.0 / float(DIV_COUNT)
+    Height_Step = float(PITCH) / float(DIV_COUNT)
 
-    Num = int(round((HEIGHT- PITCH)/PITCH))  # less one pitch for the start and end that is 1/2 pitch high
+    Num = int(round((HEIGHT - PITCH) / PITCH))  # less one pitch for the start and end that is 1/2 pitch high
 
     # Col = 0  # UNUSED
     Row = 0
 
-
-    Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
-    Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
-    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+    Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
 
     Height_Offset = 0
     FaceStart = len(verts)
 
-    Row_Inc,Height_Offset = Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV_COUNT,CREST_PERCENT,ROOT_PERCENT,Height_Offset)
+    Row_Inc, Height_Offset = Create_Internal_Thread_Start_Verts(
+                                    verts, INNER_RADIUS, OUTTER_RADIUS, PITCH,
+                                    DIV_COUNT, CREST_PERCENT, ROOT_PERCENT,
+                                    Height_Offset
+                                    )
     Row += Row_Inc
 
     for j in range(Num):
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,Height_Offset - (Height_Step*i) ])
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, Height_Offset - (Height_Step * i)])
         Height_Offset -= Crest_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
-            y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            verts.append([x,y,Height_Offset - (Height_Step*i) ])
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+            verts.append([x, y, Height_Offset - (Height_Step * i)])
         Height_Offset -= Crest_to_Root_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
-            verts.append([x,y,Height_Offset - (Height_Step*i) ])
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
+            verts.append([x, y, Height_Offset - (Height_Step * i)])
         Height_Offset -= Root_Height
         Row += 1
 
-        for i in range(DIV_COUNT+1):
-            x = sin(radians(i*Deg_Step))*INNER_RADIUS
-            y = cos(radians(i*Deg_Step))*INNER_RADIUS
-            verts.append([x,y,Height_Offset - (Height_Step*i) ])
+        for i in range(DIV_COUNT + 1):
+            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
+            verts.append([x, y, Height_Offset - (Height_Step * i)])
         Height_Offset -= Root_to_Crest_Height
         Row += 1
 
-
-    Row_Inc,Height_Offset = Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV_COUNT,CREST_PERCENT,ROOT_PERCENT,Height_Offset)
+    Row_Inc, Height_Offset = Create_Internal_Thread_End_Verts(
+                                        verts, INNER_RADIUS, OUTTER_RADIUS,
+                                        PITCH, DIV_COUNT, CREST_PERCENT,
+                                        ROOT_PERCENT, Height_Offset
+                                        )
     Row += Row_Inc
 
-    faces.extend(Build_Face_List_Quads(FaceStart,DIV_COUNT,Row -1,INTERNAL))
+    faces.extend(Build_Face_List_Quads(FaceStart, DIV_COUNT, Row - 1, INTERNAL))
 
-    return verts,faces,0 - Height_Offset
+    return verts, faces, 0 - Height_Offset
 
 
 def Nut_Mesh(props, context):
@@ -1903,122 +1819,164 @@ def Nut_Mesh(props, context):
     verts = []
     faces = []
     Head_Verts = []
-    Head_Faces= []
-    #sc = context.scene
+    Head_Faces = []
+    # sc = context.scene
 
     New_Nut_Height = 5
 
     Face_Start = len(verts)
-    Thread_Verts,Thread_Faces,New_Nut_Height = Create_Internal_Thread(props.bf_Minor_Dia,props.bf_Major_Dia,props.bf_Pitch,props.bf_Hex_Nut_Height,props.bf_Crest_Percent,props.bf_Root_Percent,1,props.bf_Div_Count)
+    Thread_Verts, Thread_Faces, New_Nut_Height = Create_Internal_Thread(
+                                                    props.bf_Minor_Dia, props.bf_Major_Dia,
+                                                    props.bf_Pitch, props.bf_Hex_Nut_Height,
+                                                    props.bf_Crest_Percent, props.bf_Root_Percent,
+                                                    1, props.bf_Div_Count
+                                                    )
     verts.extend(Thread_Verts)
-    faces.extend(Copy_Faces(Thread_Faces,Face_Start))
+    faces.extend(Copy_Faces(Thread_Faces, Face_Start))
 
     Face_Start = len(verts)
-    Head_Verts,Head_Faces,Lock_Nut_Rad = add_Hex_Nut(props.bf_Hex_Nut_Flat_Distance,props.bf_Major_Dia,New_Nut_Height)
+    Head_Verts, Head_Faces, Lock_Nut_Rad = add_Hex_Nut(
+                                                props.bf_Hex_Nut_Flat_Distance,
+                                                props.bf_Major_Dia, New_Nut_Height
+                                                )
     verts.extend((Head_Verts))
-    faces.extend(Copy_Faces(Head_Faces,Face_Start))
+    faces.extend(Copy_Faces(Head_Faces, Face_Start))
 
     LowZ = 0 - New_Nut_Height
 
     if props.bf_Nut_Type == 'bf_Nut_Lock':
         Face_Start = len(verts)
-        Nylon_Head_Verts,Nylon_Head_faces,LowZ = add_Nylon_Head(Lock_Nut_Rad,0-New_Nut_Height,props.bf_Div_Count)
+        Nylon_Head_Verts, Nylon_Head_faces, LowZ = add_Nylon_Head(
+                                                        Lock_Nut_Rad, 0 - New_Nut_Height,
+                                                        props.bf_Div_Count
+                                                        )
         verts.extend((Nylon_Head_Verts))
-        faces.extend(Copy_Faces(Nylon_Head_faces,Face_Start))
+        faces.extend(Copy_Faces(Nylon_Head_faces, Face_Start))
 
         Face_Start = len(verts)
-        Nylon_Verts,Nylon_faces,Temp_LowZ = add_Nylon_Part(Lock_Nut_Rad,0-New_Nut_Height,props.bf_Div_Count)
+        Nylon_Verts, Nylon_faces, Temp_LowZ = add_Nylon_Part(
+                                                        Lock_Nut_Rad, 0 - New_Nut_Height,
+                                                        props.bf_Div_Count
+                                                        )
         verts.extend((Nylon_Verts))
-        faces.extend(Copy_Faces(Nylon_faces,Face_Start))
+        faces.extend(Copy_Faces(Nylon_faces, Face_Start))
 
-
-    return Move_Verts_Up_Z(verts,0 - LowZ),faces
-
-
-
-##########################################################################################
-##########################################################################################
-##########################################################################################
-##                    Create Bolt
-##########################################################################################
-##########################################################################################
+    return Move_Verts_Up_Z(verts, 0 - LowZ), faces
 
 
+# ####################################################################
+#                    Create Bolt
+# ####################################################################
 
 def Bolt_Mesh(props, context):
 
-
     verts = []
     faces = []
     Bit_Verts = []
     Bit_Faces = []
     Bit_Dia = 0.001
     Head_Verts = []
-    Head_Faces= []
+    Head_Faces = []
     Head_Height = 0.0
-    #sc = context.scene
+    # sc = context.scene
 
-    ReSized_Allen_Bit_Flat_Distance = props.bf_Allen_Bit_Flat_Distance   # set default
-
-
-    Head_Height = props.bf_Hex_Head_Height # will be changed by the Head Functions
+    ReSized_Allen_Bit_Flat_Distance = props.bf_Allen_Bit_Flat_Distance  # set default
 
+    Head_Height = props.bf_Hex_Head_Height  # will be changed by the Head Functions
 
     if props.bf_Bit_Type == 'bf_Bit_Allen' and props.bf_Head_Type == 'bf_Head_Pan':
-        #need to size Allen bit if it is too big.
-        if  Allen_Bit_Dia(props.bf_Allen_Bit_Flat_Distance) > Max_Pan_Bit_Dia(props.bf_Pan_Head_Dia):
-            ReSized_Allen_Bit_Flat_Distance = Allen_Bit_Dia_To_Flat(Max_Pan_Bit_Dia(props.bf_Pan_Head_Dia)) * 1.05
-            #print ("Resized Allen Bit Flat Distance to ",ReSized_Allen_Bit_Flat_Distance)
-
-    #bit Mesh
+        # need to size Allen bit if it is too big.
+        if Allen_Bit_Dia(props.bf_Allen_Bit_Flat_Distance) > Max_Pan_Bit_Dia(props.bf_Pan_Head_Dia):
+            ReSized_Allen_Bit_Flat_Distance = Allen_Bit_Dia_To_Flat(
+                                                Max_Pan_Bit_Dia(props.bf_Pan_Head_Dia)
+                                                ) * 1.05
+            # print ("Resized Allen Bit Flat Distance to ",ReSized_Allen_Bit_Flat_Distance)
+
+    # Bit Mesh
     if props.bf_Bit_Type == 'bf_Bit_Allen':
-        Bit_Verts,Bit_Faces,Bit_Dia = Create_Allen_Bit(ReSized_Allen_Bit_Flat_Distance,props.bf_Allen_Bit_Depth)
+        Bit_Verts, Bit_Faces, Bit_Dia = Create_Allen_Bit(
+                                                ReSized_Allen_Bit_Flat_Distance,
+                                                props.bf_Allen_Bit_Depth
+                                                )
 
     if props.bf_Bit_Type == 'bf_Bit_Philips':
-        Bit_Verts,Bit_Faces,Bit_Dia = Create_Phillips_Bit(props.bf_Philips_Bit_Dia,props.bf_Philips_Bit_Dia*(0.5/1.82),props.bf_Phillips_Bit_Depth)
-
-
-    #Head Mesh
-
-    if props.bf_Head_Type =='bf_Head_Hex':
-        Head_Verts,Head_Faces,Head_Height = Create_Hex_Head(props.bf_Hex_Head_Flat_Distance,Bit_Dia,props.bf_Shank_Dia,props.bf_Hex_Head_Height)
-
+        Bit_Verts, Bit_Faces, Bit_Dia = Create_Phillips_Bit(
+                                                props.bf_Philips_Bit_Dia,
+                                                props.bf_Philips_Bit_Dia * (0.5 / 1.82),
+                                                props.bf_Phillips_Bit_Depth
+                                                )
+    # Head Mesh
+    if props.bf_Head_Type == 'bf_Head_Hex':
+        Head_Verts, Head_Faces, Head_Height = Create_Hex_Head(
+                                                props.bf_Hex_Head_Flat_Distance, Bit_Dia,
+                                                props.bf_Shank_Dia, props.bf_Hex_Head_Height
+                                                )
     elif props.bf_Head_Type == 'bf_Head_Cap':
-        Head_Verts,Head_Faces,Head_Height = Create_Cap_Head(Bit_Dia,props.bf_Cap_Head_Dia,props.bf_Shank_Dia,props.bf_Cap_Head_Height,props.bf_Cap_Head_Dia*(1.0/19.0),props.bf_Cap_Head_Dia*(1.0/19.0),props.DIV_COUNT)
-
-    elif props.bf_Head_Type =='bf_Head_Dome':
-        Head_Verts,Head_Faces,Head_Height = Create_Dome_Head(Bit_Dia,props.bf_Dome_Head_Dia,props.bf_Shank_Dia,props.bf_Hex_Head_Height,1,1,0,props.bf_Div_Count)
+        Head_Verts, Head_Faces, Head_Height = Create_Cap_Head(
+                                                Bit_Dia, props.bf_Cap_Head_Dia,
+                                                props.bf_Shank_Dia, props.bf_Cap_Head_Height,
+                                                props.bf_Cap_Head_Dia * (1.0 / 19.0),
+                                                props.bf_Cap_Head_Dia * (1.0 / 19.0),
+                                                props.bf_Div_Count
+                                                )
+    elif props.bf_Head_Type == 'bf_Head_Dome':
+        Head_Verts, Head_Faces, Head_Height = Create_Dome_Head(
+                                                Bit_Dia, props.bf_Dome_Head_Dia,
+                                                props.bf_Shank_Dia, props.bf_Hex_Head_Height,
+                                                1, 1, 0, props.bf_Div_Count
+                                                )
 
     elif props.bf_Head_Type == 'bf_Head_Pan':
-        Head_Verts,Head_Faces,Head_Height = Create_Pan_Head(Bit_Dia,props.bf_Pan_Head_Dia,props.bf_Shank_Dia,props.bf_Hex_Head_Height,1,1,0,props.bf_Div_Count)
-
+        Head_Verts, Head_Faces, Head_Height = Create_Pan_Head(
+                                                Bit_Dia, props.bf_Pan_Head_Dia,
+                                                props.bf_Shank_Dia,
+                                                props.bf_Hex_Head_Height, 1, 1, 0,
+                                                props.bf_Div_Count
+                                                )
     elif props.bf_Head_Type == 'bf_Head_CounterSink':
-        Head_Verts,Head_Faces,Head_Height = Create_CounterSink_Head(Bit_Dia,props.bf_CounterSink_Head_Dia,props.bf_Shank_Dia,props.bf_CounterSink_Head_Dia,props.bf_CounterSink_Head_Dia*(0.09/6.31),props.bf_Div_Count)
-#Head_Verts,Head_Faces,Head_Height = Create_CounterSink_Head(Bit_Dia,props.bf_CounterSink_Head_Dia,props.bf_Shank_Dia,props.bf_CounterSink_Head_Dia,props.bf_CounterSink_Head_Dia*(1.0/19.0))
-
+        Head_Verts, Head_Faces, Head_Height = Create_CounterSink_Head(
+                                                Bit_Dia, props.bf_CounterSink_Head_Dia,
+                                                props.bf_Shank_Dia, props.bf_CounterSink_Head_Dia,
+                                                props.bf_CounterSink_Head_Dia * (0.09 / 6.31),
+                                                props.bf_Div_Count
+                                                )
+    """
+    Head_Verts, Head_Faces, Head_Height = Create_CounterSink_Head(
+                                                Bit_Dia, props.bf_CounterSink_Head_Dia,
+                                                props.bf_Shank_Dia,
+                                                props.bf_CounterSink_Head_Dia,
+                                                props.bf_CounterSink_Head_Dia * (1.0 / 19.0)
+                                                )
+    """
     Face_Start = len(verts)
-    verts.extend(Move_Verts_Up_Z(Bit_Verts,Head_Height))
-    faces.extend(Copy_Faces(Bit_Faces,Face_Start))
+    verts.extend(Move_Verts_Up_Z(Bit_Verts, Head_Height))
+    faces.extend(Copy_Faces(Bit_Faces, Face_Start))
 
     Face_Start = len(verts)
-    verts.extend(Move_Verts_Up_Z(Head_Verts,Head_Height))
-    faces.extend(Copy_Faces(Head_Faces,Face_Start))
+    verts.extend(Move_Verts_Up_Z(Head_Verts, Head_Height))
+    faces.extend(Copy_Faces(Head_Faces, Face_Start))
 
     Face_Start = len(verts)
-    Thread_Verts,Thread_Faces,Thread_Height = Create_External_Thread(props.bf_Shank_Dia,props.bf_Shank_Length,props.bf_Minor_Dia,props.bf_Major_Dia,props.bf_Pitch,props.bf_Thread_Length,props.bf_Crest_Percent,props.bf_Root_Percent,props.bf_Div_Count)
+    Thread_Verts, Thread_Faces, Thread_Height = Create_External_Thread(
+                                                    props.bf_Shank_Dia, props.bf_Shank_Length,
+                                                    props.bf_Minor_Dia, props.bf_Major_Dia,
+                                                    props.bf_Pitch, props.bf_Thread_Length,
+                                                    props.bf_Crest_Percent,
+                                                    props.bf_Root_Percent, props.bf_Div_Count
+                                                    )
 
-    verts.extend(Move_Verts_Up_Z(Thread_Verts,00))
-    faces.extend(Copy_Faces(Thread_Faces,Face_Start))
+    verts.extend(Move_Verts_Up_Z(Thread_Verts, 00))
+    faces.extend(Copy_Faces(Thread_Faces, Face_Start))
+
+    return Move_Verts_Up_Z(verts, Thread_Height), faces
 
-    return Move_Verts_Up_Z(verts,Thread_Height),faces
 
 # calculates the matrix for the new object
 # depending on user pref
 def align_matrix(context):
     loc = Matrix.Translation(context.scene.cursor_location)
     obj_align = context.user_preferences.edit.object_align
-    if (context.space_data.type == 'VIEW_3D'
-        and obj_align == 'VIEW'):
+    if (context.space_data.type == 'VIEW_3D' and obj_align == 'VIEW'):
         rot = context.space_data.region_3d.view_matrix.to_3x3().inverted().to_4x4()
     else:
         rot = Matrix()
@@ -2076,7 +2034,6 @@ def create_mesh_object(context, verts, edges, faces, name, edit, align_matrix):
 
             # Assign new mesh datablock.
             ob_new.data = mesh
-
     else:
         # Create new object
         ob_new = bpy.data.objects.new(name, mesh)
@@ -2121,28 +2078,25 @@ def Create_New_Mesh(props, context, align_matrix):
     verts = []
     faces = []
     # sMeshName =''  # UNUSED
-    sObjName =''
+    sObjName = ''
 
     if props.bf_Model_Type == 'bf_Model_Bolt':
-        #print('Create Bolt')
+        # print('Create Bolt')
         verts, faces = Bolt_Mesh(props, context)
         # sMeshName = 'Bolt'  # UNUSED
         sObjName = 'Bolt'
 
     if props.bf_Model_Type == 'bf_Model_Nut':
-        #print('Create Nut')
+        # print('Create Nut')
         verts, faces = Nut_Mesh(props, context)
         # sMeshName = 'Nut'  # UNUSED
         sObjName = 'Nut'
 
-
     verts, faces = RemoveDoubles(verts, faces)
 
-    verts = Scale_Mesh_Verts(verts,GLOBAL_SCALE)
+    verts = Scale_Mesh_Verts(verts, GLOBAL_SCALE)
 
-    obj = create_mesh_object(context, verts, [], faces,sObjName,
-            props.edit, align_matrix)
+    obj = create_mesh_object(context, verts, [], faces, sObjName,
+                             props.edit, align_matrix)
 
     return obj
-
-