Apply modification from a checker

Author: AntSimi

src/py_eddy_tracker/grid/__init__.py

@@ -343,7 +343,8 @@ def get_end(theend, shape, pad):
         self.slice_i_unpad = slice(abs(pad), -abs(pad))
         self.slice_i_pad = slice(ip0, ip1)
 
-    def haversine_dist(self, lon1, lat1, lon2, lat2):
+    @staticmethod
+    def haversine_dist(lon1, lat1, lon2, lat2):
         """
         TO DO: change to use f2py version
         Haversine formula to calculate distance between two lon/lat points
@@ -367,7 +368,8 @@ def nearest_point(self, lon, lat):
         """
         return nearest(lon, lat, self._lon[0], self._lat[:, 0])
 
-    def half_interp(self, h_one, h_two):
+    @staticmethod
+    def half_interp(h_one, h_two):
         """
         Speed up frequent operations of type 0.5 * (arr[:-1] + arr[1:])
         """
@@ -418,7 +420,7 @@ def uu2ur(uu_in, 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())
+            return u_out.squeeze()
         mshp, lshp = uu_in.shape
         return uu2ur(uu_in, mshp, lshp + 1)
 
@@ -429,7 +431,7 @@ def vv2vr(vv_in, m_p, l_p):
             v_out[1:-1] = self.half_interp(vv_in[:-1], vv_in[1:])
             v_out[0] = v_out[1]
             v_out[-1] = v_out[-2]
-            return (v_out.squeeze())
+            return v_out.squeeze()
         mshp, lshp = vv_in.shape
         return vv2vr(vv_in, mshp + 1, lshp)
 

src/py_eddy_tracker/grid/aviso.py

@@ -120,8 +120,8 @@ def __init__(self, aviso_file, the_domain,
 
         # zero_crossing, used for handling a longitude range that
         # crosses zero degree meridian
-        if self.lonmin < 0 and self.lonmax >= 0 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.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()):
                 pass
             else:
                 self.zero_crossing = True

src/py_eddy_tracker/observations.py

@@ -247,7 +247,7 @@ def coherence(self, other):
         """Check coherence between two dataset
         """
         test = self.track_extra_variables == other.track_extra_variables
-        test = self.track_array_variables == other.track_array_variables
+        test *= self.track_array_variables == other.track_array_variables
         test *= self.array_variables == other.array_variables
         return test
 
@@ -783,7 +783,7 @@ def create_variable(handler_nc, kwargs_variable, attr_variable,
             var.setncattr('min', var[:].min())
             var.setncattr('max', var[:].max())
         except ValueError:
-            logging.warn('Data is empty')
+            logging.warning('Data is empty')
 
     def write_netcdf(self, path='./', filename='%(path)s/%(sign_type)s.nc'):
         """Write a netcdf with eddy obs

src/py_eddy_tracker/property_functions.py

@@ -198,8 +198,7 @@ def get_uavg(eddy, contours, centlon_e, centlat_e, poly_eff, grd,
 
         # 3. Respect size range
         mask_i_sum = poly_i.contains_points(points).sum()
-        if not (mask_i_sum >= pixel_min and
-                mask_i_sum <= eddy.pixel_threshold[1]):
+        if not (pixel_min <= mask_i_sum <= eddy.pixel_threshold[1]):
             continue
         any_inner_contours = True
 
@@ -353,8 +352,7 @@ def collection_loop(contours, grd, eddy, x_i=None, c_s_xi=None):
                 xilon, xilat = c_s_xi.find_nearest_contour(
                     centlon_e, centlat_e, pixel=False)[3:5]
                 eddy_radius_e = distance(centlon_e, centlat_e, xilon, xilat)
-                if not (eddy_radius_e >= eddy.radmin and
-                        eddy_radius_e <= eddy.radmax):
+                if not (eddy.radmin <= eddy_radius_e <= eddy.radmax):
                     continue
 
             # Get indices of centroid

src/py_eddy_tracker/property_objects.py

@@ -108,8 +108,7 @@ def mle(self):
     def within_amplitude_limits(self):
         """
         """
-        return (self.amplitude >= self.eddy.ampmin and
-                self.amplitude <= self.eddy.ampmax)
+        return self.eddy.ampmin <= self.amplitude <= self.eddy.ampmax
 
     def _set_cyc_amplitude(self):
         """Get amplitude for cyclone
@@ -130,8 +129,7 @@ def all_pixels_below_h0(self, level):
             return False  # i.e., with self.amplitude == 0
         else:
             self._set_local_extrema(1)
-            if (self.local_extrema > 0 and
-                    self.local_extrema <= self.mle):
+            if 0 < self.local_extrema <= self.mle:
                 self._set_cyc_amplitude()
             elif self.local_extrema > self.mle:
                 lmi_j, lmi_i = where(self.local_extrema_inds)
@@ -157,8 +155,7 @@ def all_pixels_above_h0(self, level):
             return False
         else:
             self._set_local_extrema(-1)
-            if (self.local_extrema > 0 and
-                    self.local_extrema <= self.mle):
+            if 0 < self.local_extrema <= self.mle:
                 self._set_acyc_amplitude()
 
             elif self.local_extrema > self.mle:
@@ -175,7 +172,7 @@ def all_pixels_above_h0(self, level):
                         levnp2 = -1e5
                 jmax += self.eddy.jmin
                 imax += self.eddy.imin
-                return (imax, jmax)
+                return imax, jmax
         return False
 
     def _set_local_extrema(self, sign):
@@ -260,15 +257,15 @@ def __init__(self, contours):
         self.x_value = empty(nb_pt, dtype=coord_dtype)
         self.y_value = empty(nb_pt, dtype=coord_dtype)
 
-        self.level_index = empty((nb_level), dtype='u4')
-        self.nb_contour_per_level = empty((nb_level), dtype='u4')
+        self.level_index = empty(nb_level, dtype='u4')
+        self.nb_contour_per_level = empty(nb_level, dtype='u4')
 
-        self.nb_pt_per_contour = empty((nb_contour), dtype='u4')
+        self.nb_pt_per_contour = empty(nb_contour, dtype='u4')
 
-        self.x_min_per_contour = empty((nb_contour), dtype=coord_dtype)
-        self.x_max_per_contour = empty((nb_contour), dtype=coord_dtype)
-        self.y_min_per_contour = empty((nb_contour), dtype=coord_dtype)
-        self.y_max_per_contour = empty((nb_contour), dtype=coord_dtype)
+        self.x_min_per_contour = empty(nb_contour, dtype=coord_dtype)
+        self.x_max_per_contour = empty(nb_contour, dtype=coord_dtype)
+        self.y_min_per_contour = empty(nb_contour, dtype=coord_dtype)
+        self.y_max_per_contour = empty(nb_contour, dtype=coord_dtype)
 
         #~ self._is_valid = empty((nb_contour), dtype='bool')
 

src/py_eddy_tracker/tracking.py

@@ -108,7 +108,7 @@ def merge_correspondance(self, other):
         i = where(other.datasets == array(self.datasets[-1]))[0]
         if len(i) != 1:
             raise Exception('More than one intersection')
-        
+
         # Merge
         # Create a hash table
         translate = empty(other.current_id, dtype='u4')
@@ -194,7 +194,7 @@ def store_correspondance(self, i_previous, i_current, nb_real_obs):
     def append(self, *args, **kwargs):
         self.nb_link_max = max(self.nb_link_max, len(args[0]))
         super(Correspondances, self).append(*args, **kwargs)
-    
+
     def id_generator(self, nb_id):
         """Generation id and incrementation
         """
@@ -221,7 +221,7 @@ def recense_dead_id_to_extend(self):
                 list_previous_virtual_id.index(i) for i in virtual_dead_id]
             # Virtual obs which can be prolongate
             alive_virtual_obs = self.virtual_obs['segment_size'
-                ][i_virtual_dead_id] < self.nb_virtual
+                                ][i_virtual_dead_id] < self.nb_virtual
             nb_virtual_extend = alive_virtual_obs.sum()
             logging.debug('%d virtual obs will be prolongate on the '
                           'next step', nb_virtual_extend)
@@ -230,7 +230,7 @@ def recense_dead_id_to_extend(self):
         self.previous_virtual_obs = self.virtual_obs
         # Creation of an virtual step for dead one
         self.virtual_obs = VirtualEddiesObservations(
-            size=nb_dead + nb_virtual_extend, 
+            size=nb_dead + nb_virtual_extend,
             track_extra_variables=self.previous_obs.track_extra_variables,
             track_array_variables=self.previous_obs.track_array_variables,
             array_variables=self.previous_obs.array_variables)
@@ -255,27 +255,27 @@ def recense_dead_id_to_extend(self):
         self.virtual_obs['dlon'][:nb_dead] = obs_b['lon'] - obs_a['lon']
         self.virtual_obs['dlat'][:nb_dead] = obs_b['lat'] - obs_a['lat']
         self.virtual_obs['lon'][:nb_dead
-            ] = obs_b['lon'] + self.virtual_obs['dlon'][:nb_dead]
+        ] = obs_b['lon'] + self.virtual_obs['dlon'][:nb_dead]
         self.virtual_obs['lat'][:nb_dead
-            ] = obs_b['lat'] + self.virtual_obs['dlat'][:nb_dead]
+        ] = obs_b['lat'] + self.virtual_obs['dlat'][:nb_dead]
         # Id which are extended
         self.virtual_obs['track'][:nb_dead] = dead_id
         # Add previous virtual
         if nb_virtual_extend > 0:
             obs_to_extend = self.previous_virtual_obs.obs[i_virtual_dead_id
-                ][alive_virtual_obs]
+            ][alive_virtual_obs]
             for key in obs_b.dtype.fields.keys():
                 if key in ['lon', 'lat', 'time', 'track', 'segment_size',
                            'dlon', 'dlat'] or 'contour_' in key:
                     continue
                 self.virtual_obs[key][nb_dead:] = obs_to_extend[key]
             self.virtual_obs['lon'][nb_dead:
-                ] = obs_to_extend['lon'] + obs_to_extend['dlon']
+            ] = obs_to_extend['lon'] + obs_to_extend['dlon']
             self.virtual_obs['lat'][nb_dead:
-                ] = obs_to_extend['lat'] + obs_to_extend['dlat']
+            ] = obs_to_extend['lat'] + obs_to_extend['dlat']
             self.virtual_obs['track'][nb_dead:] = obs_to_extend['track']
             self.virtual_obs['segment_size'][nb_dead:
-                ] = obs_to_extend['segment_size']
+            ] = obs_to_extend['segment_size']
         # Count
         self.virtual_obs['segment_size'][:] += 1
 
@@ -318,7 +318,7 @@ def save(self, filename):
             # Create dimensions
             logging.debug('Create Dimensions "Nlink" : %d', self.nb_link_max)
             h_nc.createDimension('Nlink', self.nb_link_max)
-            
+
             logging.debug('Create Dimensions "Nstep" : %d', nb_step)
             h_nc.createDimension('Nstep', nb_step)
             var_file_in = h_nc.createVariable(
@@ -333,16 +333,16 @@ def save(self, filename):
 
             var_nb_link = h_nc.createVariable(
                 zlib=True, complevel=1,
-                varname='nb_link', datatype='u2', dimensions=('Nstep'))
-            
+                varname='nb_link', datatype='u2', dimensions='Nstep')
+
             for name, dtype in self.correspondance_dtype:
                 if dtype is bool_:
                     dtype = 'byte'
                 h_nc.createVariable(zlib=True,
                                     complevel=1,
                                     varname=name,
                                     datatype=dtype,
-                                    dimensions=('Nstep','Nlink'))
+                                    dimensions=('Nstep', 'Nlink'))
 
             for i, correspondance in enumerate(self):
                 nb_elt = correspondance.shape[0]
@@ -389,8 +389,8 @@ def prepare_merging(self):
                 # correspondance
                 self.nb_obs_by_tracks[
                     correspondance['id'][correspondance['virtual']]
-                    ] += correspondance['virtual_length'][
-                        correspondance['virtual']]
+                ] += correspondance['virtual_length'][
+                    correspondance['virtual']]
 
         # Compute index of each tracks
         self.i_current_by_tracks = \
@@ -414,7 +414,7 @@ def merge(self, until=-1):
             track_extra_variables=self.current_obs.track_extra_variables,
             track_array_variables=self.current_obs.track_array_variables,
             array_variables=self.current_obs.array_variables,
-            )
+        )
 
         # Calculate the index in each tracks, we compute in u4 and translate
         # in u2 (which are limited to 65535)
@@ -433,7 +433,7 @@ def merge(self, until=-1):
 
         # To know if the track start
         first_obs_save_in_tracks = zeros(self.i_current_by_tracks.shape,
-                                            dtype=bool_)
+                                         dtype=bool_)
 
         for i, file_name in enumerate(self.datasets[1:]):
             if until != -1 and i >= until:
@@ -455,7 +455,7 @@ def merge(self, until=-1):
                 for field in fields:
                     var = field[0]
                     eddies[var][index_final[m_first_obs]
-                        ] = self.previous_obs[var][index_in]
+                    ] = self.previous_obs[var][index_in]
                 # Increment
                 self.i_current_by_tracks[i_id[m_first_obs]] += 1
                 # Active this flag, we have only one first by tracks
@@ -469,7 +469,7 @@ def merge(self, until=-1):
                 if m_virtual.any():
                     # Incrementing index
                     self.i_current_by_tracks[i_id[m_virtual]
-                        ] += self[i]['virtual_length'][m_virtual]
+                    ] += self[i]['virtual_length'][m_virtual]
                     # Get new index
                     index_final = self.i_current_by_tracks[i_id]
 
@@ -480,7 +480,7 @@ def merge(self, until=-1):
             for field in fields:
                 var = field[0]
                 eddies[var][index_final
-                    ] = self.current_obs[var][index_current]
+                ] = self.current_obs[var][index_current]
 
             # Add increment for each index used
             self.i_current_by_tracks[i_id] += 1

src/py_eddy_tracker/tracking_objects.py

@@ -51,13 +51,13 @@ def nearest(lon_pt, lat_pt, lon2d, lat2d):
     """
     try:
         i_x = int_(interp(lon_pt,
-                                lon2d,
-                                arange(len(lon2d)),
-                                left=0, right=-1))
+                          lon2d,
+                          arange(len(lon2d)),
+                          left=0, right=-1))
         i_y = int_(interp(lat_pt,
-                                lat2d,
-                                arange(len(lat2d)),
-                                left=0, right=-1))
+                          lat2d,
+                          arange(len(lat2d)),
+                          left=0, right=-1))
     except ValueError:
         logging.error('%s, %s', lat2d, lat_pt)
         raise ValueError()
@@ -68,6 +68,7 @@ class IdentificationList(object):
     """
     Class that holds list of eddy identify:
     """
+
     def __init__(self, sign_type, grd, date, **kwargs):
         """
         Initialise the list 'tracklist'
@@ -80,10 +81,10 @@ def __init__(self, sign_type, grd, date, **kwargs):
         self.the_domain = kwargs.get('THE_DOMAIN', 'Regional')
         self.track_extra_variables = kwargs.get('TRACK_EXTRA_VARIABLES', [])
         if self.track_extra_variables is None:
-           self.track_extra_variables = [] 
+            self.track_extra_variables = []
         array_properties = kwargs.get('TRACK_ARRAY_VARIABLES', dict())
         if array_properties is None:
-           array_properties = dict() 
+            array_properties = dict()
         self.track_array_variables_sampling = array_properties.get('NB_SAMPLES', 0)
         self.track_array_variables = array_properties.get('VARIABLES', [])
         self.smoothing = kwargs.get('SMOOTHING', True)
@@ -113,7 +114,7 @@ def __init__(self, sign_type, grd, date, **kwargs):
             track_extra_variables=self.track_extra_variables,
             track_array_variables=self.track_array_variables_sampling,
             array_variables=self.track_array_variables
-            )
+        )
 
         self.index = 0  # counter
         self.pad = 2
@@ -180,14 +181,14 @@ def create_variable(self, handler_nc, kwargs_variable,
             var.setncattr('min', var[:].min())
             var.setncattr('max', var[:].max())
         except ValueError:
-            logging.warn('Data is empty')
+            logging.warning('Data is empty')
 
     def write_netcdf(self, path='./'):
         """Write a netcdf with eddy obs
         """
         eddy_size = len(self.observations)
         filename = '%s/%s_%s.nc' % (
-            path,self.sign_type, self.date.strftime('%Y%m%d'))
+            path, self.sign_type, self.date.strftime('%Y%m%d'))
         with Dataset(filename, 'w', format='NETCDF4') as h_nc:
             logging.info('Create intermediary file %s', filename)
             # Create dimensions
@@ -208,7 +209,7 @@ def write_netcdf(self, path='./'):
                     self.observations.obs[name],
                     scale_factor=VAR_DESCR[name].get('scale_factor', None),
                     add_offset=VAR_DESCR[name].get('add_offset', None)
-                    )
+                )
 
             # Add cyclonic information
             self.create_variable(
@@ -260,9 +261,9 @@ def set_mask_eff(self, contour, grd):
         mask for effective contour
         """
         self.points = array([grd.lon[self.slice_j,
-                                        self.slice_i].ravel(),
-                                grd.lat[self.slice_j,
-                                        self.slice_i].ravel()]).T
+                                     self.slice_i].ravel(),
+                             grd.lat[self.slice_j,
+                                     self.slice_i].ravel()]).T
         # NOTE: Path.contains_points requires matplotlib 1.2 or higher
         self.mask_eff_1d = contour.contains_points(self.points)
         self.mask_eff_sum = self.mask_eff_1d.sum()
@@ -274,5 +275,4 @@ def reshape_mask_eff(self, grd):
         self.mask_eff = self.mask_eff_1d.reshape(shape)
 
     def check_pixel_count(self, nb_valid_pixel):
-        return nb_valid_pixel >= self.pixel_threshold[0] and \
-            nb_valid_pixel <= self.pixel_threshold[1]
+        return self.pixel_threshold[0] <= nb_valid_pixel <= self.pixel_threshold[1]