py-teststand 0.1.0__tar.gz

py_teststand-0.1.0/.gitignore

@@ -0,0 +1,37 @@
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+*.swp
+*.swo
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.venv
+.venv/
+venv/
+env/
+ENV/
+dist/
+build/
+*.egg-info/
+*.egg
+.eggs/
+.ruff_cache/
+.mypy_cache/
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.nox/
+.tox/
+
+# Dynamic Generated Documentation (#TODO)
+/site/
+/public/
+docs/
+/tmp/
+/temp/
+scratch/
+*.log

py_teststand-0.1.0/.python-version

@@ -0,0 +1 @@
+3.8

py_teststand-0.1.0/LICENSE

@@ -0,0 +1,23 @@
+SPDX-License-Identifier: MIT
+
+MIT License
+
+Copyright (c) 2026 Dominik Rajchel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

py_teststand-0.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: py-teststand
+Version: 0.1.0
+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
+Author: Dominik Rajchel
+License: MIT
+License-File: LICENSE
+Keywords: automation,com,manufacturing,national-instruments,ni,python,pywin32,station-provisioning,test-automation,teststand,windows
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: Microsoft :: Windows :: Windows 7
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Classifier: Typing :: Typed
+Requires-Python: >=3.8.20
+Requires-Dist: pywin32>=305; sys_platform == 'win32'
+Requires-Dist: typing-extensions>=4.0.0
+Description-Content-Type: text/markdown
+
+# py-teststand
+
+Community object-oriented Python 3 bindings 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** — Consider as experimental. Interfaces may change between releases without prior notice.
+
+## Overview
+
+`py-teststand` exposes the [TestStand™ COM API](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html) as an object-oriented Python interface via [pywin32](https://pypi.org/project/pywin32/).
+
+### Name
+
+The package is named `py-teststand` (with a dash) to avoid naming collision with the [pytest testing framework](https://pytest.org/) and for easier relation to TestStand™ test executive.
+
+[![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)
+[![Build Status](https://github.com/TheDomcio/py-teststand/actions/workflows/tests.yml/badge.svg)](https://github.com/TheDomcio/py-teststand/actions)
+
+---
+
+## Project Status
+
+`py-teststand` is a hobby project maintained on a best-effort basis
+and is **not** under active full-time development (for first release).
+There are no guaranteed scheduled release cadences or support (but feel free to contact).
+
+That said:
+
+- **Bug reports and feature requests** are welcome via [GitHub Issues](https://github.com/TheDomcio/py-teststand/issues).
+- **Pull requests** are welcomed and reviewed. If you are working with the TestStand™ COM API and have improvements, fixes, or additional bindings, contributions are encouraged.
+
+If you encounter a missing TestStand™ binding, an incorrect type annotation, or unexpected TestStand™ COM dispatch behavior, opening an issue with a reproducible case is the most effective way to get it addressed, I will try to investigate and find solution as fast as possible.
+
+---
+
+## Implementation Notes
+
+### Type Library Generation
+
+Python class stubs and interface definitions are generated from the TestStand™ [COM Type Library](https://learn.microsoft.com/en-us/windows/win32/com/type-libraries-and-the-component-object-model) (`.tlb`) using [pywin32's](https://pypi.org/project/pywin32/) [`makepy`](https://github.com/mhammond/pywin32/blob/main/com/win32com/client/makepy.py) utility. The generated output is cached as a [pywin32 dispatch cache](https://mhammond.github.io/pywin32/) module and checked into the repository, meaning a live TestStand™ installation is not required at import time — only at runtime when TestStand™ COM objects are actually instantiated.
+
+The generation process follows this pipeline:
+
+1. **TLB introspection** — `makepy` reads the registered TestStand™ COM type library via the Windows registry and reflects all exposed interfaces, `CoClass` definitions, enumerations, and dispatch IDs.
+2. **Cache dump** — The reflected TestStand™ metadata is serialized into a Python module stored under `win32com/gen_py/`, keyed by the TestStand™ type library GUID and version. This cache is committed to the repository so users do not need to run `makepy` themselves.
+3. **Wrapper generation** — `py-teststand` classes are authored on top of the cached TestStand™ dispatch definitions, adding Python type annotations and translating raw COM `VARIANT` and `IDispatch` returns into typed Python objects where applicable.
+
+This approach means the bindings target a specific version of the TestStand™ type library. Compatibility across TestStand™ engine versions is maintained by keeping the wrapper surface aligned with stable, long-lived TestStand™ COM interfaces present across the supported version range.
+
+---
+
+## Design Goals
+
+- **Python 3.8 minimum** — Python 3.8 (uv supports / distributes even 3.8.20) is the last CPython release with official Windows 7 support. Many manufacturing and test environments run long-lifecycle OS images on air-gapped station hardware where upgrading the OS is not feasible on short timescales. Maintaining a 3.8-compatible codebase allows incremental adoption of Python-based automation on existing TestStand™ station hardware without requiring a platform migration first.
+- **TestStand™ station options as code** — The [TestStand™ Station Options](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html) object model is fully exposed, allowing TestStand™ search directories, model paths, station globals, and result processing configuration to be read and written programmatically. This makes TestStand™ station configuration reproducible and suitable for provisioners such as [Ansible](https://www.ansible.com/), [Chef](https://www.chef.io/), or custom deployment scripts — replacing manual point-and-click TestStand™ setup with version-controlled configuration.
+- **No TestStand™ documentation mirroring** — The library does **not** duplicate or paraphrase the [official TestStand™ API reference](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html) in its docstrings, as eproducing NI's documentation would introduce a secondary source that diverges from the official TestStand™ spec as new versions evolve, creating a risk of misinformation, therefore for authoritative descriptions of TestStand™ COM objects, properties, method parameters, and return value semantics etc. refer directly to the [TestStand™ API Reference](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html).
+
+---
+
+## Technical Stack
+
+| Tool                                             | Purpose                                                     |
+| :----------------------------------------------- | :---------------------------------------------------------- |
+| [**uv**](https://github.com/astral-sh/uv)        | Python package and project manager                          |
+| [**ty**](https://github.com/astral-sh/ty)        | Static type checker for interface validation                |
+| [**ruff**](https://github.com/astral-sh/ruff)    | Linter and code formatter                                   |
+| [**pytest**](https://pytest.org/)                | Unit and integration test runner                            |
+| [**pywin32**](https://pypi.org/project/pywin32/) | Windows COM dispatch layer and TestStand™ TLB introspection |
+
+---
+
+## Compatibility
+
+| Component                                                                                                               | Versions     |
+| :---------------------------------------------------------------------------------------------------------------------- | :----------- |
+| [**Windows**](https://www.microsoft.com/en-us/windows)                                                                  | 7 — 11       |
+| [**Python**](https://www.python.org/downloads/)                                                                         | 3.8 — 3.14   |
+| [**TestStand™**](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html) | 2016 — 2026+ |
+
+> Older TestStand™ engine versions may also work if the underlying TestStand™ COM interfaces have not changed, but they were not explicitly tested.
+
+---
+
+## Features
+
+- **Pythonic attribute access** — TestStand™ COM properties are accessible via standard Python attribute notation instead of raw `Dispatch` calls.
+- **Type annotations** — All public members carry type hints compatible with [ty](https://github.com/astral-sh/ty).
+- **TestStand™ station options provisioning** — Read and write TestStand™ station-level configuration suitable for use in automated deployment pipelines (like test stations install scripts).
+- **Minimal binding surface** — No behavior is added beyond what the TestStand™ COM layer provides. Edge cases and error conditions follow the TestStand™ COM API contract documented in the [official TestStand™ reference](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html). The binding layer is intentionally lightweight and not overcommented, signatures and object hierarchy map directly to the TestStand™ COM API without adding abstraction or reinterpreting behavior (but modules themselves are sorted under domains for easier management).
+- **No live TestStand™ installation required at import time** — The committed pywin32 dispatch cache allows the library to be imported and partially used (type checking, configuration building) without a TestStand™ installation present.
+
+---
+
+## Installation
+
+### [pip](https://pip.pypa.io/en/stable/)
+
+```powershell
+pip install py-teststand
+```
+
+### [uv](https://github.com/astral-sh/uv)
+
+```powershell
+uv pip install 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
+
+TestStand™ is a registered trademark of [National Instruments Corporation](https://www.ni.com/). Refer to [NI's TestStand™ licensing options](https://www.ni.com/docs/en-US/bundle/teststand/page/teststand-licensing-options.html) for information on required licenses to operate the TestStand™ engine.
+
+`py-teststand` is an independent community project and is not affiliated with, endorsed by, or maintained by National Instruments or its parent company [Emerson](https://www.emerson.com/). References to the TestStand™ API are made solely for interoperability purposes.

py_teststand-0.1.0/README.md

@@ -0,0 +1,121 @@
+# py-teststand
+
+Community object-oriented Python 3 bindings 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** — Consider as experimental. Interfaces may change between releases without prior notice.
+
+## Overview
+
+`py-teststand` exposes the [TestStand™ COM API](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html) as an object-oriented Python interface via [pywin32](https://pypi.org/project/pywin32/).
+
+### Name
+
+The package is named `py-teststand` (with a dash) to avoid naming collision with the [pytest testing framework](https://pytest.org/) and for easier relation to TestStand™ test executive.
+
+[![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)
+[![Build Status](https://github.com/TheDomcio/py-teststand/actions/workflows/tests.yml/badge.svg)](https://github.com/TheDomcio/py-teststand/actions)
+
+---
+
+## Project Status
+
+`py-teststand` is a hobby project maintained on a best-effort basis
+and is **not** under active full-time development (for first release).
+There are no guaranteed scheduled release cadences or support (but feel free to contact).
+
+That said:
+
+- **Bug reports and feature requests** are welcome via [GitHub Issues](https://github.com/TheDomcio/py-teststand/issues).
+- **Pull requests** are welcomed and reviewed. If you are working with the TestStand™ COM API and have improvements, fixes, or additional bindings, contributions are encouraged.
+
+If you encounter a missing TestStand™ binding, an incorrect type annotation, or unexpected TestStand™ COM dispatch behavior, opening an issue with a reproducible case is the most effective way to get it addressed, I will try to investigate and find solution as fast as possible.
+
+---
+
+## Implementation Notes
+
+### Type Library Generation
+
+Python class stubs and interface definitions are generated from the TestStand™ [COM Type Library](https://learn.microsoft.com/en-us/windows/win32/com/type-libraries-and-the-component-object-model) (`.tlb`) using [pywin32's](https://pypi.org/project/pywin32/) [`makepy`](https://github.com/mhammond/pywin32/blob/main/com/win32com/client/makepy.py) utility. The generated output is cached as a [pywin32 dispatch cache](https://mhammond.github.io/pywin32/) module and checked into the repository, meaning a live TestStand™ installation is not required at import time — only at runtime when TestStand™ COM objects are actually instantiated.
+
+The generation process follows this pipeline:
+
+1. **TLB introspection** — `makepy` reads the registered TestStand™ COM type library via the Windows registry and reflects all exposed interfaces, `CoClass` definitions, enumerations, and dispatch IDs.
+2. **Cache dump** — The reflected TestStand™ metadata is serialized into a Python module stored under `win32com/gen_py/`, keyed by the TestStand™ type library GUID and version. This cache is committed to the repository so users do not need to run `makepy` themselves.
+3. **Wrapper generation** — `py-teststand` classes are authored on top of the cached TestStand™ dispatch definitions, adding Python type annotations and translating raw COM `VARIANT` and `IDispatch` returns into typed Python objects where applicable.
+
+This approach means the bindings target a specific version of the TestStand™ type library. Compatibility across TestStand™ engine versions is maintained by keeping the wrapper surface aligned with stable, long-lived TestStand™ COM interfaces present across the supported version range.
+
+---
+
+## Design Goals
+
+- **Python 3.8 minimum** — Python 3.8 (uv supports / distributes even 3.8.20) is the last CPython release with official Windows 7 support. Many manufacturing and test environments run long-lifecycle OS images on air-gapped station hardware where upgrading the OS is not feasible on short timescales. Maintaining a 3.8-compatible codebase allows incremental adoption of Python-based automation on existing TestStand™ station hardware without requiring a platform migration first.
+- **TestStand™ station options as code** — The [TestStand™ Station Options](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html) object model is fully exposed, allowing TestStand™ search directories, model paths, station globals, and result processing configuration to be read and written programmatically. This makes TestStand™ station configuration reproducible and suitable for provisioners such as [Ansible](https://www.ansible.com/), [Chef](https://www.chef.io/), or custom deployment scripts — replacing manual point-and-click TestStand™ setup with version-controlled configuration.
+- **No TestStand™ documentation mirroring** — The library does **not** duplicate or paraphrase the [official TestStand™ API reference](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html) in its docstrings, as eproducing NI's documentation would introduce a secondary source that diverges from the official TestStand™ spec as new versions evolve, creating a risk of misinformation, therefore for authoritative descriptions of TestStand™ COM objects, properties, method parameters, and return value semantics etc. refer directly to the [TestStand™ API Reference](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html).
+
+---
+
+## Technical Stack
+
+| Tool                                             | Purpose                                                     |
+| :----------------------------------------------- | :---------------------------------------------------------- |
+| [**uv**](https://github.com/astral-sh/uv)        | Python package and project manager                          |
+| [**ty**](https://github.com/astral-sh/ty)        | Static type checker for interface validation                |
+| [**ruff**](https://github.com/astral-sh/ruff)    | Linter and code formatter                                   |
+| [**pytest**](https://pytest.org/)                | Unit and integration test runner                            |
+| [**pywin32**](https://pypi.org/project/pywin32/) | Windows COM dispatch layer and TestStand™ TLB introspection |
+
+---
+
+## Compatibility
+
+| Component                                                                                                               | Versions     |
+| :---------------------------------------------------------------------------------------------------------------------- | :----------- |
+| [**Windows**](https://www.microsoft.com/en-us/windows)                                                                  | 7 — 11       |
+| [**Python**](https://www.python.org/downloads/)                                                                         | 3.8 — 3.14   |
+| [**TestStand™**](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html) | 2016 — 2026+ |
+
+> Older TestStand™ engine versions may also work if the underlying TestStand™ COM interfaces have not changed, but they were not explicitly tested.
+
+---
+
+## Features
+
+- **Pythonic attribute access** — TestStand™ COM properties are accessible via standard Python attribute notation instead of raw `Dispatch` calls.
+- **Type annotations** — All public members carry type hints compatible with [ty](https://github.com/astral-sh/ty).
+- **TestStand™ station options provisioning** — Read and write TestStand™ station-level configuration suitable for use in automated deployment pipelines (like test stations install scripts).
+- **Minimal binding surface** — No behavior is added beyond what the TestStand™ COM layer provides. Edge cases and error conditions follow the TestStand™ COM API contract documented in the [official TestStand™ reference](https://www.ni.com/docs/en-US/bundle/teststand-api-reference/page/tshelp/teststand-api-reference.html). The binding layer is intentionally lightweight and not overcommented, signatures and object hierarchy map directly to the TestStand™ COM API without adding abstraction or reinterpreting behavior (but modules themselves are sorted under domains for easier management).
+- **No live TestStand™ installation required at import time** — The committed pywin32 dispatch cache allows the library to be imported and partially used (type checking, configuration building) without a TestStand™ installation present.
+
+---
+
+## Installation
+
+### [pip](https://pip.pypa.io/en/stable/)
+
+```powershell
+pip install py-teststand
+```
+
+### [uv](https://github.com/astral-sh/uv)
+
+```powershell
+uv pip install 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
+
+TestStand™ is a registered trademark of [National Instruments Corporation](https://www.ni.com/). Refer to [NI's TestStand™ licensing options](https://www.ni.com/docs/en-US/bundle/teststand/page/teststand-licensing-options.html) for information on required licenses to operate the TestStand™ engine.
+
+`py-teststand` is an independent community project and is not affiliated with, endorsed by, or maintained by National Instruments or its parent company [Emerson](https://www.emerson.com/). References to the TestStand™ API are made solely for interoperability purposes.

py_teststand-0.1.0/examples/build_sequence.py

@@ -0,0 +1,87 @@
+"""Build a TestStand sequence file from scratch with NumericLimitTest steps.
+
+Creates a new sequence file, populates ``MainSequence`` with two
+NumericLimitTest steps (a temperature check and a voltage monitor) whose
+high/low limits are configured through the underlying
+``PropertyObject``, adds a ``CustomSubsequence`` containing an ``Action``
+step so downstream examples (``insert_step.py``) have something to target,
+prints a verification summary of the constructed sequence, and writes
+the file to a temp directory.
+
+Demonstrates:
+- Creating sequence files and adding subsequences with ``new_sequence``
+- Building steps with ``Engine.new_step`` (no adapter / None adapter)
+- Setting standard step properties (``name``, ``precondition``, ``record_result``)
+- Reaching into nested TestStand properties (``Limits.High`` / ``Limits.Low``)
+  via ``step.as_property_object()``
+- Inserting steps into a specific ``StepGroup`` at a chosen index
+"""
+
+from __future__ import annotations
+
+import tempfile
+import uuid
+from pathlib import Path
+
+from py_teststand import Engine
+from py_teststand.sequence.step_group import StepGroup
+
+ROOT_TEMP_DIR = Path(tempfile.gettempdir()) / "py-teststand"
+LATEST_POINTER = ROOT_TEMP_DIR / "latest_sequence.txt"
+
+
+def main() -> None:
+    run_dir = ROOT_TEMP_DIR / uuid.uuid4().hex
+    run_dir.mkdir(parents=True, exist_ok=True)
+    output_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")
+
+        first_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["Limits.High"] = 85.0
+        first_step_property_object["Limits.Low"] = 15.0
+
+        main_sequence.insert_step(first_step, 0, StepGroup.Main)
+
+        second_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["Limits.High"] = 5.25
+        second_step_property_object["Limits.Low"] = 4.75
+
+        main_sequence.insert_step(second_step, 1, StepGroup.Main)
+
+        sub_seq = engine.new_sequence()
+        sub_seq.name = "CustomSubsequence"
+        sequence_file.insert_sequence(sub_seq)
+
+        init_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)
+
+        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()
+
+            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")
+        print(f"\nSaved sequence file to {output_path}")
+        print(f"Pointer written to {LATEST_POINTER}")
+
+
+if __name__ == "__main__":
+    main()

py_teststand-0.1.0/examples/create_variables.py

@@ -0,0 +1,108 @@
+"""Create string variables across every TestStand variable scope.
+
+Opens the sequence file produced by ``build_sequence.py`` and populates it
+with new string variables across the four standard TestStand scopes:
+
+- **Sequence Locals** — temporary per-call storage on ``MainSequence``
+  (``Locals.OperatorName``).
+- **Sequence Parameters** — caller-supplied inputs on ``MainSequence``
+  (``Parameters.DUTSerial``).
+- **File Globals** — values shared across every sequence in the file
+  (``FileGlobals.BatchID``).
+- **Station Globals** — values shared across every sequence file run on
+  this station, persisted via ``Engine.commit_globals_to_disk``
+  (``StationInfo.StationName``).
+
+Also adds a second subsequence ``MeasurementRoutine`` with its own
+parameter and local so the example shows how variables are scoped per
+sequence rather than per file.
+
+Demonstrates:
+- Creating sub-properties of arbitrary type via
+  ``PropertyObject.new_sub_property`` + ``PropValType``
+- Reading and writing values with ``PropertyObject.__setitem__`` / ``__getitem__``
+- Reaching ``Sequence.locals`` / ``Sequence.parameters`` /
+  ``SequenceFile.file_globals`` / ``Engine.globals``
+- Adding subsequences with ``SequenceFile.new_sequence``
+- Committing station-globals changes to disk
+"""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from py_teststand import Engine
+from py_teststand.property.property_object import PropValType
+
+
+def _ensure_string_var(container, name: str, value: str) -> None:
+    """Create a scalar string sub-property and assign it if it does not exist."""
+    if not container.exists(name, 0):
+        container.new_sub_property(name, PropValType.String, False, "")
+    container[name] = value
+
+
+ROOT_TEMP_DIR = Path(tempfile.gettempdir()) / "py-teststand"
+LATEST_POINTER = ROOT_TEMP_DIR / "latest_sequence.txt"
+
+
+def main() -> None:
+    if not LATEST_POINTER.exists():
+        print(f"Error: Pointer file not found at {LATEST_POINTER}")
+        print("Run build_sequence.py first.")
+        return
+
+    sequence_path = Path(LATEST_POINTER.read_text(encoding="utf-8").strip())
+
+    if not sequence_path.exists():
+        print(f"Error: Sequence file not found at {sequence_path}")
+        return
+
+    with Engine() as engine:
+        with engine.get_sequence_file(str(sequence_path)) as seq_file:
+            main_sequence = seq_file.get_sequence_by_name("MainSequence")
+
+            with main_sequence.locals as main_locals:
+                _ensure_string_var(main_locals, "OperatorName", "Alice")
+
+            with main_sequence.parameters as main_params:
+                _ensure_string_var(main_params, "DUTSerial", "SN-000000")
+
+            with seq_file.file_globals as file_globals:
+                _ensure_string_var(file_globals, "BatchID", "BATCH-2026-Q2-001")
+
+            measurement_seq = seq_file.new_sequence("MeasurementRoutine")
+            with measurement_seq.parameters as measurement_params:
+                _ensure_string_var(measurement_params, "ChannelLabel", "CH-A")
+            with measurement_seq.locals as measurement_locals:
+                _ensure_string_var(measurement_locals, "LastReading", "")
+
+            seq_file.save()
+
+            print("Variables created:")
+            with main_sequence.locals as ml:
+                print(f"  MainSequence.Locals.OperatorName     = {ml['OperatorName']!r}")
+            with main_sequence.parameters as mp:
+                print(f"  MainSequence.Parameters.DUTSerial    = {mp['DUTSerial']!r}")
+            with seq_file.file_globals as fg:
+                print(f"  FileGlobals.BatchID                  = {fg['BatchID']!r}")
+            with measurement_seq.parameters as msp:
+                print(f"  MeasurementRoutine.Parameters.Channel= {msp['ChannelLabel']!r}")
+            with measurement_seq.locals as msl:
+                print(f"  MeasurementRoutine.Locals.LastReading= {msl['LastReading']!r}")
+
+        with engine.globals as station_globals:
+            if not station_globals.exists("StationInfo", 0):
+                station_globals.new_sub_property("StationInfo", PropValType.Container, False, "")
+            station_info = station_globals.get_property_object("StationInfo", 0)
+            assert station_info is not None
+            with station_info as info:
+                _ensure_string_var(info, "StationName", "STATION_01")
+                print(f"  StationGlobals.StationInfo.StationName = {info['StationName']!r}")
+
+        engine.commit_globals_to_disk(prompt_on_save_conflicts=False)
+
+
+if __name__ == "__main__":
+    main()

py_teststand-0.1.0/examples/execute_subsequence.py

@@ -0,0 +1,58 @@
+"""Build and run a sequence end-to-end using only built-in TestStand step types.
+
+Creates a fresh in-memory sequence file, appends three ``Action`` steps to
+``MainSequence`` using the None adapter (no external code module), starts an
+execution, waits for it to finish, and walks the resulting ``ResultList`` to
+print the recorded step name and status for each step.
+
+The example focuses on the execution + result reporting surface — no code
+modules, no LabVIEW/DLL adapters — so it can be exercised on any TestStand
+engine without external dependencies.
+"""
+
+from __future__ import annotations
+
+from py_teststand import Engine
+from py_teststand.core.engine import AdapterKeyName
+from py_teststand.sequence.step_group import StepGroup
+
+
+def main() -> None:
+    with Engine() as engine:
+        sequence_file = engine.new_sequence_file()
+        main_sequence = sequence_file.get_sequence_by_name("MainSequence")
+
+        for name in ("Initialize", "Run Test", "Cleanup"):
+            step = engine.new_step(AdapterKeyName.NoneAdapterKeyName, "Action")
+            step.name = name
+            step.record_result = True
+            main_sequence.insert_step(step, main_sequence.get_num_steps(), StepGroup.Main)
+
+        with engine.new_execution(sequence_file, "MainSequence") as execution:
+            execution.wait_for_end_ex(-1)
+
+            results = execution.result_object
+            if results is None:
+                return
+
+            with results as res:
+                if not res.exists("ResultList", 0):
+                    print("No results recorded.")
+                    return
+
+                result_list_obj = res.get_property_object("ResultList", 0)
+                if result_list_obj is None:
+                    return
+
+                with result_list_obj as result_list:
+                    for step_result in result_list:
+                        if step_result is None:
+                            continue
+                        with step_result as sr:
+                            name = sr.get_val_string("TS.StepName", 0)
+                            status = sr.get_val_string("Status", 0)
+                            print(f"{name}: {status}")
+
+
+if __name__ == "__main__":
+    main()