revitdevtool-pytest 0.4.0__tar.gz → 0.5.0__tar.gz

{revitdevtool_pytest-0.4.0 → revitdevtool_pytest-0.5.0}/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.5.0] - 2026-10-12
+
+### Changed
+
+- AutoCAD-family discovery reads `HKLM\SOFTWARE\Autodesk\AutoCAD\*\InstalledProducts`.
+  The default value is the install directory. The subkey is the product code
+  (`ACAD`, `C3D`, `PLNT3D`, `ACA`, `ACADM`, `MEP`, `ACADE`, `MAP`). The year is
+  the last token of the folder name (`AutoCAD 2026`, `Civil 3D 2026`), at or
+  above 2022. The filesystem fallback applies only to `autocad`.
+- Revit discovery lives in its own resolver: `Autodesk Revit {version}` in the
+  registry, then `Revit {version}` on disk.
+- `host_name` is the only key. The names are the lowercase `HostApp` values
+  (`Civil3D` → `civil3d`) and are declared once in `constants.py`.
+  `HOST_REGISTRY` and the AutoCAD product-code map both use those constants.
+- `HostConfig` keeps `pipe_prefix`, `exe_name`, and `launch_args`. Install
+  paths stay in the resolver for that host.
+- Requires `pytest>=9.1.1,<10` and `pywin32>=312`, matching the host pixi runtime.
+
+### Removed
+
+- `find_host_executable()`. Callers use `find_executable(host_name, version)`.
+- `HostConfig.acad_product_code` and `is_acad_family()`.
+- Registry product-id lookup (`ACAD-XXNN`, `UPIRELEASE`, `GlobUPILocation`,
+  `AcadLocation`).
+
+### Fixed
+
+- A local plugin test run no longer swallows pytest's own test loop when the
+  session has no remote results.
+
 ## [0.4.0] - 2026-08-31
 
 ### Added

{revitdevtool_pytest-0.4.0 → revitdevtool_pytest-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: revitdevtool_pytest
-Version: 0.4.0
+Version: 0.5.0
 Summary: pytest plugin for testing CAD/BIM API code inside host applications via RevitDevTool Named Pipe bridge
 Project-URL: Homepage, https://github.com/trgiangv/RevitDevTool.PyTest
 Project-URL: Repository, https://github.com/trgiangv/RevitDevTool.PyTest
@@ -21,8 +21,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
-Requires-Dist: pytest>=9.0
-Requires-Dist: pywin32>=311
+Requires-Dist: pytest<10,>=9.1.1
+Requires-Dist: pywin32>=312
 Description-Content-Type: text/markdown
 
 # RevitDevTool.PyTest
@@ -46,13 +46,15 @@ uv add revitdevtool_pytest
 | Requirement | Version |
 |---|---|
 | Python | >= 3.10 |
-| pytest | >= 9.0 |
+| pytest | >= 9.1.1, < 10 |
 | pywin32 | >= 311 |
 | OS | Windows (Named Pipes) |
 | Host | [RevitDevTool](https://github.com/trgiangv/RevitDevTool) add-in loaded |
 
 ## Supported hosts
 
+`host_name` is the lowercase name of the RevitDevTool `HostApp` enum (`Revit` → `revit`, `Civil3D` → `civil3d`). Each name is declared once in `src/revitdevtool_pytest/constants.py`. `HOST_REGISTRY` and the AutoCAD `InstalledProducts` map (`ACAD`, `C3D`, `PLNT3D`, …) both use those constants as keys. Do not add a second spelling for the same host.
+
 ### Supported today
 
 | `host_name` | Application | Pipe prefix |

{revitdevtool_pytest-0.4.0 → revitdevtool_pytest-0.5.0}/README.md

@@ -19,13 +19,15 @@ uv add revitdevtool_pytest
 | Requirement | Version |
 |---|---|
 | Python | >= 3.10 |
-| pytest | >= 9.0 |
+| pytest | >= 9.1.1, < 10 |
 | pywin32 | >= 311 |
 | OS | Windows (Named Pipes) |
 | Host | [RevitDevTool](https://github.com/trgiangv/RevitDevTool) add-in loaded |
 
 ## Supported hosts
 
+`host_name` is the lowercase name of the RevitDevTool `HostApp` enum (`Revit` → `revit`, `Civil3D` → `civil3d`). Each name is declared once in `src/revitdevtool_pytest/constants.py`. `HOST_REGISTRY` and the AutoCAD `InstalledProducts` map (`ACAD`, `C3D`, `PLNT3D`, …) both use those constants as keys. Do not add a second spelling for the same host.
+
 ### Supported today
 
 | `host_name` | Application | Pipe prefix |

{revitdevtool_pytest-0.4.0 → revitdevtool_pytest-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "revitdevtool_pytest"
-version = "0.4.0"
+version = "0.5.0"
 description = "pytest plugin for testing CAD/BIM API code inside host applications via RevitDevTool Named Pipe bridge"
 readme = "README.md"
 license = "MIT"
@@ -24,7 +24,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Topic :: Software Development :: Testing",
 ]
-dependencies = ["pytest>=9.0", "pywin32>=311"]
+dependencies = ["pytest>=9.1.1,<10", "pywin32>=312"]
 
 [project.entry-points."pytest11"]
 revitdevtool = "revitdevtool_pytest.plugin"

{revitdevtool_pytest-0.4.0 → revitdevtool_pytest-0.5.0}/src/revitdevtool_pytest/__init__.py

@@ -1,3 +1,3 @@
 """RevitDevTool.PyTest: Run pytest tests inside a live Autodesk host (Revit, AutoCAD, Civil3D, etc.) via Named Pipe bridge."""
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"

{revitdevtool_pytest-0.4.0 → revitdevtool_pytest-0.5.0}/src/revitdevtool_pytest/connection.py

@@ -17,16 +17,17 @@ import pytest
 
 from .bridge import HostBridge
 from .constants import (
+    DEFAULT_HOST,
     EXIT_CODE_CONFIG_ERROR,
     PLUGIN_NAME,
     get_host_config,
 )
 from .discovery import (
-    find_host_executable,
     find_host_pipes,
     start_host,
     wait_for_host_pipe,
 )
+from .hosts import find_executable
 
 if TYPE_CHECKING:
     from .dialog_resolver import StartupDialogResolver
@@ -122,7 +123,7 @@ class LaunchResult:
 
 
 def auto_launch(host_name: str, version: str, launch_timeout_s: float) -> LaunchResult:
-    if find_host_executable(host_name, version) is None:
+    if find_executable(host_name, version) is None:
         pytest.exit(
             f"{PLUGIN_NAME}: {host_name} {version} is not installed on this machine.",
             returncode=EXIT_CODE_CONFIG_ERROR,
@@ -174,7 +175,7 @@ def find_instance_by_pid(
     return None
 
 
-def is_process_alive(process_id: int, host_name: str = "revit") -> bool:
+def is_process_alive(process_id: int, host_name: str = DEFAULT_HOST) -> bool:
     """Check if process is alive AND matches the expected executable name.
 
     Plain PID-alive checks are vulnerable to Windows PID reuse.

{revitdevtool_pytest-0.4.0 → revitdevtool_pytest-0.5.0}/src/revitdevtool_pytest/constants.py

@@ -19,7 +19,21 @@ OPT_PIPE: Final = "host_pipe"
 OPT_FORCE_LAUNCH: Final = "force_launch"
 OPT_LAUNCH_TIMEOUT: Final = "launch_timeout"
 
-DEFAULT_HOST: Final = "revit"
+# Lowercase form of the RevitDevTool HostApp enum
+REVIT: Final = "revit"  # HostApp.Revit
+AUTOCAD: Final = "autocad"  # HostApp.AutoCad
+CIVIL3D: Final = "civil3d"  # HostApp.Civil3D
+PLANT3D: Final = "plant3d"  # HostApp.Plant3D
+ACAD_ARCH: Final = "acadarch"  # HostApp.AcadArch
+ACAD_MECH: Final = "acadmech"  # HostApp.AcadMech
+ACAD_ELEC: Final = "acadelec"  # HostApp.AcadElec
+ACAD_MEP: Final = "acadmep"  # HostApp.AcadMep
+ACAD_MAP3D: Final = "acadmap3d"  # HostApp.AcadMap3D
+NAVISWORKS: Final = "navisworks"  # HostApp.Navisworks
+RHINO: Final = "rhino"  # HostApp.Rhino
+TEKLA: Final = "tekla"  # HostApp.Tekla
+
+DEFAULT_HOST: Final = REVIT
 DEFAULT_TEST_TIMEOUT_S: Final = 60.0
 DEFAULT_LAUNCH_TIMEOUT_S: Final = 120.0
 DEFAULT_CONNECT_TIMEOUT_MS: Final = 30_000
@@ -65,93 +79,64 @@ class HostConfig:
     pipe_prefix: str
     exe_name: str | None = None
     launch_args: list[str] = field(default_factory=list)
-    registry_key: str | None = None
-    registry_value: str | None = None
-    default_dir_pattern: str | None = None
-    acad_product_ids: list[str] | None = None
 
 
-ACAD_REGISTRY_ROOT: Final = r"SOFTWARE\Autodesk\AutoCAD"
 _ACAD_EXE: Final = "acad.exe"
-_ACAD_DIR: Final = "AutoCAD {version}"
 _ACAD_ARGS: Final = ["/nologo"]
 
 HOST_REGISTRY: dict[str, HostConfig] = {
-    # --- Autodesk Revit ---
-    "revit": HostConfig(
+    REVIT: HostConfig(
         pipe_prefix="Revit",
         exe_name="Revit.exe",
-        registry_key=r"SOFTWARE\Autodesk\Revit\Autodesk Revit {version}",
-        registry_value="InstallationLocation",
-        default_dir_pattern="Revit {version}",
         launch_args=["/nosplash"],
     ),
-    # --- Autodesk AutoCAD family ---
-    "autocad": HostConfig(
+    AUTOCAD: HostConfig(
         pipe_prefix="AutoCad",
         exe_name=_ACAD_EXE,
-        default_dir_pattern=_ACAD_DIR,
         launch_args=_ACAD_ARGS,
-        acad_product_ids=["01"],
     ),
-    "civil3d": HostConfig(
+    CIVIL3D: HostConfig(
         pipe_prefix="Civil3D",
         exe_name=_ACAD_EXE,
-        default_dir_pattern=_ACAD_DIR,
         launch_args=_ACAD_ARGS,
-        acad_product_ids=["00"],
     ),
-    "plant3d": HostConfig(
+    PLANT3D: HostConfig(
         pipe_prefix="Plant3D",
         exe_name=_ACAD_EXE,
-        default_dir_pattern=_ACAD_DIR,
         launch_args=_ACAD_ARGS,
-        acad_product_ids=["17"],
     ),
-    "acadarch": HostConfig(
+    ACAD_ARCH: HostConfig(
         pipe_prefix="AcadArch",
         exe_name=_ACAD_EXE,
-        default_dir_pattern=_ACAD_DIR,
         launch_args=_ACAD_ARGS,
-        acad_product_ids=["04"],
     ),
-    "acadmech": HostConfig(
+    ACAD_MECH: HostConfig(
         pipe_prefix="AcadMech",
         exe_name=_ACAD_EXE,
-        default_dir_pattern=_ACAD_DIR,
         launch_args=_ACAD_ARGS,
-        acad_product_ids=["05"],
     ),
-    "acadmep": HostConfig(
-        pipe_prefix="AcadMep",
+    ACAD_ELEC: HostConfig(
+        pipe_prefix="AcadElec",
         exe_name=_ACAD_EXE,
-        default_dir_pattern=_ACAD_DIR,
         launch_args=_ACAD_ARGS,
-        acad_product_ids=["06"],
     ),
-    "acadelec": HostConfig(
-        pipe_prefix="AcadElec",
+    ACAD_MEP: HostConfig(
+        pipe_prefix="AcadMep",
         exe_name=_ACAD_EXE,
-        default_dir_pattern=_ACAD_DIR,
         launch_args=_ACAD_ARGS,
-        acad_product_ids=["07"],
     ),
-    "acadmap3d": HostConfig(
+    ACAD_MAP3D: HostConfig(
         pipe_prefix="AcadMap3D",
         exe_name=_ACAD_EXE,
-        default_dir_pattern=_ACAD_DIR,
         launch_args=_ACAD_ARGS,
-        acad_product_ids=["02"],
     ),
-    # --- Autodesk Navisworks ---
-    "navisworks": HostConfig(
+    NAVISWORKS: HostConfig(
         pipe_prefix="Navisworks",
     ),
-    # --- Non-Autodesk hosts ---
-    "rhino": HostConfig(
+    RHINO: HostConfig(
         pipe_prefix="Rhino",
     ),
-    "tekla": HostConfig(
+    TEKLA: HostConfig(
         pipe_prefix="Tekla",
     ),
 }
@@ -169,9 +154,3 @@ def get_host_config(host_name: str) -> HostConfig:
     if config is not None:
         return config
     return HostConfig(pipe_prefix=host_name)
-
-
-def is_acad_family(host_name: str) -> bool:
-    """Return True if *host_name* is an AutoCAD-family product."""
-    cfg = HOST_REGISTRY.get(host_name.strip().lower())
-    return cfg is not None and cfg.acad_product_ids is not None

revitdevtool_pytest-0.5.0/src/revitdevtool_pytest/discovery.py

@@ -0,0 +1,117 @@
+"""Discover running host instances and launch hosts if needed.
+
+Executable lookup is delegated to ``hosts``. This module owns pipes and process start.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import time
+from dataclasses import dataclass
+
+from .constants import (
+    DEFAULT_LAUNCH_TIMEOUT_S,
+    DEFAULT_POLL_INTERVAL_S,
+    HOST_REGISTRY,
+    PIPE_DIR,
+    PIPE_PATTERN,
+    get_host_config,
+)
+from .hosts import find_executable
+
+_PIPE_RE = re.compile(PIPE_PATTERN)
+
+_PREFIX_TO_HOST: dict[str, str] = {
+    cfg.pipe_prefix.lower(): name for name, cfg in HOST_REGISTRY.items()
+}
+
+
+@dataclass(frozen=True, slots=True)
+class HostInstance:
+    pipe_name: str
+    host_name: str
+    version: str
+    process_id: int
+
+
+def find_host_pipes(host_name: str | None = None) -> list[HostInstance]:
+    """Scan Named Pipes for pipes matching ``{Host}_{Version}_{PID}``.
+
+    When *host_name* is given, only pipes whose prefix matches the
+    host's ``pipe_prefix`` are returned.
+    """
+    target_prefix: str | None = None
+    if host_name is not None:
+        cfg = get_host_config(host_name)
+        target_prefix = cfg.pipe_prefix.lower()
+
+    instances: list[HostInstance] = []
+    for name in _list_named_pipes():
+        m = _PIPE_RE.match(name)
+        if not m:
+            continue
+        prefix_raw = m.group(1)
+        prefix_lower = prefix_raw.lower()
+        if target_prefix is not None and prefix_lower != target_prefix:
+            continue
+        resolved = _PREFIX_TO_HOST.get(prefix_lower, prefix_raw)
+        instances.append(HostInstance(
+            pipe_name=name,
+            host_name=resolved,
+            version=m.group(2),
+            process_id=int(m.group(3)),
+        ))
+    return instances
+
+
+def start_host(host_name: str, version: str) -> int:
+    """Start the host application and return the spawned process id."""
+    cfg = get_host_config(host_name)
+    exe_path = find_executable(host_name, version)
+    if exe_path is None:
+        raise FileNotFoundError(f"{host_name} {version} installation not found.")
+
+    process = subprocess.Popen(  # noqa: S603
+        [exe_path, *cfg.launch_args],
+        creationflags=subprocess.DETACHED_PROCESS,
+    )
+    return int(process.pid)
+
+
+def wait_for_host_pipe(
+    host_name: str,
+    version: str | None = None,
+    timeout_s: float = DEFAULT_LAUNCH_TIMEOUT_S,
+    poll_interval_s: float = DEFAULT_POLL_INTERVAL_S,
+    process_id: int | None = None,
+) -> HostInstance | None:
+    """Block until a host pipe appears.
+
+    When *process_id* is given, wait for that exact process to register its pipe.
+    """
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        instances = find_host_pipes(host_name)
+        if process_id is not None:
+            match = next((i for i in instances if i.process_id == process_id), None)
+        elif not instances:
+            match = None
+        elif version is not None:
+            matches = [i for i in instances if i.version == version]
+            match = max(matches, key=lambda i: i.process_id) if matches else None
+        else:
+            match = max(instances, key=lambda i: (i.version, i.process_id))
+        if match is not None:
+            return match
+        time.sleep(poll_interval_s)
+    return None
+
+
+def _list_named_pipes() -> list[str]:
+    """Return base names of all Named Pipes visible to the current user."""
+    try:
+        return os.listdir(PIPE_DIR)
+    except OSError:
+        return []

revitdevtool_pytest-0.5.0/src/revitdevtool_pytest/hosts/__init__.py

@@ -0,0 +1,29 @@
+"""Per-host executable resolvers.
+
+``discovery`` finds pipes and launches a process. Which file to launch lives
+here, one module per install layout.
+"""
+
+from __future__ import annotations
+
+from ..constants import get_host_config
+from .acad import find_acad_executable, product_code
+from .revit import find_revit_executable, supports as revit_supports
+
+__all__ = ["find_executable"]
+
+
+def find_executable(host_name: str, version: str) -> str | None:
+    """Return the host executable for *version*, or None when it is not installed.
+
+    *host_name* is the only key. Hosts with no ``exe_name`` are pipe-only.
+    """
+    cfg = get_host_config(host_name)
+    if cfg.exe_name is None:
+        return None
+    key = host_name.strip().lower()
+    if revit_supports(key):
+        return find_revit_executable(version)
+    if product_code(key) is not None:
+        return find_acad_executable(key, cfg, version)
+    return None

revitdevtool_pytest-0.5.0/src/revitdevtool_pytest/hosts/acad.py

@@ -0,0 +1,127 @@
+"""AutoCAD-family installs via InstalledProducts (mirrors AcadPathResolver)."""
+
+from __future__ import annotations
+
+import os
+import winreg
+from pathlib import Path
+from typing import Final
+
+from ..constants import (
+    ACAD_ARCH,
+    ACAD_ELEC,
+    ACAD_MAP3D,
+    ACAD_MECH,
+    ACAD_MEP,
+    AUTOCAD,
+    CIVIL3D,
+    PLANT3D,
+    HostConfig,
+)
+from .version import is_autodesk_version, version_from_install_dir
+from .winreg import open_hklm, subkey_count
+
+ACAD_REGISTRY_ROOT: Final = r"SOFTWARE\Autodesk\AutoCAD"
+ACAD_INSTALLED_PRODUCTS: Final = "InstalledProducts"
+
+# InstalledProducts subkey, keyed by the host name constants. Mirrors AcadProductCatalog.ProductCodes.
+_PRODUCT_CODES: Final[dict[str, str]] = {
+    AUTOCAD: "ACAD",
+    CIVIL3D: "C3D",
+    PLANT3D: "PLNT3D",
+    ACAD_MAP3D: "MAP",
+    ACAD_ARCH: "ACA",
+    ACAD_MECH: "ACADM",
+    ACAD_MEP: "MEP",
+    ACAD_ELEC: "ACADE",
+}
+
+
+def product_code(host_name: str) -> str | None:
+    """Return the InstalledProducts subkey for *host_name*."""
+    return _PRODUCT_CODES.get(host_name)
+
+
+def find_acad_executable(host_name: str, cfg: HostConfig, version: str) -> str | None:
+    """Locate acad.exe for *host_name* at *version*.
+
+    Verticals resolve only through InstalledProducts. Vanilla AutoCAD may
+    fall back to ``AutoCAD {version}`` on disk.
+    """
+    code = product_code(host_name)
+    if code is None or not is_autodesk_version(version):
+        return None
+    exe = _from_registry(code, cfg, version)
+    if exe:
+        return exe
+    if host_name != AUTOCAD:
+        return None
+    return _from_filesystem(cfg, version)
+
+
+def _from_registry(code: str, cfg: HostConfig, version: str) -> str | None:
+    try:
+        root = open_hklm(ACAD_REGISTRY_ROOT)
+    except OSError:
+        return None
+
+    try:
+        for i in range(subkey_count(root)):
+            release_name = winreg.EnumKey(root, i)
+            try:
+                release_key = winreg.OpenKey(root, release_name)
+            except OSError:
+                continue
+            try:
+                result = _scan_installed_products(release_key, code, cfg, version)
+                if result is not None:
+                    return result
+            finally:
+                winreg.CloseKey(release_key)
+    finally:
+        winreg.CloseKey(root)
+    return None
+
+
+def _scan_installed_products(
+    release_key: winreg.HKEYType, code: str, cfg: HostConfig, version: str
+) -> str | None:
+    try:
+        products = winreg.OpenKey(release_key, ACAD_INSTALLED_PRODUCTS)
+    except OSError:
+        return None
+    try:
+        try:
+            install_dir, _ = winreg.QueryValueEx(products, "")
+        except OSError:
+            return None
+        if not isinstance(install_dir, str) or not install_dir.strip():
+            return None
+        if version_from_install_dir(install_dir) != version:
+            return None
+        try:
+            sub = winreg.OpenKey(products, code)
+        except OSError:
+            return None
+        winreg.CloseKey(sub)
+        assert cfg.exe_name is not None
+        exe = os.path.join(install_dir.rstrip("\\/"), cfg.exe_name)
+        return exe if os.path.isfile(exe) else None
+    finally:
+        winreg.CloseKey(products)
+
+
+def _from_filesystem(cfg: HostConfig, version: str) -> str | None:
+    program_files = os.environ.get("ProgramFiles", r"C:\Program Files")
+    autodesk_dir = os.path.join(program_files, "Autodesk")
+    if not os.path.isdir(autodesk_dir):
+        return None
+
+    patterns = [f"AutoCAD {version}", f"AutoCAD {version} *"]
+    for pattern in patterns:
+        for entry in sorted(Path(autodesk_dir).glob(pattern)):
+            assert cfg.exe_name is not None
+            exe = entry / cfg.exe_name
+            if exe.is_file():
+                return str(exe)
+    return None

revitdevtool_pytest-0.5.0/src/revitdevtool_pytest/hosts/revit.py

@@ -0,0 +1,59 @@
+"""Revit installs via the Autodesk Revit registry key (mirrors RevitPathResolver)."""
+
+from __future__ import annotations
+
+import os
+import winreg
+from pathlib import Path
+from typing import Final
+
+from ..constants import REVIT
+from .version import is_autodesk_version
+from .winreg import open_hklm
+
+_HOST: Final = REVIT
+_EXE: Final = "Revit.exe"
+_REGISTRY_KEY: Final = r"SOFTWARE\Autodesk\Revit\Autodesk Revit {version}"
+_REGISTRY_VALUE: Final = "InstallationLocation"
+_FOLDER: Final = "Revit {version}"
+
+
+def supports(host_name: str) -> bool:
+    return host_name == _HOST
+
+
+def find_revit_executable(version: str) -> str | None:
+    if not is_autodesk_version(version):
+        return None
+    path = _from_registry(version)
+    if path:
+        return path
+    return _from_filesystem(version)
+
+
+def _from_registry(version: str) -> str | None:
+    try:
+        with open_hklm(_REGISTRY_KEY.format(version=version)) as key:
+            install_dir, _ = winreg.QueryValueEx(key, _REGISTRY_VALUE)
+        if not isinstance(install_dir, str):
+            return None
+        exe = os.path.join(install_dir, _EXE)
+        return exe if os.path.isfile(exe) else None
+    except OSError:
+        return None
+
+
+def _from_filesystem(version: str) -> str | None:
+    program_files = os.environ.get("ProgramFiles", r"C:\Program Files")
+    autodesk_dir = os.path.join(program_files, "Autodesk")
+    folder = _FOLDER.format(version=version)
+    exact = os.path.join(autodesk_dir, folder, _EXE)
+    if os.path.isfile(exact):
+        return exact
+    if not os.path.isdir(autodesk_dir):
+        return None
+    for entry in sorted(Path(autodesk_dir).glob(f"{folder}*")):
+        exe = entry / _EXE
+        if exe.is_file():
+            return str(exe)
+    return None

revitdevtool_pytest-0.5.0/src/revitdevtool_pytest/hosts/version.py

@@ -0,0 +1,39 @@
+"""Autodesk version vocabulary.
+
+Revit and the AutoCAD family are addressed by a calendar year (``2026``),
+the same token used by ``--host-version`` and pipe names. The floor matches
+``HostVersions.AutodeskMinimal``. Other hosts do not use this pattern.
+
+An Autodesk install folder matches when its last whitespace-separated token
+is that year. ``AutoCAD 2026`` and ``Civil 3D 2026`` both yield ``2026``.
+``AutoCAD 12026`` does not.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Final
+
+AUTODESK_VERSION_MINIMAL: Final = 2022
+
+
+def is_autodesk_version(version: str) -> bool:
+    """Return True when *version* is an Autodesk calendar-year token."""
+    if len(version) != 4 or not version.isdigit():
+        return False
+    return int(version) >= AUTODESK_VERSION_MINIMAL
+
+
+def version_from_folder(folder: str) -> str | None:
+    """Return the Autodesk year at the end of an install folder name."""
+    name = folder.strip()
+    if not name:
+        return None
+    token = name.rsplit(maxsplit=1)[-1]
+    return token if is_autodesk_version(token) else None
+
+
+def version_from_install_dir(install_dir: str) -> str | None:
+    """Return the Autodesk year of an install directory."""
+    folder = os.path.basename(install_dir.rstrip("\\/"))
+    return version_from_folder(folder)