PyIBIS-AMI 9.2.0__tar.gz → 9.3.0__tar.gz

{pyibis_ami-9.2.0/src/pyibis_ami.egg-info → pyibis_ami-9.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyibis-ami
-Version: 9.2.0
+Version: 9.3.0
 Summary: Facilitates working directly with IBIS-AMI DLLs from the Python command prompt.
 Author-email: David Banas <capn.freako@gmail.com>
 Project-URL: Documentation, https://pyibis-ami.readthedocs.io/en/latest/

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "pyibis-ami"
 description = "Facilitates working directly with IBIS-AMI DLLs from the Python command prompt."
-version = "9.2.0"
+version = "9.3.0"
 authors = [ {name = "David Banas",     email = "capn.freako@gmail.com"}
           ]
 readme = "README.md"
@@ -96,6 +96,13 @@ ignore = [
 exclude = [
     "*.ipynb"
 ]
+lint.ignore = [
+    "UP045",    # "Optional[X] -> "X | None"
+    "I001",     # import formatting
+    "BLE001",   # blind exceptions
+    "UP031",    # format specifiers instead of '%'
+    "RUF022",   # unsorted all
+]
 
 [[tool.mypy.overrides]]
 module = [

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0/src/pyibis_ami.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyibis-ami
-Version: 9.2.0
+Version: 9.3.0
 Summary: Facilitates working directly with IBIS-AMI DLLs from the Python command prompt.
 Author-email: David Banas <capn.freako@gmail.com>
 Project-URL: Documentation, https://pyibis-ami.readthedocs.io/en/latest/

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/ami/config.py

@@ -171,7 +171,7 @@ def mk_model(
                     "param_types": param_types,
                     "model_name": model_name,
                     "description": description,
-                    "date": str(date.today()),
+                    "date": str(date.today()),  # noqa: DTZ011
                 },
             )
             try:
@@ -246,8 +246,8 @@ def mk_tests(  # pylint: disable=too-many-locals
     pname.mkdir(exist_ok=True)
     pname = (pname / file_base_name).resolve()
     pname.mkdir(exist_ok=True)
-    for fname in test_defs.keys():
-        desc, ami_defs, sim_defs, ref_fstr = test_defs[fname]
+    for fname, value in test_defs.items():
+        desc, ami_defs, sim_defs, ref_fstr = value
         ami_str, ami_dict = ami_defs
         sim_str, sim_dict = sim_defs
         with open((pname / fname).with_suffix(".run"), "w", encoding="utf-8") as f:
@@ -258,8 +258,7 @@ def mk_tests(  # pylint: disable=too-many-locals
                     pdict.update(dict(sim_comb))
                     f.write(f"\n('{ami_str.format(pdict=pdict)}_{sim_str.format(pdict=pdict)}', \\\n")
                     f.write(f"  ({{'root_name': '{file_base_name}', \\\n")
-                    for k, v in ami_comb:
-                        f.write(f"    '{k}': {v}, \\\n")
+                    f.writelines(f"    '{k}': {v}, \\\n" for k, v in ami_comb)
                     f.write("   }, \\\n")
                     if sim_comb:
                         head, *tail = sim_comb

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/ami/model.py

@@ -355,11 +355,12 @@ class AMIModel:  # pylint: disable=too-many-instance-attributes
         self._info_params = init_object.info_params  # pylint: disable=attribute-defined-outside-init
 
         # Check GetWave() consistency if possible.
-        if init_object.info_params and init_object.info_params["GetWave_Exists"] and init_object.info_params["GetWave_Exists"].pvalue:
-            if not self._amiGetWave:
-                raise RuntimeError(
-                    "Reserved parameter `GetWave_Exists` is True, but I can't bind to `AMI_GetWave()`!"
-                )
+        if (init_object.info_params and init_object.info_params["GetWave_Exists"] and
+            init_object.info_params["GetWave_Exists"].pvalue and
+            not self._amiGetWave):  # noqa: E129
+            raise RuntimeError(
+                "Reserved parameter `GetWave_Exists` is True, but I can't bind to `AMI_GetWave()`!"
+            )
 
         # Construct the AMI parameters string.
         def sexpr(pname: str, pval: Any) -> str:
@@ -387,7 +388,7 @@ class AMIModel:  # pylint: disable=too-many-instance-attributes
         self._root_name = root_name  # pylint: disable=attribute-defined-outside-init
         ami_params_in = f"({root_name} "
         for item in list(init_object.ami_params.items()):
-            if not item[0] == "root_name":
+            if item[0] != "root_name":
                 ami_params_in += sexpr(item[0], item[1])
         ami_params_in += ")"
         self._ami_params_in = ami_params_in.encode("utf-8")  # pylint: disable=attribute-defined-outside-init
@@ -424,7 +425,7 @@ class AMIModel:  # pylint: disable=too-many-instance-attributes
             print(f"&ami_params_out = {byref(self._ami_params_out)}")
             print(f"&ami_mem_handle = {byref(self._ami_mem_handle)}")  # type: ignore
             print(f"&msg = {byref(self._msg)}")
-            raise err
+            raise
 
         # Initialize attributes used by getWave().
         bit_time = init_object.bit_time
@@ -441,7 +442,7 @@ class AMIModel:  # pylint: disable=too-many-instance-attributes
         )
         self._getwave_step_response_out_params = None
 
-    def getWave(self, wave: Rvec, bits_per_call: int = 0) -> tuple[Rvec, Rvec, list[str]]:  # noqa: F405
+    def getWave(self, wave: Rvec, bits_per_call: int = 0) -> tuple[Rvec, Rvec, list[str]]:
         """
         Performs time domain processing of input waveform, using the ``AMI_GetWave()`` function.
 
@@ -562,9 +563,8 @@ class AMIModel:  # pylint: disable=too-many-instance-attributes
         ts = self.sample_interval
         info_params = self._info_params
         ignore_bits = 0
-        if info_params:
-            if "Ignore_Bits" in info_params:
-                ignore_bits = info_params["Ignore_Bits"].pvalue
+        if info_params and "Ignore_Bits" in info_params:
+            ignore_bits = info_params["Ignore_Bits"].pvalue
 
         # Capture/convert instance variables.
         chnl_imp = np.array(self.channel_response[:self.row_size]) * ts   # input (a.k.a. - "channel") impulse response (V/sample)
@@ -584,7 +584,7 @@ class AMIModel:  # pylint: disable=too-many-instance-attributes
         ):
             pass
         else:
-            h_model = deconv_same(out_imp, chnl_imp)  # noqa: F405
+            h_model = deconv_same(out_imp, chnl_imp)
             rslt[IMP_RESP_INIT] = np.roll(h_model, -len(h_model) // 2 + 3 * nspui)
 
             h_init = np.roll(out_imp, pad_samps)

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/ami/parameter.py

@@ -7,6 +7,10 @@ Original date:   December 24, 2016
 Copyright (c) 2019 David Banas; all rights reserved World wide.
 """
 
+from typing import ClassVar
+
+from traits.api import Bool, Float, HasTraits, List, Str
+
 #####
 # AMI parameter
 #####
@@ -179,7 +183,7 @@ class AMIParameter:  # pylint: disable=too-many-instance-attributes,too-few-publ
     # The idea is to allow this class to grow along with the IBIS
     # standard, without having to change any of its boilerplate.
 
-    _param_def_tag_procs = {
+    _param_def_tag_procs: ClassVar = {
         "Usage": _set_usage,
         "Type": _set_type,
         "Format": _set_format,
@@ -326,3 +330,66 @@ class AMIParameter:  # pylint: disable=too-many-instance-attributes,too-few-publ
 
     def __str__(self):
         return f"{self.pvalue}"
+
+
+#####
+# AMI parameter tuner
+#####
+
+
+# pylint: disable=too-many-instance-attributes,too-few-public-methods
+class AmiParamTuner(HasTraits):
+    """Object used to populate the rows of a Tx/Rx AMI parameter tuning table.
+
+    Represents one *Model_Specific* 'In'/'InOut' AMI parameter, of 'Range'
+    format, offered to the user for inclusion in EQ optimization.
+    """
+
+    name = Str("(noname)")  # Display name (fully hierarchical, e.g. "tx_preset_coeffs_main").
+    branch_names = List(Str)  # Hierarchical path for `fetch_param_val()`/`set_param_val()`.
+    enabled = Bool(False)  # Will participate in EQ optimization when *True*.
+    min_val = Float(0.0)  # Minimum allowed value during optimization.
+    max_val = Float(0.0)  # Maximum allowed value during optimization.
+    step = Float(0.0)  # Increment used during optimization.
+    value = Float(0.0)  # Current value.
+    is_int = Bool(False)  # Round swept values to the nearest integer when *True*.
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(
+        self, name: str = "(noname)", branch_names: "list[str] | None" = None, enabled: bool = False,
+        min_val: float = 0.0, max_val: float = 0.0, step: float = 0.0, value: float = 0.0, is_int: bool = False
+    ):
+        """
+        Allows user to define properties, at instantiation.
+
+        Keyword Args:
+            name: Parameter name/label.
+                Default: "(noname)"
+            branch_names: Hierarchical path to the parameter, rooted at "Model_Specific".
+                Default: []
+            enabled: Will participate in EQ optimization when *True*.
+                Default: *False*
+            min_val: Minimum allowed value during optimization.
+                Default: 0.0
+            max_val: Maximum allowed value during optimization.
+                Default: 0.0
+            step: Increment used during optimization.
+                Default: 0.0
+            value: Current value.
+                Default: 0.0
+            is_int: Round swept values to the nearest integer when *True*.
+                Default: *False*
+        """
+
+        # Super-class initialization is ABSOLUTELY NECESSARY, in order
+        # to get all the Traits/UI machinery setup correctly.
+        super().__init__()
+
+        self.name = name
+        self.branch_names = branch_names or []
+        self.enabled = enabled
+        self.min_val = min_val
+        self.max_val = max_val
+        self.step = step
+        self.value = value
+        self.is_int = is_int

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/ami/parser.py

@@ -11,7 +11,8 @@ from __future__     import annotations
 from ctypes         import c_double
 from dataclasses    import dataclass
 import re
-from typing         import Any, Callable, NewType, Optional, TypeAlias
+from typing         import Any, NewType, Optional, TypeAlias
+from collections.abc import Callable
 
 import numpy as np
 from numpy.typing import NDArray
@@ -21,7 +22,7 @@ from traitsui.api import Group, HGroup, Item, VGroup, View
 from traitsui.menu import ModalButtons
 
 from .model                     import AMIModelInitializer
-from .parameter                 import AMIParamError, AMIParameter
+from .parameter                 import AmiParamTuner, AMIParamError, AMIParameter
 from .reserved_parameter_names  import AmiReservedParameterName, RESERVED_PARAM_NAMES
 
 # New types and aliases.
@@ -47,7 +48,7 @@ class AmiLeaf:
 @dataclass(frozen=True)
 class AmiBranch:
     name: AmiName
-    children: list["AmiNode"]
+    children: list[AmiNode]
 
 
 AmiNode:       TypeAlias = AmiLeaf | AmiBranch
@@ -60,7 +61,7 @@ AmiRootName = NewType("AmiRootName", str)
 ReservedParamDict: TypeAlias = dict[AmiReservedParameterName, AMIParameter]
 ModelSpecificDict: TypeAlias = dict[ParamName, "'AMIParameter' | 'ModelSpecificDict'"]
 
-__all__ = [
+__all__ = [  # ruff: ignore=RUF022
     "ParamName", "ParamValue", "Parameters", "ParamValues",
     "AmiName", "AmiAtom", "AmiNode", "AmiNodeParser", "AmiParser",
     "ami_parse", "AMIParamConfigurator"]
@@ -186,32 +187,125 @@ class AMIParamConfigurator(HasTraits):
             return _param.pvalue
         return None
 
-    def set_param_val(self, branch_names, new_val):
-        """Sets the value of the parameter found by traversing 'branch_names'
+    def set_param_val(
+        self: AMIParamConfigurator,
+        branch_names: list[str],
+        new_val: Any
+    ) -> None:
+        """
+        Sets the value of the parameter found by traversing 'branch_names'
         or raises an exception if not found.
 
-        Note: 'branch_names' should *not* begin with 'root_name'.
-        Note: Be careful! There is no checking done here!
+        Args:
+            branch_names: A sequence of node names, used to traverse the parameter tree.
+            new_val: The value to assign to the target parameter.
+
+        Notes:
+            1. ``branch_names`` should *not* begin with <root_name>.
+            2. Be careful! There is no checking done here!
         """
 
         param_dict = self.ami_param_defs
+        tname_parts: list[str] = []  # Fully hierarchical trait name, minus the root key.
+        root_key: Optional[str] = None
         while branch_names:
             branch_name = branch_names.pop(0)
+            if root_key is None:
+                root_key = branch_name  # "Reserved_Parameters" or "Model_Specific"; not part of the trait name.
+            else:
+                tname_parts.append(branch_name)
             if branch_name in param_dict:
-                param_dict = param_dict[branch_name]
+                param_dict = param_dict[branch_name]  # type: ignore
             else:
                 raise ValueError(
                     f"Failed parameter tree search looking for: {branch_name}; available keys: {param_dict.keys()}"
                 )
         if isinstance(param_dict, AMIParameter):
-            param_dict.pvalue = new_val
-            try:
-                eval(f"self.set({branch_name}_={new_val})")  # pylint: disable=eval-used
-            except Exception:  # pylint: disable=broad-exception-caught
-                eval(f"self.set({branch_name}={new_val})")  # pylint: disable=eval-used
+            # Coerce to the parameter's declared type. Notably: a `Bool` trait rejects a
+            # float outright, and a vendor's AMI_Init() parser may choke on "1.0" where an
+            # Integer-typed value (e.g. a List-format mode selector) is expected.
+            if param_dict.ptype == "Boolean":
+                if not isinstance(new_val, bool):
+                    if isinstance(new_val, str):
+                        match new_val:
+                            case "FALSE" | "False" | "false":
+                                new_val = False
+                            case _:
+                                new_val = bool(new_val)
+                    else:
+                        new_val = bool(new_val)
+            elif param_dict.ptype in ("Integer", "Tap"):
+                new_val = int(new_val)
+            # `pvalue`, for 'List' format, holds the list of *legal* values, not the
+            # current one (that lives on the Trait) -- leave it alone, to avoid corrupting it.
+            if param_dict.pformat != "List":
+                param_dict.pvalue = new_val
+            tname = "_".join(tname_parts)
+            if tname:
+                try:
+                    self.trait_set(**{f"{tname}_": new_val})
+                except Exception:  # pylint: disable=broad-exception-caught
+                    self.trait_set(**{tname: new_val})
         else:
             raise TypeError(f"{param_dict} is not of type: AMIParameter!")
 
+    @property
+    def tunable_params(self) -> list[tuple[list[str], AMIParameter]]:
+        """Every *Model Specific* parameter of type 'In' or 'InOut' that is a
+        candidate for automated sweeping/optimization, paired with its fully
+        hierarchical branch name path. This includes:
+
+            - numeric 'Range'-format parameters (real min/max bounds),
+            - 'Boolean' parameters (True/False), and
+            - 'List'-format 'Integer' parameters whose legal values form a
+              contiguous range (e.g. a mode selector like `(List 0 1)`) --
+              this is deliberately conservative: a non-contiguous legal set
+              (e.g. `(List 6 12 18)`) can't be swept with a uniform step
+              without risking illegal intermediate values, so it's excluded.
+
+        The returned branch name paths are ready to pass directly into
+        ``fetch_param_val()``/``set_param_val()`` (i.e. - they are rooted at
+        ``"Model_Specific"``).
+        """
+        return _walk_tunable_params(self._model_specific_dict, ["Model_Specific"])
+
+    def mk_tap_tuners(self) -> list[AmiParamTuner]:
+        """Build a fresh list of `AmiParamTuner`s from this AMI model's tunable
+        Model_Specific parameters (see `tunable_params` for exactly which ones
+        qualify: Range-format, Boolean, and contiguous Integer/List "mode
+        selector" parameters)."""
+        tuners = []
+        for branch_names, param in self.tunable_params:
+            tname = "_".join(branch_names[1:])  # Drop the "Model_Specific" root.
+            if param.pformat == "Range":
+                pmin, pmax = float(param.pmin), float(param.pmax)
+                step = (pmax - pmin) / 10 or 1.0
+                is_int = param.ptype == "Integer"
+                value = float(param.pvalue)
+            elif param.pformat == "Value" and param.ptype == "Boolean":
+                pmin, pmax, step, is_int = 0.0, 1.0, 1.0, True
+                value = float(param.pvalue)
+            else:  # List-format Integer "mode selector" (contiguous legal values).
+                vals = [float(v) for v in param.pvalue]
+                pmin, pmax, step, is_int = min(vals), max(vals), 1.0, True
+                # `pvalue`, for 'List' format, is the list of *legal* values, not the
+                # current one -- that lives on the Trait `make_gui_items()` registered.
+                try:
+                    value = float(self.trait_get(tname + "_")[tname + "_"])
+                except Exception:  # pylint: disable=broad-exception-caught
+                    value = float(self.trait_get(tname)[tname])
+            tuners.append(AmiParamTuner(
+                name=tname,
+                branch_names=branch_names,
+                enabled=False,
+                min_val=pmin,
+                max_val=pmax,
+                step=step,
+                value=value,
+                is_int=is_int,
+            ))
+        return tuners
+
     @property
     def ami_parsing_errors(self) -> list[str]:
         """Any errors or warnings encountered, while parsing the AMI parameter
@@ -286,7 +380,7 @@ class AMIParamConfigurator(HasTraits):
         elif isinstance(param, dict):  # We received a dictionary of subparameters, in 'param'.
             subs: ParamValues = {}
             for sname in param:
-                subs.update(self.input_ami_param(param, sname, prefix=pname + "_"))  # type: ignore
+                subs.update(self.input_ami_param(param, sname, prefix=tname + "_"))  # type: ignore
             res[pname] = subs
         return res
 
@@ -332,6 +426,47 @@ class AMIParamConfigurator(HasTraits):
         return initializer
 
 
+def _is_sweepable(param: AMIParameter) -> bool:
+    "See `AMIParamConfigurator.tunable_params` for the exact criteria."
+    if param.pusage not in ("In", "InOut"):
+        return False
+    if param.pformat == "Range":
+        return True
+    if param.pformat == "Value" and param.ptype == "Boolean":
+        return True
+    if param.pformat == "List" and param.ptype == "Integer":
+        vals = sorted(int(v) for v in param.pvalue)
+        return vals == list(range(vals[0], vals[-1] + 1))  # Contiguous?
+    return False
+
+
+def _walk_tunable_params(
+    params: Parameters, prefix: list[str]
+) -> list[tuple[list[str], AMIParameter]]:
+    """Recursively collect every sweepable (see `_is_sweepable`) leaf of a
+    *Model Specific* parameter (sub)tree.
+
+    Args:
+        params: The (sub)dictionary of AMI parameters to walk.
+        prefix: The branch name path leading to ``params``.
+
+    Returns:
+        A list of (branch name path, parameter) pairs, one per sweepable leaf.
+    """
+
+    results: list[tuple[list[str], AMIParameter]] = []
+    for pname, param in params.items():
+        if pname == "description":  # A branch's optional descriptive text, not a subparameter.
+            continue
+        path = prefix + [pname]
+        if isinstance(param, AMIParameter):
+            if _is_sweepable(param):
+                results.append((path, param))
+        else:  # Subparameter branch.
+            results.extend(_walk_tunable_params(param, path))
+    return results
+
+
 #####
 # AMI file parser.
 #####
@@ -558,7 +693,7 @@ def parse_ami_file_contents(  # pylint: disable=too-many-locals,too-many-branche
     init_returns_impulse_found = False
     getwave_exists_found = False
     model_spec_found = False
-    root_name, params = list(param_dict.items())[0]
+    root_name, params = next(iter(param_dict.items()))
     description = ""
     reserved_params_dict: dict[AmiReservedParameterName, AMIParameter] = {}
     model_specific_dict: ModelSpecificDict = {}
@@ -606,8 +741,7 @@ def parse_ami_file_contents(  # pylint: disable=too-many-locals,too-many-branche
 # Legacy client code support:
 def parse_ami_param_defs(file_contents: str) -> tuple[ParseErrMsg, dict[str, Any]]:
     "The legacy version of ``parse_ami_file_contents()``."
-    # err_msg, root_name, description, reserved_params_dict, model_specific_dict = parse_ami_file_contents(file_contents)
-    errors, warnings, root_name, description, reserved_params_dict, model_specific_dict = parse_ami_file_contents(file_contents)
+    errors, _warnings, root_name, description, reserved_params_dict, model_specific_dict = parse_ami_file_contents(file_contents)
     if errors:
         err_msg = errors[0]
     else:
@@ -650,8 +784,8 @@ def make_gui(params: ModelSpecificDict) -> tuple[Group, list[tuple[str, TraitTyp
     # but no pre-existing enclosing group, in a ``VGroup``.
     # - Generate grouped parameter names and list of unique group names.
     pnames = list(params.keys())
-    pnames_split = list(map(lambda n: n.split('_'), pnames))
-    group_names = list(map(lambda xs: xs[0], pnames_split))
+    pnames_split = [n.split('_') for n in pnames]
+    group_names = [xs[0] for xs in pnames_split]
     grouped_pnames = list(zip(pnames, group_names))
     # The following doesn't preserve the parameter ordering of the AMI file!
     # for group_name in set(group_names):  # Iterate over unique group names.
@@ -729,7 +863,7 @@ def make_gui_items(  # pylint: disable=too-many-locals,too-many-branches
                 if list_tips:
                     tmp_dict: dict[str, Any] = {}
                     tmp_dict.update(list(zip(list_tips, param.pvalue)))
-                    val = list(tmp_dict.keys())[0]
+                    val = next(iter(tmp_dict.keys()))
                     if default:
                         for tip in tmp_dict.items():
                             if tip[1] == default:

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/ami/reserved_parameter_names.py

@@ -12,7 +12,7 @@ from dataclasses import dataclass
 
 
 @dataclass
-class AmiReservedParameterName():
+class AmiReservedParameterName:
     "IBIS-AMI Reserved Parameter Name"
 
     pname: str

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/ibis/file.py

@@ -15,7 +15,7 @@ Copyright (c) 2019 by David Banas; All rights reserved World wide.
 """
 
 import platform
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 from typing import Optional
 
 from traits.api import (
@@ -70,16 +70,6 @@ class IBISModel(HasTraits):  # pylint: disable=too-many-instance-attributes
     via the ``model_dict`` property.
     """
 
-    _file_name: str = ""
-    _ibis_ver: float = 0.0
-    _file_rev: str = ""
-    _date: str = ""
-    _model_dict: dict[str, Any] = {}
-    _models: dict[str, Model] = {}
-    _model_selectors: dict[str, list[str]] = {}
-    _components: dict[str, Component] = {}
-    _log: str = ""
-
     pin_ = Property(Any, depends_on=["pin"])
     pin_rlcs = Property(Dict, depends_on=["pin"])
     model = Property(Any, depends_on=["mod"])
@@ -118,7 +108,7 @@ class IBISModel(HasTraits):  # pylint: disable=too-many-instance-attributes
         """
 
         if mname in self._model_selectors:
-            return list(map(lambda pr: pr[0], self._model_selectors[mname]))
+            return [pr[0] for pr in self._model_selectors[mname]]
         else:
             if mname in self._models:
                 return [mname]
@@ -158,7 +148,12 @@ class IBISModel(HasTraits):  # pylint: disable=too-many-instance-attributes
 
         return list(filter(pin_ok, list(pins)))
 
-    def __init__(self, ibis_file_name, debug=False, gui=True):
+    def __init__(
+        self: "IBISModel",
+        ibis_file_name: str,
+        debug: bool = False,
+        gui: bool = True
+    ) -> None:
         """
         Args:
             ibis_file_name (str): The name of the IBIS file.
@@ -176,6 +171,7 @@ class IBISModel(HasTraits):  # pylint: disable=too-many-instance-attributes
 
         self.debug = debug
         self.GUI = gui
+        self._log: str = ""
         if debug:
             self.log("pyibisami.ibis_file.IBISModel initializing in debug mode...")
         else:
@@ -185,10 +181,10 @@ class IBISModel(HasTraits):  # pylint: disable=too-many-instance-attributes
         with open(ibis_file_name, "r", encoding="utf-8") as file:
             ibis_file_contents_str = file.read()
         err_str, model_dict = parse_ibis_file(ibis_file_contents_str, debug=debug)
-        self._file_name = model_dict.get("file_name", "(n/a)")
-        self._ibis_ver = model_dict.get("ibis_ver", "(n/a)")
-        self._file_rev = model_dict.get("file_rev", "(n/a)")
-        self._date = model_dict.get("date", "(n/a)")
+        self._file_name: str = model_dict.get("file_name", "(n/a)")
+        self._ibis_ver: float = model_dict.get("ibis_ver", "(n/a)")
+        self._file_rev: str = model_dict.get("file_rev", "(n/a)")
+        self._date: str = model_dict.get("date", "(n/a)")
         self.log("IBIS parsing errors/warnings:\n" + err_str)
         if "components" not in model_dict or not model_dict["components"]:
             if debug:
@@ -199,22 +195,25 @@ class IBISModel(HasTraits):  # pylint: disable=too-many-instance-attributes
             if debug:
                 print(f":\n{model_dict}", flush=True)
             raise ValueError("This IBIS model has no models!")
-        self._model_dict = model_dict
-        self._models = model_dict["models"]
-        self._components = components
+
+        self._model_dict: dict[str, Any] = model_dict
+        self._models: dict[str, Model] = model_dict["models"]
+        self._components: dict[str, Component] = components
+        self._model_selectors: dict[str, list[str]] = {}
         if "model_selectors" in model_dict:
-            self._model_selectors = model_dict["model_selectors"]
+            self._model_selectors.update(model_dict["model_selectors"])
 
         # Add Traits for various attributes found in the IBIS file.
-        self.add_trait("comp", Trait(list(components)[0], components))  # Doesn't need a custom mapper, because
-        self.pins = self.get_pins()                                     # the thing above it (file) can't change.
+        # Doesn't need a custom mapper because the thing above it (file) can't change:
+        self.add_trait("comp", Trait(next(iter(components)), components))
+        self.pins = self.get_pins()  # type: ignore
         try:
-            self.add_trait("pin", Enum(self.pins[0], values="pins"))
+            self.add_trait("pin", Enum(self.pins[0], values="pins"))  # type: ignore
         except Exception as err:
             raise ValueError(f"self.pins: {self.pins}") from err
         (mname, _) = self.pin_
-        self.models = self.get_models(mname)
-        self.add_trait("mod", Enum(self.models[0], values="models"))
+        self.models = self.get_models(mname)  # type: ignore
+        self.add_trait("mod", Enum(self.models[0], values="models"))  # type: ignore
         self.add_trait("ibis_ver", Float(model_dict["ibis_ver"]))
         self.add_trait("file_name", String(model_dict["file_name"]))
         self.add_trait("file_rev", String(model_dict["file_rev"]))
@@ -227,8 +226,9 @@ class IBISModel(HasTraits):  # pylint: disable=too-many-instance-attributes
         self._os_type = platform.system()  # These 2 are used, to choose
         self._os_bits = platform.architecture()[0]  # the correct AMI executable.
 
-        self._comp_changed(list(components)[0])  # Wasn't being called automatically.
-        self._pin_changed(self.pins[0])  # Wasn't being called automatically.
+        self._comp_changed(next(iter(components)))  # Wasn't being called automatically.
+        # Wasn't being called automatically:
+        self._pin_changed(self.pins[0])  # type: ignore
 
         self.log("Done.")
 
@@ -266,7 +266,7 @@ class IBISModel(HasTraits):  # pylint: disable=too-many-instance-attributes
         """Log a message to the console and, optionally, to terminal and/or
         pop-up dialog."""
         _msg = msg.strip()
-        txt = f"\n[{datetime.now()}]: IBISModel: {_msg}\n"
+        txt = f"\n[{datetime.now(tz=timezone(timedelta(hours=0)))}]: IBISModel: {_msg}\n"
         self._log += txt
         if self.debug:
             print(txt, flush=True)

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/ibis/model.py

@@ -43,7 +43,7 @@ class Component(HasTraits):
         # Set up the GUI.
         self.add_trait("manufacturer", String(self._mfr))
         self.add_trait("package", String(self._pkg))
-        self.add_trait("_pin", Trait(list(self._pins)[0], self._pins))
+        self.add_trait("_pin", Trait(next(iter(self._pins)), self._pins))
         self._content = [
             Group(
                 Item("manufacturer", label="Manufacturer", style="readonly"),
@@ -109,7 +109,7 @@ class Model(HasTraits):  # pylint: disable=too-many-instance-attributes
 
         # Fetch available keyword/parameter definitions.
         def maybe(name):
-            return subDict[name] if name in subDict else None
+            return subDict.get(name, None)
 
         self._mtype = maybe("model_type")
         self._ccomp = maybe("c_comp")
@@ -164,7 +164,7 @@ class Model(HasTraits):  # pylint: disable=too-many-instance-attributes
             pu_ityps = -np.array(pu_ityps)  # Correct for current sense, for nicer plot.
             pu_imins = -np.array(pu_imins)
             pu_imaxs = -np.array(pu_imaxs)
-            self._zout = (list(pd_zs)[0] + list(pu_zs)[0]) / 2
+            self._zout = (next(iter(pd_zs)) + next(iter(pu_zs))) / 2
             plotdata.set_data("pd_vs", pd_vs)
             plotdata.set_data("pd_ityps", pd_ityps)
             plotdata.set_data("pd_imins", pd_imins)
@@ -204,7 +204,7 @@ class Model(HasTraits):  # pylint: disable=too-many-instance-attributes
 
             if "gnd_clamp" in subDict:
                 gc_vs, gc_ityps, gc_imins, gc_imaxs, gc_zs = proc_iv(subDict["gnd_clamp"])
-                gc_z = list(gc_zs)[0]  # Use typical value for Zin calc.
+                gc_z = next(iter(gc_zs))  # Use typical value for Zin calc.
                 plotdata.set_data("gc_vs", gc_vs)
                 plotdata.set_data("gc_ityps", gc_ityps)
                 plotdata.set_data("gc_imins", gc_imins)
@@ -214,7 +214,7 @@ class Model(HasTraits):  # pylint: disable=too-many-instance-attributes
 
             if "power_clamp" in subDict:
                 pc_vs, pc_ityps, pc_imins, pc_imaxs, pc_zs = proc_iv(subDict["power_clamp"])
-                pc_z = list(pc_zs)[0]
+                pc_z = next(iter(pc_zs))
                 pc_vs = self._vrange[0] - np.array(pc_vs)  # Correct for Vdd-relative pull-up voltages.
                 pc_ityps = -np.array(pc_ityps)  # Correct for current sense, for nicer plot.
                 pc_imins = -np.array(pc_imins)

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/ibis/parser.py

@@ -13,7 +13,8 @@ Copyright (c) 2019 by David Banas; All rights reserved World wide.
 import re
 
 from functools import reduce
-from typing import Any, Generator, Iterable, Optional, TypeAlias, TypeVar
+from typing import Any, Optional, TypeAlias, TypeVar
+from collections.abc import Generator, Iterable
 
 from parsec import (
     ParseError,
@@ -419,7 +420,7 @@ def model():
     try:
         theModel = Model(dict(res))
     except LookupError as le:
-        return fail_with(f"[Model] {nm}: {str(le)}")
+        return fail_with(f"[Model] {nm}: {le!s}")
     return {nm: theModel}
 
 
@@ -501,9 +502,9 @@ def comp():
     try:
         Component(dict(res))
     except LookupError as le:
-        return fail_with(f"[Component] {nm}: {str(le)}")
+        return fail_with(f"[Component] {nm}: {le!s}")
     except Exception as err:  # pylint: disable=broad-exception-caught
-        return fail_with(f"[Component] {nm}: {str(err)}")
+        return fail_with(f"[Component] {nm}: {err!s}")
     return {nm: Component(dict(res))}
 
 

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/testing/ami_test_config.py

@@ -145,11 +145,11 @@ def _compare_params_out(
         actual_norm = _normalize_params_str(ami_model.ami_params_out)
         golden_norm = _normalize_params_str(golden_str)
         matched = (actual_norm == golden_norm)
-        msgs = [] if matched else [
-            f"params_out mismatch.\n"
+        msgs = [] if matched else [(
+            "params_out mismatch.\n"
             f"  Got:      {actual_norm}\n"
             f"  Expected: {golden_norm}"
-        ]
+        )]
         return True, matched, msgs
     except Exception as exc:  # pylint: disable=broad-exception-caught
         return True, False, [f"params_out comparison failed: {exc}"]

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/testing/ami_tests.py

@@ -11,9 +11,10 @@ Copyright (c) 2026 David Banas; All rights reserved World wide.
 import platform
 
 from abc     import ABC
+from collections.abc import Sequence
 from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing  import Optional, Sequence
+from typing  import ClassVar, Optional
 
 import em
 
@@ -58,7 +59,7 @@ class AmiTester(ABC):
     def pcfg(self):
         return self._pcfg
 
-    _test_sweepers: list[TestSweeper] = []
+    _test_sweepers: list[TestSweeper]
 
     @property
     def test_sweepers(self):
@@ -96,7 +97,7 @@ class AmiTester(ABC):
     def msg(self):
         return self._msg
 
-    _preamble: list[Flowable] = []  # Any desired introductory text for report body.
+    _preamble: list[Flowable]  # Any desired introductory text for report body.
 
     @property
     def preamble(self):
@@ -106,9 +107,8 @@ class AmiTester(ABC):
     def preamble(self, value):
         if not isinstance(value, list):
             raise TypeError(f"New value for `preamble` needs type `list[Flowable]` not {type(value)}.")
-        if len(value) > 0:
-            if not isinstance(value[0], Flowable):
-                raise TypeError(f"New value for `preamble` needs type `list[Flowable]` not `list[{type(value[0])}]`.")
+        if len(value) > 0 and not isinstance(value[0], Flowable):
+            raise TypeError(f"New value for `preamble` needs type `list[Flowable]` not `list[{type(value[0])}]`.")
         self._preamble = value
 
     @property
@@ -173,7 +173,8 @@ class AmiTester(ABC):
             self._init_ok = True
         self._getwave_ok = ami_model.has_getwave
 
-        return
+        # Set misc. defaults.
+        self._preamble = []
 
     # Execution
     def __call__(self):
@@ -218,7 +219,7 @@ class AmiTester(ABC):
 class AmiTestLinearityChecker(AmiTester):
     "Check ``AMI_Init()`` for linearity."
 
-    preamble = [
+    preamble: ClassVar = [
         Paragraph(f"{fixed('AMI_Init()')} Linearity Check", H2),
         Paragraph(f"Here, we check that the {fixed('AMI_Init()')} function is linear."),
         spacer,
@@ -297,7 +298,7 @@ class AmiTestInitVsGetwave(AmiTester):
 
     helper = AmiTestHelperInitVsGetwave(DEBUG)
 
-    preamble = [
+    preamble: ClassVar = [
         Paragraph("Init() vs. GetWave()", H2),
         Paragraph(
             "Here, we check to see that the fundamental responses of the model are the same \
@@ -327,7 +328,7 @@ class AmiTestSamplesPerBit(AmiTester):
 
     helper = AmiTestHelperSamplesPerBit()
 
-    preamble = [
+    preamble: ClassVar = [
         Paragraph("Samples per Bit", H2),
         Paragraph("Here, we test the model's sensitivity to the oversampling factor, \
                    i.e., number of samples per bit (or, symbol).", P),
@@ -420,7 +421,7 @@ def test_ami_model(
 
     # Attempt to create the AMI model and its configurator.
     ibis_file_dir = ibis_file.parent
-    dll_file, ami_file = list(map(lambda f: ibis_file_dir / Path(f), ami_files))
+    dll_file, ami_file = [ibis_file_dir / Path(f) for f in ami_files]
     try:
         ami_model = AMIModel(str(dll_file))
     except Exception as err:
@@ -435,7 +436,7 @@ def test_ami_model(
         has_getwave = pcfg.fetch_param_val(["Reserved_Parameters", "GetWave_Exists"]) or False
         ignore_bits = pcfg.fetch_param_val(["Reserved_Parameters", "Ignore_Bits"]) or 0
         returns_impulse = pcfg.fetch_param_val(["Reserved_Parameters", "Init_Returns_Impulse"]) or False
-        has_ts4 = True if pcfg.fetch_param_val(["Reserved_Parameters", "Ts4file"]) else False
+        has_ts4 = bool(pcfg.fetch_param_val(["Reserved_Parameters", "Ts4file"]))
     except Exception as err:
         flowables.append(Paragraph(str(err), P))
         flowables.append(Paragraph(f"Error loading AMI parameter file: {ami_file}!", P))

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/testing/ami_tests_helpers.py

@@ -96,7 +96,7 @@ class AmiTestHelperInitVsGetwave(AmiTestHelper):
                PLOT_LINESTYLE: "dashed"}))]
 
         fig = plt.figure(figsize=(fig_x, fig_y))
-        top_fig, bottom_fig = fig.subfigures(2, 1)
+        top_fig, bottom_fig = fig.subfigures(2, 1)  # type: ignore
         top_fig.suptitle("Model Responses (Post-Adaptation)")
         top_fig.subplots_adjust(left=.1, right=.9, wspace=.3)
         bottom_fig.subplots_adjust(top=.7, bottom=.1)
@@ -120,7 +120,7 @@ class AmiTestHelperSamplesPerBit(AmiTestHelper):
         model_responses = do_samples_per_bit(model, initializer, nbits)
 
         fig = plt.figure(figsize=(fig_x, fig_y))
-        top_fig, bottom_fig = fig.subfigures(2, 1)
+        top_fig, bottom_fig = fig.subfigures(2, 1)  # type: ignore
         top_fig.suptitle("Model Responses (Post-Adaptation)")
         top_fig.subplots_adjust(left=.1, right=.9, wspace=.3)
         bottom_fig.subplots_adjust(top=.7, bottom=.1)

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/testing/ibis_file_tests.py

@@ -74,7 +74,7 @@ def golden_parser_results(ibis_file: Path) -> list[Flowable]:
     """
 
     flowables: list[Flowable] = [Paragraph("IBIS Golden Parser Results", H1)]
-    result = subprocess.run([IBIS_CHK_EXEC, str(ibis_file)], capture_output=True, text=True)
+    result = subprocess.run([IBIS_CHK_EXEC, str(ibis_file)], capture_output=True, text=True, check=False)
     flowables.append(Paragraph(preformatted(result.stdout), styles['Code']))
     flowables.append(Paragraph(preformatted(result.stderr), styles['Code']))
     flowables.append(page_break)
@@ -136,7 +136,7 @@ def test_ami_models(
         do_model(model_name)
         return flowables
 
-    for model_name in ami_model_names:
-        do_model(model_name)
+    for _model_name in ami_model_names:
+        do_model(_model_name)
 
     return flowables

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/testing/test_defs.py

@@ -11,7 +11,8 @@ Copyright (C) 2026 David Banas; all rights reserved World wide.
 from abc                import abstractmethod
 from dataclasses        import dataclass
 from pathlib            import Path
-from typing             import Any, Generator, NewType, Optional
+from typing             import Any, NewType, Optional
+from collections.abc    import Generator
 
 import numpy as np
 from scipy.interpolate  import interp1d
@@ -101,7 +102,7 @@ def mk_default_test_sweep_file(
 
     # Import the `*.ibs` file.
     try:
-        ibis = IBISModel(ibis_file, debug=debug, gui=False)
+        ibis = IBISModel(str(ibis_file.resolve()), debug=debug, gui=False)
         dName = ibis_file.parent
         assert ibis.ami_file, RuntimeError(
             "Missing AMI file definition in IBIS file!"

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/testing/util.py

@@ -36,7 +36,7 @@ def get_sweepers(
     return (
         mod.__doc__,
         [obj for name, obj in inspect.getmembers(mod, inspect.isclass)  # type: ignore
-         if issubclass(obj, TestSweep) and not obj == TestSweep]
+         if issubclass(obj, TestSweep) and obj != TestSweep]
     )
 
 

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/tools/run_notebook.py

@@ -41,7 +41,7 @@ def mk_dummy_run_file(ibis_file: Path, is_tx: bool, debug: bool) -> Path:
 
     # Import the `*.ibs` file.
     try:
-        ibis = IBISModel(ibis_file, debug=debug, gui=False)
+        ibis = IBISModel(str(ibis_file.resolve()), debug=debug, gui=False)
         dName = ibis_file.parent
         assert ibis.ami_file, RuntimeError(
             "Missing AMI file definition in IBIS file!"
@@ -113,13 +113,9 @@ def run_notebook(
         print("\nNOTE: Since you provided no parameter sweep information,")
         print(f'a "dummy" sweep file has been created: {dummy_run_file_name}.')
         print("You may use this file as a template for creating parameter sweep specifications.")
-        print("")
+        print()
 
     # Define temp. (i.e. - parameterized) notebook and output file locations.
-    tmp_notebook = NamedTemporaryFile(
-        suffix='.ipynb',
-        prefix=(notebook.stem + "_papermill"),
-        delete_on_close=False)
     html_file = Path(out_dir.joinpath(ibis_file.name)).with_suffix(".html")
 
     # Run the notebook.
@@ -132,7 +128,9 @@ def run_notebook(
     extra_args = [tok for item in notebook_params.items()
                       for tok  in ['-p', f'{item[0]}', f'{item[1]}']]  # noqa: E127
 
-    with tmp_notebook:
+    with NamedTemporaryFile(suffix='.ipynb',
+                            prefix=(notebook.stem + "_papermill"),
+                            delete_on_close=False) as tmp_notebook:
         subprocess.run(['papermill', str(notebook), tmp_notebook.name] + extra_args, check=True)
         subprocess.run(
             ['jupyter', 'nbconvert', '--to', 'html', '--no-input', '--output', html_file, tmp_notebook.name],

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/util/plot.py

@@ -9,8 +9,8 @@ Copyright (c) 2026 David Banas; All rights reserved World wide.
 """
 
 from dataclasses import dataclass
-# import logging
-from typing import Generator, Optional, Sequence, TypeAlias
+from typing import Optional, TypeAlias
+from collections.abc import Generator, Sequence
 import warnings
 
 from matplotlib import pyplot as plt
@@ -249,13 +249,13 @@ def plot_resps(
     if OUT_RESP_INIT in resps:
         if debug:
             print("Plotting OUT_RESP_INIT...")
-        t, h, s, p, f, H = resps[OUT_RESP_INIT]
+        t, _, s, p, f, H = resps[OUT_RESP_INIT]
         left_ax.plot(t * 1e9, s,            color=init_color, linestyle=init_linestyle,)
         left_ax.plot(t * 1e9, p, label=lbl, color=init_color, linestyle=init_linestyle,)
         right_ax.semilogx(f / 1e9, 20 * np.log10(np.abs(H)), label=lbl,
                           color=init_color, linestyle=init_linestyle,)
     if OUT_RESP_GETW in resps:
-        t, h, s, p, f, H = resps[OUT_RESP_GETW]
+        t, _, s, p, f, H = resps[OUT_RESP_GETW]
         left_ax.plot(t * 1e9, s, color=getwave_color, linestyle=getwave_linestyle,)
         left_ax.plot(t * 1e9, p, color=getwave_color, linestyle=getwave_linestyle,)
         right_ax.semilogx(f / 1e9, 20 * np.log10(np.abs(H)),

{pyibis_ami-9.2.0 → pyibis_ami-9.3.0}/src/pyibisami/util/reportlab.py

@@ -10,7 +10,7 @@ Copyright (c) 2026 David Banas; All rights reserved World wide.
 
 import sys
 
-from datetime   import datetime
+from datetime   import datetime, timezone, timedelta
 from pathlib    import Path
 
 import numpy as np
@@ -112,7 +112,7 @@ def title_page(ibis_file: Path) -> list[Flowable]:
 
     flowables: list[Flowable] = [Spacer(1, 3 * inch)]
     flowables.append(Paragraph(f"<em>PyIBIS-AMI</em> v{pyibisami.__version__} - IBIS-AMI Model Testing Report", title_style))
-    flowables.append(Paragraph(f"{bold('Date:')} {datetime.now()}", P))
+    flowables.append(Paragraph(f"{bold('Date:')} {datetime.now(tz=timezone(timedelta(hours=0)))}", P))
     flowables.append(Paragraph(f"{bold('Tested:')} {ibis_file}", P))
     flowables.append(Paragraph(f"{bold('Python:')} {sys.version}", P))
     flowables.append(Paragraph(f"{bold('NumPy:')} {np.__version__}", P))