orchestra-cli 0.5.0__tar.gz → 0.5.2__tar.gz

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestra-cli
-Version: 0.5.0
+Version: 0.5.2
 Summary: Orchestra CLI. Perform operations with Orchestra locally.
 Author-email: Orchestra Technologies <support@getorchestra.io>
 Requires-Python: >=3.10

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/orchestra_cli/src/migrate_pipeline.py

@@ -364,7 +364,8 @@ def migrate_pipeline(
         typer.echo(red("Could not detect repository URL from git"))
         raise typer.Exit(code=1)
 
-    storage_provider_value = detect_storage_provider(get_remote_url(repo_root))
+    remote_url = get_remote_url(repo_root)
+    storage_provider_value = detect_storage_provider(remote_url)
     if not storage_provider_value:
         typer.echo(red("Could not detect storage provider - no matching host"))
         raise typer.Exit(code=1)
@@ -437,6 +438,7 @@ def migrate_pipeline(
             repository_slug,
             default_branch,
             pushed_branch,
+            remote_url,
         )
         if compare_link:
             typer.echo(yellow(f"Open PR / compare link: {compare_link}"))

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/orchestra_cli/src/run_pipeline.py

@@ -37,13 +37,14 @@ STATUS_STYLES = {
     "CREATED": "cyan",
     "QUEUED": "yellow",
     "RUNNING": "blue",
+    "CANCELLING": "red",
     "SUCCEEDED": "green",
     "WARNING": "yellow",
     "SKIPPED": "yellow",
     "FAILED": "red",
     "CANCELLED": "red",
 }
-IN_PROGRESS_RUN_STATUSES = {"RUNNING", "QUEUED", "CREATED"}
+IN_PROGRESS_RUN_STATUSES = {"RUNNING", "QUEUED", "CREATED", "CANCELLING"}
 TERMINAL_RUN_STATUSES = {"SUCCEEDED", "WARNING", "SKIPPED", "FAILED", "CANCELLED"}
 
 
@@ -307,13 +308,23 @@ def _format_pipeline_duration(created_at_utc: datetime, now_utc: datetime | None
     return f"{seconds} {unit}"
 
 
+def _run_message(status_body: dict[str, object]) -> str | None:
+    message = status_body.get("message")
+    if isinstance(message, str) and message.strip():
+        return message.strip()
+    return None
+
+
 def _build_poll_status_text(
     status_value: str,
     created_at_utc: datetime | None = None,
     now_utc: datetime | None = None,
+    status_message: str | None = None,
 ) -> Text:
     text = Text("Pipeline status: ")
     text.append(status_value, style=f"bold {STATUS_STYLES.get(status_value, 'white')}")
+    if status_message is not None:
+        text.append(f" - {status_message}")
     if created_at_utc is not None:
         text.append(f" ({_format_pipeline_duration(created_at_utc, now_utc)})", style="dim")
     return text
@@ -419,10 +430,11 @@ def _build_poll_display(
     task_runs: list[dict[str, object]],
     can_fetch_task_runs: bool,
     now_utc: datetime | None = None,
+    status_message: str | None = None,
 ) -> Group:
     return Group(
         _build_live_status_text(seconds_since_check),
-        _build_poll_status_text(status_value, created_at_utc, now_utc),
+        _build_poll_status_text(status_value, created_at_utc, now_utc, status_message),
         _build_task_runs_table(
             task_runs,
             can_fetch_task_runs=can_fetch_task_runs,
@@ -452,6 +464,7 @@ def _sleep_with_status_updates(
     created_at_utc: datetime | None,
     task_runs: list[dict[str, object]],
     can_fetch_task_runs: bool,
+    status_message: str | None = None,
     sleep_fn: Callable[[float], None] | None = None,
 ) -> None:
     sleep_fn = sleep_fn or time.sleep
@@ -468,6 +481,7 @@ def _sleep_with_status_updates(
                 created_at_utc=created_at_utc,
                 task_runs=task_runs,
                 can_fetch_task_runs=can_fetch_task_runs,
+                status_message=status_message,
             ),
         )
 
@@ -489,6 +503,7 @@ def _poll_until_terminal(
     status_url = get_api_url(f"pipeline_runs/{pipeline_run_id}/status")
     poll_status_display = _create_poll_status_display()
     last_status_value: str | None = None
+    last_status_message: str | None = None
     last_task_runs: list[dict[str, object]] = []
     can_fetch_task_runs = False
     missing_run_status_polls = 0
@@ -502,6 +517,7 @@ def _poll_until_terminal(
                 created_at_utc=created_at_utc,
                 task_runs=last_task_runs,
                 can_fetch_task_runs=can_fetch_task_runs,
+                status_message=last_status_message,
             )
             try:
                 status_resp = client.get(status_url)
@@ -530,11 +546,13 @@ def _poll_until_terminal(
                 status_body = {}
 
             status_value = status_body.get("runStatus")
+            run_message = _run_message(status_body)
             created_at_utc = created_at_utc or _parse_created_at_utc(status_body)
 
             if isinstance(status_value, str):
                 missing_run_status_polls = 0
                 last_status_value = status_value
+                last_status_message = run_message if status_value == "QUEUED" else None
                 can_fetch_task_runs = status_value in (
                     IN_PROGRESS_RUN_STATUSES | TERMINAL_RUN_STATUSES
                 )
@@ -548,10 +566,14 @@ def _poll_until_terminal(
                             created_at_utc=created_at_utc,
                             task_runs=last_task_runs,
                             can_fetch_task_runs=can_fetch_task_runs,
+                            status_message=last_status_message,
                         ),
                     )
                 else:
-                    typer.echo(f"Pipeline ({selector_name}) status: {status_value}")
+                    status_line = f"Pipeline ({selector_name}) status: {status_value}"
+                    if last_status_message is not None:
+                        status_line += f" - {last_status_message}"
+                    typer.echo(status_line)
             else:
                 missing_run_status_polls += 1
                 if missing_run_status_polls <= max_missing_run_status_polls:
@@ -572,7 +594,10 @@ def _poll_until_terminal(
             if status_value == "SKIPPED":
                 _stop_poll_status_display(poll_status_display)
                 poll_status_display = None
-                typer.echo(yellow("⚠ Pipeline skipped"))
+                skipped_text = (
+                    f"⚠ Pipeline skipped: {run_message}" if run_message else "⚠ Pipeline skipped"
+                )
+                typer.echo(yellow(skipped_text))
                 raise typer.Exit(code=0)
 
             if status_value in {"FAILED", "CANCELLED"}:

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/orchestra_cli/tests/test_import_pipeline.py

@@ -36,6 +36,8 @@ def mock_env(monkeypatch):
     [
         ("https://github.com/org/repo.git", "GITHUB", "org/repo"),
         ("git@github.com:org/repo.git", "GITHUB", "org/repo"),
+        ("https://acme.ghe.com/org/repo.git", "GITHUB", "org/repo"),
+        ("git@acme.ghe.com:org/repo.git", "GITHUB", "org/repo"),
         ("https://gitlab.com/org/repo.git", "GITLAB", "org/repo"),
         ("git@gitlab.com:org/repo.git", "GITLAB", "org/repo"),
         ("https://dev.azure.com/org/project/_git/repo", "AZURE_DEVOPS", "project/repo"),

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/orchestra_cli/tests/test_run_pipeline.py

@@ -1,3 +1,5 @@
+import subprocess
+import time
 from datetime import UTC, datetime
 from pathlib import Path
 
@@ -96,6 +98,11 @@ def test_build_poll_status_text_includes_duration() -> None:
     assert text.plain == "Pipeline status: RUNNING (1:30 minutes)"
 
 
+def test_build_poll_status_text_includes_status_message() -> None:
+    text = _build_poll_status_text("QUEUED", status_message="Waiting for a free slot")
+    assert text.plain == "Pipeline status: QUEUED - Waiting for a free slot"
+
+
 def test_build_live_status_text_includes_update_age() -> None:
     text = _build_live_status_text(3)
     assert text.plain == "Live status (updated 3 seconds ago)"
@@ -1094,6 +1101,93 @@ def test_run_wait_warning(httpx_mock: HTTPXMock, monkeypatch, tmp_path: Path):
     assert result.output.strip().splitlines()[-1] == "⚠ Pipeline completed with warnings"
 
 
+def _invoke_run_through_statuses(
+    httpx_mock: HTTPXMock,
+    monkeypatch,
+    tmp_path: Path,
+    status_bodies: list[dict[str, str]],
+):
+    mapping = {
+        ("rev-parse", "--show-toplevel"): (0, str(tmp_path), ""),
+        ("status", "--porcelain"): (0, "", ""),
+        ("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"): (1, "", ""),
+    }
+    monkeypatch.setattr(time, "sleep", lambda _: None)
+    monkeypatch.setattr(subprocess, "run", make_git_subprocess_mock(mapping))
+
+    base = "https://app.getorchestra.io/api/engine/public"
+    httpx_mock.add_response(
+        method="POST",
+        url=f"{base}/pipelines/demo/start",
+        json={"pipelineRunId": "run-q"},
+    )
+    for status_body in status_bodies:
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base}/pipeline_runs/run-q/status",
+            json={**status_body, "pipelineName": "demo"},
+        )
+        httpx_mock.add_response(
+            method="GET",
+            url=f"{base}/pipeline_runs/run-q/task_runs?page_size=50&page=1",
+            json={"results": []},
+        )
+
+    return runner.invoke(app, ["pipeline", "run", "--alias", "demo", "--wait"])
+
+
+def test_run_wait_keeps_polling_while_cancelling(
+    httpx_mock: HTTPXMock,
+    monkeypatch,
+    tmp_path: Path,
+):
+    result = _invoke_run_through_statuses(
+        httpx_mock,
+        monkeypatch,
+        tmp_path,
+        [{"runStatus": "QUEUED"}, {"runStatus": "CANCELLING"}, {"runStatus": "CANCELLED"}],
+    )
+
+    assert result.exit_code == 1
+    assert "Invalid status value" not in result.output
+    assert "status: CANCELLING" in result.output
+    assert "status CANCELLED" in result.output
+
+
+def test_run_wait_shows_queued_message_then_final_status(
+    httpx_mock: HTTPXMock,
+    monkeypatch,
+    tmp_path: Path,
+):
+    result = _invoke_run_through_statuses(
+        httpx_mock,
+        monkeypatch,
+        tmp_path,
+        [
+            {"runStatus": "QUEUED", "message": "Waiting for a free slot"},
+            {"runStatus": "RUNNING", "message": "Waiting for a free slot"},
+            {"runStatus": "SUCCEEDED"},
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert "Pipeline (alias: demo) status: QUEUED - Waiting for a free slot" in result.output
+    assert "Pipeline (alias: demo) status: RUNNING\n" in result.output
+    assert result.output.strip().splitlines()[-1] == "✅ Pipeline succeeded"
+
+
+def test_run_wait_skipped_prints_reason(httpx_mock: HTTPXMock, monkeypatch, tmp_path: Path):
+    result = _invoke_run_through_statuses(
+        httpx_mock,
+        monkeypatch,
+        tmp_path,
+        [{"runStatus": "SKIPPED", "message": "Replaced by a newer run"}],
+    )
+
+    assert result.exit_code == 0
+    assert result.output.strip().splitlines()[-1] == "⚠ Pipeline skipped: Replaced by a newer run"
+
+
 def test_run_git_backed_path_uses_prepared_branch_and_commit(
     httpx_mock: HTTPXMock,
     monkeypatch,

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/orchestra_cli/tests/utils/test_git.py

@@ -114,3 +114,46 @@ def test_require_repo_root_walks_up_from_nonexistent_parent(monkeypatch, tmp_pat
     monkeypatch.setattr(subprocess, "run", make_git_subprocess_mock(mapping))
 
     assert git_module.require_repo_root(target_file, git_module.GitAction.MIGRATE) == tmp_path
+
+
+@pytest.mark.parametrize(
+    "remote_url, expected",
+    [
+        ("https://github.com/org/repo.git", "GITHUB"),
+        ("git@github.com:org/repo.git", "GITHUB"),
+        ("https://acme.ghe.com/org/repo.git", "GITHUB"),
+        ("https://user:token@acme.ghe.com/org/repo.git", "GITHUB"),
+        ("git@acme.ghe.com:org/repo.git", "GITHUB"),
+        ("ssh://git@acme.ghe.com/org/repo.git", "GITHUB"),
+        ("https://gitlab.com/org/repo.git", "GITLAB"),
+        ("https://git.example.com/org/repo.git", None),
+        ("https://example.com/ghe.com/repo.git", None),
+        ("https://[malformed/org/repo.git", None),
+        (None, None),
+    ],
+)
+def test_detect_storage_provider(remote_url: str | None, expected: str | None):
+    assert git_module.detect_storage_provider(remote_url) == expected
+
+
+@pytest.mark.parametrize(
+    "remote_url, expected",
+    [
+        (
+            "git@github.com:org/repo.git",
+            "https://github.com/org/repo/compare/main...feature?expand=1",
+        ),
+        (
+            "git@acme.ghe.com:org/repo.git",
+            "https://acme.ghe.com/org/repo/compare/main...feature?expand=1",
+        ),
+        (
+            "https://user:token@acme.ghe.com/org/repo.git",
+            "https://acme.ghe.com/org/repo/compare/main...feature?expand=1",
+        ),
+        (None, "https://github.com/org/repo/compare/main...feature?expand=1"),
+    ],
+)
+def test_build_compare_link_github(remote_url: str | None, expected: str):
+    link = git_module.build_compare_link("GITHUB", "org/repo", "main", "feature", remote_url)
+    assert link == expected

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/orchestra_cli/utils/git.py

@@ -4,11 +4,14 @@ import string
 import subprocess
 from enum import StrEnum
 from pathlib import Path
+from urllib.parse import urlsplit
 
 import typer
 
 from .styling import bold, red, yellow
 
+GHE_COM_HOST_SUFFIX = ".ghe.com"
+
 
 class GitAction(StrEnum):
     BUILD = "Build"
@@ -84,12 +87,30 @@ def detect_current_branch(repo_root: Path, allow_detached: bool = True) -> str |
     return out
 
 
+def _remote_host(remote_url: str) -> str | None:
+    """The host of a URL remote, or of the SSH shorthand ``[user@]host:path``."""
+    remote_url = remote_url.strip()
+    if "://" in remote_url:
+        try:
+            return urlsplit(remote_url).hostname
+        except ValueError:
+            return None
+    user_and_host, separator, _ = remote_url.partition(":")
+    return user_and_host.rpartition("@")[2].lower() if separator else None
+
+
+def _ghe_com_host(remote_url: str | None) -> str | None:
+    """The remote's host if it's on GitHub Enterprise Cloud with data residency."""
+    host = _remote_host(remote_url) if remote_url else None
+    return host if host and host.endswith(GHE_COM_HOST_SUFFIX) else None
+
+
 def detect_storage_provider(repository_url: str | None) -> str | None:
     if not repository_url:
         return None
 
     url = repository_url.lower()
-    if "github.com" in url:
+    if "github.com" in url or _ghe_com_host(repository_url):
         return "GITHUB"
     if "gitlab.com" in url:
         return "GITLAB"
@@ -103,10 +124,12 @@ def build_compare_link(
     repository_slug: str,
     default_branch: str,
     branch_name: str,
+    remote_url: str | None,
 ) -> str | None:
     provider = storage_provider.upper()
     if provider == "GITHUB":
-        return f"https://github.com/{repository_slug}/compare/{default_branch}...{branch_name}?expand=1"
+        host = _ghe_com_host(remote_url) or "github.com"
+        return f"https://{host}/{repository_slug}/compare/{default_branch}...{branch_name}?expand=1"
     if provider == "GITLAB":
         return f"https://gitlab.com/{repository_slug}/-/compare/{default_branch}...{branch_name}"
     return None

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/orchestra_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestra-cli
-Version: 0.5.0
+Version: 0.5.2
 Summary: Orchestra CLI. Perform operations with Orchestra locally.
 Author-email: Orchestra Technologies <support@getorchestra.io>
 Requires-Python: >=3.10

{orchestra_cli-0.5.0 → orchestra_cli-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "orchestra-cli"
-version = "0.5.0"
+version = "0.5.2"
 description = "Orchestra CLI. Perform operations with Orchestra locally."
 readme = "README.md"
 authors = [