Feature/cleanup (#28)

* fix: flake8 compliant code

* fix: fixed code formatting

Author: jlerat

src/hydrodiy/data/containers.py

@@ -9,8 +9,9 @@
 class Vector(object):
     """ Vector data container. Implements min, max and default values. """
 
-    def __init__(self, names, defaults=None, mins=None, maxs=None, \
-            check_bounds=True, check_hitbounds=False, accept_nan=False):
+    def __init__(self, names, defaults=None, mins=None,
+                 maxs=None, check_bounds=True, check_hitbounds=False,
+                 accept_nan=False):
 
         # Set parameter names
         if names is None:
@@ -26,8 +27,8 @@ def __init__(self, names, defaults=None, mins=None, maxs=None, \
         self._check_bounds = bool(check_bounds)
         self._check_hitbounds = bool(check_hitbounds)
         if self._check_hitbounds and not self._check_bounds:
-            raise ValueError("check_hitbounds cannot be True while "+\
-                    "check_bounds is False")
+            raise ValueError("check_hitbounds cannot be True while " +
+                             "check_bounds is False")
         self._hitbounds = False
 
         # Set number of parameters
@@ -36,40 +37,40 @@ def __init__(self, names, defaults=None, mins=None, maxs=None, \
         self._nval = nval
 
         # Define names indexes
-        self._names_index = {nm:i for nm, i \
-                        in zip(self._names, np.arange(nval))}
+        self._names_index = {nm: i for nm, i
+                             in zip(self._names, np.arange(nval))}
 
         # Set mins and maxs
         self._mins = -np.inf * np.ones(nval)
         self._maxs = np.inf * np.ones(nval)
 
-        if not mins is None:
+        if mins is not None:
             # Just convert mins to proper array
             self._mins, _ = self.__checkvalues__(mins, False)
 
-        if not maxs is None:
+        if maxs is not None:
             # Convert maxs to proper array and checks it is greater than mins
             maxs2, hit = self.__checkvalues__(maxs, True)
 
             if hit:
-                raise ValueError(("Expected maxs within [{0}, {1}]," +\
-                    " got {2}").format(self._mins, self._maxs, maxs))
+                raise ValueError("Expected maxs within " +
+                                 f"[{self._mins}, {self._maxs}], got {maxs}.")
             self._maxs = maxs2
 
         # Set defaults values
-        if not defaults is None:
+        if defaults is not None:
             self._defaults, hit = self.__checkvalues__(defaults, True)
 
             if hit:
-                raise ValueError(("Expected defaults within [{0}, {1}]," +\
-                    " got {2}").format(self._mins, self._maxs, defaults))
+                raise ValueError("Expected defaults within " +
+                                 f"[{self._mins}, {self._maxs}]," +
+                                 f"got {defaults}.")
         else:
             self._defaults = np.clip(np.zeros(nval), self._mins, self._maxs)
 
         # Set values to defaults
         self._values = self._defaults.copy()
 
-
     @classmethod
     def from_dict(cls, dct):
         """ Create vector from  dictionary """
@@ -87,16 +88,15 @@ def from_dict(cls, dct):
             maxs.append(dct["data"][i]["max"])
             values.append(dct["data"][i]["value"])
 
-        vect = Vector(names, defaults, mins, maxs, \
-                        check_bounds=bool(dct["check_bounds"]), \
-                        check_hitbounds=bool(dct["check_hitbounds"]),
-                        accept_nan=bool(dct["accept_nan"]))
+        vect = Vector(names, defaults, mins, maxs,
+                      check_bounds=bool(dct["check_bounds"]),
+                      check_hitbounds=bool(dct["check_hitbounds"]),
+                      accept_nan=bool(dct["accept_nan"]))
         vect._hitbounds = bool(dct["hitbounds"])
         vect.values = values
 
         return vect
 
-
     def __getattribute__(self, name):
         # Except _names and _hitbounds to avoid infinite recursion
         if name in ["_names", "_check_hitbounds", "_hitbounds"]:
@@ -108,7 +108,6 @@ def __getattribute__(self, name):
 
         return super(Vector, self).__getattribute__(name)
 
-
     def __setattr__(self, name, value):
         # Except _names and _hitbounds to avoid infinite recursion
         if name in ["_names", "_check_hitbounds", "_hitbounds"]:
@@ -128,27 +127,24 @@ def __setattr__(self, name, value):
                                             or (value > self._maxs[idx])
 
             # Store clipped value
-            self.values[idx] = min(max(value, \
-                                    self.mins[idx]), self.maxs[idx])
+            self.values[idx] = min(max(value, self.mins[idx]),
+                                   self.maxs[idx])
 
         else:
             super(Vector, self).__setattr__(name, value)
 
-
     def __str__(self):
-        return "vector ["+", ".join(["{0}:{1:3.3e}".format(key, self[key]) \
-                                    for key in self.names]) + "]"
-
+        return "vector ["+", ".join(["{0}:{1:3.3e}".format(key, self[key])
+                                     for key in self.names]) + "]"
 
     def __checkvalues__(self, val, check_hitbounds):
         """ Check vector is of proper length and contains no nan"""
 
         val = np.atleast_1d(val).flatten().astype(np.float64)
 
         if val.shape[0] != self.nval:
-            raise ValueError("Expected vector of length "+\
-                    "{0}, got {1}".format(\
-                    self.nval, val.shape[0]))
+            raise ValueError("Expected vector of length "
+                             + f"{self.nval}, got {val.shape[0]}.")
 
         if np.any(np.isnan(val)) and not self._accept_nan:
             raise ValueError("Cannot process values with NaN")
@@ -163,126 +159,111 @@ def __checkvalues__(self, val, check_hitbounds):
 
         return val, hit
 
-
     def __setitem__(self, key, value):
-        if not key in self._names_index:
-            raise ValueError("Expected key in {0}, got {1}".format(\
-                self._names, key))
+        if key not in self._names_index:
+            raise ValueError(f"Expected key in {self._names}, got {key}.")
 
         setattr(self, key, value)
 
-
     def __getitem__(self, key):
-        if not key in self._names_index:
-            raise ValueError("Expected key in {0}, got {1}".format(\
-                self._names, key))
+        if key not in self._names_index:
+            raise ValueError(f"Expected key in {self._names}, got {key}.")
 
         return getattr(self, key)
 
-
     @property
     def nval(self):
         """ Number of values in vector """
         return self._nval
 
-
     @property
     def check_bounds(self):
         """ Are the bounds checked or not """
         return self._check_bounds
 
-
     @property
     def check_hitbounds(self):
         """ Is the hit to bounds checked or not """
         return self._check_hitbounds
 
-
     @property
     def hitbounds(self):
         """ Has the boundaries been reached when setting data ? """
         return self._hitbounds
 
-
     @property
     def accept_nan(self):
         """ Accept nan values """
         return self._accept_nan
 
-
     @property
     def names(self):
         """ Names of vector elements """
         return self._names
 
-
     @property
     def mins(self):
         """ Minimum values of vector elements """
         return self._mins
 
-
     @property
     def maxs(self):
         """ Maximum values of vector elements """
         return self._maxs
 
-
     @property
     def defaults(self):
         """ Default values of vector elements """
         return self._defaults
 
-
     @property
     def values(self):
         """ Get data """
         return self._values
 
-
     @values.setter
     def values(self, val):
         """ Set data """
-        self._values, self._hitbounds = self.__checkvalues__(val, \
-                                            self._check_hitbounds)
-
+        ck = self._check_hitbounds
+        self._values, self._hitbounds = self.__checkvalues__(val, ck)
 
     def reset(self):
         """ Reset vector values to defaults """
         self.values = self.defaults
 
-
     def clone(self):
         """ Clone the vector """
-        clone = Vector(self.names, self.defaults, self.mins, \
-                    self.maxs, self.check_hitbounds)
+        clone = Vector(self.names, self.defaults, self.mins,
+                       self.maxs, self.check_hitbounds)
 
         clone.values = self.values.copy()
 
         return clone
 
-
     def to_dict(self):
         """ Write vector data to json format """
 
-        dct = {"nval": self.nval, "hitbounds":self.hitbounds, \
-                    "check_bounds":self.check_bounds, \
-                    "check_hitbounds":self.check_hitbounds, \
-                    "accept_nan":self.accept_nan, \
-                    "data":[]}
+        dct = {
+            "nval": self.nval,
+            "hitbounds": self.hitbounds,
+            "check_bounds": self.check_bounds,
+            "check_hitbounds": self.check_hitbounds,
+            "accept_nan": self.accept_nan,
+            "data": []
+            }
 
         for i in range(self.nval):
-            elem = {"name":self.names[i], \
-                "value":self.values[i], \
-                "min":self.mins[i], \
-                "max":self.maxs[i], \
-                "default":self.defaults[i]}
+            elem = {
+                "name": self.names[i],
+                "value": self.values[i],
+                "min": self.mins[i],
+                "max": self.maxs[i],
+                "default": self.defaults[i]
+                }
             dct["data"].append(elem)
 
         return dct
 
-
     def to_series(self):
         """ Write vector data to json format """
         return pd.Series(self.values, index=self.names)
-