Make flake8 happy

alea/examples/gaussian_model.py

@@ -1,8 +1,10 @@
 from typing import Optional
-from alea.statistical_model import StatisticalModel
-import scipy.stats as stats
+
+from scipy import stats
 import numpy as np
 
+from alea.statistical_model import StatisticalModel
+
 
 class GaussianModel(StatisticalModel):
     def __init__(self, parameter_definition: Optional[dict or list] = None):
@@ -13,7 +15,7 @@ def __init__(self, parameter_definition: Optional[dict or list] = None):
         sigma is fixed in this example.
         """
         if parameter_definition is None:
-            parameter_definition = ["mu", "sigma"]
+            parameter_definition = ['mu', 'sigma']
         super().__init__(parameter_definition=parameter_definition)
 
     def _ll(self, mu=None, sigma=None):

alea/parameters.py

@@ -12,9 +12,11 @@ class Parameter:
         nominal_value (float, optional): The nominal value of the parameter.
         fittable (bool, optional): Indicates if the parameter is fittable or always fixed.
         ptype (str, optional): The type of the parameter.
-        uncertainty (float or str, optional): The uncertainty of the parameter. If a string,
+        uncertainty (float or str, optional):
+            The uncertainty of the parameter. If a string,
             it can be evaluated as a numpy or scipy function to define non-gaussian constraints.
-        relative_uncertainty (bool, optional): Indicates if the uncertainty is relative to the nominal_value.
+        relative_uncertainty (bool, optional):
+        Indicates if the uncertainty is relative to the nominal_value.
         blueice_anchors (list, optional): Anchors for blueice template morphing.
         fit_limits (tuple, optional): The limits for fitting the parameter.
         parameter_interval_bounds (tupe, optional): limits for computing confidence intervals
@@ -49,11 +51,12 @@ def __init__(
         self.description = description
 
     def __repr__(self) -> str:
-        parameter_str = [f"{k}={v}" for k,
-                         v in self.__dict__.items() if v is not None]
+        parameter_str = [
+            f"{k}={v}" for k, v in self.__dict__.items() if v is not None]
         parameter_str = ", ".join(parameter_str)
-        return f'{self.__class__.__module__}.{self.__class__.__qualname__}'\
-            f'({parameter_str})'
+        repr = f'{self.__class__.__module__}.{self.__class__.__qualname__}'
+        repr += f'({parameter_str})'
+        return repr
 
     @property
     def uncertainty(self) -> float or Any:
@@ -67,7 +70,8 @@ def uncertainty(self) -> float or Any:
                 return eval(self._uncertainty)
             else:
                 raise ValueError(
-                    f"Uncertainty string '{self._uncertainty}' must start with 'scipy.' or 'numpy.'")
+                    f"Uncertainty string '{self._uncertainty}'"
+                    " must start with 'scipy.' or 'numpy.'")
         else:
             return self._uncertainty
 
@@ -155,8 +159,9 @@ def from_list(cls, names: List[str]):
 
     def __repr__(self) -> str:
         parameter_str = ", ".join(self.names)
-        return f'{self.__class__.__module__}.{self.__class__.__qualname__}'\
-            f'({parameter_str})'
+        repr = f'{self.__class__.__module__}.{self.__class__.__qualname__}'
+        repr += f'({parameter_str})'
+        return repr
 
     def add_parameter(self, parameter: Parameter) -> None:
         """
@@ -181,14 +186,20 @@ def fit_guesses(self) -> Dict[str, float]:
         """
         Returns a dictionary of fit guesses.
         """
-        return {name: param.fit_guess for name, param in self.parameters.items() if param.fit_guess is not None}
+        return {
+            name: param.fit_guess
+            for name, param in self.parameters.items()
+            if param.fit_guess is not None}
 
     @property
     def fit_limits(self) -> Dict[str, float]:
         """
         Returns a dictionary of fit limits.
         """
-        return {name: param.fit_limits for name, param in self.parameters.items() if param.fit_limits is not None}
+        return {
+            name: param.fit_limits
+            for name, param in self.parameters.items()
+            if param.fit_limits is not None}
 
     @property
     def fittable(self) -> List[str]:
@@ -209,16 +220,21 @@ def nominal_values(self) -> dict:
         """
         return a dict of name:nominal value for all applicable parameters
         """
-        return {k: i.nominal_value for k, i in self.parameters.items() if i.nominal_value is not None}
-
-    def __call__(self, return_fittable: bool = False,
-                 **kwargs: Any) -> Dict[str, float]:
+        return {
+            k: i.nominal_value
+            for k, i in self.parameters.items()
+            if i.nominal_value is not None}
+
+    def __call__(
+            self, return_fittable: bool = False,
+            **kwargs: Any) -> Dict[str, float]:
         """
         Returns a dictionary of parameter values, optionally filtered
         to return only fittable parameters.
 
         Args:
-            return_fittable (bool, optional): Indicates if only fittable parameters should be returned.
+            return_fittable (bool, optional):
+                Indicates if only fittable parameters should be returned.
             **kwargs: Additional keyword arguments to override parameter values.
 
         Returns:
@@ -233,7 +249,7 @@ def __call__(self, return_fittable: bool = False,
 
         for name, param in self.parameters.items():
             new_val = kwargs.get(name, None)
-            if (return_fittable and param.fittable) or not return_fittable:
+            if (return_fittable and param.fittable) or (not return_fittable):
                 values[name] = new_val if new_val is not None else param.nominal_value
         return values
 
@@ -285,5 +301,6 @@ def values_in_fit_limits(self, **kwargs: Any) -> bool:
         """
         Returns True if all values are within the fit limits.
         """
-        return all(self.parameters[name].value_in_fit_limits(value)
-                   for name, value in kwargs.items())
+        return all(
+            self.parameters[name].value_in_fit_limits(value)
+            for name, value in kwargs.items())