pycodestyle fixes

NanoVNASaver/Charts/Chart.py

@@ -224,7 +224,9 @@ class Chart(QtWidgets.QWidget):
         self.draggedMarker = None
         if self.dragbox.state:
             self.zoomTo(
-                self.dragbox.pos_start[0], self.dragbox.pos_start[1], a0.x(), a0.y())
+                self.dragbox.pos_start[0],
+                self.dragbox.pos_start[1],
+                a0.x(), a0.y())
             self.dragbox.state = False
             self.dragbox.pos = (-1, -1)
             self.dragbox.pos_start = (0, 0)

NanoVNASaver/Charts/Frequency.py

@@ -172,8 +172,9 @@ class FrequencyChart(Chart):
         self.menu.addAction(self.action_popout)
         self.setFocusPolicy(QtCore.Qt.ClickFocus)
 
-        self.setMinimumSize(self.dim.width + self.rightMargin + self.leftMargin,
-                            self.dim.height + self.topMargin + self.bottomMargin)
+        self.setMinimumSize(
+            self.dim.width + self.rightMargin + self.leftMargin,
+            self.dim.height + self.topMargin + self.bottomMargin)
         self.setSizePolicy(
             QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding,
                                   QtWidgets.QSizePolicy.MinimumExpanding))
@@ -435,8 +436,10 @@ class FrequencyChart(Chart):
             m.frequencyInput.setText(str(f))
 
     def resizeEvent(self, a0: QtGui.QResizeEvent) -> None:
-        self.dim.width = a0.size().width() - self.rightMargin - self.leftMargin
-        self.dim.height = a0.size().height() - self.bottomMargin - self.topMargin
+        self.dim.width = (
+            a0.size().width() - self.rightMargin - self.leftMargin)
+        self.dim.height = (
+            a0.size().height() - self.bottomMargin - self.topMargin)
         self.update()
 
     def paintEvent(self, _: QtGui.QPaintEvent) -> None:
@@ -478,10 +481,14 @@ class FrequencyChart(Chart):
             headline += f" ({self.name_unit})"
         qp.drawText(3, 15, headline)
         qp.setPen(QtGui.QPen(Chart.color.foreground))
-        qp.drawLine(self.leftMargin, 20,
-                    self.leftMargin, self.topMargin + self.dim.height + 5)
-        qp.drawLine(self.leftMargin - 5, self.topMargin + self.dim.height,
-                    self.leftMargin + self.dim.width, self.topMargin + self.dim.height)
+        qp.drawLine(self.leftMargin,
+                    20,
+                    self.leftMargin,
+                    self.topMargin + self.dim.height + 5)
+        qp.drawLine(self.leftMargin - 5,
+                    self.topMargin + self.dim.height,
+                    self.leftMargin + self.dim.width,
+                    self.topMargin + self.dim.height)
         self.drawTitle(qp)
 
     def drawValues(self, qp: QtGui.QPainter):
@@ -506,7 +513,8 @@ class FrequencyChart(Chart):
         span = max_value - min_value
         if span == 0:
             logger.info(
-                "Span is zero for %s-Chart, setting to a small value.", self.name)
+                "Span is zero for %s-Chart, setting to a small value.",
+                self.name)
             span = 1e-15
         self.span = span
 
@@ -575,7 +583,9 @@ class FrequencyChart(Chart):
             if self.logarithmicX:
                 fspan = math.log(self.fstop) - math.log(self.fstart)
                 freq = round(
-                    math.exp(((i + 1) * fspan / ticks) + math.log(self.fstart)))
+                    math.exp(
+                        ((i + 1) * fspan / ticks) +
+                        math.log(self.fstart)))
             else:
                 freq = round(fspan / ticks * (i + 1) + self.fstart)
             qp.setPen(QtGui.QPen(Chart.color.foreground))
@@ -629,12 +639,14 @@ class FrequencyChart(Chart):
                 if prevy is None:
                     continue
                 qp.setPen(line_pen)
-                if self.isPlotable(x, y) and self.isPlotable(prevx, prevy):
-                    qp.drawLine(x, y, prevx, prevy)
-                elif self.isPlotable(x, y) and not self.isPlotable(prevx, prevy):
-                    new_x, new_y = self.getPlotable(x, y, prevx, prevy)
-                    qp.drawLine(x, y, new_x, new_y)
-                elif not self.isPlotable(x, y) and self.isPlotable(prevx, prevy):
+                if self.isPlotable(x, y):
+                    if self.isPlotable(prevx, prevy):
+                        qp.drawLine(x, y, prevx, prevy)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y, prevx, prevy)
+                        qp.drawLine(x, y, new_x, new_y)
+                elif self.isPlotable(prevx, prevy):
                     new_x, new_y = self.getPlotable(prevx, prevy, x, y)
                     qp.drawLine(prevx, prevy, new_x, new_y)
                 qp.setPen(pen)

NanoVNASaver/Charts/GroupDelay.py

@@ -176,12 +176,13 @@ class GroupDelayChart(FrequencyChart):
                 prevx = self.getXPosition(data[i - 1])
                 prevy = self.getYPositionFromDelay(delay[i - 1])
                 qp.setPen(line_pen)
-                if self.isPlotable(x, y) and self.isPlotable(prevx, prevy):
-                    qp.drawLine(x, y, prevx, prevy)
-                elif self.isPlotable(x, y) and not self.isPlotable(prevx, prevy):
-                    new_x, new_y = self.getPlotable(x, y, prevx, prevy)
-                    qp.drawLine(x, y, new_x, new_y)
-                elif not self.isPlotable(x, y) and self.isPlotable(prevx, prevy):
+                if self.isPlotable(x, y):
+                    if self.isPlotable(prevx, prevy):
+                        qp.drawLine(x, y, prevx, prevy)
+                    else:
+                        new_x, new_y = self.getPlotable(x, y, prevx, prevy)
+                        qp.drawLine(x, y, new_x, new_y)
+                elif self.isPlotable(prevx, prevy):
                     new_x, new_y = self.getPlotable(prevx, prevy, x, y)
                     qp.drawLine(prevx, prevy, new_x, new_y)
                 qp.setPen(pen)
@@ -197,8 +198,9 @@ class GroupDelayChart(FrequencyChart):
                 delay = 0
         return self.getYPositionFromDelay(delay)
 
-    def getYPositionFromDelay(self, delay: float):
-        return self.topMargin + round((self.maxDelay - delay) / self.span * self.dim.height)
+    def getYPositionFromDelay(self, delay: float) -> int:
+        return self.topMargin + int(
+            (self.maxDelay - delay) / self.span * self.dim.height)
 
     def valueAtPosition(self, y) -> List[float]:
         absy = y - self.topMargin

NanoVNASaver/Charts/Magnitude.py

@@ -61,7 +61,8 @@ class MagnitudeChart(FrequencyChart):
                 mag = self.magnitude(d)
                 max_value = max(max_value, mag)
                 min_value = min(min_value, mag)
-            for d in self.reference:  # Also check min/max for the reference sweep
+            # Also check min/max for the reference sweep
+            for d in self.reference:
                 if d.freq < self.fstart or d.freq > self.fstop:
                     continue
                 max_value = max(max_value, mag)
@@ -114,7 +115,8 @@ class MagnitudeChart(FrequencyChart):
 
     def getYPosition(self, d: Datapoint) -> int:
         mag = self.magnitude(d)
-        return self.topMargin + round((self.maxValue - mag) / self.span * self.dim.height)
+        return self.topMargin + int(
+            (self.maxValue - mag) / self.span * self.dim.height)
 
     def valueAtPosition(self, y) -> List[float]:
         absy = y - self.topMargin

NanoVNASaver/Charts/MagnitudeZ.py

@@ -69,7 +69,8 @@ class MagnitudeZChart(FrequencyChart):
                     continue
                 self.maxValue = max(self.maxValue, mag)
                 self.minValue = min(self.minValue, mag)
-            for d in self.reference:  # Also check min/max for the reference sweep
+            # Also check min/max for the reference sweep
+            for d in self.reference:
                 if d.freq < self.fstart or d.freq > self.fstop:
                     continue
                 mag = self.magnitude(d)
@@ -114,9 +115,11 @@ class MagnitudeZChart(FrequencyChart):
         if math.isfinite(mag):
             if self.logarithmicY:
                 span = math.log(self.maxValue) - math.log(self.minValue)
-                return self.topMargin + round(
-                    (math.log(self.maxValue) - math.log(mag)) / span * self.dim.height)
-            return self.topMargin + round((self.maxValue - mag) / self.span * self.dim.height)
+                return self.topMargin + int(
+                    (math.log(self.maxValue) - math.log(mag)) /
+                    span * self.dim.height)
+            return self.topMargin + int(
+                (self.maxValue - mag) / self.span * self.dim.height)
         return self.topMargin
 
     def valueAtPosition(self, y) -> List[float]:

NanoVNASaver/Charts/Permeability.py

@@ -96,7 +96,8 @@ class PermeabilityChart(FrequencyChart):
                 max_val = max(max_val, im)
                 min_val = min(min_val, re)
                 min_val = min(min_val, im)
-            for d in self.reference:  # Also check min/max for the reference sweep
+            # Also check min/max for the reference sweep
+            for d in self.reference:
                 if d.freq < self.fstart or d.freq > self.fstop:
                     continue
                 imp = d.impedance()
@@ -171,24 +172,28 @@ class PermeabilityChart(FrequencyChart):
                 # Real part first
                 line_pen.setColor(Chart.color.sweep)
                 qp.setPen(line_pen)
-                if self.isPlotable(x, y_re) and self.isPlotable(prev_x, prev_y_re):
-                    qp.drawLine(x, y_re, prev_x, prev_y_re)
-                elif self.isPlotable(x, y_re) and not self.isPlotable(prev_x, prev_y_re):
-                    new_x, new_y = self.getPlotable(x, y_re, prev_x, prev_y_re)
-                    qp.drawLine(x, y_re, new_x, new_y)
-                elif not self.isPlotable(x, y_re) and self.isPlotable(prev_x, prev_y_re):
+                if self.isPlotable(x, y_re):
+                    if self.isPlotable(prev_x, prev_y_re):
+                        qp.drawLine(x, y_re, prev_x, prev_y_re)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y_re, prev_x, prev_y_re)
+                        qp.drawLine(x, y_re, new_x, new_y)
+                elif self.isPlotable(prev_x, prev_y_re):
                     new_x, new_y = self.getPlotable(prev_x, prev_y_re, x, y_re)
                     qp.drawLine(prev_x, prev_y_re, new_x, new_y)
 
                 # Imag part second
                 line_pen.setColor(Chart.color.sweep_secondary)
                 qp.setPen(line_pen)
-                if self.isPlotable(x, y_im) and self.isPlotable(prev_x, prev_y_im):
-                    qp.drawLine(x, y_im, prev_x, prev_y_im)
-                elif self.isPlotable(x, y_im) and not self.isPlotable(prev_x, prev_y_im):
-                    new_x, new_y = self.getPlotable(x, y_im, prev_x, prev_y_im)
-                    qp.drawLine(x, y_im, new_x, new_y)
-                elif not self.isPlotable(x, y_im) and self.isPlotable(prev_x, prev_y_im):
+                if self.isPlotable(x, y_im):
+                    if self.isPlotable(prev_x, prev_y_im):
+                        qp.drawLine(x, y_im, prev_x, prev_y_im)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y_im, prev_x, prev_y_im)
+                        qp.drawLine(x, y_im, new_x, new_y)
+                elif self.isPlotable(prev_x, prev_y_im):
                     new_x, new_y = self.getPlotable(prev_x, prev_y_im, x, y_im)
                     qp.drawLine(prev_x, prev_y_im, new_x, new_y)
 
@@ -231,24 +236,28 @@ class PermeabilityChart(FrequencyChart):
                 line_pen.setColor(Chart.color.reference)
                 qp.setPen(line_pen)
                 # Real part first
-                if self.isPlotable(x, y_re) and self.isPlotable(prev_x, prev_y_re):
-                    qp.drawLine(x, y_re, prev_x, prev_y_re)
-                elif self.isPlotable(x, y_re) and not self.isPlotable(prev_x, prev_y_re):
-                    new_x, new_y = self.getPlotable(x, y_re, prev_x, prev_y_re)
-                    qp.drawLine(x, y_re, new_x, new_y)
-                elif not self.isPlotable(x, y_re) and self.isPlotable(prev_x, prev_y_re):
+                if self.isPlotable(x, y_re):
+                    if self.isPlotable(prev_x, prev_y_re):
+                        qp.drawLine(x, y_re, prev_x, prev_y_re)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y_re, prev_x, prev_y_re)
+                        qp.drawLine(x, y_re, new_x, new_y)
+                elif self.isPlotable(prev_x, prev_y_re):
                     new_x, new_y = self.getPlotable(prev_x, prev_y_re, x, y_re)
                     qp.drawLine(prev_x, prev_y_re, new_x, new_y)
 
                 line_pen.setColor(Chart.color.reference_secondary)
                 qp.setPen(line_pen)
                 # Imag part second
-                if self.isPlotable(x, y_im) and self.isPlotable(prev_x, prev_y_im):
-                    qp.drawLine(x, y_im, prev_x, prev_y_im)
-                elif self.isPlotable(x, y_im) and not self.isPlotable(prev_x, prev_y_im):
-                    new_x, new_y = self.getPlotable(x, y_im, prev_x, prev_y_im)
-                    qp.drawLine(x, y_im, new_x, new_y)
-                elif not self.isPlotable(x, y_im) and self.isPlotable(prev_x, prev_y_im):
+                if self.isPlotable(x, y_im):
+                    if self.isPlotable(prev_x, prev_y_im):
+                        qp.drawLine(x, y_im, prev_x, prev_y_im)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y_im, prev_x, prev_y_im)
+                        qp.drawLine(x, y_im, new_x, new_y)
+                elif self.isPlotable(prev_x, prev_y_im):
                     new_x, new_y = self.getPlotable(prev_x, prev_y_im, x, y_im)
                     qp.drawLine(prev_x, prev_y_im, new_x, new_y)
 

NanoVNASaver/Charts/Phase.py

@@ -49,7 +49,8 @@ class PhaseChart(FrequencyChart):
         self.y_menu.addSeparator()
         self.action_unwrap = QtWidgets.QAction("Unwrap")
         self.action_unwrap.setCheckable(True)
-        self.action_unwrap.triggered.connect(lambda: self.setUnwrap(self.action_unwrap.isChecked()))
+        self.action_unwrap.triggered.connect(
+            lambda: self.setUnwrap(self.action_unwrap.isChecked()))
         self.y_menu.addAction(self.action_unwrap)
 
     def copy(self):
@@ -67,14 +68,8 @@ class PhaseChart(FrequencyChart):
             return
 
         if self.unwrap:
-            rawData = []
-            for d in self.data:
-                rawData.append(d.phase)
-
-            rawReference = []
-            for d in self.reference:
-                rawReference.append(d.phase)
-
+            rawData = [d.phase for d in self.data]
+            rawReference = [d.phase for d in self.reference]
             self.unwrappedData = np.degrees(np.unwrap(rawData))
             self.unwrappedReference = np.degrees(np.unwrap(rawReference))
 
@@ -102,27 +97,28 @@ class PhaseChart(FrequencyChart):
 
         for i in range(tickcount):
             angle = minAngle + span * i / tickcount
-            y = self.topMargin + round((self.maxAngle - angle) / self.span * self.dim.height)
-            if angle != minAngle and angle != maxAngle:
+            y = self.topMargin + int(
+                (self.maxAngle - angle) / self.span * self.dim.height)
+            if angle not in [minAngle, maxAngle]:
                 qp.setPen(QtGui.QPen(Chart.color.text))
                 if angle != 0:
-                    digits = max(0, min(2, math.floor(3 - math.log10(abs(angle)))))
-                    if digits == 0:
-                        anglestr = str(round(angle))
-                    else:
-                        anglestr = str(round(angle, digits))
+                    digits = max(
+                        0, min(2, math.floor(3 - math.log10(abs(angle)))))
+                    anglestr = str(round(angle)) if digits == 0 else str(
+                        round(angle, digits))
                 else:
                     anglestr = "0"
-                qp.drawText(3, y + 3, anglestr + "°")
+                qp.drawText(3, y + 3, f"{anglestr}°")
                 qp.setPen(QtGui.QPen(Chart.color.foreground))
-                qp.drawLine(self.leftMargin - 5, y, self.leftMargin + self.dim.width, y)
+                qp.drawLine(self.leftMargin - 5, y,
+                            self.leftMargin + self.dim.width, y)
         qp.drawLine(self.leftMargin - 5,
                     self.topMargin,
                     self.leftMargin + self.dim.width,
                     self.topMargin)
         qp.setPen(Chart.color.text)
-        qp.drawText(3, self.topMargin + 5, str(maxAngle) + "°")
-        qp.drawText(3, self.dim.height + self.topMargin, str(minAngle) + "°")
+        qp.drawText(3, self.topMargin + 5, f"{maxAngle}°")
+        qp.drawText(3, self.dim.height + self.topMargin, f"{minAngle}°")
 
         self._set_start_stop()
 
@@ -136,16 +132,14 @@ class PhaseChart(FrequencyChart):
         self.drawMarkers(qp)
 
     def getYPosition(self, d: Datapoint) -> int:
-        if self.unwrap:
-            if d in self.data:
-                angle = self.unwrappedData[self.data.index(d)]
-            elif d in self.reference:
-                angle = self.unwrappedReference[self.reference.index(d)]
-            else:
-                angle = math.degrees(d.phase)
+        if self.unwrap and d in self.data:
+            angle = self.unwrappedData[self.data.index(d)]
+        elif self.unwrap and d in self.reference:
+            angle = self.unwrappedReference[self.reference.index(d)]
         else:
             angle = math.degrees(d.phase)
-        return self.topMargin + round((self.maxAngle - angle) / self.span * self.dim.height)
+        return self.topMargin + int(
+            (self.maxAngle - angle) / self.span * self.dim.height)
 
     def valueAtPosition(self, y) -> List[float]:
         absy = y - self.topMargin

NanoVNASaver/Charts/RI.py

@@ -162,7 +162,8 @@ class RealImaginaryChart(FrequencyChart):
                 min_real = min(min_real, re)
                 max_imag = max(max_imag, im)
                 min_imag = min(min_imag, im)
-            for d in self.reference:  # Also check min/max for the reference sweep
+            # Also check min/max for the reference sweep
+            for d in self.reference:
                 if d.freq < self.fstart or d.freq > self.fstop:
                     continue
                 imp = self.impedance(d)
@@ -194,10 +195,12 @@ class RealImaginaryChart(FrequencyChart):
                 span = max_imag - min_imag
                 step_size = span / 8
                 if max_imag < step_size:
-                    # The 0 line is the first step after the top. Scale accordingly.
+                    # The 0 line is the first step after the top.
+                    # Scale accordingly.
                     max_imag = -min_imag / 7
                 elif -min_imag < step_size:
-                    # The 0 line is the last step before the bottom. Scale accordingly.
+                    # The 0 line is the last step before the bottom.
+                    # Scale accordingly.
                     min_imag = -max_imag / 7
                 else:
                     # Scale max_imag to be a whole factor of min_imag
@@ -275,24 +278,28 @@ class RealImaginaryChart(FrequencyChart):
                 # Real part first
                 line_pen.setColor(Chart.color.sweep)
                 qp.setPen(line_pen)
-                if self.isPlotable(x, y_re) and self.isPlotable(prev_x, prev_y_re):
-                    qp.drawLine(x, y_re, prev_x, prev_y_re)
-                elif self.isPlotable(x, y_re) and not self.isPlotable(prev_x, prev_y_re):
-                    new_x, new_y = self.getPlotable(x, y_re, prev_x, prev_y_re)
-                    qp.drawLine(x, y_re, new_x, new_y)
-                elif not self.isPlotable(x, y_re) and self.isPlotable(prev_x, prev_y_re):
+                if self.isPlotable(x, y_re):
+                    if self.isPlotable(prev_x, prev_y_re):
+                        qp.drawLine(x, y_re, prev_x, prev_y_re)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y_re, prev_x, prev_y_re)
+                        qp.drawLine(x, y_re, new_x, new_y)
+                elif self.isPlotable(prev_x, prev_y_re):
                     new_x, new_y = self.getPlotable(prev_x, prev_y_re, x, y_re)
                     qp.drawLine(prev_x, prev_y_re, new_x, new_y)
 
                 # Imag part second
                 line_pen.setColor(Chart.color.sweep_secondary)
                 qp.setPen(line_pen)
-                if self.isPlotable(x, y_im) and self.isPlotable(prev_x, prev_y_im):
-                    qp.drawLine(x, y_im, prev_x, prev_y_im)
-                elif self.isPlotable(x, y_im) and not self.isPlotable(prev_x, prev_y_im):
-                    new_x, new_y = self.getPlotable(x, y_im, prev_x, prev_y_im)
-                    qp.drawLine(x, y_im, new_x, new_y)
-                elif not self.isPlotable(x, y_im) and self.isPlotable(prev_x, prev_y_im):
+                if self.isPlotable(x, y_im):
+                    if self.isPlotable(prev_x, prev_y_im):
+                        qp.drawLine(x, y_im, prev_x, prev_y_im)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y_im, prev_x, prev_y_im)
+                        qp.drawLine(x, y_im, new_x, new_y)
+                elif self.isPlotable(prev_x, prev_y_im):
                     new_x, new_y = self.getPlotable(prev_x, prev_y_im, x, y_im)
                     qp.drawLine(prev_x, prev_y_im, new_x, new_y)
 
@@ -335,24 +342,28 @@ class RealImaginaryChart(FrequencyChart):
                 line_pen.setColor(Chart.color.reference)
                 qp.setPen(line_pen)
                 # Real part first
-                if self.isPlotable(x, y_re) and self.isPlotable(prev_x, prev_y_re):
-                    qp.drawLine(x, y_re, prev_x, prev_y_re)
-                elif self.isPlotable(x, y_re) and not self.isPlotable(prev_x, prev_y_re):
-                    new_x, new_y = self.getPlotable(x, y_re, prev_x, prev_y_re)
-                    qp.drawLine(x, y_re, new_x, new_y)
-                elif not self.isPlotable(x, y_re) and self.isPlotable(prev_x, prev_y_re):
+                if self.isPlotable(x, y_re):
+                    if self.isPlotable(prev_x, prev_y_re):
+                        qp.drawLine(x, y_re, prev_x, prev_y_re)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y_re, prev_x, prev_y_re)
+                        qp.drawLine(x, y_re, new_x, new_y)
+                elif self.isPlotable(prev_x, prev_y_re):
                     new_x, new_y = self.getPlotable(prev_x, prev_y_re, x, y_re)
                     qp.drawLine(prev_x, prev_y_re, new_x, new_y)
 
                 line_pen.setColor(Chart.color.reference_secondary)
                 qp.setPen(line_pen)
                 # Imag part second
-                if self.isPlotable(x, y_im) and self.isPlotable(prev_x, prev_y_im):
-                    qp.drawLine(x, y_im, prev_x, prev_y_im)
-                elif self.isPlotable(x, y_im) and not self.isPlotable(prev_x, prev_y_im):
-                    new_x, new_y = self.getPlotable(x, y_im, prev_x, prev_y_im)
-                    qp.drawLine(x, y_im, new_x, new_y)
-                elif not self.isPlotable(x, y_im) and self.isPlotable(prev_x, prev_y_im):
+                if self.isPlotable(x, y_im):
+                    if self.isPlotable(prev_x, prev_y_im):
+                        qp.drawLine(x, y_im, prev_x, prev_y_im)
+                    else:
+                        new_x, new_y = self.getPlotable(
+                            x, y_im, prev_x, prev_y_im)
+                        qp.drawLine(x, y_im, new_x, new_y)
+                elif self.isPlotable(prev_x, prev_y_im):
                     new_x, new_y = self.getPlotable(prev_x, prev_y_im, x, y_im)
                     qp.drawLine(prev_x, prev_y_im, new_x, new_y)
 

NanoVNASaver/Charts/SParam.py

@@ -52,10 +52,14 @@ class SParameterChart(FrequencyChart):
         qp.drawText(10, 15, "Real")
         qp.drawText(self.leftMargin + self.dim.width - 15, 15, "Imag")
         qp.setPen(QtGui.QPen(Chart.color.foreground))
-        qp.drawLine(self.leftMargin, self.topMargin - 5,
-                    self.leftMargin, self.topMargin + self.dim.height + 5)
-        qp.drawLine(self.leftMargin - 5, self.topMargin + self.dim.height,
-                    self.leftMargin + self.dim.width, self.topMargin + self.dim.height)
+        qp.drawLine(self.leftMargin,
+                    self.topMargin - 5,
+                    self.leftMargin,
+                    self.topMargin + self.dim.height + 5)
+        qp.drawLine(self.leftMargin - 5,
+                    self.topMargin + self.dim.height,
+                    self.leftMargin + self.dim.width,
+                    self.topMargin + self.dim.height)
 
     def drawValues(self, qp: QtGui.QPainter):
         if len(self.data) == 0 and len(self.reference) == 0:

NanoVNASaver/Charts/Square.py

@@ -114,8 +114,11 @@ class SquareChart(Chart):
         y = a0.y()
         absx = x - (self.width() - self.dim.width) / 2
         absy = y - (self.height() - self.dim.height) / 2
-        if absx < 0 or absx > self.dim.width or absy < 0 or absy > self.dim.height \
-                or len(self.data) == len(self.reference) == 0:
+        if (absx < 0 or
+            absx > self.dim.width or
+            absy < 0 or
+            absy > self.dim.height or
+                (not self.data and not self.reference)):
             a0.ignore()
             return
         a0.accept()

NanoVNASaver/Charts/TDR.py

@@ -389,7 +389,8 @@ class TDRChart(Chart):
             id_max = np.argmax(self.tdrWindow.td)
             max_point = QtCore.QPoint(
                 self.leftMargin + int((id_max - min_index) / x_step),
-                (self.topMargin + height) - int(self.tdrWindow.td[id_max] / y_step))
+                (self.topMargin + height) - int(
+                    self.tdrWindow.td[id_max] / y_step))
             qp.setPen(self.markers[0].color)
             qp.drawEllipse(max_point, 2, 2)
             qp.setPen(Chart.color.text)
@@ -408,8 +409,9 @@ class TDRChart(Chart):
                 qp.drawText(
                     marker_point.x() - 10,
                     marker_point.y() - 5,
-                    str(round(self.tdrWindow.distance_axis[self.markerLocation] / 2,
-                              2)) + "m")
+                    str(round(
+                        self.tdrWindow.distance_axis[self.markerLocation] / 2,
+                        2)) + "m")
 
         if self.dragbox.state and self.dragbox.pos[0] != -1:
             dashed_pen = QtGui.QPen(
@@ -456,7 +458,8 @@ class TDRChart(Chart):
         x_step = (max_length - min_length) / width
         if limit and absx < 0:
             return min_length
-        return max_length if limit and absx > width else absx * x_step + min_length
+        return (max_length if limit and absx > width else
+                absx * x_step + min_length)
 
     def zoomTo(self, x1, y1, x2, y2):
         logger.debug(

NanoVNASaver/Charts/VSWR.py

@@ -147,10 +147,12 @@ class VSWRChart(FrequencyChart):
             else:
                 return -1
             return (
-                self.topMargin +
-                round((math.log(self.maxVSWR) - math.log(vswr)) / span * self.dim.height))
+                self.topMargin + int(
+                    (math.log(self.maxVSWR) - math.log(vswr)) /
+                    span * self.dim.height))
         try:
-            return self.topMargin + round((self.maxVSWR - vswr) / self.span * self.dim.height)
+            return self.topMargin + int(
+                (self.maxVSWR - vswr) / self.span * self.dim.height)
         except OverflowError:
             return self.topMargin
 

NanoVNASaver/Marker/Widget.py

@@ -363,6 +363,8 @@ class Marker(QtCore.QObject, Value):
             self.label['s21magseries'].setText(
                 format_magnitude(abs(_s21.seriesImpedance())))
             self.label['s21realimagshunt'].setText(
-                format_complex_imp(_s21.shuntImpedance(), allow_negative=True))
+                format_complex_imp(
+                    _s21.shuntImpedance(), allow_negative=True))
             self.label['s21realimagseries'].setText(
-                format_complex_imp(_s21.seriesImpedance(), allow_negative=True))
+                format_complex_imp(
+                    _s21.seriesImpedance(), allow_negative=True))

NanoVNASaver/Settings/Bands.py

@@ -93,10 +93,12 @@ class BandsModel(QtCore.QAbstractTableModel):
         if role == QtCore.Qt.TextAlignmentRole:
             if index.column() == 0:
                 return QtCore.QVariant(QtCore.Qt.AlignCenter)
-            return QtCore.QVariant(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
+            return QtCore.QVariant(
+                QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
         return QtCore.QVariant()
 
-    def setData(self, index: QModelIndex, value: typing.Any, role: int = ...) -> bool:
+    def setData(self, index: QModelIndex,
+                value: typing.Any, role: int = ...) -> bool:
         if role == QtCore.Qt.EditRole and index.isValid():
             t = self.bands[index.row()]
             name = t[0]
@@ -114,7 +116,8 @@ class BandsModel(QtCore.QAbstractTableModel):
             return True
         return False
 
-    def index(self, row: int, column: int, _: QModelIndex = ...) -> QModelIndex:
+    def index(self, row: int,
+              column: int, _: QModelIndex = ...) -> QModelIndex:
         return self.createIndex(row, column)
 
     def addRow(self):