pylint/peps8

Author: adelepoulle

src/py_eddy_tracker/observations.py

@@ -67,10 +67,13 @@ class EddiesObservations(object):
         Time
     """
 
-    def __init__(self, size=0, track_extra_variables=None, track_array_variables=0, array_variables=None):
-        self.track_extra_variables = track_extra_variables if track_extra_variables is not None else []
+    def __init__(self, size=0, track_extra_variables=None,
+                 track_array_variables=0, array_variables=None):
+        self.track_extra_variables = \
+            track_extra_variables if track_extra_variables is not None else []
         self.track_array_variables = track_array_variables
-        self.array_variables = array_variables if array_variables is not None else []
+        self.array_variables = \
+            array_variables if array_variables is not None else []
         for elt in self.elements:
             if elt not in VAR_DESCR:
                 raise Exception('Unknown element : %s' % elt)
@@ -116,7 +119,7 @@ def elements(self):
             'time']  # 'rtime'
         if self.track_array_variables > 0:
             elements += self.array_variables
-        
+
         if len(self.track_extra_variables):
             elements += self.track_extra_variables
         return elements
@@ -171,7 +174,7 @@ def insert_observations(self, other, index):
             return self
         if index < 0:
             index = self_size + index + 1
-        eddies = self.__class__(new_size, 
+        eddies = self.__class__(new_size,
             track_extra_variables=self.track_extra_variables,
             track_array_variables=self.track_array_variables,
             array_variables=self.array_variables
@@ -217,7 +220,8 @@ def load_from_netcdf(filename):
             nb_obs = len(h_nc.dimensions['Nobs'])
             kwargs = dict()
             if array_dim in h_nc.dimensions:
-                kwargs['track_array_variables'] = len(h_nc.dimensions[array_dim])
+                kwargs['track_array_variables'] = len(
+                    h_nc.dimensions[array_dim])
                 kwargs['array_variables'] = []
                 for variable in h_nc.variables:
                     if array_dim in h_nc.variables[variable].dimensions:
@@ -357,8 +361,8 @@ def elements(self):
         return elements
 
     @staticmethod
-    def create_variable(handler_nc, kwargs_variable,
-                        attr_variable, data, scale_factor=None, add_offset=None):
+    def create_variable(handler_nc, kwargs_variable, attr_variable,
+                        data, scale_factor=None, add_offset=None):
         var = handler_nc.createVariable(
             zlib=True,
             complevel=1,

src/py_eddy_tracker/property_functions.py

@@ -37,7 +37,8 @@
 from .tracking_objects import nearest
 from .observations import EddiesObservations
 from .property_objects import Amplitude
-from .tools import distance, winding_number_poly, fit_circle_c, poly_contain_poly
+from .tools import distance, winding_number_poly, fit_circle_c, \
+    poly_contain_poly
 from matplotlib.path import Path as BasePath
 from scipy.interpolate import griddata
 from .tools import distance_vector
@@ -172,7 +173,7 @@ def vorticity(u_val, v_val, d_x, d_y):
     # Relative vorticity
     x_i = vorticity(u_val, v_val, p_m, p_n)
     # Okubo
-    lambda2 = s_n**2 + s_t**2 - x_i**2
+    lambda2 = s_n ** 2 + s_t ** 2 - x_i ** 2
     return lambda2, x_i
 
 
@@ -352,11 +353,11 @@ def _fit_circle_path(self):
             logging.warning('An edge is only define in one position')
             logging.debug('%d coordinates %s,%s', len(self.lon), self.lon,
                           self.lat)
-            self._circle_params =  0, -90, nan, nan
+            self._circle_params = 0, -90, nan, nan
 
     centlon_e, centlat_e = proj(centlon_e, centlat_e, inverse=True)
     centlon_e = (centlon_e - lon_mean + 180) % 360 + lon_mean - 180
-    self._circle_params =  centlon_e, centlat_e, eddy_radius_e, aerr
+    self._circle_params = centlon_e, centlat_e, eddy_radius_e, aerr
 
 BasePath.fit_circle = fit_circle_path
 BasePath._fit_circle_path = _fit_circle_path
@@ -489,7 +490,7 @@ def collection_loop(contours, grd, rtime, eddy,
                             anticyclonic_search)
 
                     #~ if eddy.track_array_variables > 0:
-                        
+
                     #~ if not eddy.track_extra_variables:
                     if True:
                         (uavg, contlon_s, contlat_s,
@@ -540,11 +541,13 @@ def collection_loop(contours, grd, rtime, eddy,
                     properties.obs['lon'] = centlon_s
                     properties.obs['lat'] = centlat_s
                     if 'contour_lon_e' in eddy.track_array_variables:
-                        properties.obs['contour_lon_e'], properties.obs['contour_lat_e'] = uniform_resample(
+                        (properties.obs['contour_lon_e'],
+                         properties.obs['contour_lat_e']) = uniform_resample(
                             cont.lon, cont.lat,
                             fixed_size=eddy.track_array_variables_sampling)
                     if 'contour_lon_s' in eddy.track_array_variables:
-                        properties.obs['contour_lon_s'], properties.obs['contour_lat_s'] = uniform_resample(
+                        (properties.obs['contour_lon_s'],
+                         properties.obs['contour_lat_s']) = uniform_resample(
                             contlon_s, contlat_s,
                             fixed_size=eddy.track_array_variables_sampling)
 
@@ -601,7 +604,7 @@ def hann2d_fast(var, n_i, n_j):
         weight = 8. - c_c  # This is the weight for values on each grid point,
 #                                         based on number of valid neighbours
         # Final smoothed version of var
-        hsm = 0.125 * (var_s + weight * var_ext[1:jsz+1, 1:isz+1])
+        hsm = 0.125 * (var_s + weight * var_ext[1:jsz + 1, 1:isz + 1])
         return hsm
 
     for _ in arange(numpasses):

src/py_eddy_tracker/property_objects.py

@@ -34,8 +34,7 @@
 from scipy.ndimage import minimum_filter
 from numpy import array, isfinite, ma, where, ones
 from .tools import index_from_nearest_path, \
-    index_from_nearest_path_with_pt_in_bbox, distance_matrix
-import logging
+    index_from_nearest_path_with_pt_in_bbox
 
 
 class Amplitude (object):
@@ -59,21 +58,19 @@ class Amplitude (object):
     def __init__(self, contlon, contlat, eddy, grd):
         """
         """
-        self.contlon = contlon.copy()
-        self.contlat = contlat.copy()
         eddy.grd = grd  # temporary fix
         self.eddy = eddy
         self.sla = self.eddy.sla[self.jslice,
                                  self.islice].copy()
 
         if 'RectBivariate' in eddy.interp_method:
-            h_0 = grd.sla_coeffs.ev(self.contlat[1:], self.contlon[1:])
+            h_0 = grd.sla_coeffs.ev(contlat[1:], contlon[1:])
 
         elif 'griddata' in eddy.interp_method:
             points = array([grd.lon()[self.jslice, self.islice].ravel(),
                                grd.lat()[self.jslice, self.islice].ravel()]).T
             h_0 = griddata(points, self.sla.ravel(),
-                           (self.contlon[1:], self.contlat[1:]),
+                           (contlon[1:], contlat[1:]),
                            'linear')
         else:
             raise Exception('Unknown method : %s' % eddy.interp_method)
@@ -82,7 +79,7 @@ def __init__(self, contlon, contlat, eddy, grd):
         self.amplitude = 0  # atleast_1d(0.)
         self.local_extrema = None  # int(0)
         self.local_extrema_inds = None
-        self.sla = ma.masked_where(-self.mask, self.sla)
+        self.sla = ma.array(self.sla, mask=-self.mask)
 
     @property
     def islice(self):
@@ -99,24 +96,22 @@ def mask(self):
     @property
     def mle(self):
         return self.eddy.max_local_extrema
-    
+
     def within_amplitude_limits(self):
         """
         """
         return (self.amplitude >= self.eddy.ampmin and
                 self.amplitude <= self.eddy.ampmax)
 
     def _set_cyc_amplitude(self):
+        """Get amplitude for cyclone
         """
-        """
-        self.amplitude = self.h_0
-        self.amplitude -= self.sla.min()
+        self.amplitude = self.h_0 - self.sla.min()
 
     def _set_acyc_amplitude(self):
+        """Get amplitude for anticyclone
         """
-        """
-        self.amplitude = self.sla.max()
-        self.amplitude -= self.h_0
+        self.amplitude = self.sla.max() - self.h_0
 
     def all_pixels_below_h0(self, level):
         """
@@ -184,7 +179,7 @@ def _set_local_extrema(self, sign):
         """
         self._detect_local_minima(self.sla * sign)
 
-    def _detect_local_minima(self, arr):
+    def _detect_local_minima(self, grid):
         """
         Take an array and detect the troughs using the local maximum filter.
         Returns a boolean mask of the troughs (i.e., 1 when
@@ -193,12 +188,12 @@ def _detect_local_minima(self, arr):
         """
         # Equivalent
         neighborhood = ones((3, 3), dtype='bool')
-        #~ neighborhood = generate_binary_structure(arr.ndim, 2)
+        #~ neighborhood = generate_binary_structure(grid.ndim, 2)
 
         # Get local mimima
         detected_minima = minimum_filter(
-            arr, footprint=neighborhood) == arr
-        background = (arr == 0)
+            grid, footprint=neighborhood) == grid
+        background = (grid == 0)
         # Aims ?
         eroded_background = binary_erosion(
             background, structure=neighborhood, border_value=1)
@@ -259,11 +254,12 @@ def __init__(self, contour, nearest_contain_in_bbox=False):
         self.nb_c_per_l = array(li_list, dtype='u4')
         self.l_i = array(self.nb_c_per_l.cumsum() - self.nb_c_per_l,
                          dtype='u4')
-                         
+
         self.nearest_contain_in_bbox = nearest_contain_in_bbox
 
     def get_index_nearest_path_bbox_contain_pt(self, level, xpt, ypt):
-        """
+        """Get index from the nearest path in the level, if the bbox of the
+        path contain pt
         """
         return index_from_nearest_path_with_pt_in_bbox(
             level,
@@ -282,7 +278,7 @@ def get_index_nearest_path_bbox_contain_pt(self, level, xpt, ypt):
             )
 
     def get_index_nearest_path(self, level, xpt, ypt):
-        """
+        """ Get index from the nearest path in the level
         """
         return index_from_nearest_path(
             level,

src/py_eddy_tracker/tools.pyx

@@ -415,14 +415,14 @@ def index_from_nearest_path_with_pt_in_bbox(
     # We iterate over contour in the same level
     for i_elt_c from i_start_c <= i_elt_c < i_end_c:
         # if bbox of contour doesn't contain pt, we skip this contour
-        if x_min_per_c[i_elt_c] > xpt:
-            continue
-        if x_max_per_c[i_elt_c] < xpt:
-            continue
         if y_min_per_c[i_elt_c] > ypt:
             continue
         if y_max_per_c[i_elt_c] < ypt:
             continue
+        if x_min_per_c[i_elt_c] > xpt:
+            continue
+        if x_max_per_c[i_elt_c] < xpt:
+            continue
         # Indice of first pt of contour
         i_start_pt = indices_of_first_pts[i_elt_c]
         # Indice of first pt of the next contour