py-teststand 0.2.0__tar.gz → 0.2.1__tar.gz

{py_teststand-0.2.0 → py_teststand-0.2.1}/.gitignore

@@ -21,4 +21,4 @@ dist/
 docs/
 env/
 htmlcov/
-uv.lock
+monkeytype.sqlite3

{py_teststand-0.2.0 → py_teststand-0.2.1}/CLAUDE.md

@@ -201,6 +201,16 @@ Prefer extending this facade over deep imports in user-facing code and examples.
   typing (`list[str]`, `str | None`); do not import `List`/`Optional`/`Union`.
   The codebase targets Python 3.8 syntax (Windows 7 support), so avoid 3.9+/3.10+
   only syntax such as `match`.
+- Ruff lint selects `ANN` (flake8-annotations): every function parameter and
+  return needs a type, including in `examples/` (tests are exempt via
+  per-file-ignores). `ANN401` is ignored on purpose: COM members return
+  VARIANT/IDispatch, so `typing.Any` is the *correct* annotation, not a missing
+  one. So annotate from the wrapper body, never guess: a member that returns
+  `bool(...)`/`int(...)`/`str(...)`/`float(...)` is typed accordingly, one that
+  wraps `Foo(...)` returns `Foo`, and a raw `return self._com_obj.X` (a VARIANT)
+  is `typing.Any`. Generator `__iter__` methods are `typing.Iterator[typing.Any]`.
+  Run `uv run ruff check` after typing changes; do not add blanket `# noqa` to
+  silence ANN.
 - Compatibility matrix is real and must hold: Python 3.8–3.14, Windows 7–11,
   32-bit and 64-bit, TestStand 2016 through 2026+. Do not drop a path because the
   current dev box is 64-bit / TestStand 2026.

{py_teststand-0.2.0 → py_teststand-0.2.1}/PKG-INFO

@@ -1,17 +1,14 @@
 Metadata-Version: 2.4
 Name: py-teststand
-Version: 0.2.0
+Version: 0.2.1
 Summary: Community object-oriented Python 3 bindings for the National Instruments TestStand™ COM API
-Project-URL: Homepage, https://github.com/TheDomcio/py-teststand
 Project-URL: Repository, https://github.com/TheDomcio/py-teststand
 Project-URL: Issues, https://github.com/TheDomcio/py-teststand/issues
-Project-URL: Bug Reports, https://github.com/TheDomcio/py-teststand/issues
-Project-URL: Source Code, https://github.com/TheDomcio/py-teststand
-Project-URL: TestStand API Reference, https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html
+Project-URL: TestStand™ API Reference, https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html
 Author: Dominik Rajchel
 License: MIT
 License-File: LICENSE
-Keywords: automation,com,manufacturing,national-instruments,ni,python,pywin32,station-provisioning,test-automation,teststand,windows
+Keywords: automation,com,manufacturing,national-instruments,ni,python,pywin32,scripting,station-provisioning,sugaring,test-automation,teststand,windows
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Manufacturing
@@ -39,9 +36,14 @@ Description-Content-Type: text/markdown
 
 # py-teststand
 
+[![PyPI version](https://img.shields.io/pypi/v/py-teststand.svg)](https://pypi.org/project/py-teststand/)
+[![Python versions](https://img.shields.io/pypi/pyversions/py-teststand.svg)](https://pypi.org/project/py-teststand/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Downloads](https://static.pepy.tech/badge/py-teststand)](https://pepy.tech/projects/py-teststand)
+
 Community object-oriented Python 3 bindings (twin API) for the [National Instruments TestStand™ COM API](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html).
 
-> ⚠️ **Early Implementation Stage**: Treat it as experimental. Interfaces may change between releases without notice.
+> ⚠️ **Early Implementation Stage**: Treat it as experimental. Wrapper behaviour may change between releases without notice (like error catching).
 > 🤖 **AI Disclaimer**: This project uses LLMs for codebase and coverage audits and does not replace or integrate with the [NIGEL™ AI Advisor](https://www.ni.com/en/support/software-support/nigel-ai.html).
 
 ## 📖 Overview
@@ -129,17 +131,17 @@ This approach means the bindings target a specific version of the TestStand™ t
 
 ## 🚀 Installation
 
-### 📦 pip
+### ⚡ uv
 
 ```powershell
-pip install py-teststand
+uv add py-teststand
 
 ```
 
-### ⚡ uv
+### 📦 pip
 
 ```powershell
-uv add py-teststand
+pip install py-teststand
 
 ```
 
@@ -147,6 +149,8 @@ uv add py-teststand
 
 ## 📈 Popularity Over Time
 
+[![Star History Chart](https://api.star-history.com/svg?repos=TheDomcio/py-teststand&type=Date)](https://star-history.com/#TheDomcio/py-teststand&Date)
+
 ---
 
 ## ⚖️ Legal

{py_teststand-0.2.0 → py_teststand-0.2.1}/README.md

@@ -1,8 +1,13 @@
 # py-teststand
 
+[![PyPI version](https://img.shields.io/pypi/v/py-teststand.svg)](https://pypi.org/project/py-teststand/)
+[![Python versions](https://img.shields.io/pypi/pyversions/py-teststand.svg)](https://pypi.org/project/py-teststand/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Downloads](https://static.pepy.tech/badge/py-teststand)](https://pepy.tech/projects/py-teststand)
+
 Community object-oriented Python 3 bindings (twin API) for the [National Instruments TestStand™ COM API](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html).
 
-> ⚠️ **Early Implementation Stage**: Treat it as experimental. Interfaces may change between releases without notice.
+> ⚠️ **Early Implementation Stage**: Treat it as experimental. Wrapper behaviour may change between releases without notice (like error catching).
 > 🤖 **AI Disclaimer**: This project uses LLMs for codebase and coverage audits and does not replace or integrate with the [NIGEL™ AI Advisor](https://www.ni.com/en/support/software-support/nigel-ai.html).
 
 ## 📖 Overview
@@ -90,17 +95,17 @@ This approach means the bindings target a specific version of the TestStand™ t
 
 ## 🚀 Installation
 
-### 📦 pip
+### ⚡ uv
 
 ```powershell
-pip install py-teststand
+uv add py-teststand
 
 ```
 
-### ⚡ uv
+### 📦 pip
 
 ```powershell
-uv add py-teststand
+pip install py-teststand
 
 ```
 
@@ -108,6 +113,8 @@ uv add py-teststand
 
 ## 📈 Popularity Over Time
 
+[![Star History Chart](https://api.star-history.com/svg?repos=TheDomcio/py-teststand&type=Date)](https://star-history.com/#TheDomcio/py-teststand&Date)
+
 ---
 
 ## ⚖️ Legal

{py_teststand-0.2.0 → py_teststand-0.2.1}/examples/analyzer_step_name_length.py

@@ -17,6 +17,9 @@ from typing import Any, cast
 
 from py_teststand import Engine, StepGroup
 from py_teststand.analyzer import AnalysisContext, AnalysisTransition, RuleSeverity, rule
+from py_teststand.sequence.sequence import Sequence
+from py_teststand.sequence.sequence_file import SequenceFile
+from py_teststand.sequence.step import Step
 
 RULE_ID = "PyTS_CheckStepNameLength"
 MAXIMUM_STEP_NAME_LENGTH = 15
@@ -30,8 +33,8 @@ MAXIMUM_STEP_NAME_LENGTH = 15
 )
 def check_step_name_length(context: Any) -> None:
     """Report any step whose name is longer than MAXIMUM_STEP_NAME_LENGTH."""
-    step = context.object
-    name = step.name
+    step: Any = context.object
+    name: Any = step.name
     if len(name) > MAXIMUM_STEP_NAME_LENGTH:
         context.report(
             RULE_ID,
@@ -43,9 +46,9 @@ def check_step_name_length(context: Any) -> None:
 
 class _Violation:
     def __init__(self, rule_id: str, text: str, location: Any) -> None:
-        self.rule_id = rule_id
-        self.text = text
-        self.location = location
+        self.rule_id: str = rule_id
+        self.text: str = text
+        self.location: Any = location
 
 
 class _OfflineStepContext:
@@ -57,7 +60,7 @@ class _OfflineStepContext:
     """
 
     def __init__(self, analyzed_object: Any) -> None:
-        self.object = analyzed_object
+        self.object: Any = analyzed_object
         self.transition = AnalysisTransition.BeforeStep
         self.findings: list[_Violation] = []
 
@@ -65,13 +68,13 @@ class _OfflineStepContext:
         self.findings.append(_Violation(rule_id, text, location_object))
 
 
-def _build_sequence(engine: Engine):
-    sequence_file = engine.new_sequence_file()
-    main_sequence = sequence_file.get_sequence_by_name("MainSequence")
+def _build_sequence(engine: Engine) -> Sequence:
+    sequence_file: SequenceFile = engine.new_sequence_file()
+    main_sequence: Sequence = sequence_file.get_sequence_by_name("MainSequence")
     for name in ("Init", "Temperature Check", "Measure Output Voltage Rail", "Cleanup"):
-        step = engine.new_step(adapter_key_name="", step_type_name="Action")
+        step: Step = engine.new_step(adapter_key_name="", step_type_name="Action")
         step.name = name
-        main_sequence.insert_step(step, main_sequence.get_num_steps(), StepGroup.Main)
+        main_sequence.insert_step(step, index=main_sequence.get_num_steps(), group=StepGroup.Main)
     return main_sequence
 
 
@@ -83,10 +86,10 @@ def main() -> None:
         violations = 0
         for i in range(main_sequence.get_num_steps()):
             step = main_sequence.get_step(i)
-            context = _OfflineStepContext(step)
+            context = _OfflineStepContext(analyzed_object=step)
             # The analyzer would pass a real AnalysisContext; the offline stand-in
             # provides the same surface the rule uses.
-            check_step_name_length.invoke(cast("AnalysisContext", context))
+            check_step_name_length.invoke(context=cast(typ="AnalysisContext", val=context))
             status = "VIOLATION" if context.findings else "ok"
             print(f"  [{status:9}] {step.name!r} (length {len(step.name)})")
             for finding in context.findings:

py_teststand-0.2.1/examples/data_type_manage.py

@@ -0,0 +1,148 @@
+"""Create and evolve custom TestStand data types in a sequence file.
+
+A custom data type can be a Number, Enumeration, String, Boolean, Object
+Reference, Container, or an n-dimensional array of those. This example registers
+two of them in a sequence file and then evolves one, which is the part that
+matters in practice: a type ships, instances of it exist, and later you need to
+change the type without breaking those instances.
+
+It builds:
+- DigitalMultimeter, a container type (Resolution, AutoZero, Mode, Range).
+- Coupling, a strict enumeration (AC = 0, DC = 1). Strict means a variable of
+  this type only accepts the defined enumerators, which is the default in the
+  sequence editor, so the example sets it explicitly.
+
+Then it evolves Coupling: prints the current TypeVersion, adds a GND enumerator,
+and bumps the minor version (0.0.0.0 to 0.1.0.0). TestStand type versions are
+"major.minor.revision.build". A bump of the build field (the lowest) signals an
+automatic conversion that updates instances silently; bumping a higher field
+like minor marks a deliberate change. UpdateEnumerators updates every loaded
+instance of the type, so the InputCoupling variable created here reflects the
+new enumerator immediately.
+"""
+
+from __future__ import annotations
+
+import tempfile
+import uuid
+from pathlib import Path
+
+from py_teststand import Engine, PropertyOption, PropValType, TypeCategory, TypeUsageList
+from py_teststand.property.property_object import PropertyObject
+
+ROOT_TEMP_DIR: Path = Path(tempfile.gettempdir()) / "py-teststand"
+INSERT_IF_MISSING = int(PropertyOption.InsertIfMissing)
+COERCE_TO_NUMBER = int(PropertyOption.CoerceToNumber)
+
+
+def _build_digital_multimeter_type(engine: Engine) -> PropertyObject:
+    """Build the DigitalMultimeter container type; field defaults define field types."""
+    data_type: PropertyObject = engine.new_property_object(
+        value_type=PropValType.Container, as_array=False, type_name_param="", options=0
+    )
+    data_type.set_val_number(lookup_string="Resolution", options=INSERT_IF_MISSING, value=6.5)
+    data_type.set_val_boolean(lookup_string="AutoZero", options=INSERT_IF_MISSING, value=False)
+    data_type.set_val_string(lookup_string="Mode", options=INSERT_IF_MISSING, value="Voltage")
+    data_type.set_val_number(lookup_string="Range", options=INSERT_IF_MISSING, value=100.0)
+    data_type.name = "DigitalMultimeter"
+    return data_type
+
+
+def _enumerator_array(
+    engine: Engine, named_values: list[tuple[str, float]], *, strict: bool
+) -> PropertyObject:
+    """Build the array UpdateEnumerators expects: one container per enumerator.
+
+    Each element carries EnumeratorName and EnumeratorValue. IsStrict rides along
+    as a boolean attribute on the array, not as a sub-property.
+    """
+    array: PropertyObject = engine.new_property_object(PropValType.Container, True, "", 0)
+    array.set_num_elements(len(named_values), 0)
+    for index, (name, value) in enumerate(named_values):
+        element = array.get_property_object_by_offset(index, 0)
+        assert element is not None
+        element.set_val_string("EnumeratorName", INSERT_IF_MISSING, name)
+        element.set_val_number("EnumeratorValue", INSERT_IF_MISSING, value)
+    array.attributes.set_val_boolean("TestStand.Enum.IsStrict", INSERT_IF_MISSING, strict)
+    return array
+
+
+def _register_enum(
+    engine: Engine,
+    type_usage_list: TypeUsageList,
+    name: str,
+    named_values: list[tuple[str, float]],
+    *,
+    strict: bool,
+) -> PropertyObject:
+    """Register an empty enumeration type, then set its enumerators on the root definition."""
+    enum_type = engine.new_property_object(PropValType.Enum, False, "", 0)
+    enum_type.name = name
+    type_usage_list.insert_type(enum_type, type_usage_list.num_types, TypeCategory.CustomDataTypes)
+    # UpdateEnumerators only works on the registered root definition, not the loose object.
+    definition = type_usage_list.get_type_definition(type_usage_list.get_type_index(name))
+    definition.update_enumerators(_enumerator_array(engine, named_values, strict=strict))
+    return definition
+
+
+def _print_enumerators(definition: PropertyObject) -> None:
+    enumerators = definition.enumerators
+    assert enumerators is not None
+    strict = enumerators.attributes.get_val_boolean("TestStand.Enum.IsStrict", 0)
+    print(f"  {definition.name} v{definition.type_version} (strict={strict}):")
+    for index in range(enumerators.get_num_elements()):
+        element = enumerators.get_property_object_by_offset(index, 0)
+        assert element is not None
+        value = int(element.get_val_number("", COERCE_TO_NUMBER))
+        print(f"    {element.get_value_display_name('', 0)} -> {value}")
+
+
+def main() -> None:
+    run_dir = ROOT_TEMP_DIR / uuid.uuid4().hex
+    run_dir.mkdir(parents=True, exist_ok=True)
+    sequence_path = run_dir / "with_custom_types.seq"
+
+    with Engine() as engine:
+        sequence_file = engine.new_sequence_file()
+        property_object_file = sequence_file.as_property_object_file()
+        type_usage_list = property_object_file.type_usage_list
+
+        type_usage_list.insert_type(
+            _build_digital_multimeter_type(engine),
+            type_usage_list.num_types,
+            TypeCategory.CustomDataTypes,
+        )
+        coupling = _register_enum(
+            engine, type_usage_list, "Coupling", [("AC", 0), ("DC", 1)], strict=True
+        )
+
+        # A variable typed as the enum, so the type change below has an instance to update.
+        main_sequence = sequence_file.get_sequence_by_name("MainSequence")
+        main_sequence.locals.new_sub_property(
+            "InputCoupling", PropValType.NamedType, False, "Coupling", INSERT_IF_MISSING
+        )
+
+        property_object_file.inc_change_count()
+        sequence_file.save(str(sequence_path))
+        print("Registered custom data types:")
+        _print_enumerators(coupling)
+
+        # Evolve the type: read the current version, add an enumerator, bump minor.
+        print(f"\nCoupling version before update: {coupling.type_version}")
+        coupling.update_enumerators(
+            _enumerator_array(engine, [("AC", 0), ("DC", 1), ("GND", 2)], strict=True)
+        )
+        major, minor, *_rest = (coupling.type_version + ".0.0.0").split(".")
+        coupling.type_version = f"{int(major)}.{int(minor) + 1}.0.0"
+        print(f"Coupling version after  update: {coupling.type_version}")
+
+        property_object_file.inc_change_count()
+        sequence_file.save(path=str(object=sequence_path))
+
+        print("\nCoupling now defines (the InputCoupling variable reflects this):")
+        _print_enumerators(definition=coupling)
+        print(f"\nSaved sequence file with the evolved types to {sequence_path}")
+
+
+if __name__ == "__main__":
+    main()

{py_teststand-0.2.0 → py_teststand-0.2.1}/examples/execution_run_test_headless.py

@@ -22,15 +22,18 @@ records Passed or Failed, which we read from each entry in the ResultList.
 from __future__ import annotations
 
 from py_teststand import AdapterKeyName, Engine, StepGroup
+from py_teststand.sequence.sequence import Sequence
 
 # (name, measurement expression, low limit, high limit)
-TESTS = [
+TESTS: list[tuple[str, str, float, float]] = [
     ("Supply Voltage", "5.0", 4.75, 5.25),
     ("Bias Current", "9.0", 1.0, 8.0),
 ]
 
 
-def _add_numeric_limit_test(engine, sequence, name, data_source, low, high):
+def _add_numeric_limit_test(
+    engine: Engine, sequence: Sequence, name: str, data_source: str, low: float, high: float
+) -> None:
     """Append a runnable NumericLimitTest to a sequence's Main step group."""
     step = engine.new_step(AdapterKeyName.NoneAdapterKeyName, "NumericLimitTest")
     step.name = name

{py_teststand-0.2.0 → py_teststand-0.2.1}/examples/launch_all_examples.py

@@ -9,8 +9,8 @@ EXAMPLES_DIR: Path = Path(__file__).resolve().parent
 # Script name, and what it does / how it relates to the rest.
 EXAMPLES: list[tuple[str, str]] = [
     ("station_options_update", "Set station and debug options. Start here."),
-    ("variables_create", "Add Locals and Parameters to a sequence."),
-    ("data_type_create_custom", "Define a DigitalMultimeter custom data type."),
+    ("variables_manage", "Create variables across scopes, then retype and remove one."),
+    ("data_type_manage", "Create and evolve custom data types (container + strict enum)."),
     ("property_object_serialize", "Dump variables and typedefs to JSON and back."),
     ("sequence_build", "Build a sequence file with steps and save it."),
     ("step_insert", "Insert a step into the sequence sequence_build made."),

{py_teststand-0.2.0 → py_teststand-0.2.1}/examples/property_object_serialize.py

@@ -3,7 +3,7 @@
 TestStand keeps variables, parameters, and custom data types as PropertyObjects: a
 tree of named sub-properties. A sub-property can be a scalar (number, string,
 boolean), a nested container (including a typedef such as the DigitalMultimeter
-type from data_type_create_custom.py), or an array of any of those.
+type from data_type_manage.py), or an array of any of those.
 
 property_object_to_dict walks that tree into an ordinary dict; dict_to_property_object
 rebuilds an equivalent PropertyObject. The walk asks PropertyObject.get_type what

{py_teststand-0.2.0 → py_teststand-0.2.1}/examples/sequence_build.py

@@ -24,60 +24,64 @@ import uuid
 from pathlib import Path
 
 from py_teststand import Engine, StepGroup
+from py_teststand.property.property_object import PropertyObject
+from py_teststand.sequence.sequence import Sequence
+from py_teststand.sequence.sequence_file import SequenceFile
+from py_teststand.sequence.step import Step
 
-ROOT_TEMP_DIR = Path(tempfile.gettempdir()) / "py-teststand"
-LATEST_POINTER = ROOT_TEMP_DIR / "latest_sequence.txt"
+ROOT_TEMP_DIR: Path = Path(tempfile.gettempdir()) / "py-teststand"
+LATEST_POINTER: Path = ROOT_TEMP_DIR / "latest_sequence.txt"
 
 
 def main() -> None:
-    run_dir = ROOT_TEMP_DIR / uuid.uuid4().hex
+    run_dir: Path = ROOT_TEMP_DIR / uuid.uuid4().hex
     run_dir.mkdir(parents=True, exist_ok=True)
-    output_path = run_dir / "test_sequence.seq"
+    output_path: Path = run_dir / "test_sequence.seq"
 
     with Engine() as engine:
-        sequence_file = engine.new_sequence_file()
-        main_sequence = sequence_file.get_sequence_by_name("MainSequence")
+        sequence_file: SequenceFile = engine.new_sequence_file()
+        main_sequence: Sequence = sequence_file.get_sequence_by_name("MainSequence")
 
-        first_step = engine.new_step(adapter_key_name="", step_type_name="NumericLimitTest")
+        first_step: Step = engine.new_step(adapter_key_name="", step_type_name="NumericLimitTest")
         first_step.name = "Temperature Check"
         first_step.precondition = "Locals.TempSensorPresent == True"
         first_step.record_result = True
 
-        first_step_property_object = first_step.as_property_object()
+        first_step_property_object: PropertyObject = first_step.as_property_object()
         first_step_property_object["Limits.High"] = 85.0
         first_step_property_object["Limits.Low"] = 15.0
 
-        main_sequence.insert_step(first_step, 0, StepGroup.Main)
+        main_sequence.insert_step(first_step, index=0, group=StepGroup.Main)
 
-        second_step = engine.new_step(adapter_key_name="", step_type_name="NumericLimitTest")
+        second_step: Step = engine.new_step(adapter_key_name="", step_type_name="NumericLimitTest")
         second_step.name = "Voltage Monitor"
         second_step.precondition = "Locals.DUTPowered == True"
 
-        second_step_property_object = second_step.as_property_object()
+        second_step_property_object: PropertyObject = second_step.as_property_object()
         second_step_property_object["Limits.High"] = 5.25
         second_step_property_object["Limits.Low"] = 4.75
 
-        main_sequence.insert_step(second_step, 1, StepGroup.Main)
+        main_sequence.insert_step(second_step, index=1, group=StepGroup.Main)
 
-        sub_seq = engine.new_sequence()
-        sub_seq.name = "CustomSubsequence"
-        sequence_file.insert_sequence(sub_seq)
+        subsequence: Sequence = engine.new_sequence()
+        subsequence.name = "CustomSubsequence"
+        sequence_file.insert_sequence(sequence=subsequence)
 
-        init_step = engine.new_step(adapter_key_name="", step_type_name="Action")
+        init_step: Step = engine.new_step(adapter_key_name="", step_type_name="Action")
         init_step.name = "Initialize Hardware"
-        sub_seq.insert_step(init_step, 0, StepGroup.Main)
+        subsequence.insert_step(init_step, index=0, group=StepGroup.Main)
 
         print(f"Created sequence with {main_sequence.get_num_steps()} steps:")
         for i in range(main_sequence.get_num_steps()):
-            s = main_sequence.get_step(i)
-            po_s = s.as_property_object()
+            s: Step = main_sequence.get_step(index=i)
+            po_s: PropertyObject = s.as_property_object()
 
             print(f"  [{i}] {s.name}")
             print(f"      Limits: Low={po_s['Limits.Low']}, High={po_s['Limits.High']}")
             print(f"      Precond: {s.precondition}")
 
-        sequence_file.save(str(output_path))
-        LATEST_POINTER.write_text(str(output_path), encoding="utf-8")
+        sequence_file.save(path=str(object=output_path))
+        LATEST_POINTER.write_text(data=str(object=output_path), encoding="utf-8")
         print(f"\nSaved sequence file to {output_path}")
         print(f"Pointer written to {LATEST_POINTER}")
 

{py_teststand-0.2.0 → py_teststand-0.2.1}/examples/step_insert.py

@@ -25,7 +25,7 @@ from __future__ import annotations
 import tempfile
 from pathlib import Path
 
-from py_teststand import AdapterKeyName, Engine, Error, RunMode, StepGroup
+from py_teststand import AdapterKeyName, Engine, Error, RunMode, Step, StepGroup
 
 
 def _new_vi_call_step(
@@ -35,7 +35,7 @@ def _new_vi_call_step(
     project_path: str = "",
     icon: str = "",
     run_mode: RunMode = RunMode.Normal,
-):
+) -> Step:
     """Build a configured LabVIEW VI-call step ready for insertion."""
     step = engine.new_step(
         adapter_key_name=AdapterKeyName.LVAdapterKeyName,

{py_teststand-0.2.0 → py_teststand-0.2.1}/examples/ui_messages_handle.py

@@ -23,7 +23,8 @@ plus the execution id that identifies who posted.
 
 from __future__ import annotations
 
-from py_teststand import AdapterKeyName, Engine, StepGroup, UIMessageCode
+from py_teststand import AdapterKeyName, Engine, StepGroup, UIMessage, UIMessageCode
+from py_teststand.sequence.sequence import Sequence
 
 STAGE_MESSAGE = int(UIMessageCode.UserMessageBase) + 1
 PROGRESS_MESSAGE = int(UIMessageCode.UserMessageBase) + 2
@@ -37,7 +38,7 @@ POST_FOR_THREAD = (
 )
 
 
-def _add_statement_step(engine, sequence, name, expression):
+def _add_statement_step(engine: Engine, sequence: Sequence, name: str, expression: str) -> None:
     """Append a Statement step whose expression runs when the step executes."""
     step = engine.new_step(AdapterKeyName.NoneAdapterKeyName, "Statement")
     step.name = name
@@ -48,7 +49,7 @@ def _add_statement_step(engine, sequence, name, expression):
 def main() -> None:
     received = []
 
-    def on_stage(message) -> None:
+    def on_stage(message: UIMessage) -> None:
         execution = message.execution
         received.append(
             f"stage message    (execution {execution.id if execution else '?'}): "
@@ -56,7 +57,7 @@ def main() -> None:
             f"synchronous={message.is_synchronous}"
         )
 
-    def on_progress(message) -> None:
+    def on_progress(message: UIMessage) -> None:
         received.append(
             f"progress message (thread-posted): "
             f"numeric={message.numeric_data} string={message.string_data!r} "