openadapt-types 0.2.0__tar.gz → 0.3.1__tar.gz

{openadapt_types-0.2.0 → openadapt_types-0.3.1}/.github/workflows/publish.yml

@@ -16,7 +16,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 0
           token: ${{ secrets.ADMIN_TOKEN }}
@@ -28,33 +28,19 @@ jobs:
             echo "skip=true" >> $GITHUB_OUTPUT
           fi
 
-      - name: Set up Python
-        if: steps.check_skip.outputs.skip != 'true'
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-
-      - name: Install uv
-        if: steps.check_skip.outputs.skip != 'true'
-        uses: astral-sh/setup-uv@v4
-
       - name: Python Semantic Release
         if: steps.check_skip.outputs.skip != 'true'
         id: release
-        uses: python-semantic-release/python-semantic-release@v9.15.2
+        uses: python-semantic-release/python-semantic-release@7b3f71697ccfbaef884e1e754b6364e974b134cf # v9.15.2
         with:
           github_token: ${{ secrets.ADMIN_TOKEN }}
 
-      - name: Build package
-        if: steps.check_skip.outputs.skip != 'true' && steps.release.outputs.released == 'true'
-        run: uv build
-
       - name: Publish to PyPI
         if: steps.check_skip.outputs.skip != 'true' && steps.release.outputs.released == 'true'
-        uses: pypa/gh-action-pypi-publish@release/v1
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # release/v1
 
       - name: Publish to GitHub Releases
         if: steps.check_skip.outputs.skip != 'true' && steps.release.outputs.released == 'true'
-        uses: python-semantic-release/publish-action@v9.15.2
+        uses: python-semantic-release/publish-action@b9c41d4b0754dee5a6c7188d42b33f66e3a8aafd # v9.15.2
         with:
           github_token: ${{ secrets.ADMIN_TOKEN }}

openadapt_types-0.3.1/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.12"
+      - uses: astral-sh/setup-uv@11f9893b081a58869d3b5fccaea48c9e9e46f990 # v8.3.2
+        with:
+          version: "0.11.29"
+      - run: uv sync --locked --extra dev
+      - run: uv run pytest

{openadapt_types-0.2.0 → openadapt_types-0.3.1}/CHANGELOG.md

@@ -1,6 +1,37 @@
 # CHANGELOG
 
 
+## v0.3.1 (2026-07-16)
+
+### Bug Fixes
+
+- Keep release lock metadata consistent
+  ([`e3c78f4`](https://github.com/OpenAdaptAI/openadapt-types/commit/e3c78f458e52aec69377c48e4ece7b77e8c88968))
+
+Pin release tooling, verify editable lock metadata, and build the reviewed lock state during
+  semantic release.
+
+
+## v0.3.0 (2026-07-13)
+
+### Features
+
+- Add canonical Benchmark* types (Task/Observation/Action/Agent)
+  ([#5](https://github.com/OpenAdaptAI/openadapt-types/pull/5),
+  [`82ad485`](https://github.com/OpenAdaptAI/openadapt-types/commit/82ad48590e89e23c44cdf25ce636035195d6ea14))
+
+Move the Benchmark* vocabulary into the canonical schema package so both openadapt-ml and
+  openadapt-evals can import it without depending on each other, breaking the historical ml<->evals
+  import cycle.
+
+Definitions are dependency-free (dataclasses + abc) and faithfully match the previous
+  openadapt-evals definitions.
+
+Claude-Session: https://claude.ai/code/session_01CKrVJJy5jWVCkXAqgUqtqZ
+
+Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
+
+
 ## v0.2.0 (2026-03-29)
 
 ### Continuous Integration

{openadapt_types-0.2.0 → openadapt_types-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openadapt-types
-Version: 0.2.0
+Version: 0.3.1
 Summary: Canonical Pydantic schemas for computer-use agents: ComputerState, Action, ActionResult, UINode
 Project-URL: Homepage, https://github.com/OpenAdaptAI/openadapt-types
 Project-URL: Repository, https://github.com/OpenAdaptAI/openadapt-types

{openadapt_types-0.2.0 → openadapt_types-0.3.1}/openadapt_types/__init__.py

@@ -26,6 +26,12 @@ from openadapt_types.action import (
     ActionTarget,
     ActionType,
 )
+from openadapt_types.benchmark import (
+    BenchmarkAction,
+    BenchmarkAgent,
+    BenchmarkObservation,
+    BenchmarkTask,
+)
 from openadapt_types.computer_state import (
     BoundingBox,
     ComputerState,
@@ -57,6 +63,11 @@ __all__ = [
     "ActionResult",
     "ActionTarget",
     "ActionType",
+    # benchmark
+    "BenchmarkAction",
+    "BenchmarkAgent",
+    "BenchmarkObservation",
+    "BenchmarkTask",
     # episode
     "Episode",
     "Step",

openadapt_types-0.3.1/openadapt_types/benchmark.py

@@ -0,0 +1,202 @@
+"""Canonical benchmark vocabulary shared across the OpenAdapt ecosystem.
+
+This module hosts the ``Benchmark*`` types that describe the interaction
+surface between GUI-agent benchmarks and the agents/environments that run
+them. They live here (in the canonical schema package) so that both
+``openadapt-ml`` (model library) and ``openadapt-evals`` (evaluation
+harness) can import them without depending on each other -- breaking the
+historical ``ml <-> evals`` import cycle.
+
+The definitions are deliberately dependency-free (plain ``dataclasses`` and
+an ``abc.ABC``) so importing them never pulls in heavy optional deps.
+
+Example::
+
+    from openadapt_types import (
+        BenchmarkAgent,
+        BenchmarkAction,
+        BenchmarkObservation,
+        BenchmarkTask,
+    )
+
+    class MyAgent(BenchmarkAgent):
+        def act(self, observation, task, history=None):
+            return BenchmarkAction(type="click", x=0.5, y=0.5)
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class BenchmarkTask:
+    """Canonical task representation.
+
+    Attributes:
+        task_id: Unique identifier for the task.
+        instruction: Natural language task instruction.
+        domain: Task domain ("web", "desktop", "mobile").
+        initial_state_ref: Reference to initial state (VM snapshot, URL, etc.).
+        time_limit_steps: Maximum steps allowed for the task.
+        raw_config: Original benchmark config (lossless preservation).
+        evaluation_spec: Benchmark-native evaluation specification.
+    """
+
+    task_id: str
+    instruction: str
+    domain: str  # "web", "desktop", "mobile"
+
+    # Environment setup
+    initial_state_ref: str | None = None  # VM snapshot, storage_state, start URL
+    time_limit_steps: int | None = None
+
+    # Preserve original config losslessly
+    raw_config: dict[str, Any] = field(default_factory=dict)
+
+    # Evaluation spec (benchmark-native)
+    evaluation_spec: dict[str, Any] | None = None
+
+
+@dataclass
+class BenchmarkObservation:
+    """Canonical observation at each step.
+
+    Supports multiple observation modalities:
+    - Visual: screenshots with viewport info
+    - Structured UI: accessibility tree (UIA/AXTree/DOM)
+    - Context: URL, window title, focused element
+
+    Attributes:
+        screenshot: PNG image bytes.
+        screenshot_path: Path to saved screenshot.
+        viewport: (width, height) of the viewport.
+        accessibility_tree: Platform-specific UI tree (UIA/AXTree/DOM).
+        dom_html: Raw HTML for web tasks.
+        url: Current URL for web tasks.
+        window_title: Active window title for desktop tasks.
+        focused_element: Currently focused UI element.
+        raw_observation: Original benchmark observation (lossless).
+    """
+
+    # Visual
+    screenshot: bytes | None = None  # PNG image bytes
+    screenshot_path: str | None = None
+    viewport: tuple[int, int] | None = None  # (width, height)
+
+    # Structured UI (format varies by platform)
+    accessibility_tree: dict | None = None  # UIA (Windows), AXTree (macOS), DOM (web)
+    dom_html: str | None = None  # Raw HTML for web
+
+    # Context
+    url: str | None = None  # For web tasks
+    window_title: str | None = None  # For desktop tasks
+    app_name: str | None = None  # Active application
+    focused_element: dict | None = None  # {node_id, bbox, text}
+
+    # Raw benchmark-specific data (lossless)
+    raw_observation: dict[str, Any] | None = None
+
+
+@dataclass
+class BenchmarkAction:
+    """Canonical action representation.
+
+    Supports multiple action types with both coordinate-based and element-based
+    grounding. The "grounding-first" approach stores both when available.
+
+    Attributes:
+        type: Action type ("click", "type", "scroll", "key", "drag", "answer", "done").
+        x: X coordinate (normalized [0,1] or pixels).
+        y: Y coordinate (normalized [0,1] or pixels).
+        target_node_id: Element ID from accessibility tree.
+        target_bbox: Element bounding box.
+        target_role: Element role (button, textfield, etc.).
+        target_name: Element accessible name.
+        text: Text to type (for "type" action).
+        key: Single key (for "key" action, e.g., "Enter", "Tab").
+        modifiers: Key modifiers (["ctrl", "shift", "alt"]).
+        scroll_direction: Scroll direction ("up", "down", "left", "right").
+        scroll_amount: Scroll amount (pixels or normalized).
+        end_x: Drag end X coordinate.
+        end_y: Drag end Y coordinate.
+        answer: Answer string (for benchmarks that score by answer).
+        raw_action: Original benchmark action (lossless).
+    """
+
+    type: str  # "click", "type", "scroll", "key", "drag", "answer", "done", "error"
+
+    # Pointer actions - coordinates
+    x: float | None = None  # Normalized [0,1] or pixel
+    y: float | None = None
+
+    # Element grounding (when available)
+    target_node_id: str | None = None  # DOM/AX/UIA node ID
+    target_bbox: tuple[float, float, float, float] | None = None
+    target_role: str | None = None  # "button", "textfield", etc.
+    target_name: str | None = None  # Accessible name
+
+    # Keyboard actions
+    text: str | None = None  # For "type" action - text to type
+    key: str | None = None  # For "key" action - single key
+    modifiers: list[str] | None = None  # ["ctrl", "shift", "alt"]
+
+    # Scroll actions
+    scroll_direction: str | None = None  # "up", "down", "left", "right"
+    scroll_amount: float | None = None  # Pixels or normalized
+
+    # Drag actions
+    end_x: float | None = None
+    end_y: float | None = None
+
+    # Answer action (some benchmarks score by final answer)
+    answer: str | None = None
+
+    # Raw benchmark-specific format (lossless)
+    raw_action: dict[str, Any] | None = None
+
+
+class BenchmarkAgent(ABC):
+    """Abstract interface for agents evaluated on benchmarks.
+
+    Agents must implement the `act` method to receive observations
+    and return actions. The agent can maintain internal state across
+    steps within an episode.
+    """
+
+    @abstractmethod
+    def act(
+        self,
+        observation: BenchmarkObservation,
+        task: BenchmarkTask,
+        history: list[tuple[BenchmarkObservation, BenchmarkAction]] | None = None,
+    ) -> BenchmarkAction:
+        """Given observation and task, return next action.
+
+        Args:
+            observation: Current observation from the environment.
+            task: Task being performed.
+            history: Optional list of previous (observation, action) pairs.
+
+        Returns:
+            Action to execute.
+        """
+        ...
+
+    def reset(self) -> None:
+        """Reset agent state between episodes.
+
+        Called before starting a new task. Override to clear any
+        internal state.
+        """
+        pass
+
+
+__all__ = [
+    "BenchmarkAction",
+    "BenchmarkAgent",
+    "BenchmarkObservation",
+    "BenchmarkTask",
+]

{openadapt_types-0.2.0 → openadapt_types-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openadapt-types"
-version = "0.2.0"
+version = "0.3.1"
 description = "Canonical Pydantic schemas for computer-use agents: ComputerState, Action, ActionResult, UINode"
 readme = "README.md"
 license = "MIT"
@@ -40,6 +40,8 @@ dev = [
     "pytest-cov",
 ]
 
+
+
 [tool.hatch.build.targets.wheel]
 packages = ["openadapt_types"]
 
@@ -50,6 +52,12 @@ testpaths = ["tests"]
 version_toml = ["pyproject.toml:project.version"]
 commit_message = "chore: release {version}"
 major_on_zero = false
+allow_zero_version = true
+# Semantic Release changes only project metadata. Stamp that version into the
+# existing editable lock entry without resolving dependencies, stage it in the
+# generated release commit, and build exactly those reviewed inputs. The PSR
+# action is a Docker action, so uv must be installed inside its container.
+build_command = "python -m pip install uv==0.11.29 && python scripts/verify_release_lock.py --write && git add uv.lock && uv build"
 
 [tool.semantic_release.branches.main]
 match = "main"

openadapt_types-0.3.1/scripts/verify_release_lock.py

@@ -0,0 +1,124 @@
+"""Verify that project metadata and the editable uv lock entry agree."""
+
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _quoted_table_value(text: str, table: str, key: str) -> str:
+    table_match = re.search(
+        rf"(?ms)^\[{re.escape(table)}\]\s*$\n(?P<body>.*?)(?=^\[|\Z)",
+        text,
+    )
+    if table_match is None:
+        raise ValueError(f"missing [{table}] table")
+    value_match = re.search(
+        rf'(?m)^{re.escape(key)}\s*=\s*"(?P<value>[^"]+)"\s*$',
+        table_match.group("body"),
+    )
+    if value_match is None:
+        raise ValueError(f"missing quoted [{table}].{key}")
+    return value_match.group("value")
+
+
+def _editable_lock_entry(lock_text: str, package_name: str) -> tuple[int, int, str]:
+    matches: list[tuple[int, int, str]] = []
+    for block_match in re.finditer(
+        r"(?ms)^\[\[package\]\]\s*$\n.*?(?=^\[\[package\]\]\s*$|\Z)",
+        lock_text,
+    ):
+        block = block_match.group(0)
+        name_match = re.search(r'(?m)^name\s*=\s*"(?P<value>[^"]+)"\s*$', block)
+        if name_match is None or name_match.group("value") != package_name:
+            continue
+        if not re.search(
+            r'(?m)^source\s*=\s*\{\s*editable\s*=\s*"\."\s*\}\s*$',
+            block,
+        ):
+            continue
+        version_match = re.search(
+            r'(?m)^version\s*=\s*"(?P<value>[^"]+)"\s*$', block
+        )
+        if version_match is None:
+            raise ValueError(f"editable {package_name!r} lock entry has no version")
+        matches.append(
+            (
+                block_match.start() + version_match.start("value"),
+                block_match.start() + version_match.end("value"),
+                version_match.group("value"),
+            )
+        )
+    if len(matches) != 1:
+        raise ValueError(
+            f"expected exactly one editable {package_name!r} lock entry; "
+            f"found {len(matches)}"
+        )
+    return matches[0]
+
+
+def _project_identity(root: Path) -> tuple[str, str]:
+    project_text = (root / "pyproject.toml").read_text(encoding="utf-8")
+    return (
+        _quoted_table_value(project_text, "project", "name"),
+        _quoted_table_value(project_text, "project", "version"),
+    )
+
+
+def release_versions(root: Path = ROOT) -> tuple[str, str]:
+    """Return ``(project_version, editable_lock_version)``."""
+    package_name, project_version = _project_identity(root)
+    lock_text = (root / "uv.lock").read_text(encoding="utf-8")
+    _, _, lock_version = _editable_lock_entry(lock_text, package_name)
+    return project_version, lock_version
+
+
+def synchronize_release_lock(root: Path = ROOT) -> bool:
+    """Stamp only the editable root version, preserving reviewed resolution."""
+    package_name, project_version = _project_identity(root)
+    lock_path = root / "uv.lock"
+    lock_text = lock_path.read_text(encoding="utf-8")
+    version_start, version_end, lock_version = _editable_lock_entry(
+        lock_text, package_name
+    )
+    if lock_version == project_version:
+        return False
+    lock_path.write_text(
+        lock_text[:version_start] + project_version + lock_text[version_end:],
+        encoding="utf-8",
+    )
+    return True
+
+
+def verify_release_lock(root: Path = ROOT) -> None:
+    project_version, lock_version = release_versions(root)
+    if project_version != lock_version:
+        raise ValueError(
+            "release version drift: "
+            f"pyproject.toml={project_version}, uv.lock={lock_version}; "
+            "run `python scripts/verify_release_lock.py --write`"
+        )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--write",
+        action="store_true",
+        help="stamp the project version into the editable lock entry before checking",
+    )
+    args = parser.parse_args()
+    try:
+        if args.write:
+            synchronize_release_lock()
+        verify_release_lock()
+    except ValueError as exc:
+        parser.exit(1, f"{exc}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

openadapt_types-0.3.1/tests/test_benchmark.py

@@ -0,0 +1,86 @@
+"""Tests for the canonical Benchmark* vocabulary."""
+
+from openadapt_types import (
+    BenchmarkAction,
+    BenchmarkAgent,
+    BenchmarkObservation,
+    BenchmarkTask,
+)
+
+
+def test_benchmark_task_defaults():
+    task = BenchmarkTask(task_id="t1", instruction="do it", domain="desktop")
+    assert task.task_id == "t1"
+    assert task.instruction == "do it"
+    assert task.domain == "desktop"
+    assert task.initial_state_ref is None
+    assert task.time_limit_steps is None
+    assert task.raw_config == {}
+    assert task.evaluation_spec is None
+
+
+def test_benchmark_task_raw_config_is_independent():
+    a = BenchmarkTask(task_id="a", instruction="i", domain="web")
+    b = BenchmarkTask(task_id="b", instruction="i", domain="web")
+    a.raw_config["k"] = "v"
+    assert b.raw_config == {}
+
+
+def test_benchmark_observation_defaults():
+    obs = BenchmarkObservation()
+    assert obs.screenshot is None
+    assert obs.viewport is None
+    assert obs.raw_observation is None
+
+
+def test_benchmark_observation_fields():
+    obs = BenchmarkObservation(
+        screenshot=b"png",
+        viewport=(1920, 1080),
+        url="https://example.com",
+        window_title="Notepad",
+    )
+    assert obs.screenshot == b"png"
+    assert obs.viewport == (1920, 1080)
+    assert obs.url == "https://example.com"
+    assert obs.window_title == "Notepad"
+
+
+def test_benchmark_action_click():
+    action = BenchmarkAction(type="click", x=0.5, y=0.25)
+    assert action.type == "click"
+    assert action.x == 0.5
+    assert action.y == 0.25
+    assert action.text is None
+
+
+def test_benchmark_action_type_and_key():
+    typing = BenchmarkAction(type="type", text="hello")
+    assert typing.text == "hello"
+    key = BenchmarkAction(type="key", key="Enter", modifiers=["ctrl"])
+    assert key.key == "Enter"
+    assert key.modifiers == ["ctrl"]
+
+
+def test_benchmark_agent_is_abstract():
+    # BenchmarkAgent is an ABC; instantiating directly must fail.
+    try:
+        BenchmarkAgent()  # type: ignore[abstract]
+    except TypeError:
+        pass
+    else:  # pragma: no cover
+        raise AssertionError("BenchmarkAgent should be abstract")
+
+
+def test_benchmark_agent_subclass_roundtrip():
+    class Echo(BenchmarkAgent):
+        def act(self, observation, task, history=None):
+            return BenchmarkAction(type="done")
+
+    agent = Echo()
+    obs = BenchmarkObservation()
+    task = BenchmarkTask(task_id="t", instruction="i", domain="desktop")
+    action = agent.act(obs, task)
+    assert action.type == "done"
+    # Default reset is a no-op and must not raise.
+    agent.reset()

openadapt_types-0.3.1/tests/test_release_contract.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import importlib.util
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = ROOT / "scripts" / "verify_release_lock.py"
+SPEC = importlib.util.spec_from_file_location("verify_release_lock", SCRIPT)
+assert SPEC and SPEC.loader
+release_lock = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(release_lock)
+
+
+def _write_release_files(root: Path, project_version: str, lock_version: str) -> None:
+    (root / "pyproject.toml").write_text(
+        '[project]\nname = "example-package"\n'
+        f'version = "{project_version}"\n',
+        encoding="utf-8",
+    )
+    (root / "uv.lock").write_text(
+        '[[package]]\nname = "dependency"\nversion = "8.1.8"\n'
+        'source = { registry = "https://pypi.org/simple" }\n\n'
+        '[[package]]\nname = "example-package"\n'
+        f'version = "{lock_version}"\nsource = {{ editable = "." }}\n',
+        encoding="utf-8",
+    )
+
+
+def test_real_release_metadata_is_consistent() -> None:
+    project_version, lock_version = release_lock.release_versions()
+    assert project_version == lock_version
+    release_lock.verify_release_lock()
+
+
+def test_release_lock_rejects_version_drift(tmp_path: Path) -> None:
+    _write_release_files(tmp_path, "0.4.0", "0.3.0")
+    try:
+        release_lock.verify_release_lock(tmp_path)
+    except ValueError as exc:
+        assert "pyproject.toml=0.4.0, uv.lock=0.3.0" in str(exc)
+    else:
+        raise AssertionError("version drift was accepted")
+
+
+def test_sync_changes_only_editable_root_and_is_idempotent(tmp_path: Path) -> None:
+    _write_release_files(tmp_path, "0.4.0", "0.3.0")
+    before = (tmp_path / "uv.lock").read_text(encoding="utf-8")
+    assert release_lock.synchronize_release_lock(tmp_path) is True
+    after = (tmp_path / "uv.lock").read_text(encoding="utf-8")
+    assert after == before.replace(
+        'name = "example-package"\nversion = "0.3.0"',
+        'name = "example-package"\nversion = "0.4.0"',
+    )
+    assert release_lock.synchronize_release_lock(tmp_path) is False
+    assert (tmp_path / "uv.lock").read_text(encoding="utf-8") == after
+
+
+def test_release_configuration_is_fail_closed() -> None:
+    metadata = (ROOT / "pyproject.toml").read_text(encoding="utf-8")
+    workflow = (ROOT / ".github/workflows/publish.yml").read_text(encoding="utf-8")
+    test_workflow = (ROOT / ".github/workflows/test.yml").read_text(
+        encoding="utf-8"
+    )
+    assert "major_on_zero = false" in metadata
+    assert "allow_zero_version = true" in metadata
+    assert (
+        "python -m pip install uv==0.11.29 && "
+        "python scripts/verify_release_lock.py --write && "
+        "git add uv.lock && uv build"
+    ) in metadata
+    assert metadata.index("python -m pip install uv==0.11.29") < metadata.index(
+        "python scripts/verify_release_lock.py --write"
+    ) < metadata.index("git add uv.lock") < metadata.index("uv build")
+    assert "run: uv build" not in workflow
+    assert "astral-sh/setup-uv" not in workflow
+    assert "actions/setup-python" not in workflow
+    assert workflow.count("secrets.ADMIN_TOKEN") >= 3
+    assert "secrets.GITHUB_TOKEN" not in workflow
+    assert 'version: "0.11.29"' in test_workflow
+    assert 'python-version: "3.12"' in test_workflow
+    assert "uv sync --locked --extra dev" in test_workflow
+
+
+def test_all_third_party_actions_are_commit_pinned() -> None:
+    action_pattern = re.compile(r"uses:\s*([^\s@]+)@([^\s#]+)")
+    for path in (ROOT / ".github" / "workflows").glob("*.yml"):
+        for action, action_ref in action_pattern.findall(path.read_text(encoding="utf-8")):
+            assert re.fullmatch(r"[0-9a-f]{40}", action_ref), (
+                f"{path.name}: {action}@{action_ref} is not pinned to a commit"
+            )

{openadapt_types-0.2.0 → openadapt_types-0.3.1}/uv.lock

@@ -160,7 +160,7 @@ wheels = [
 
 [[package]]
 name = "openadapt-types"
-version = "0.1.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },

openadapt_types-0.2.0/.github/workflows/test.yml

@@ -1,16 +0,0 @@
-name: test
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: astral-sh/setup-uv@v4
-      - run: uv sync --extra dev
-      - run: uv run pytest