Add more flake8 linters (#10)

* Add flake8-clean-block

* Add indent-in-def & picky-parentheses

* Add implicit-str-concat

* Add flake8-return

* Add flake8-broken-line

* Remove unnecessary blank line

* Add Python 3.11 checks

* Remove Python 3.11 checks

* Change incorrect unpacking

* v0.5.2 -> v0.5.3

Author: jsh9

PySeismoSoil/__init__.py

@@ -1,3 +1,3 @@
 # Author: Jian Shi
 
-__version__ = 'v0.5.2'
+__version__ = 'v0.5.3'

PySeismoSoil/class_Vs_profile.py

@@ -92,6 +92,7 @@ def __init__(
 
         if damping_unit not in ['1', '%']:
             raise ValueError("`damping_unit` must be '1' or '%'.")
+
         if density_unit not in ['kg/m^3', 'g/cm^3', 'kg/m3', 'g/cm3']:
             raise ValueError("`density_unit` must be 'kg/m^3' or 'g/cm^3'.")
 
@@ -105,6 +106,7 @@ def __init__(
                 material_number = np.append(np.arange(1, n_layer_tmp), [0])
             else:
                 material_number = np.arange(1, n_layer_tmp + 1)
+
             full_data = np.column_stack((thk, vs, xi, rho, material_number))
         elif n_col == 5:
             xi = data_[:, 2]
@@ -128,6 +130,7 @@ def __init__(
 
             if density_unit in ['g/cm^3', 'g/cm3']:
                 data_[:, 3] *= 1000.0  # g/cm^3 --> kg/m^3
+
             if damping_unit == '%':
                 data_[:, 2] /= 100.0  # percent --> 1
 
@@ -352,8 +355,10 @@ def truncate(self, depth=None, Vs=1000.0):
         """
         if depth is None or depth <= 0:
             raise ValueError('`depth` needs to be a positive number.')
+
         if Vs is None or Vs <= 0:
             raise ValueError('`Vs` needs to be a positive number.')
+
         profile_ = []
         total_depth = 0
         for j in range(len(self._vs)):
@@ -363,9 +368,9 @@ def truncate(self, depth=None, Vs=1000.0):
                 last_row[0] = last_thk
                 profile_.append(last_row)
                 break
-            else:
-                profile_.append(self.vs_profile[j, :])
-                total_depth += self._thk[j]
+
+            profile_.append(self.vs_profile[j, :])
+            total_depth += self._thk[j]
         else:  # `depth` > total depth of the current profile
             last_thk = profile_[-1][0]  # thickness of the original last layer
             profile_[-1][0] = depth + last_thk - total_depth  # extend to `depth`
@@ -375,6 +380,7 @@ def truncate(self, depth=None, Vs=1000.0):
             bedrock = [0, Vs, xi[0], rho[0], 0]
         else:  # just numbers
             bedrock = [0, Vs, xi, rho, 0]
+
         profile_.append(bedrock)  # add half space whose Vs is `Vs`
         profile_ = np.array(profile_)
 
@@ -413,6 +419,7 @@ def query_Vs_at_depth(self, depth, as_profile=False, show_fig=False):
                     'If `as_profile` is set to True, the given '
                     '`depth` needs to be monotonically increasing.',
                 )
+
             if has_duplicate_values:
                 raise ValueError(
                     'If `as_profile` is set to True, the given '
@@ -425,6 +432,7 @@ def query_Vs_at_depth(self, depth, as_profile=False, show_fig=False):
                 vs_queried = np.append(vs_queried[0:1], vs_queried)
             else:  # `depth` has been guarenteed to be sorted with no duplicates
                 thk_array = sr.dep2thk(depth)
+
             vs_ = np.column_stack((thk_array, vs_queried))
 
             if show_fig:
@@ -433,13 +441,14 @@ def query_Vs_at_depth(self, depth, as_profile=False, show_fig=False):
 
             # A halfspace is already implicitly added by sr.depth2thk()
             return Vs_Profile(vs_, add_halfspace=False)
-        else:
-            if show_fig:
-                self._plot_queried_Vs(vs_queried, depth)
-            if is_scalar:
-                return float(vs_queried)
-            else:
-                return vs_queried
+
+        if show_fig:
+            self._plot_queried_Vs(vs_queried, depth)
+
+        if is_scalar:
+            return float(vs_queried)
+
+        return vs_queried
 
     def query_Vs_given_thk(
             self,
@@ -482,6 +491,7 @@ def query_Vs_given_thk(
         """
         if n_layers is None and isinstance(thk, (int, float, np.number)):
             n_layers = int(np.ceil(self.z_max / thk))
+
         vs_queried, thk_array = sr.query_Vs_given_thk(
             self.vs_profile,
             thk,
@@ -493,13 +503,15 @@ def query_Vs_given_thk(
             if show_fig:
                 depth = sr.thk2dep(thk_array, midpoint=at_midpoint)
                 self._plot_queried_Vs(vs_queried, depth)
+
             return vs_queried
-        else:
-            vs_ = np.column_stack((thk_array, vs_queried))
-            if show_fig:
-                fig, ax, _ = self.plot()
-                sr.plot_Vs_profile(vs_, fig=fig, ax=ax, c='orange', alpha=0.75)
-            return Vs_Profile(vs_, add_halfspace=add_halfspace)
+
+        vs_ = np.column_stack((thk_array, vs_queried))
+        if show_fig:
+            fig, ax, _ = self.plot()
+            sr.plot_Vs_profile(vs_, fig=fig, ax=ax, c='orange', alpha=0.75)
+
+        return Vs_Profile(vs_, add_halfspace=add_halfspace)
 
     def _plot_queried_Vs(self, vs_queried, depth, dpi=100):
         """
@@ -518,8 +530,6 @@ def _plot_queried_Vs(self, vs_queried, depth, dpi=100):
         if np.max(y_lim) <= np.max(depth):
             ax.set_ylim((np.max(depth), np.min(y_lim)))
 
-        return None
-
     def get_basin_depth(self, bedrock_Vs=1000.0):
         """
         Query the depth of the basin as indicated in the Vs profile data.
@@ -604,6 +614,7 @@ def to_txt(
         """
         if not isinstance(precision, list):
             raise TypeError('precision must be a list.')
+
         if len(precision) != 5:
             raise ValueError('Length of precision must be 5.')
 

PySeismoSoil/class_batch_simulation.py

@@ -35,8 +35,10 @@ class Batch_Simulation:
     def __init__(self, list_of_simulations):
         if not isinstance(list_of_simulations, list):
             raise TypeError('`list_of_simulations` should be a list.')
+
         if len(list_of_simulations) == 0:
             raise ValueError('`list_of_simulations` should have at least one element.')
+
         sim_0 = list_of_simulations[0]
         if not isinstance(
             sim_0,
@@ -47,10 +49,12 @@ def __init__(self, list_of_simulations):
                 'type `Linear_Simulation`, `Equiv_Linear_Simulation`, '
                 'or `Nonlinear_Simulation`.',
             )
+
         if not all(isinstance(i, type(sim_0)) for i in list_of_simulations):
             raise TypeError(
                 'All the elements of `list_of_simulations` should be of the same type.',
             )
+
         n_simulations = len(list_of_simulations)
 
         self.list_of_simulations = list_of_simulations
@@ -103,6 +107,7 @@ def run(self, parallel=False, n_cores=1, base_output_dir=None, options=None):
             # Because no outputs can be printed to stdout in the parellel pool
             if options.get('verbose', True):  # default value is `True`
                 print('Parallel computing in progress...', end=' ')
+
             p = mp.Pool(n_cores)
             sim_results = p.map(
                 self._run_single_sim,

PySeismoSoil/class_curves.py

@@ -149,10 +149,12 @@ def plot(
                 self.raw_data[:, 1],
                 **kwargs_to_matplotlib,
             )
+
         ax.grid(ls=':')
         ax.set_xlabel(xlabel)
         if ylabel:
             ax.set_ylabel(ylabel)
+
         if title:
             ax.set_title(title)
 
@@ -619,13 +621,16 @@ def __len__(self):
     def __setitem__(self, i, item):
         if not isinstance(item, self.element_class):
             raise TypeError('The new `item` must be of type %s.' % self.element_class)
+
         self.curves[i] = item
 
     def __getitem__(self, i):
         if isinstance(i, int):
             return self.curves[i]
+
         if isinstance(i, slice):  # return an object of the same class
             return self.__class__(self.curves[i])  # filled with the sliced data
+
         raise TypeError('Indices must be integers or slices, not %s' % type(i))
 
     def __delitem__(self, i):
@@ -636,6 +641,7 @@ def append(self, item):
         """Append another curve item to the curves."""
         if not isinstance(item, self.element_class):
             raise TypeError('The new `item` must be of type %s.' % self.element_class)
+
         self.curves.append(item)
         self.n_layer += 1
 
@@ -962,6 +968,7 @@ def get_all_HH_x_params(
         if save_txt:
             if txt_filename is None:
                 txt_filename = self._produce_output_file_name('HH', 'txt')
+
             if sep is None:
                 sep = self._sep
 
@@ -1081,6 +1088,7 @@ def get_all_H4_x_params(
         if save_txt:
             if txt_filename is None:
                 txt_filename = self._produce_output_file_name('H4', 'txt')
+
             if sep is None:
                 sep = self._sep
 
@@ -1365,26 +1373,32 @@ def __init__(self, *, mgc_and_mdc=None, data=None):
                 'Both parameters are `None`. Please provide '
                 'one and only one input parameter.',
             )
+
         if mgc_and_mdc is not None and data is not None:
             raise ValueError(
                 'Both parameters are not `None`. Please provide '
                 'one and only one input parameter.',
             )
+
         if mgc_and_mdc is not None:
             if not isinstance(mgc_and_mdc, tuple):
                 raise TypeError('`mgc_and_mdc` needs to be a tuple.')
+
             if len(mgc_and_mdc) != 2:
                 raise ValueError('Length of `mgc_and_mdc` needs to be 2.')
+
             if not isinstance(mgc_and_mdc[0], Multiple_GGmax_Curves):
                 raise TypeError(
                     'The 0th element of `mgc_and_mdc` needs to '
                     'be of type `Multiple_GGmax_Curves`.',
                 )
+
             if not isinstance(mgc_and_mdc[-1], Multiple_Damping_Curves):
                 raise TypeError(
                     'The last element of `mgc_and_mdc` needs to '
                     'be of type `Multiple_Damping_Curves`.',
                 )
+
             self.mgc = mgc_and_mdc[0]
             self.mdc = mgc_and_mdc[-1]
             self.data = None
@@ -1394,12 +1408,15 @@ def __init__(self, *, mgc_and_mdc=None, data=None):
                     'the ``Multiple_Damping_Curves`` instance '
                     'need to have the same number of soil layers.',
                 )
+
             self.n_layer = self.mgc.n_layer
         else:  # `data` is not `None`
             if not isinstance(data, (np.ndarray, str)):
                 raise TypeError('`data` must be a 2D numpy array or a file name.')
+
             if isinstance(data, str):
                 data = np.genfromtxt(data)
+
             self.mgc = None
             self.mdc = None
             hlp.assert_2D_numpy_array(data, name='`data`')
@@ -1409,6 +1426,7 @@ def __init__(self, *, mgc_and_mdc=None, data=None):
                     'to be a multiple of 4. However, your '
                     '`data` has %d columns.' % data.shape[1],
                 )
+
             self.data = data
             self.n_layer = data.shape[1] // 4
 
@@ -1425,14 +1443,15 @@ def get_MGC_MDC_objects(self):
         """
         if self.mgc is not None:
             return self.mgc, self.mdc
-        else:  # the user provides a matrix containing curve information
-            GGmax_curve_list, damping_curves_list = hlp.extract_from_curve_format(
-                self.data,
-                ensure_non_negative=False,
-            )
-            mgc = Multiple_GGmax_Curves(GGmax_curve_list)
-            mdc = Multiple_Damping_Curves(damping_curves_list)
-            return mgc, mdc
+
+        # the user provides a matrix containing curve information
+        GGmax_curve_list, damping_curves_list = hlp.extract_from_curve_format(
+            self.data,
+            ensure_non_negative=False,
+        )
+        mgc = Multiple_GGmax_Curves(GGmax_curve_list)
+        mdc = Multiple_Damping_Curves(damping_curves_list)
+        return mgc, mdc
 
     def get_curve_matrix(self):
         """
@@ -1450,10 +1469,10 @@ def get_curve_matrix(self):
         """
         if self.data is not None:
             return self.data
-        else:
-            mgc_matrix = self.mgc.get_curve_matrix()
-            mdc_matrix = self.mdc.get_curve_matrix()
-            return hlp.merge_curve_matrices(mgc_matrix, mdc_matrix)
+
+        mgc_matrix = self.mgc.get_curve_matrix()
+        mdc_matrix = self.mdc.get_curve_matrix()
+        return hlp.merge_curve_matrices(mgc_matrix, mdc_matrix)
 
     def plot(self):
         """Plot the G/Gmax and damping curves."""

PySeismoSoil/class_damping_calibration.py

@@ -18,6 +18,7 @@ class Damping_Calibration:
     def __init__(self, vs_profile):
         if not isinstance(vs_profile, Vs_Profile):
             raise TypeError('`vs_profile` must be of type Vs_Profile.')
+
         self.vs_profile = vs_profile
 
     def get_damping_curves(
@@ -77,6 +78,7 @@ def get_damping_curves(
             if not use_Darendeli_Dmin:
                 xi_j -= xi_j[0]
                 xi_j += self.vs_profile.vs_profile[j, 2]
+
             dc = Damping_Curve(
                 np.column_stack((strain_in_pct, xi_j)),
                 strain_unit='%',
@@ -85,6 +87,7 @@ def get_damping_curves(
                 check_values=True,
             )
             curve_list.append(dc)
+
         mdc = Multiple_Damping_Curves(curve_list)
 
         if show_fig:

PySeismoSoil/class_frequency_spectrum.py

@@ -112,6 +112,7 @@ def __init__(
                 data_[:, 1],
                 log_scale=log_scale,
             )
+
         self.raw_df = df
         self.raw_data = data_
         self.n_pts = n_pts
@@ -183,13 +184,16 @@ def plot(
             ax.plot(self.freq, self.amplitude, **kwargs_plot)
         else:
             ax.plot(self.freq, self.spectrum, **kwargs_plot)
+
         ax.set_xlabel('Frequency [Hz]')
         ax.set_ylabel('Amplitude or phase')
         ax.grid(ls=':')
         if logx:
             ax.set_xscale('log')
+
         if logy:
             ax.set_yscale('log')
+
         if self._file_name:
             ax.set_title(self._file_name)