Merge branch 'main' of https://github.com/UiPath/uipath-python into josh/cas-interrupt

Author: JoshParkSJ

.github/labeler.yml

@@ -1,7 +1,15 @@
+test:uipath-langchain:
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath/src/**/*.py']
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath-platform/src/**/*.py']
+  - changed-files:
+    - any-glob-to-any-file: ['packages/uipath-core/src/**/*.py']
+
 test:uipath-llamaindex:
   - changed-files:
-    - any-glob-to-any-file: ['src/**/*.py']
+    - any-glob-to-any-file: ['packages/uipath/src/**/*.py']
 
-test:uipath-langchain:
+test:uipath-runtime:
   - changed-files:
-    - any-glob-to-any-file: ['src/**/*.py']
+    - any-glob-to-any-file: ['packages/uipath-core/src/**/*.py']

.github/scripts/detect_changed_packages.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Detect which packages have changed in a PR or push to main.
+
+Includes dependency-aware propagation: when a package changes, all
+downstream dependents are also included in the test list.
+"""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+# Internal dependency graph: package -> packages that depend on it.
+# When a package changes, its dependents' tests also run.
+# Add new entries here as packages are added to the monorepo.
+# External dependents (uipath-langchain, uipath-runtime, etc.) are
+# handled separately via labeler.yml auto-labels.
+DEPENDENTS: dict[str, list[str]] = {
+    "uipath-core": ["uipath-platform", "uipath"],
+    "uipath-platform": ["uipath"],
+}
+
+
+def expand_with_dependents(changed: list[str], all_packages: list[str]) -> list[str]:
+    """Expand changed package list to include downstream dependents."""
+    expanded = set(changed)
+    for pkg in changed:
+        for dep in DEPENDENTS.get(pkg, []):
+            if dep in all_packages:
+                expanded.add(dep)
+    return sorted(expanded)
+
+
+def get_all_packages() -> list[str]:
+    """Get all packages in the monorepo."""
+    packages_dir = Path("packages")
+    packages = []
+
+    for item in packages_dir.iterdir():
+        if item.is_dir() and (item / "pyproject.toml").exists():
+            packages.append(item.name)
+
+    return sorted(packages)
+
+
+def get_changed_packages(base_sha: str, head_sha: str) -> list[str]:
+    """Get packages that have changed between two commits."""
+    try:
+        # Get changed files
+        result = subprocess.run(
+            ["git", "diff", "--name-only", f"{base_sha}...{head_sha}"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        changed_files = result.stdout.strip().split("\n")
+
+        # Extract package names from paths like "packages/uipath-llamaindex/..."
+        changed_packages = set()
+        for file_path in changed_files:
+            if file_path.startswith("packages/"):
+                parts = file_path.split("/")
+                if len(parts) >= 2:
+                    package_name = parts[1]
+                    # Verify it's a real package
+                    if (Path("packages") / package_name / "pyproject.toml").exists():
+                        changed_packages.add(package_name)
+
+        return sorted(changed_packages)
+
+    except subprocess.CalledProcessError as e:
+        print(f"Error running git diff: {e}", file=sys.stderr)
+        return []
+
+
+def get_changed_packages_auto() -> list[str]:
+    """Auto-detect changed packages using git."""
+    try:
+        # Try to detect changes against origin/main
+        result = subprocess.run(
+            ["git", "diff", "--name-only", "origin/main...HEAD"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        changed_files = result.stdout.strip().split("\n")
+
+        # Extract package names
+        changed_packages = set()
+        for file_path in changed_files:
+            if file_path.startswith("packages/"):
+                parts = file_path.split("/")
+                if len(parts) >= 2:
+                    package_name = parts[1]
+                    if (Path("packages") / package_name / "pyproject.toml").exists():
+                        changed_packages.add(package_name)
+
+        return sorted(changed_packages)
+
+    except (subprocess.CalledProcessError, Exception) as e:
+        print(f"Warning: Could not auto-detect changes: {e}", file=sys.stderr)
+        return []
+
+
+def main():
+    """Main entry point."""
+    event_name = os.getenv("GITHUB_EVENT_NAME", "")
+    base_sha = os.getenv("BASE_SHA", "")
+    head_sha = os.getenv("HEAD_SHA", "")
+
+    all_packages = get_all_packages()
+
+    # If we have explicit SHAs (from PR or push), detect changed packages
+    if base_sha and head_sha:
+        packages = get_changed_packages(base_sha, head_sha)
+        event_type = "pull request" if event_name == "pull_request" else "push"
+        print(f"{event_type.capitalize()} - detected {len(packages)} directly changed package(s):")
+        for pkg in packages:
+            print(f"  - {pkg}")
+
+    # workflow_call or missing context - try auto-detection
+    else:
+        print(f"Event: {event_name or 'workflow_call'} - attempting auto-detection")
+        packages = get_changed_packages_auto()
+
+        if packages:
+            print(f"Auto-detected {len(packages)} directly changed package(s):")
+            for pkg in packages:
+                print(f"  - {pkg}")
+        else:
+            # Fallback: test all packages
+            print("Could not detect changes - testing all packages")
+            packages = all_packages
+            for pkg in packages:
+                print(f"  - {pkg}")
+
+    # Expand with downstream dependents
+    expanded = expand_with_dependents(packages, all_packages)
+    added = sorted(set(expanded) - set(packages))
+    if added:
+        print(f"\nAdded {len(added)} dependent package(s):")
+        for pkg in added:
+            print(f"  - {pkg}")
+    packages = expanded
+
+    # Output as JSON for GitHub Actions
+    packages_json = json.dumps(packages)
+    print(f"\nPackages JSON: {packages_json}")
+
+    # Write to GitHub output
+    github_output = os.getenv("GITHUB_OUTPUT")
+    if github_output:
+        with open(github_output, "a") as f:
+            f.write(f"packages={packages_json}\n")
+            f.write(f"count={len(packages)}\n")
+
+
+if __name__ == "__main__":
+    main()

.github/scripts/detect_publishable_packages.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Detect which packages need publishing to PyPI.
+
+Compares local package versions against what's already on PyPI.
+Only outputs packages whose local version doesn't exist on PyPI yet.
+"""
+
+import json
+import os
+import sys
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+def get_all_packages() -> list[dict[str, str]]:
+    """Get all packages with their names and versions from pyproject.toml."""
+    packages_dir = Path("packages")
+    packages = []
+
+    for item in sorted(packages_dir.iterdir()):
+        pyproject = item / "pyproject.toml"
+        if item.is_dir() and pyproject.exists():
+            with open(pyproject, "rb") as f:
+                data = tomllib.load(f)
+            project = data.get("project", {})
+            name = project.get("name")
+            version = project.get("version")
+            if name and version:
+                packages.append(
+                    {"directory": item.name, "name": name, "version": version}
+                )
+
+    return packages
+
+
+def version_exists_on_pypi(package_name: str, version: str) -> bool:
+    """Check if a specific version of a package exists on PyPI."""
+    url = f"https://pypi.org/pypi/{package_name}/{version}/json"
+    try:
+        req = urllib.request.Request(url, method="HEAD")
+        with urllib.request.urlopen(req, timeout=10):
+            return True
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return False
+        print(
+            f"  Warning: PyPI returned HTTP {e.code} for {package_name}=={version}",
+            file=sys.stderr,
+        )
+        return False
+    except Exception as e:
+        print(
+            f"  Warning: Could not check PyPI for {package_name}=={version}: {e}",
+            file=sys.stderr,
+        )
+        # If we can't reach PyPI, skip publishing to be safe
+        return True
+
+
+def main():
+    """Main entry point."""
+    all_packages = get_all_packages()
+    publishable = []
+
+    print(f"Checking {len(all_packages)} package(s) against PyPI...")
+
+    for pkg in all_packages:
+        name, version, directory = pkg["name"], pkg["version"], pkg["directory"]
+        exists = version_exists_on_pypi(name, version)
+        if exists:
+            print(f"  {name}=={version} — already on PyPI, skipping")
+        else:
+            print(f"  {name}=={version} — new version, will publish")
+            publishable.append(directory)
+
+    # Output as JSON for GitHub Actions
+    packages_json = json.dumps(publishable)
+    print(f"\nPublishable packages JSON: {packages_json}")
+
+    github_output = os.getenv("GITHUB_OUTPUT")
+    if github_output:
+        with open(github_output, "a") as f:
+            f.write(f"packages={packages_json}\n")
+            f.write(f"count={len(publishable)}\n")
+
+
+if __name__ == "__main__":
+    main()