docstrings, coverage, pylint

Author: basaks

.coveragerc

@@ -8,9 +8,8 @@ omit =
     # omit these files
     pyrate/pyratelog.py
     pyrate/scripts/main.py
-    pyrate/aps.py
+    pyrate/pyaps.py
     pyrate/compat.py
-    *__init__*
 
 [report]
 # Regexes for lines to exclude from consideration

.pylintrc

@@ -226,7 +226,7 @@ expected-line-ending-format=
 [BASIC]
 
 # Good variable names which should always be accepted, separated by a comma
-good-names=i,j,k,ex,Run,_,x,w,f,n,v,t,r,d,c,cd,g,r,q,V,m,A,b,log,y,id,ds,gt,md
+good-names=ts,i,j,k,ex,Run,_,x,w,f,n,v,t,r,d,c,cd,g,r,q,V,m,A,b,log,y,id,ds,gt,md
 
 # Bad variable names which should always be refused, separated by a comma
 bad-names=foo,bar,baz,toto,tutu,tata

pyrate/aps/__init__.py

@@ -1,3 +1,22 @@
+#   This Python module is part of the PyRate software package.
+#
+#   Copyright 2017 Geoscience Australia
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+"""
+This is the aps/spatio-temporal filter main module.
+"""
+
 import logging
 import os
 from copy import deepcopy
@@ -36,10 +55,10 @@ def wrap_spatio_temporal_filter(ifg_paths, params, tiles, preread_ifgs):
 def spatio_temporal_filter(tsincr, ifg, params, preread_ifgs):
     """
     Applies spatio-temportal (aps) filter and save the interferograms.
-    
+
     A first step is to compute the time series using the non-smooth SVD method.
     This is followed by temporal and spatial filters respectively.
-     
+
     Parameters
     ----------
     tsincr: ndarray
@@ -60,13 +79,13 @@ def spatio_temporal_filter(tsincr, ifg, params, preread_ifgs):
     tsincr -= ts_aps
 
     mpiops.run_once(ts_to_ifgs, tsincr, preread_ifgs)
-    
+
 
 def calc_svd_time_series(ifg_paths, params, preread_ifgs, tiles):
     """
     Time series inversion with no smoothing (svd method)
     This is the matlab tsinvnosm.m equivalent.
-    
+
     Parameters
     ----------
     ifg_paths: list
@@ -77,12 +96,12 @@ def calc_svd_time_series(ifg_paths, params, preread_ifgs, tiles):
         prepread ifgs dict
     tiles: list
         list of shared.Tile class instances
-    
+
     Returns
     -------
     tsincr_g: ndarray
         non smooth (svd method) time series of shape (ifg.shape, nvels)
-    
+
     """
     log.info('Calculating time series without smoothing for '
              'spatio-temporal filter')
@@ -95,11 +114,11 @@ def calc_svd_time_series(ifg_paths, params, preread_ifgs, tiles):
 
     nvels = None
     for t in process_tiles:
-        log.info('Calculating time series for tile {}'.format(t.index))
+        log.info('Calculating time series for tile {} during aps '
+                 'correction'.format(t.index))
         ifg_parts = [shared.IfgPart(p, t, preread_ifgs) for p in ifg_paths]
         mst_tile = np.load(os.path.join(output_dir,
                                         'mst_mat_{}.npy'.format(t.index)))
-        # don't save this time_series calc, this is done as part of aps filter
         tsincr = time_series(ifg_parts, new_params, vcmt=None, mst=mst_tile)[0]
         np.save(file=os.path.join(output_dir, 'tsincr_aps_{}.npy'.format(
             t.index)), arr=tsincr)
@@ -132,16 +151,16 @@ def ts_to_ifgs(ts, preread_ifgs):
         time series nd array (ifg.shape, nvels)
     preread_ifgs: dict
         dict with ifg basic informations
-    
+
     Saves ifgs on disc after conversion.
     """
     log.info('Converting time series to ifgs')
     ifgs = list(OrderedDict(sorted(preread_ifgs.items())).values())
-    epochlist, n = get_epochs(ifgs)
+    _, n = get_epochs(ifgs)
     index_master, index_slave = n[:len(ifgs)], n[len(ifgs):]
-    for i in range(len(ifgs)):
+    for i, ifg in enumerate(ifgs):
         phase = np.sum(ts[:, :, index_master[i]: index_slave[i]], axis=2)
-        _save_aps_corrected_phase(ifgs[i].path, phase)
+        _save_aps_corrected_phase(ifg.path, phase)
 
 
 def _save_aps_corrected_phase(ifg_path, phase):

pyrate/aps/spatial.py

@@ -1,3 +1,22 @@
+#   This Python module is part of the PyRate software package.
+#
+#   Copyright 2017 Geoscience Australia
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+"""
+Spatial low pass filter.
+"""
+# pylint: disable=invalid-name, too-many-locals, too-many-arguments
 import logging
 import numpy as np
 from scipy.fftpack import fft2, ifft2, fftshift, ifftshift
@@ -12,17 +31,17 @@ def spatial_low_pass_filter(ts_hp, ifg, params):
     Parameters
     ----------
     ts_hp: ndarray
-        time series from previous temporal low pass filter output of 
+        time series from previous temporal low pass filter output of
         shape (ifg.shape, n_epochs)
     ifg: shared.Ifg instance
     params: dict
         params dict
-    
+
     Returns
     -------
     ts_hp: ndarray
-        spatio-temporal filtered time series output of 
-        shape (ifg.shape, n_epochs)  
+        spatio-temporal filtered time series output of
+        shape (ifg.shape, n_epochs)
     """
     log.info('Applying spatial low pass filter')
     ts_hp[np.isnan(ts_hp)] = 0  # need it here for cvd and fft
@@ -43,7 +62,7 @@ def slpfilter(phase, ifg, r_dist, params):
     ifg: shared.Ifg class instance
     params: dict
         paramters dict
-    
+
     Returns
     -------
     out: ndarray
@@ -53,9 +72,8 @@ def slpfilter(phase, ifg, r_dist, params):
         return phase
     cutoff = params[cf.SLPF_CUTOFF]
 
-
     if cutoff == 0:
-        maxvar, alpha = cvd_from_phase(phase, ifg, r_dist, calc_alpha=True)
+        _, alpha = cvd_from_phase(phase, ifg, r_dist, calc_alpha=True)
         cutoff = 1.0/alpha
     rows, cols = ifg.shape
     return _slp_filter(phase, cutoff, rows, cols,

pyrate/aps/temporal.py

@@ -1,3 +1,22 @@
+#   This Python module is part of the PyRate software package.
+#
+#   Copyright 2017 Geoscience Australia
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+"""
+Temporal low pass filter.
+"""
+# pylint: disable=invalid-name, too-many-locals, too-many-arguments
 import logging
 import numpy as np
 from numpy import isnan
@@ -8,9 +27,24 @@
 
 # TODO: use tiles here and distribute amongst processes
 def tlpfilter(tsincr, epochlist, params):
-    log.info('Applying temporal low pass filter')
+    """
+    Temporal low pass filter
+
+    Parameters
+    ----------
+    tsincr : ndarray
+        time series array of size (ifg.shape, nvels)
+    epochlist : list
+        list of shared.EpochList class instances
+    params : dict
+        parameters dict
 
-    """temporal low pass filter"""
+    Returns
+    -------
+    tsfilt_incr : ndarray
+        temporal filtered time series of shape (ifg.shape, nvels)
+    """
+    log.info('Applying temporal low pass filter')
     nanmat = ~isnan(tsincr)
     tsfilt_incr = np.empty_like(tsincr, dtype=np.float32) * np.nan
     intv = np.diff(epochlist.spans)  # time interval for the neighboring epoch
@@ -22,7 +56,7 @@ def tlpfilter(tsincr, epochlist, params):
     if method == 1:  # gaussian filter
         func = gauss
     elif method == 2:  # triangular filter
-        func = triangle
+        func = _triangle
     else:
         func = mean_filter
 
@@ -35,7 +69,8 @@ def tlpfilter(tsincr, epochlist, params):
 gauss = lambda m, yr, cutoff: np.exp(-(yr / cutoff) ** 2 / 2)
 
 
-def triangle(m, yr, cutoff):
+def _triangle(m, yr, cutoff):
+    # pylint: disable=unused-argument
     wgt = cutoff - abs(yr)
     wgt[wgt < 0] = 0
     return wgt

pyrate/compat.py

@@ -17,7 +17,7 @@
 This Python module tests compatibilities
 """
 # coding: utf-8
-# pylint: disable= invalid-name,  unused-import
+# pylint: disable= invalid-name,  unused-import, import-error
 
 from __future__ import absolute_import
 import sys

pyrate/covariance.py

@@ -35,6 +35,7 @@
 from pyrate import ifgconstants as ifc
 from pyrate import config as cf
 
+# pylint: disable=too-many-arguments
 # distance division factor of 1000 converts to km and is needed to match
 # Matlab code output
 DISTFACT = 1000
@@ -213,6 +214,10 @@ def cvd_from_phase(phase, ifg, r_dist, calc_alpha, save_acg=False,
 
 
 class RDist:
+    """
+    RDist class used for caching r_dist during maxvar/alpha computation
+    """
+    # pylint: disable=invalid-name
     def __init__(self, ifg):
         self.r_dist = None
         self.ifg = ifg
@@ -229,8 +234,8 @@ def __call__(self):
             # calculations in the numpy land
             self.r_dist = np.divide(np.sqrt(((xx - self.ifg.x_centre) *
                                              self.ifg.x_size) ** 2 +
-                                    ((yy - self.ifg.y_centre) *
-                                     self.ifg.y_size) ** 2),
+                                            ((yy - self.ifg.y_centre) *
+                                             self.ifg.y_size) ** 2),
                                     DISTFACT)  # km
             self.r_dist = reshape(self.r_dist, size, order='F')
             self.r_dist = self.r_dist[:int(ceil(size / 2.0)) + self.nrows]

pyrate/orbital.py

@@ -31,7 +31,6 @@
 from pyrate.shared import nanmedian, Ifg
 from pyrate import config as cf
 from pyrate import ifgconstants as ifc
-from pyrate import mpiops
 
 log = logging.getLogger(__name__)
 

pyrate/scripts/main.py

@@ -20,8 +20,8 @@
 import os
 from os.path import abspath
 import logging
-import click
 import json
+import click
 from pyrate import pyratelog as pylog
 from pyrate import config as cf
 from pyrate.scripts import run_prepifg, run_pyrate, postprocessing

pyrate/scripts/postprocessing.py

@@ -24,7 +24,6 @@
 import numpy as np
 from osgeo import gdal
 
-import pyrate.shared
 from pyrate import config as cf
 from pyrate import ifgconstants as ifc
 from pyrate import shared
@@ -59,7 +58,7 @@ def postprocess_linrate(rows, cols, params):
     # load previously saved prepread_ifgs dict
     preread_ifgs_file = join(params[cf.TMPDIR], 'preread_ifgs.pk')
     ifgs = cp.load(open(preread_ifgs_file, 'rb'))
-    tiles = pyrate.shared.get_tiles(dest_tifs[0], rows, cols)
+    tiles = shared.get_tiles(dest_tifs[0], rows, cols)
 
     # linrate aggregation
     if mpiops.size >= 3:
@@ -117,7 +116,7 @@ def postprocess_timeseries(rows, cols, params):
     epochlist = ifgs['epochlist']
     ifgs = [v for v in ifgs.values() if isinstance(v, PrereadIfg)]
 
-    tiles = pyrate.shared.get_tiles(dest_tifs[0], rows, cols)
+    tiles = shared.get_tiles(dest_tifs[0], rows, cols)
 
     # load the first tsincr file to determine the number of time series tifs
     tsincr_file = os.path.join(output_dir, 'tsincr_0.npy')
@@ -166,6 +165,7 @@ def postprocess_timeseries(rows, cols, params):
 
 
 def assemble_tiles(i, n, tile, tsincr_g, output_dir, outtype):
+    # pylint: disable=too-many-arguments
     """ A reusable time series assembling function"""
     tsincr_file = os.path.join(output_dir,
                                '{}_{}.npy'.format(outtype, n))

pyrate/scripts/run_prepifg.py

@@ -54,9 +54,10 @@ def main(params=None):
     # and the original gamma generated list is ordered) this may not affect
     # the important pyrate stuff anyway, but might affect gen_thumbs.py.
     # Going to assume base_ifg_paths is ordered correcly
+    # pylint: disable=too-many-branches
 
     usage = 'Usage: pyrate prepifg <config_file>'
-    if mpiops.size > 1: # Over-ride input options if this is an MPI job
+    if mpiops.size > 1:  # Over-ride input options if this is an MPI job
         params[cf.LUIGI] = False
         params[cf.PARALLEL] = False
 

pyrate/scripts/run_pyrate.py

@@ -20,8 +20,8 @@
 
 import logging
 import os
-import pickle as cp
 from os.path import join
+import pickle as cp
 from collections import OrderedDict
 import numpy as np
 

pyrate/shared.py

@@ -1093,4 +1093,4 @@ def get_tiles(ifg_path, rows, cols):
     ifg.open(readonly=True)
     tiles = create_tiles(ifg.shape, nrows=rows, ncols=cols)
     ifg.close()
-    return tiles
+    return tiles

tests/test_mpi.py

@@ -207,7 +207,7 @@ def orbfit_degrees(request):
 
 
 @pytest.mark.skipif(not MPITEST, reason='skipping mpi tests in travis except '
-                                        'python 3.5 and GDAL=2.0.0')
+                                        'in TRAVIS and GDAL=2.0.0')
 def test_timeseries_linrate_mpi(mpisync, tempdir, modify_config,
                                 ref_est_method, row_splits, col_splits,
                                 get_crop, orbfit_lks, orbfit_method,