Merge pull request matplotlib#1384 from NelleV/pep8_hatch

PEP8 fixes on hatch.py

Author: dmcdougall

lib/matplotlib/hatch.py

@@ -6,45 +6,52 @@
 import numpy as np
 from matplotlib.path import Path
 
+
 class HatchPatternBase:
     """
     The base class for a hatch pattern.
     """
     pass
 
+
 class HorizontalHatch(HatchPatternBase):
     def __init__(self, hatch, density):
         self.num_lines = (hatch.count('-') + hatch.count('+')) * density
         self.num_vertices = self.num_lines * 2
 
     def set_vertices_and_codes(self, vertices, codes):
-        steps, stepsize = np.linspace(0.0, 1.0, self.num_lines, False, retstep=True)
-        steps += stepsize/2.
+        steps, stepsize = np.linspace(0.0, 1.0, self.num_lines, False,
+                                      retstep=True)
+        steps += stepsize / 2.
         vertices[0::2, 0] = 0.0
         vertices[0::2, 1] = steps
         vertices[1::2, 0] = 1.0
         vertices[1::2, 1] = steps
         codes[0::2] = Path.MOVETO
         codes[1::2] = Path.LINETO
 
+
 class VerticalHatch(HatchPatternBase):
     def __init__(self, hatch, density):
         self.num_lines = (hatch.count('|') + hatch.count('+')) * density
         self.num_vertices = self.num_lines * 2
 
     def set_vertices_and_codes(self, vertices, codes):
-        steps, stepsize = np.linspace(0.0, 1.0, self.num_lines, False, retstep=True)
-        steps += stepsize/2.
+        steps, stepsize = np.linspace(0.0, 1.0, self.num_lines, False,
+                                      retstep=True)
+        steps += stepsize / 2.
         vertices[0::2, 0] = steps
         vertices[0::2, 1] = 0.0
         vertices[1::2, 0] = steps
         vertices[1::2, 1] = 1.0
         codes[0::2] = Path.MOVETO
         codes[1::2] = Path.LINETO
 
+
 class NorthEastHatch(HatchPatternBase):
     def __init__(self, hatch, density):
-        self.num_lines = (hatch.count('/') + hatch.count('x') + hatch.count('X')) * density
+        self.num_lines = (hatch.count('/') + hatch.count('x') +
+                          hatch.count('X')) * density
         if self.num_lines:
             self.num_vertices = (self.num_lines + 1) * 2
         else:
@@ -59,9 +66,11 @@ def set_vertices_and_codes(self, vertices, codes):
         codes[0::2] = Path.MOVETO
         codes[1::2] = Path.LINETO
 
+
 class SouthEastHatch(HatchPatternBase):
     def __init__(self, hatch, density):
-        self.num_lines = (hatch.count('\\') + hatch.count('x') + hatch.count('X')) * density
+        self.num_lines = (hatch.count('\\') + hatch.count('x') +
+                          hatch.count('X')) * density
         self.num_vertices = (self.num_lines + 1) * 2
         if self.num_lines:
             self.num_vertices = (self.num_lines + 1) * 2
@@ -77,8 +86,10 @@ def set_vertices_and_codes(self, vertices, codes):
         codes[0::2] = Path.MOVETO
         codes[1::2] = Path.LINETO
 
+
 class Shapes(HatchPatternBase):
     filled = False
+
     def __init__(self, hatch, density):
         if self.num_rows == 0:
             self.num_shapes = 0
@@ -103,38 +114,45 @@ def set_vertices_and_codes(self, vertices, codes):
             if row % 2 == 0:
                 cols = np.linspace(0.0, 1.0, self.num_rows + 1, True)
             else:
-                cols = np.linspace(offset / 2.0, 1.0 - offset / 2.0, self.num_rows, True)
+                cols = np.linspace(offset / 2.0, 1.0 - offset / 2.0,
+                                   self.num_rows, True)
             row_pos = row * offset
             for col_pos in cols:
-                vertices[cursor:cursor+shape_size] = shape_vertices + (col_pos, row_pos)
-                codes[cursor:cursor+shape_size] = shape_codes
+                vertices[cursor:cursor + shape_size] = (shape_vertices +
+                                                        (col_pos, row_pos))
+                codes[cursor:cursor + shape_size] = shape_codes
                 cursor += shape_size
                 if not self.filled:
-                    vertices[cursor:cursor+shape_size] = inner_vertices + (col_pos, row_pos)
-                    codes[cursor:cursor+shape_size] = shape_codes
+                    vertices[cursor:cursor + shape_size] = (inner_vertices +
+                                                            (col_pos, row_pos))
+                    codes[cursor:cursor + shape_size] = shape_codes
                     cursor += shape_size
 
+
 class Circles(Shapes):
     def __init__(self, hatch, density):
         path = Path.unit_circle()
         self.shape_vertices = path.vertices
         self.shape_codes = path.codes
         Shapes.__init__(self, hatch, density)
 
+
 class SmallCircles(Circles):
     size = 0.2
 
     def __init__(self, hatch, density):
         self.num_rows = (hatch.count('o')) * density
         Circles.__init__(self, hatch, density)
 
+
 class LargeCircles(Circles):
     size = 0.35
 
     def __init__(self, hatch, density):
         self.num_rows = (hatch.count('O')) * density
         Circles.__init__(self, hatch, density)
 
+
 class SmallFilledCircles(SmallCircles):
     size = 0.1
     filled = True
@@ -143,6 +161,7 @@ def __init__(self, hatch, density):
         self.num_rows = (hatch.count('.')) * density
         Circles.__init__(self, hatch, density)
 
+
 class Stars(Shapes):
     size = 1.0 / 3.0
     filled = True
@@ -166,23 +185,24 @@ def __init__(self, hatch, density):
     Stars
     ]
 
+
 def get_path(hatchpattern, density=6):
     """
     Given a hatch specifier, *hatchpattern*, generates Path to render
     the hatch in a unit square.  *density* is the number of lines per
     unit square.
     """
-    size = 1.0
     density = int(density)
 
-    patterns = [hatch_type(hatchpattern, density) for hatch_type in _hatch_types]
+    patterns = [hatch_type(hatchpattern, density)
+                for hatch_type in _hatch_types]
     num_vertices = sum([pattern.num_vertices for pattern in patterns])
 
     if num_vertices == 0:
         return Path(np.empty((0, 2)))
 
     vertices = np.empty((num_vertices, 2))
-    codes    = np.empty((num_vertices,), np.uint8)
+    codes = np.empty((num_vertices,), np.uint8)
 
     cursor = 0
     for pattern in patterns: