Fix remaining E501 line too long errors

- Break long URLs, docstrings, f-strings and function signatures into multiple lines
- Physics/RTD.py: Split long source URL comment
- SignalProcessing/FFT.py: Split long docstrings and function signatures
- SignalProcessing/Filter.py: Split long error message
- SignalProcessing/Ramp.py: Split long f-string exception messages
- SignalProcessing/Utils.py: Split long __repr__ f-string
- Utils/Range.py: Split long __repr__ f-string

Author: Uli Köhler

UliEngineering/Physics/RTD.py

@@ -47,7 +47,8 @@ def normalize_resistance(resistance: NormalizableArgument) -> NormalizedComputab
 
 PTCoefficientStandard = namedtuple("PTCoefficientStandard", ["a", "b", "c"])
 
-# Source: http://www.code10.info/index.php%3Foption%3Dcom_content%26view%3Darticle%26id%3D82:measuring-temperature-platinum-resistance-thermometers%26catid%3D60:temperature%26Itemid%3D83
+# Source: http://www.code10.info/index.php%3Foption%3Dcom_content%26view%3Darticle%26id%3D82:
+# measuring-temperature-platinum-resistance-thermometers%26catid%3D60:temperature%26Itemid%3D83
 ptx_ipts68 = PTCoefficientStandard(+3.90802e-03, -5.80195e-07, -4.27350e-12)
 ptx_its90 = PTCoefficientStandard(+3.9083E-03, -5.7750E-07, -4.1830E-12)
 

UliEngineering/SignalProcessing/FFT.py

@@ -40,7 +40,9 @@ def __init__(self, frequencies, amplitudes, angles=None):
         self.angles = angles
 
     def __getitem__(self, arg):
-        """Select a frequency range: fft[1.0:100.0] selects the 1.0 ... 100.0 Hz frequency range. fft[1.0:] selects everything from 1.0 Hz to the max frequency. fft[:100.0] selects everything from 1.0 Hz to the max frequency. fft[10.0] selects (frequency, value, angle) of."""
+        """Select a frequency range: fft[1.0:100.0] selects the 1.0 ... 100.0 Hz frequency range.
+        fft[1.0:] selects everything from 1.0 Hz to the max frequency. fft[:100.0] selects
+        everything from 1.0 Hz to the max frequency. fft[10.0] selects (frequency, value, angle) of."""
         if isinstance(arg, slice) or isinstance(arg, tuple):
             if isinstance(arg, slice):
                 start, end = arg.start, arg.stop
@@ -56,7 +58,10 @@ def __getitem__(self, arg):
         elif isinstance(arg, (float, int)):
             return self.closest_value(arg)
         else: # Delegate to tuple impl
-            raise ValueError("FFT [] operator selects a frequency range([start:stop]) or (value, angle) at the closest frequency ([frequency])! {} is an illegal argument".format(arg))
+            raise ValueError(
+                "FFT [] operator selects a frequency range([start:stop]) or "
+                "(value, angle) at the closest frequency ([frequency])! "
+                "{} is an illegal argument".format(arg))
 
     def dominant_frequency(self, low=None, high=None):
         """
@@ -276,7 +281,8 @@ def normalize_fft_reduction(values, fftsize, nchunks=1, power=False):
         factor = 2.0 / (nchunks * fftsize)
     return vals * factor
 
-def parallel_fft_reduce(chunkgen, samplerate, fftsize, removeDC=False, window="blackman", reducer=sum_reducer, normalize=True, executor=None, window_param=None):
+def parallel_fft_reduce(chunkgen, samplerate, fftsize, removeDC=False, window="blackman",
+                        reducer=sum_reducer, normalize=True, executor=None, window_param=None):
     """
     Perform multiple FFTs on a single dataset, returning the reduction of all FFTs.
     
@@ -322,10 +328,14 @@ def serial_fft_reduce(chunkgen, samplerate, fftsize, removeDC=False, window="bla
     if len(chunkgen) == 0:
         raise ValueError("Can't perform FFT on empty chunk generator")
     executor = QueuedThreadExecutor(nthreads=1)
-    return parallel_fft_reduce(chunkgen, samplerate, fftsize, removeDC=removeDC, window=window, reducer=reducer, normalize=normalize, executor=executor, window_param=window_param)
+    return parallel_fft_reduce(chunkgen, samplerate, fftsize, removeDC=removeDC,
+                               window=window, reducer=reducer, normalize=normalize,
+                               executor=executor, window_param=window_param)
 
 
-def parallel_spectral_power_fft_reduce(chunkgen, samplerate, fftsize, removeDC=False, window="blackman", normalize=True, start=0.0, end=None, executor=None, window_param=None):
+def parallel_spectral_power_fft_reduce(chunkgen, samplerate, fftsize, removeDC=False,
+                                      window="blackman", normalize=True, start=0.0,
+                                      end=None, executor=None, window_param=None):
     """
     Like (parallel|serial)_fft_reduce, but computes a single power value per FFT chunk.
     

UliEngineering/SignalProcessing/Filter.py

@@ -140,7 +140,10 @@ def iir(self, order, ftype="butter", rp=0.01, rs=100.0):
                                           ftype=ftype, rp=rp, rs=rs)
         if not self.is_stable():
             self.a = self.b = None
-            raise FilterUnstableError("The filter is numerically unstable. Use a lower order or a wider frequency range. You can use ChainedFilter to chain multiple filters of lower order to avoid this issue.")
+            raise FilterUnstableError(
+                "The filter is numerically unstable. Use a lower order or a wider "
+                "frequency range. You can use ChainedFilter to chain multiple filters "
+                "of lower order to avoid this issue.")
         return self
 
     def as_samplerate(self, samplerate):

UliEngineering/SignalProcessing/Ramp.py

@@ -119,9 +119,13 @@ def periodic_ramp(frequency, samplerate, amplitude=1.0, offset=0.0,
         min_acc_fall = factor * amplitude / (fall_time ** 2) if fall_time > 0 else 0
 
         if acceleration < min_acc_rise:
-            raise OperationImpossibleException(f"Acceleration {acceleration} is too low for rise time {rise_time} with {continuity} continuity. Min required: {min_acc_rise}")
+            raise OperationImpossibleException(
+                f"Acceleration {acceleration} is too low for rise time {rise_time} "
+                f"with {continuity} continuity. Min required: {min_acc_rise}")
         if acceleration < min_acc_fall:
-            raise OperationImpossibleException(f"Acceleration {acceleration} is too low for fall time {fall_time} with {continuity} continuity. Min required: {min_acc_fall}")
+            raise OperationImpossibleException(
+                f"Acceleration {acceleration} is too low for fall time {fall_time} "
+                f"with {continuity} continuity. Min required: {min_acc_fall}")
 
     # Generate time array
     num_samples = int(length * samplerate)

UliEngineering/SignalProcessing/Utils.py

@@ -207,7 +207,9 @@ def __dtype_name(self):
 
     def __repr__(self):
         """Return repr(self)."""
-        return f"LinRange({self.start}, {self.stop}, {str(self.step) if isinstance(self.step, np.timedelta64) else self.step}{'' if self.dtype == float else f', dtype={self.__dtype_name()}'})"
+        step_str = str(self.step) if isinstance(self.step, np.timedelta64) else self.step
+        dtype_str = '' if self.dtype == float else f', dtype={self.__dtype_name()}'
+        return f"LinRange({self.start}, {self.stop}, {step_str}{dtype_str})"
 
     def __eq__(self, other):
         """Return True if equal to other."""

UliEngineering/Utils/Range.py

@@ -18,7 +18,9 @@ def __new__(cls, min_val, max_val, unit=None, significant_digits=4):
 
     def __repr__(self):
         """Return string representation of the ValueRange."""
-        return f"ValueRange('{format_value(self.min, self.unit, significant_digits=self.significant_digits)}', '{format_value(self.max, self.unit, significant_digits=self.significant_digits)}')"
+        min_str = format_value(self.min, self.unit, significant_digits=self.significant_digits)
+        max_str = format_value(self.max, self.unit, significant_digits=self.significant_digits)
+        return f"ValueRange('{min_str}', '{max_str}')"
 
     @property
     def minmax(self):