[autorevert] properly resolve github workflow names

Author: izaitsevfb

aws/lambda/pytorch-auto-revert/pytorch_auto_revert/tests/test_workflow_resolver.py

@@ -0,0 +1,48 @@
+import sys
+import unittest
+
+
+# Ensure package import when running from repo root
+sys.path.insert(0, "aws/lambda/pytorch-auto-revert")
+
+from pytorch_auto_revert.workflow_resolver import WorkflowResolver
+
+
+class TestWorkflowResolverRealRepo(unittest.TestCase):
+    def test_resolve_pull_workflow(self):
+        resolver = WorkflowResolver.get("pytorch/pytorch")
+
+        # Resolve by display name
+        pull_by_name = resolver.resolve("pull")
+        self.assertIsNotNone(pull_by_name, "Expected to resolve 'pull' by display name")
+
+        # Resolve by basename
+        pull_by_file = resolver.resolve("pull.yml")
+        self.assertIsNotNone(
+            pull_by_file, "Expected to resolve 'pull.yml' by file name"
+        )
+        self.assertTrue(
+            pull_by_file.file_name.endswith("pull.yml"),
+            "Resolved file name should be 'pull.yml'",
+        )
+
+    def test_resolve_trunk_workflow(self):
+        resolver = WorkflowResolver.get("pytorch/pytorch")
+
+        trunk_by_name = resolver.resolve("trunk")
+        self.assertIsNotNone(
+            trunk_by_name, "Expected to resolve 'trunk' by display name"
+        )
+
+        trunk_by_file = resolver.resolve("trunk.yml")
+        self.assertIsNotNone(
+            trunk_by_file, "Expected to resolve 'trunk.yml' by file name"
+        )
+        self.assertTrue(
+            trunk_by_file.file_name.endswith("trunk.yml"),
+            "Resolved file name should be 'trunk.yml'",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

aws/lambda/pytorch-auto-revert/pytorch_auto_revert/workflow_checker.py

@@ -1,12 +1,15 @@
 """
-WorkflowRestartChecker for querying restarted workflows via ClickHouse.
+WorkflowRestartChecker for querying restarted workflows via ClickHouse and
+dispatching workflows via GitHub with consistent workflow name resolution.
 """
 
 import logging
 from datetime import datetime, timedelta
+from functools import cached_property
 from typing import Dict, Set
 
 from .clickhouse_client_helper import CHCliFactory
+from .workflow_resolver import WorkflowResolver
 
 
 class WorkflowRestartChecker:
@@ -28,9 +31,10 @@ def has_restarted_workflow(self, workflow_name: str, commit_sha: str) -> bool:
         Returns:
             bool: True if workflow was restarted (workflow_dispatch with trunk/* branch)
         """
-        # Normalize workflow name - remove .yml extension for consistency
-        normalized_workflow_name = workflow_name.replace(".yml", "")
-        cache_key = f"{normalized_workflow_name}:{commit_sha}"
+        # Resolve to display name via GitHub (exact display or file name)
+        display_name = self.resolver.require(workflow_name).display_name
+
+        cache_key = f"{display_name}:{commit_sha}"
         if cache_key in self._cache:
             return self._cache[cache_key]
 
@@ -54,7 +58,7 @@ def has_restarted_workflow(self, workflow_name: str, commit_sha: str) -> bool:
                 "commit_sha": commit_sha,
                 "workflow_event": "workflow_dispatch",
                 "head_branch": f"trunk/{commit_sha}",
-                "workflow_name": normalized_workflow_name,
+                "workflow_name": display_name,
             },
         )
 
@@ -73,8 +77,7 @@ def get_restarted_commits(self, workflow_name: str, days_back: int = 7) -> Set[s
         Returns:
             Set of commit SHAs that have restarted workflows
         """
-        # Normalize workflow name - remove .yml extension for consistency
-        normalized_workflow_name = workflow_name.replace(".yml", "")
+        display_name = self.resolver.require(workflow_name).display_name
         since_date = datetime.now() - timedelta(days=days_back)
 
         query = """
@@ -87,14 +90,14 @@ def get_restarted_commits(self, workflow_name: str, days_back: int = 7) -> Set[s
         """
 
         result = CHCliFactory().client.query(
-            query, {"workflow_name": normalized_workflow_name, "since_date": since_date}
+            query, {"workflow_name": display_name, "since_date": since_date}
         )
 
         commits = {row[0] for row in result.result_rows}
 
         # Update cache
         for commit_sha in commits:
-            cache_key = f"{normalized_workflow_name}:{commit_sha}"
+            cache_key = f"{display_name}:{commit_sha}"
             self._cache[cache_key] = True
 
         return commits
@@ -114,13 +117,10 @@ def restart_workflow(self, workflow_name: str, commit_sha: str) -> bool:
         Returns:
             bool: True if workflow was successfully dispatched, False otherwise
         """
-        # Normalize workflow name
-        normalized_workflow_name = workflow_name.replace(".yml", "")
-
         # Check if already restarted
-        if self.has_restarted_workflow(normalized_workflow_name, commit_sha):
+        if self.has_restarted_workflow(workflow_name, commit_sha):
             logging.warning(
-                f"Workflow {normalized_workflow_name} already restarted for commit {commit_sha}"
+                f"Workflow {workflow_name} already restarted for commit {commit_sha}"
             )
             return False
 
@@ -144,33 +144,35 @@ def restart_workflow(self, workflow_name: str, commit_sha: str) -> bool:
             # Use trunk/{sha} tag format
             tag_ref = f"trunk/{commit_sha}"
 
-            # Add .yml extension for workflow name
-            workflow_file_name = f"{normalized_workflow_name}.yml"
+            # Resolve workflow
+            wf_ref = self.resolver.require(workflow_name)
 
-            # Get repo and workflow objects
-            repo = client.get_repo(f"{self.repo_owner}/{self.repo_name}")
-            workflow = repo.get_workflow(workflow_file_name)
-
-            # Dispatch the workflow
-            workflow.create_dispatch(ref=tag_ref, inputs={})
+            # Dispatch via file name
+            client.get_repo(f"{self.repo_owner}/{self.repo_name}").get_workflow(
+                wf_ref.file_name
+            ).create_dispatch(ref=tag_ref, inputs={})
 
             # Construct the workflow runs URL
             workflow_url = (
                 f"https://github.com/{self.repo_owner}/{self.repo_name}"
-                f"/actions/workflows/{workflow_file_name}"
+                f"/actions/workflows/{wf_ref.file_name}"
                 f"?query=branch%3Atrunk%2F{commit_sha}"
             )
             logging.info(
-                f"Successfully dispatched workflow {normalized_workflow_name} for commit {commit_sha}\n"
+                f"Successfully dispatched workflow {wf_ref.display_name} for commit {commit_sha}\n"
                 f"  View at: {workflow_url}"
             )
 
             # Invalidate cache for this workflow/commit
-            cache_key = f"{normalized_workflow_name}:{commit_sha}"
+            cache_key = f"{wf_ref.display_name}:{commit_sha}"
             if cache_key in self._cache:
                 del self._cache[cache_key]
             return True
 
         except Exception as e:
-            logging.error(f"Error dispatching workflow {normalized_workflow_name}: {e}")
+            logging.error(f"Error dispatching workflow {workflow_name}: {e}")
             return False
+
+    @cached_property
+    def resolver(self) -> WorkflowResolver:
+        return WorkflowResolver.get(f"{self.repo_owner}/{self.repo_name}")

aws/lambda/pytorch-auto-revert/pytorch_auto_revert/workflow_resolver.py

@@ -0,0 +1,103 @@
+"""
+WorkflowResolver: Resolve GitHub Actions workflows by exact display or file name.
+
+- Exact matches only (no lowercasing or fuzzy matching)
+- Caches per-repo resolver instances
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Optional
+
+import github
+
+from .github_client_helper import GHClientFactory
+
+
+@dataclass(frozen=True)
+class WorkflowRef:
+    """Reference to a workflow's identities in a repository."""
+
+    display_name: str
+    file_name: str  # basename, e.g., "pull.yml"
+
+
+class WorkflowResolver:
+    """Caches workflows for a repo and resolves by exact names.
+
+    Usage:
+        resolver = WorkflowResolver.get("owner/repo")
+        wf = resolver.resolve("pull")        # display name
+        wf = resolver.resolve("pull.yml")    # file basename
+        wf = resolver.resolve(".github/workflows/pull.yml")  # full path
+    """
+
+    def __init__(
+        self, repo_full_name: str, repository: "github.Repository.Repository"
+    ) -> None:
+        self._repo_full_name = repo_full_name
+        self._repository = repository
+        self._by_display: dict[str, WorkflowRef] = {}
+        self._by_file: dict[str, WorkflowRef] = {}
+        self._build_indices()
+
+    @staticmethod
+    @lru_cache(maxsize=None)
+    def get(repo: str) -> "WorkflowResolver":
+        """Get a cached resolver for a repo in owner/repo format.
+
+        Internally creates a GitHub Repository client using GHClientFactory when
+        available; otherwise falls back to an anonymous client for public repos.
+        """
+        # Build a client: prefer configured factory; fall back to anonymous
+        try:
+            client = GHClientFactory().client
+        except Exception as e:
+            # log exception
+            print(f"Warning: Failed to create GitHub client: {e}")
+            # Anonymous client for public data; may be rate limited
+            # (used mostly for the tests)
+            client = github.Github()
+
+        repository = client.get_repo(repo)
+        return WorkflowResolver(repo_full_name=repo, repository=repository)
+
+    def resolve(self, input_name: str) -> Optional[WorkflowRef]:
+        """Resolve by exact display name, file basename, or full path.
+
+        Returns None if no exact match is found.
+        """
+        if input_name in self._by_display:
+            return self._by_display[input_name]
+        if input_name in self._by_file:
+            return self._by_file[input_name]
+        return None
+
+    def require(self, input_name: str) -> WorkflowRef:
+        """Resolve or raise ValueError with a helpful message."""
+        ref = self.resolve(input_name)
+        if ref is None:
+            # Build an informative message with available names
+            display = ", ".join(sorted(self._by_display))
+            files = ", ".join(sorted(self._by_file))
+            raise ValueError(
+                f"Workflow '{input_name}' not found in {self._repo_full_name}. "
+                f"Available display names: [{display}]. Available files: [{files}]"
+            )
+        return ref
+
+    # Internal helpers
+
+    def _build_indices(self) -> None:
+        for w in self._repository.get_workflows():
+            name = getattr(w, "name", "") or ""
+            path = getattr(w, "path", "") or ""
+            base = os.path.basename(path) if path else ""
+            if not (name and base):
+                continue
+            ref = WorkflowRef(display_name=name, file_name=base)
+            self._by_display[name] = ref
+            self._by_file[base] = ref