Run black formatting again on codebase. (tox -e format) Ignored some formats in view/pybert.py since the comments and view are laid out in a particular way.

Author: jdpatt

pybert/__main__.py

@@ -1,5 +1,5 @@
 """Main entry into the PyBERT GUI."""
-from pybert.pybert      import PyBERT
+from pybert.pybert import PyBERT
 from pybert.pybert_view import traits_view
 
 thePyBERT = PyBERT()

pybert/pybert.py

@@ -1021,10 +1021,10 @@ def _get_jitter_info(self):
             )
             info_str += "</TR>\n"
             info_str += '<TR align="right">\n'
-            info_str += '<TD align="center">Pj</TD><TD>%6.3f</TD><TD>%6.3f</TD><TD>n/a</TD>\n' % (pj_chnl, pj_tx)
+            info_str += '<TD align="center">Pj</TD><TD>%6.3f</TD><TD>%6.3f</TD><TD>n/a</TD>\n' % (pj_chnl, pj_tx,)
             info_str += "</TR>\n"
             info_str += '<TR align="right">\n'
-            info_str += '<TD align="center">Rj</TD><TD>%6.3f</TD><TD>%6.3f</TD><TD>n/a</TD>\n' % (rj_chnl, rj_tx)
+            info_str += '<TD align="center">Rj</TD><TD>%6.3f</TD><TD>%6.3f</TD><TD>n/a</TD>\n' % (rj_chnl, rj_tx,)
             info_str += "</TR>\n"
             info_str += "</TABLE>\n"
 
@@ -1199,7 +1199,7 @@ def _get_sweep_info(self):
 
     @cached_property
     def _get_status_str(self):
-        status_str = "%-20s | Perf. (Msmpls./min.):  %4.1f" % (self.status, self.total_perf * 60.0e-6)
+        status_str = "%-20s | Perf. (Msmpls./min.):  %4.1f" % (self.status, self.total_perf * 60.0e-6,)
         dly_str = "         | ChnlDly (ns):    %5.3f" % (self.chnl_dly * 1.0e9)
         err_str = "         | BitErrs: %d" % self.bit_errs
         pwr_str = "         | TxPwr (W): %4.2f" % self.rel_power
@@ -1397,23 +1397,23 @@ def _rx_dll_file_changed(self, new_value):
     def _ch_type_changed(self, new_value):
         channel = draw_channel(self.height, self.width, self.thickness, self.separation, new_value)
         self.drawdata.set_data("channel", channel)
-        
+
     def _height_changed(self, new_value):
         channel = draw_channel(new_value, self.width, self.thickness, self.separation, self.ch_type)
         self.drawdata.set_data("channel", channel)
-        
+
     def _width_changed(self, new_value):
         channel = draw_channel(self.height, new_value, self.thickness, self.separation, self.ch_type)
         self.drawdata.set_data("channel", channel)
-        
+
     def _thickness_changed(self, new_value):
         channel = draw_channel(self.height, self.width, new_value, self.separation, self.ch_type)
         self.drawdata.set_data("channel", channel)
-        
+
     def _separation_changed(self, new_value):
         channel = draw_channel(self.height, self.width, self.thickness, new_value, self.ch_type)
         self.drawdata.set_data("channel", channel)
-        
+
     # This function has been pulled outside of the standard Traits/UI "depends_on / @cached_property" mechanism,
     # in order to more tightly control when it executes. I wasn't able to get truly lazy evaluation, and
     # this was causing noticeable GUI slowdown.
@@ -1500,9 +1500,7 @@ def calc_chnl_h(self):
 
     def log_information(self):
         """Log the system information."""
-        self.log(
-            f"System: {platform.system()} {platform.release()} Version: {platform.version()}"
-        )
+        self.log(f"System: {platform.system()} {platform.release()} Version: {platform.version()}")
         self.log(f"Python Version: {platform.python_version()}")
         self.log(f"PyBERT Version: {VERSION}")
 

pybert/pybert_cfg.py

@@ -67,7 +67,7 @@ def __init__(self, the_PyBERT):
         self.tx_taps = tx_taps
         self.tx_tap_tuners = []
         for tap in the_PyBERT.tx_tap_tuners:
-            self.tx_tap_tuners.append((tap.enabled, tap.value))        
+            self.tx_tap_tuners.append((tap.enabled, tap.value))
         self.tx_use_ami = the_PyBERT.tx_use_ami
         self.tx_use_getwave = the_PyBERT.tx_use_getwave
         self.tx_ami_file = the_PyBERT.tx_ami_file

pybert/pybert_cntrl.py

@@ -354,10 +354,10 @@ def my_run_simulation(self, initial_run=False, update_plots=True):
                 ctle_out_h = convolve(ctle_h, tx_out_h)[: len(chnl_h)]
             else:  # Init() only.
                 ctle_out_h_padded = pad(
-                    ctle_out_h, (nspb, len(rx_in) - nspb - len(ctle_out_h)), "linear_ramp", end_values=(0.0, 0.0)
+                    ctle_out_h, (nspb, len(rx_in) - nspb - len(ctle_out_h)), "linear_ramp", end_values=(0.0, 0.0),
                 )
                 tx_out_h_padded = pad(
-                    tx_out_h, (nspb, len(rx_in) - nspb - len(tx_out_h)), "linear_ramp", end_values=(0.0, 0.0)
+                    tx_out_h, (nspb, len(rx_in) - nspb - len(tx_out_h)), "linear_ramp", end_values=(0.0, 0.0),
                 )
                 ctle_H = fft(ctle_out_h_padded) / fft(tx_out_h_padded)
                 ctle_h = real(ifft(ctle_H)[: len(chnl_h)])
@@ -724,11 +724,11 @@ def update_results(self):
     self.plotdata.set_data("tap_weight_index", list(range(len(tap_weight))))
     if self._old_n_taps != n_taps:
         new_plot = Plot(
-            self.plotdata, auto_colors=["red", "orange", "yellow", "green", "blue", "purple"], padding_left=75
+            self.plotdata, auto_colors=["red", "orange", "yellow", "green", "blue", "purple"], padding_left=75,
         )
         for i in range(self.n_taps):
             new_plot.plot(
-                ("tap_weight_index", "tap%d_weights" % (i + 1)), type="line", color="auto", name="tap%d" % (i + 1)
+                ("tap_weight_index", "tap%d_weights" % (i + 1)), type="line", color="auto", name="tap%d" % (i + 1),
             )
         new_plot.title = "DFE Adaptation"
         new_plot.tools.append(PanTool(new_plot, constrain=True, constrain_key=None, constrain_direction="x"))
@@ -845,7 +845,7 @@ def update_results(self):
     bathtub_chnl.reverse()
     bathtub_chnl = array(bathtub_chnl + list(cumsum(jitter_ext_chnl[: half_len + 1])))
     bathtub_chnl = where(
-        bathtub_chnl < MIN_BATHTUB_VAL, 0.1 * MIN_BATHTUB_VAL * ones(len(bathtub_chnl)), bathtub_chnl
+        bathtub_chnl < MIN_BATHTUB_VAL, 0.1 * MIN_BATHTUB_VAL * ones(len(bathtub_chnl)), bathtub_chnl,
     )  # To avoid Chaco log scale plot wierdness.
     self.plotdata.set_data("bathtub_chnl", log10(bathtub_chnl))
     #  - Tx
@@ -861,7 +861,7 @@ def update_results(self):
     bathtub_ctle.reverse()
     bathtub_ctle = array(bathtub_ctle + list(cumsum(jitter_ext_ctle[: half_len + 1])))
     bathtub_ctle = where(
-        bathtub_ctle < MIN_BATHTUB_VAL, 0.1 * MIN_BATHTUB_VAL * ones(len(bathtub_ctle)), bathtub_ctle
+        bathtub_ctle < MIN_BATHTUB_VAL, 0.1 * MIN_BATHTUB_VAL * ones(len(bathtub_ctle)), bathtub_ctle,
     )  # To avoid Chaco log scale plot wierdness.
     self.plotdata.set_data("bathtub_ctle", log10(bathtub_ctle))
     #  - DFE

pybert/pybert_plot.py

@@ -10,7 +10,7 @@
 from chaco.api import ColorMapper, GridPlotContainer, Plot
 from chaco.tools.api import PanTool, ZoomTool
 
-from numpy import (linspace)
+from numpy import linspace
 
 from pybert.pybert_cntrl import update_eyes
 
@@ -27,9 +27,11 @@ def make_plots(self, n_dfe_taps):
     plot2.index_axis.title = "Time (ns)"
     plot2.value_axis.title = "UI (ps)"
 
-    plot9 = Plot(plotdata, auto_colors=["red", "orange", "yellow", "green", "blue", "purple"], padding_left=75)
+    plot9 = Plot(plotdata, auto_colors=["red", "orange", "yellow", "green", "blue", "purple"], padding_left=75,)
     for i in range(n_dfe_taps):
-        plot9.plot(("tap_weight_index", "tap%d_weights" % (i + 1)), type="line", color="auto", name="tap%d" % (i + 1))
+        plot9.plot(
+            ("tap_weight_index", "tap%d_weights" % (i + 1)), type="line", color="auto", name="tap%d" % (i + 1),
+        )
     plot9.title = "DFE Adaptation"
     plot9.tools.append(PanTool(plot9, constrain=True, constrain_key=None, constrain_direction="x"))
     zoom9 = ZoomTool(plot9, tool_mode="range", axis="index", always_on=False)
@@ -212,7 +214,9 @@ def make_plots(self, n_dfe_taps):
     # - Frequency Responses tab
     plot_H_chnl = Plot(plotdata, padding_left=75)
     plot_H_chnl.plot(("f_GHz", "chnl_H"), type="line", color="blue", name="Original Impulse", index_scale="log")
-    plot_H_chnl.plot(("f_GHz", "chnl_trimmed_H"), type="line", color="red", name="Trimmed Impulse", index_scale="log")
+    plot_H_chnl.plot(
+        ("f_GHz", "chnl_trimmed_H"), type="line", color="red", name="Trimmed Impulse", index_scale="log",
+    )
     plot_H_chnl.title = "Channel"
     plot_H_chnl.index_axis.title = "Frequency (GHz)"
     plot_H_chnl.y_axis.title = "Frequency Response (dB)"

pybert/pybert_util.py

@@ -66,7 +66,7 @@ def moving_average(a, n=3):
 
 
 def find_crossing_times(
-    t, x, min_delay: float = 0.0, rising_first: bool = True, min_init_dev: float = 0.1, thresh: float = 0.0
+    t, x, min_delay: float = 0.0, rising_first: bool = True, min_init_dev: float = 0.1, thresh: float = 0.0,
 ):
     """
     Finds the threshold crossing times of the input signal.
@@ -150,7 +150,9 @@ def find_crossing_times(
     return array(xings[i:])
 
 
-def find_crossings(t, x, amplitude, min_delay: float = 0.0, rising_first: bool = True, min_init_dev=0.1, mod_type=0):
+def find_crossings(
+    t, x, amplitude, min_delay: float = 0.0, rising_first: bool = True, min_init_dev=0.1, mod_type=0,
+):
     """
     Finds the crossing times in a signal, according to the modulation type.
 
@@ -549,7 +551,7 @@ def calc_gamma_RLGC(R, L, G, C, ws):
         w[0] = 1.0e-12
 
     gamma = sqrt((1j * w * L0 + R) * (1j * w * C + G))  # propagation constant (nepers/m)
-    Zc    = sqrt((1j * w * L0 + R) / (1j * w * C + G))  # characteristic impedance (Ohms)
+    Zc = sqrt((1j * w * L0 + R) / (1j * w * C + G))  # characteristic impedance (Ohms)
 
     return (gamma, Zc)
 
@@ -642,7 +644,7 @@ def calc_eye(ui, samps_per_ui, height, ys, y_max, clock_times=None):
             interp_fac = (start_time - start_ix * tsamp) // tsamp
             i = 0
             for (samp1, samp2) in zip(
-                ys[start_ix : start_ix + 2 * samps_per_ui], ys[start_ix + 1 : start_ix + 1 + 2 * samps_per_ui]
+                ys[start_ix : start_ix + 2 * samps_per_ui], ys[start_ix + 1 : start_ix + 1 + 2 * samps_per_ui],
             ):
                 y = samp1 + (samp2 - samp1) * interp_fac
                 img_array[int(y * y_scale + 0.5) + y_offset, i] += 1
@@ -659,6 +661,7 @@ def calc_eye(ui, samps_per_ui, height, ys, y_max, clock_times=None):
 
     return img_array
 
+
 def draw_channel(height, width, thickness, separation, ch_type, arraySize=[25, 100]):
     """
     Draws the channel cross section.
@@ -682,26 +685,26 @@ def draw_channel(height, width, thickness, separation, ch_type, arraySize=[25, 1
     xMid = int(xMax // 2)
     yMid = int(yMax // 2)
     yOff = int(yMax // 10 + hScale * height)
-    if ch_type == 'microstrip_se' or ch_type == 'stripline_se':  # single-ended configuration
-        xOff1 = xMid - int(hScale * (width/2))
+    if ch_type == "microstrip_se" or ch_type == "stripline_se":  # single-ended configuration
+        xOff1 = xMid - int(hScale * (width / 2))
         xOff2 = None
-    else :                                                       # differential configuration
-        xOff1 = xMid - int(hScale * (separation/2 + width))
-        xOff2 = xMid + int(hScale * separation/2)
+    else:  # differential configuration
+        xOff1 = xMid - int(hScale * (separation / 2 + width))
+        xOff2 = xMid + int(hScale * separation / 2)
     # Generate the cross-section drawing.
     # - Fill w/ dielectric color.
     img_array = 10 * ones(arraySize)
     # - Draw the reference plane.
     for y in range(yMax // 10):
         for x in range(xMax):
-            img_array[y,x] = 0
+            img_array[y, x] = 0
     # - Draw air, or second plane, depending on configuration.
-    if ch_type == 'microstrip_se' or ch_type == 'microstrip_diff':  # microstrip configuration
+    if ch_type == "microstrip_se" or ch_type == "microstrip_diff":  # microstrip configuration
         for y in range(yOff, yMax):
             for x in range(xMax):
                 img_array[y, x] = 255  # air (white)
-    else :                                                          # stripline configuration
-        for y in range(yOff + int(hScale*(thickness + height)), yMax):
+    else:  # stripline configuration
+        for y in range(yOff + int(hScale * (thickness + height)), yMax):
             for x in range(xMax):
                 img_array[y, x] = 0  # metal (black)
     # - Draw trace(s).
@@ -712,6 +715,7 @@ def draw_channel(height, width, thickness, separation, ch_type, arraySize=[25, 1
                 img_array[yOff + y, xOff2 + x] = 0
     return img_array
 
+
 def make_ctle(rx_bw, peak_freq, peak_mag, w, mode="Passive", dc_offset=0):
     """
     Generate the frequency response of a continuous time linear
@@ -1043,6 +1047,7 @@ def pulse_center(p, nspui):
     clock_pos = int(mean([main_lobe_ixs[0], main_lobe_ixs[-1]]))
     return (clock_pos, thresh)
 
+
 def submodules(package):
 
     # mod_path = package.__file__
@@ -1062,4 +1067,4 @@ def submodules(package):
         # mod = loader.load_module(package.__name__ + "." + name)
         rst[name] = mod
 
-    return rst 
+    return rst

pybert/pybert_view.py

@@ -14,7 +14,7 @@
 from enable.component_editor import ComponentEditor
 from pyface.api import OK, FileDialog
 from pyface.image_resource import ImageResource
-from traits.api import (Instance, HasTraits)
+from traits.api import Instance, HasTraits
 from traitsui.api import (
     Action,
     CheckListEditor,

pybert/solver.py

@@ -12,34 +12,37 @@
 
 Copyright (c) 2019 by David Banas; all rights reserved World wide.
 """
-from abc    import ABC, abstractmethod
+from abc import ABC, abstractmethod
 from typing import List, Tuple, Dict
-from enum   import Enum
+from enum import Enum
+
+ChType = Enum("ChType", "microstrip_se microstrip_diff stripline_se stripline_diff")
 
-ChType = Enum('ChType', 'microstrip_se microstrip_diff stripline_se stripline_diff')
 
 class Solver(ABC):
     """Abstract base class providing a consistent interface to channel solver.
     """
+
     def __init__(self):
         super().__init__()
-    
+
     @abstractmethod
-    def solve(self,
-          ch_type    : ChType = "microstrip_se",  #: Channel cross-sectional configuration.
-          diel_const : float  = 4.3,    #: Dielectric constant of substrate at ``des_freq`` (rel.).
-          loss_tan   : float  = 0.02,   #: Loss tangent at ``des_freq``.
-          des_freq   : float  = 1.0e9,   #: Frequency at which ``diel_const`` and ``loss_tan`` are quoted (Hz).
-          thickness  : float  = 0.036,  #: Trace thickness (mm).
-          width      : float  = 0.254,  #: Trace width (mm).
-          height     : float  = 0.127,  #: Trace height above/below ground plane (mm).
-          separation : float  = 0.508,  #: Trace separation (mm).
-          roughness  : float  = 0.004,  #: Trace surface roughness (mm-rms).
-          fs         : [float] = None,  #: Angular frequency sample points (Hz).
-          lic_path   : str    = "",     #: Path to license file.
-          lic_name   : str    = "",     #: Name of license type (if needed by solver).
-          prj_name   : str    = "",     #: Name of project (if needed by solver).
-          ) -> tuple(([complex], [complex], [float])):
+    def solve(
+        self,
+        ch_type: ChType = "microstrip_se",  #: Channel cross-sectional configuration.
+        diel_const: float = 4.3,  #: Dielectric constant of substrate at ``des_freq`` (rel.).
+        loss_tan: float = 0.02,  #: Loss tangent at ``des_freq``.
+        des_freq: float = 1.0e9,  #: Frequency at which ``diel_const`` and ``loss_tan`` are quoted (Hz).
+        thickness: float = 0.036,  #: Trace thickness (mm).
+        width: float = 0.254,  #: Trace width (mm).
+        height: float = 0.127,  #: Trace height above/below ground plane (mm).
+        separation: float = 0.508,  #: Trace separation (mm).
+        roughness: float = 0.004,  #: Trace surface roughness (mm-rms).
+        fs: [float] = None,  #: Angular frequency sample points (Hz).
+        lic_path: str = "",  #: Path to license file.
+        lic_name: str = "",  #: Name of license type (if needed by solver).
+        prj_name: str = "",  #: Name of project (if needed by solver).
+    ) -> tuple(([complex], [complex], [float])):
         """Solves a particular channel cross-section.
 
         Returns:

pybert/solvers/__init__.py

@@ -14,5 +14,7 @@
 
 Copyright (c) 2019 by David Banas; all rights reserved World wide.
 """
-__all__ = ["simbeor",]  # Should contain the name of each submodule.
-from . import *       # Makes each solver package available as: solvers.simbeor, etc.
+__all__ = [
+    "simbeor",
+]  # Should contain the name of each submodule.
+from . import *  # Makes each solver package available as: solvers.simbeor, etc.