apply proposition of checker

AntSimi · AntSimi · commit 7df1dc3cc5f7 · 2018-02-13T15:12:57.000+01:00
diff --git a/src/py_eddy_tracker/featured_tracking/old_tracker_reference.py b/src/py_eddy_tracker/featured_tracking/old_tracker_reference.py
@@ -26,7 +26,7 @@ def mask_function(self, other):
             cmax=1.5,
             lat1=23,
             lat2=5,
-            )
+        )
         # mask from ellips
         mask = self.shifted_ellipsoid_degrees_mask(
             other,
@@ -56,10 +56,10 @@ def across_ground(cls, record0, record1):
             y0=record0['lat'],
             x1=record1['lon'],
             y1=record1['lat'],
-            )
+        )
 
         data = cls.GROUND.grid('mask')[i, j]
-        i_ground = unique(arange(len(record0)).repeat(d_pix + 1)[data==1])
+        i_ground = unique(arange(len(record0)).repeat(d_pix + 1)[data == 1])
         mask = ones(record1.shape, dtype='bool')
         mask[i_ground] = False
         return mask
diff --git a/src/py_eddy_tracker/grid/__init__.py b/src/py_eddy_tracker/grid/__init__.py
@@ -43,7 +43,7 @@
 
 
 def browse_dataset_in(data_dir, files_model, date_regexp, date_model,
-        start_date=None, end_date=None, sub_sampling_step=1):
+                      start_date=None, end_date=None, sub_sampling_step=1):
     pattern_regexp = re_compile('.*/' + date_regexp)
     full_path = join_path(data_dir, files_model)
     logging.info('Search files : %s', full_path)
@@ -75,7 +75,7 @@ def browse_dataset_in(data_dir, files_model, date_regexp, date_model,
             result = pattern_regexp.match(str(item['filename']))
             if result:
                 str_date = result.groups()[0]
-            
+
         if str_date is not None:
             item['date'] = datetime.strptime(str_date, date_model).date()
 
@@ -120,7 +120,7 @@ class BaseData(object):
       ROMS:   get_ROMS_f_pm_pn
 
     """
-    
+
     __slots__ = (
         'zero_crossing',
         'slice_i',
@@ -154,8 +154,8 @@ class BaseData(object):
         'pad',
         'shape',
         'mask',
-        )
-    
+    )
+
     GRAVITY = 9.81
     earth_radius = 6371315.0
 
@@ -229,11 +229,11 @@ def read_nc_att(self, varname, att):
 
     @property
     def is_regular(self):
-        steps_lon = unique(self._lon[0, 1:] - self._lon[0,:-1])
+        steps_lon = unique(self._lon[0, 1:] - self._lon[0, :-1])
         steps_lat = unique(self._lat[1:, 0] - self._lat[:-1, 0])
         return len(steps_lon) == 1 and len(steps_lat) == 1 and \
-            steps_lon[0] != 0. and steps_lat[0] != 0.
-    
+               steps_lon[0] != 0. and steps_lat[0] != 0.
+
     def set_initial_indices(self):
         """
         Set indices for desired domain
@@ -276,18 +276,19 @@ def kdt(lon, lat, limits, k=4):
                 """
                 if self.is_regular:
                     i_1 = int(floor(interp((lonmin - 0.5) % 360,
-                                       self._lon[0],
-                                       arange(len(self._lon[0])))))
+                                           self._lon[0],
+                                           arange(len(self._lon[0])))))
                     i_0 = int(floor(interp((lonmax + 0.5) % 360,
-                                       self._lon[0],
-                                       arange(len(self._lon[0])))
-                                       ) + 1)
+                                           self._lon[0],
+                                           arange(len(self._lon[0])))
+                                    ) + 1)
                 else:
                     def half_limits(lon, lat):
                         return array([[lon.min(), lon.max(),
-                                          lon.max(), lon.min()],
-                                         [lat.min(), lat.min(),
-                                          lat.max(), lat.max()]]).T
+                                       lon.max(), lon.min()],
+                                      [lat.min(), lat.min(),
+                                       lat.max(), lat.max()]]).T
+
                     # Get bounds for right part of grid
                     lat = self._lat[self._lon >= 360 + lonmin - 0.5]
                     lon = self._lon[self._lon >= 360 + lonmin - 0.5]
@@ -415,12 +416,14 @@ def u2rho_2d(self, uu_in):
         """
         Convert a 2D field at u_val points to a field at rho points
         """
+
         def uu2ur(uu_in, m_p, l_p):
             u_out = zeros((m_p, l_p))
             u_out[:, 1:-1] = self.half_interp(uu_in[:, :-1], uu_in[:, 1:])
             u_out[:, 0] = u_out[:, 1]
             u_out[:, -1] = u_out[:, -2]
             return u_out.squeeze()
+
         mshp, lshp = uu_in.shape
         return uu2ur(uu_in, mshp, lshp + 1)
 
@@ -432,6 +435,7 @@ def vv2vr(vv_in, m_p, l_p):
             v_out[0] = v_out[1]
             v_out[-1] = v_out[-2]
             return v_out.squeeze()
+
         mshp, lshp = vv_in.shape
         return vv2vr(vv_in, mshp + 1, lshp)
 
@@ -458,7 +462,7 @@ def set_basemap(self, with_pad=True):
             llcrnrlat=self.latmin - 1,
             urcrnrlat=self.latmax + 1,
             lat_ts=0.5 * (self.latmin + self.latmax)
-            )
+        )
 
         if with_pad:
             x_val, y_val = self.m_val(self.lonpad, self.latpad)
@@ -475,13 +479,13 @@ def set_geostrophic_velocity(self, zeta):
         zeta1, zeta2 = zeta.data[1:].view(), zeta.data[:-1].view()
         pn1, pn2 = self.p_n[1:].view(), self.p_n[:-1].view()
         self.upad[:] = self.v2rho_2d(
-            ma.array((zeta1 - zeta2) * 0.5 * (pn1 + pn2), mask= self.vmask))
+            ma.array((zeta1 - zeta2) * 0.5 * (pn1 + pn2), mask=self.vmask))
         self.upad *= -self.gof
 
         zeta1, zeta2 = zeta.data[:, 1:].view(), zeta.data[:, :-1].view()
         pm1, pm2 = self.p_m[:, 1:].view(), self.p_m[:, :-1].view()
         self.vpad[:] = self.u2rho_2d(
-            ma.array((zeta1 - zeta2) *0.5 * (pm1 + pm2), mask=self.umask))
+            ma.array((zeta1 - zeta2) * 0.5 * (pm1 + pm2), mask=self.umask))
         self.vpad *= self.gof
 
     def set_u_v_eke(self, pad=2):
@@ -495,7 +499,7 @@ def set_u_v_eke(self, pad=2):
             self.upad = ma.concatenate((u_0, u_1), axis=1)
         else:
             self.upad = empty((j_size,
-                                  self.slice_i_pad.stop - self.slice_i_pad.start))
+                               self.slice_i_pad.stop - self.slice_i_pad.start))
         self.vpad = empty(self.upad.shape)
 
     def get_eke(self):
@@ -532,7 +536,7 @@ def create_index_inverse(slice_to_inverse, size):
         """Return an array of index
         """
         index = concatenate((arange(slice_to_inverse.stop, size),
-                                arange(slice_to_inverse.start)))
+                             arange(slice_to_inverse.start)))
         return index
 
     def gaussian_resolution(self, zwl, mwl):
diff --git a/src/py_eddy_tracker/grid/aviso.py b/src/py_eddy_tracker/grid/aviso.py
@@ -32,7 +32,7 @@
 from dateutil import parser
 from numpy import meshgrid, zeros, array, where, ma, argmin, vstack, ones, \
     newaxis, sqrt, diff, r_, arange
-from scipy.interpolate  import interp1d
+from scipy.interpolate import interp1d
 import logging
 from netCDF4 import Dataset
 
@@ -45,9 +45,9 @@ class AvisoGrid(BaseData):
     to have a grid class
     """
     KNOWN_UNITS = dict(
-            m=100.,
-            cm=1.,
-            )
+        m=100.,
+        cm=1.,
+    )
     __slots__ = (
         'lonmin',
         'lonmax',
@@ -69,11 +69,11 @@ class AvisoGrid(BaseData):
         '__lonpad',
         '__latpad',
         'labels',
-        )
+    )
 
     def __init__(self, aviso_file, the_domain,
                  lonmin, lonmax, latmin, latmax, grid_name, lon_name,
-                 lat_name,with_pad=True):
+                 lat_name, with_pad=True):
         """
         Initialise the grid object
         """
@@ -121,7 +121,7 @@ def __init__(self, aviso_file, the_domain,
         # zero_crossing, used for handling a longitude range that
         # crosses zero degree meridian
         if self.lonmin < 0 <= self.lonmax and 'MedSea' not in self.domain:
-            if (self.lonmax < self._lon.max()) and (self.lonmax > self._lon.min()) and (self.lonmin < self._lon.max()) and (self.lonmin > self._lon.min()):
+            if self._lon.min() < self.lonmax < self._lon.max() and self._lon.min() < self.lonmin < self._lon.max():
                 pass
             else:
                 self.zero_crossing = True
@@ -141,15 +141,17 @@ def __init__(self, aviso_file, the_domain,
         # self.init_pos_interpolator()
 
     def init_pos_interpolator(self):
-        self.xinterp = interp1d(self.lon[0].copy(), arange(self.lon.shape[1]), assume_sorted=True, copy=False, fill_value=(0, -1), bounds_error=False, kind='nearest')
-        self.yinterp = interp1d(self.lat[:, 0].copy(), arange(self.lon.shape[0]), assume_sorted=True, copy=False, fill_value=(0, -1), bounds_error=False, kind='nearest')
+        self.xinterp = interp1d(self.lon[0].copy(), arange(self.lon.shape[1]), assume_sorted=True, copy=False,
+                                fill_value=(0, -1), bounds_error=False, kind='nearest')
+        self.yinterp = interp1d(self.lat[:, 0].copy(), arange(self.lon.shape[0]), assume_sorted=True, copy=False,
+                                fill_value=(0, -1), bounds_error=False, kind='nearest')
 
     def nearest_indice(self, lon, lat):
         return self.xinterp(lon), self.yinterp(lat)
 
     def set_filename(self, file_name):
         self.grid_filename = file_name
-    
+
     def get_aviso_data(self, aviso_file, dimensions=None):
         """
         Read nc data from AVISO file
@@ -160,7 +162,7 @@ def get_aviso_data(self, aviso_file, dimensions=None):
         units = self.read_nc_att(self.grid_name, 'units')
         if units not in self.KNOWN_UNITS:
             raise Exception('Unknown units : %s' % units)
-            
+
         with Dataset(self.grid_filename.decode('utf-8')) as h_nc:
             grid_dims = array(h_nc.variables[self.grid_name].dimensions)
             lat_dim = h_nc.variables[self.lat_name].dimensions[0]
@@ -196,7 +198,6 @@ def set_mask(self, sla):
         else:
             self.mask = sla.mask.copy()
             if 'Global' in self.domain:
-
                 # Close Drake Passage
                 minus70 = argmin(abs(self.lonpad[0] + 70))
                 self.mask[:125, minus70] = True
@@ -232,7 +233,7 @@ def lonpad(self):
             self.__lonpad = self._lon[self.view_pad]
             if self.zero_crossing:
                 self.__lonpad[:, :self._lon.shape[1] - self.slice_i_pad.stop
-                              ] -= 360
+                ] -= 360
         return self.__lonpad
 
     @property
@@ -280,7 +281,7 @@ def p_n(self):  # Reciprocal of d_y
     @property
     def resolution(self):
         return sqrt(diff(self.lon[1:], axis=1) *
-                       diff(self.lat[:, 1:], axis=0)).mean()
+                    diff(self.lat[:, 1:], axis=0)).mean()
 
     @property
     def boundary(self):
@@ -292,7 +293,7 @@ def boundary(self):
           lon/lat boundary points
         """
         lon = r_[(self.lon[:, 0], self.lon[-1],
-                     self.lon[::-1, -1], self.lon[0, ::-1])]
+                  self.lon[::-1, -1], self.lon[0, ::-1])]
         lat = r_[(self.lat[:, 0], self.lat[-1],
-                     self.lat[::-1, -1], self.lat[0, ::-1])]
+                  self.lat[::-1, -1], self.lat[0, ::-1])]
         return lon, lat
diff --git a/src/py_eddy_tracker/property_functions.py b/src/py_eddy_tracker/property_functions.py
