remaining errors

Author: glass-ships

RefRed/_version.py

@@ -47,7 +47,7 @@ def get_config():
     return cfg
 
 
-class NotThisMethod(Exception):
+class NotThisMethod(Exception):  # noqa: N818
     """Exception raised if a method is not valid for the current scenario."""
 
 

RefRed/config/__init__.py

@@ -74,7 +74,7 @@ def _create_proxy():
             continue
         try:
             modi = __import__("RefRed.config." + name, fromlist=[name])
-        except Exception as error:
+        except Exception as error:  # noqa: BLE001
             _warn("Could not import module %s,\n %s: %s" % (name, error.__class__.__name__, error))
             continue
         if "config_path" in modi.__dict__:

RefRed/export/export_plot_ascii.py

@@ -202,8 +202,8 @@ def export_stitched(self):
         path = Path(self.parent.path_ascii)
         default_filename = path / default_filename
         caption = "Select Location and Name"
-        filter = "Reduced Ascii (*.txt);; All (*.*)"
-        filename, filter = QFileDialog.getSaveFileName(
+        filter = "Reduced Ascii (*.txt);; All (*.*)"  # noqa: A001
+        filename, filter = QFileDialog.getSaveFileName(  # noqa: A001
             self.parent,
             caption,
             str(default_filename),

RefRed/interfaces/mplwidgets.py

@@ -271,7 +271,7 @@ def save_figure(self, *args):
         if figname:
             try:
                 self.canvas.print_figure(str(figname))
-            except Exception as e:
+            except Exception as e:  # noqa: BLE001
                 QtWidgets.QMessageBox.critical(
                     self,
                     "Error saving file",

RefRed/peak_finder_algorithms/peak_finder_derivation.py

@@ -22,63 +22,63 @@ class PeakFinderDerivation(object):
     peak_max_final_value = -1
     peak_min_final_value = -1
 
-    def __init__(cls, xdata, ydata, edata=[], back_offset=3):
-        cls.initArrays()
-
-        cls.xdata = np.array(xdata)
-        cls.ydata = np.array(ydata)
-        cls.edata = np.array(edata)
-
-        cls.calculate5HighestPoints()  # step2
-        cls.calculatePeakPixel()  # step3
-
-        cls.calculateFirstDerivative()  # step4
-        cls.calculateMinMaxDerivativePixels()  # step5
-        cls.calculateAvgAndStdDerivative()  # step6
-        cls.calculateMinMaxSignalPixel()  # step7
-
-    def initArrays(cls):
-        cls.xdata_firstderi = []
-        cls.ydata_firstderi = []
-        cls.edata_firstderi = []
-        cls.peaks = [-1, -1]
-        cls.five_highest_ydata = []
-        cls.five_highest_xdata = []
-        cls.sum_five_highest_ydata = -1
-        cls.peak_pixel = -1
-        cls.deri_min = 1
-        cls.deri_max = -1
-        cls.deri_min_pixel_value = -1
-        cls.deri_max_pixel_value = -1
-        cls.mean_counts_firstderi = -1
-        cls.std_deviation_counts_firstderi = -1
-        cls.peak_max_final_value = -1
-        cls.peak_min_final_value = -1
-
-    def calculate5HighestPoints(cls):
-        _xdata = cls.xdata
-        _ydata = cls.ydata
+    def __init__(self, xdata, ydata, edata=[], back_offset=3):
+        self.initArrays()
+
+        self.xdata = np.array(xdata)
+        self.ydata = np.array(ydata)
+        self.edata = np.array(edata)
+
+        self.calculate5HighestPoints()  # step2
+        self.calculatePeakPixel()  # step3
+
+        self.calculateFirstDerivative()  # step4
+        self.calculateMinMaxDerivativePixels()  # step5
+        self.calculateAvgAndStdDerivative()  # step6
+        self.calculateMinMaxSignalPixel()  # step7
+
+    def initArrays(self):
+        self.xdata_firstderi = []
+        self.ydata_firstderi = []
+        self.edata_firstderi = []
+        self.peaks = [-1, -1]
+        self.five_highest_ydata = []
+        self.five_highest_xdata = []
+        self.sum_five_highest_ydata = -1
+        self.peak_pixel = -1
+        self.deri_min = 1
+        self.deri_max = -1
+        self.deri_min_pixel_value = -1
+        self.deri_max_pixel_value = -1
+        self.mean_counts_firstderi = -1
+        self.std_deviation_counts_firstderi = -1
+        self.peak_max_final_value = -1
+        self.peak_min_final_value = -1
+
+    def calculate5HighestPoints(self):
+        _xdata = self.xdata
+        _ydata = self.ydata
 
         _sort_ydata = np.sort(_ydata)
         _decreasing_sort_ydata = _sort_ydata[::-1]
-        cls.five_highest_ydata = _decreasing_sort_ydata[0:5]
+        self.five_highest_ydata = _decreasing_sort_ydata[0:5]
 
         _sort_index = np.argsort(_ydata)
         _decreasing_sort_index = _sort_index[::-1]
         _5decreasing_sort_index = _decreasing_sort_index[0:5]
-        cls.five_highest_xdata = _xdata[_5decreasing_sort_index]
+        self.five_highest_xdata = _xdata[_5decreasing_sort_index]
 
-    def calculatePeakPixel(cls):
-        cls.sum_peak_counts = sum(cls.five_highest_ydata)
+    def calculatePeakPixel(self):
+        self.sum_peak_counts = sum(self.five_highest_ydata)
         _sum_peak_counts_time_pixel = -1
-        for index, yvalue in enumerate(cls.five_highest_ydata):
-            _sum_peak_counts_time_pixel += yvalue * cls.five_highest_xdata[index]
-        cls.sum_peak_counts_time_pixel = _sum_peak_counts_time_pixel
-        cls.peak_pixel = round(cls.sum_peak_counts_time_pixel / cls.sum_peak_counts)
+        for index, yvalue in enumerate(self.five_highest_ydata):
+            _sum_peak_counts_time_pixel += yvalue * self.five_highest_xdata[index]
+        self.sum_peak_counts_time_pixel = _sum_peak_counts_time_pixel
+        self.peak_pixel = round(self.sum_peak_counts_time_pixel / self.sum_peak_counts)
 
-    def calculateFirstDerivative(cls):
-        xdata = cls.xdata
-        ydata = cls.ydata
+    def calculateFirstDerivative(self):
+        xdata = self.xdata
+        ydata = self.ydata
 
         _xdata_firstderi = []
         _ydata_firstderi = []
@@ -91,35 +91,35 @@ def calculateFirstDerivative(cls):
             _right_y = ydata[i + 1]
             _ydata_firstderi.append((_right_y - _left_y) / (_right_x - _left_x))
 
-        cls.xdata_firstderi = _xdata_firstderi
-        cls.ydata_firstderi = _ydata_firstderi
+        self.xdata_firstderi = _xdata_firstderi
+        self.ydata_firstderi = _ydata_firstderi
 
-    def calculateMinMaxDerivativePixels(cls):
-        _pixel = cls.xdata_firstderi
-        _counts_firstderi = cls.ydata_firstderi
+    def calculateMinMaxDerivativePixels(self):
+        _pixel = self.xdata_firstderi
+        _counts_firstderi = self.ydata_firstderi
 
         _sort_counts_firstderi = np.sort(_counts_firstderi)
-        cls.deri_min = _sort_counts_firstderi[0]
-        cls.deri_max = _sort_counts_firstderi[-1]
+        self.deri_min = _sort_counts_firstderi[0]
+        self.deri_max = _sort_counts_firstderi[-1]
 
         _sort_index = np.argsort(_counts_firstderi)
-        cls.deri_min_pixel_value = min([_pixel[_sort_index[0]], _pixel[_sort_index[-1]]])
-        cls.deri_max_pixel_value = max([_pixel[_sort_index[0]], _pixel[_sort_index[-1]]])
+        self.deri_min_pixel_value = min([_pixel[_sort_index[0]], _pixel[_sort_index[-1]]])
+        self.deri_max_pixel_value = max([_pixel[_sort_index[0]], _pixel[_sort_index[-1]]])
 
-    def calculateAvgAndStdDerivative(cls):
-        _counts_firstderi = np.array(cls.ydata_firstderi)
-        cls.mean_counts_firstderi = np.mean(_counts_firstderi)
+    def calculateAvgAndStdDerivative(self):
+        _counts_firstderi = np.array(self.ydata_firstderi)
+        self.mean_counts_firstderi = np.mean(_counts_firstderi)
         _mean_counts_firstderi = np.mean(_counts_firstderi * _counts_firstderi)
-        cls.std_deviation_counts_firstderi = math.sqrt(_mean_counts_firstderi)
+        self.std_deviation_counts_firstderi = math.sqrt(_mean_counts_firstderi)
 
-    def calculateMinMaxSignalPixel(cls):
-        _counts = cls.ydata_firstderi
-        _pixel = cls.xdata_firstderi
+    def calculateMinMaxSignalPixel(self):
+        _counts = self.ydata_firstderi
+        _pixel = self.xdata_firstderi
 
-        _deri_min_pixel_value = cls.deri_min_pixel_value
-        _deri_max_pixel_value = cls.deri_max_pixel_value
+        _deri_min_pixel_value = self.deri_min_pixel_value
+        _deri_max_pixel_value = self.deri_max_pixel_value
 
-        _std_deviation_counts_firstderi = cls.std_deviation_counts_firstderi
+        _std_deviation_counts_firstderi = self.std_deviation_counts_firstderi
 
         px_offset = 0
         while abs(_counts[int(_deri_min_pixel_value - px_offset)]) > _std_deviation_counts_firstderi:
@@ -131,45 +131,45 @@ def calculateMinMaxSignalPixel(cls):
             px_offset += 1
         _peak_max_final_value = _pixel[int(round(_deri_max_pixel_value + px_offset))]
 
-        cls.peaks = [int(_peak_min_final_value), int(np.ceil(_peak_max_final_value))]
+        self.peaks = [int(_peak_min_final_value), int(np.ceil(_peak_max_final_value))]
 
     # getters
 
-    def getAverageOfFirstDerivationCounts(cls):
-        return cls.mean_counts_firstderi
+    def getAverageOfFirstDerivationCounts(self):
+        return self.mean_counts_firstderi
 
-    def getStdDeviationOfFirstDerivationCounts(cls):
-        return cls.std_deviation_counts_firstderi
+    def getStdDeviationOfFirstDerivationCounts(self):
+        return self.std_deviation_counts_firstderi
 
-    def getMinDerivativeValue(cls):
-        return cls.deri_min
+    def getMinDerivativeValue(self):
+        return self.deri_min
 
-    def getMaxDerivativeValue(cls):
-        return cls.deri_max
+    def getMaxDerivativeValue(self):
+        return self.deri_max
 
-    def getMinDerivationPixelValue(cls):
-        return cls.deri_min_pixel_value
+    def getMinDerivationPixelValue(self):
+        return self.deri_min_pixel_value
 
-    def getMaxDerivationPixelValue(cls):
-        return cls.deri_max_pixel_value
+    def getMaxDerivationPixelValue(self):
+        return self.deri_max_pixel_value
 
-    def getPeakPixel(cls):
-        return cls.peak_pixel
+    def getPeakPixel(self):
+        return self.peak_pixel
 
-    def getSumPeakCounts(cls):
-        return cls.sum_peak_counts
+    def getSumPeakCounts(self):
+        return self.sum_peak_counts
 
-    def getSumPeakCountsTimePixel(cls):
-        return cls.sum_peak_counts_time_pixel
+    def getSumPeakCountsTimePixel(self):
+        return self.sum_peak_counts_time_pixel
 
-    def get5HighestPoints(cls):
-        return [cls.five_highest_xdata, cls.five_highest_ydata]
+    def get5HighestPoints(self):
+        return [self.five_highest_xdata, self.five_highest_ydata]
 
-    def getFirstDerivative(cls):
-        return [cls.xdata_firstderi, cls.ydata_firstderi]
+    def getFirstDerivative(self):
+        return [self.xdata_firstderi, self.ydata_firstderi]
 
-    def getPeaks(cls):
-        return cls.peaks
+    def getPeaks(self):
+        return self.peaks
 
 
 if __name__ == "__main__":

RefRed/reduction/calculate_sf_overlap_range.py

@@ -30,8 +30,8 @@ def getSF(self):
             _sf = 1
 
         else:
-            [a_left, b_left] = self.fitData(left_set, index_min_in_left, type="left")
-            [a_right, b_right] = self.fitData(right_set, index_max_in_right, type="right")
+            [a_left, b_left] = self.fitData(left_set, index_min_in_left, data_type="left")
+            [a_right, b_right] = self.fitData(right_set, index_max_in_right, data_type="right")
 
             nbr_points = 10
             fit_range_to_use = self.gitFittingOverlapRange(min_x, max_x, nbr_points)
@@ -83,11 +83,11 @@ def calculateOverlapAxis(self, left_axis, right_axis):
 
         return [_min_x, _max_x, left_min_index, right_max_index, no_overlap]
 
-    def fitData(self, data_set, threshold_index, type="right"):
+    def fitData(self, data_set, threshold_index, data_type="right"):
         """
         will fit the data with linear fitting y=ax + b
         """
-        if type == "left":
+        if data_type == "left":
             x_axis = data_set.reduce_q_axis[threshold_index:]
             y_axis = data_set.tmp_y_axis[threshold_index:]
             e_axis = data_set.tmp_e_axis[threshold_index:]

docs/conf.py

@@ -64,7 +64,7 @@
 
 # General information about the project.
 project = "RefRed"
-copyright = "2017, Jose Borreguero"
+copyright = "2017, Jose Borreguero"  # noqa: A001
 
 # The version info for the project you're documenting, acts as replacement
 # for |version| and |release|, also used in various other places throughout

pyproject.toml

@@ -20,12 +20,17 @@ select = ["A", "ARG", "ASYNC", "BLE", "C90", "E", "F", "I", "N", "UP032", "W"]
 ignore = [
   "ARG001", # Unused function argument
   "ARG002", # Unused method argument
+  "ARG003", # Unused class method argument
+  "C901",   # function is too complex
   "E402",   # module level import not at top of file
   "E722",   # do not use bare 'except'
   "F821",   # undefined name
   "N802",   # function name should be lowercase
   "N803",   # argument name should be lowercase
   "N806",   # variable in function should be lowercase
+  "N815",   # mixed case class variable name
+  "N816",   # mixed case global variable name
+  "N999",   # invalid module name
 ]
 
 [tool.mypy]