recce-nightly 1.9.0.20250623__py3-none-any.whl → 1.25.0.20251112a2066__py3-none-any.whl

recce/util/perf_tracking.py

@@ -0,0 +1,85 @@
+import time
+from dataclasses import dataclass
+
+
+@dataclass
+class LineagePerfTracker:
+    lineage_start = None
+    lineage_elapsed = None
+    column_lineage_start = None
+    column_lineage_elapsed = None
+
+    total_nodes = None
+    init_nodes = None
+    cll_nodes = 0
+    change_analysis_nodes = 0
+    anchor_nodes = None
+
+    params = None
+
+    def start_lineage(self):
+        self.lineage_start = time.perf_counter_ns()
+
+    def end_lineage(self):
+        if self.lineage_start is None:
+            return
+        self.lineage_elapsed = (time.perf_counter_ns() - self.lineage_start) / 1000000
+
+    def start_column_lineage(self):
+        self.column_lineage_start = time.perf_counter_ns()
+
+    def end_column_lineage(self):
+        if self.column_lineage_start is None:
+            return
+        self.column_lineage_elapsed = (time.perf_counter_ns() - self.column_lineage_start) / 1000000
+
+    def set_total_nodes(self, total_nodes):
+        self.total_nodes = total_nodes
+
+    def set_init_nodes(self, init_nodes):
+        self.init_nodes = init_nodes
+
+    def set_anchor_nodes(self, anchor_nodes):
+        self.anchor_nodes = anchor_nodes
+
+    def increment_cll_nodes(self):
+        self.cll_nodes += 1
+
+    def increment_change_analysis_nodes(self):
+        self.change_analysis_nodes += 1
+
+    def set_params(self, has_node, has_column, change_analysis, no_cll, no_upstream, no_downstream):
+        self.params = {
+            "has_node": has_node,
+            "has_column": has_column,
+            "change_analysis": change_analysis,
+            "no_cll": no_cll,
+            "no_upstream": no_upstream,
+            "no_downstream": no_downstream,
+        }
+
+    def to_dict(self):
+        return {
+            "lineage_elapsed_ms": self.lineage_elapsed,
+            "column_lineage_elapsed_ms": self.column_lineage_elapsed,
+            "total_nodes": self.total_nodes,
+            "init_nodes": self.init_nodes,
+            "cll_nodes": self.cll_nodes,
+            "change_analysis_nodes": self.change_analysis_nodes,
+            "anchor_nodes": self.anchor_nodes,
+            "params": self.params,
+        }
+
+    def reset(self):
+        self.lineage_start = None
+        self.lineage_elapsed = None
+        self.column_lineage_start = None
+        self.column_lineage_elapsed = None
+
+        self.total_nodes = None
+        self.init_nodes = None
+        self.change_analysis_nodes = 0
+        self.cll_nodes = 0
+        self.anchor_nodes = 0
+
+        self.params = None

recce/util/recce_cloud.py

@@ -12,6 +12,9 @@ from recce.pull_request import PullRequestInfo
 RECCE_CLOUD_API_HOST = os.environ.get("RECCE_CLOUD_API_HOST", "https://cloud.datarecce.io")
 RECCE_CLOUD_BASE_URL = os.environ.get("RECCE_CLOUD_BASE_URL", RECCE_CLOUD_API_HOST)
 
+DOCKER_INTERNAL_URL_PREFIX = "http://host.docker.internal"
+LOCALHOST_URL_PREFIX = "http://localhost"
+
 logger = logging.getLogger("uvicorn")
 
 
@@ -39,6 +42,7 @@ class RecceCloud:
         self.token = token
         self.token_type = "github_token" if token.startswith(("ghp_", "gho_", "ghu_", "ghs_", "ghr_")) else "api_token"
         self.base_url = f"{RECCE_CLOUD_API_HOST}/api/v1"
+        self.base_url_v2 = f"{RECCE_CLOUD_API_HOST}/api/v2"
 
     def _request(self, method, url, headers: Dict = None, **kwargs):
         headers = {
@@ -66,7 +70,7 @@ class RecceCloud:
             pass
         return False
 
-    def get_presigned_url(
+    def get_presigned_url_by_github_repo(
         self,
         method: PresignedUrlMethod,
         repository: str,
@@ -78,7 +82,37 @@ class RecceCloud:
         response = self._fetch_presigned_url(method, repository, artifact_name, metadata, pr_id, branch)
         return response.get("presigned_url")
 
-    def get_download_presigned_url_with_tags(
+    def _replace_localhost_with_docker_internal(self, url: str) -> str:
+        if url is None:
+            return None
+        if (
+            os.environ.get("RECCE_SHARE_INSTANCE_ENV") == "docker"
+            or os.environ.get("RECCE_TASK_INSTANCE_ENV") == "docker"
+            or os.environ.get("RECCE_INSTANCE_ENV") == "docker"
+        ):
+            # For local development, convert the presigned URL from localhost to host.docker.internal
+            if url.startswith(LOCALHOST_URL_PREFIX):
+                return url.replace(LOCALHOST_URL_PREFIX, DOCKER_INTERNAL_URL_PREFIX)
+        return url
+
+    def get_presigned_url_by_share_id(
+        self,
+        method: PresignedUrlMethod,
+        share_id: str,
+        metadata: dict = None,
+    ) -> str:
+        response = self._fetch_presigned_url_by_share_id(method, share_id, metadata=metadata)
+        presigned_url = response.get("presigned_url")
+        if not presigned_url:
+            raise RecceCloudException(
+                message="Failed to get presigned URL from Recce Cloud.",
+                reason="No presigned URL returned from the server.",
+                status_code=404,
+            )
+        presigned_url = self._replace_localhost_with_docker_internal(presigned_url)
+        return presigned_url
+
+    def get_download_presigned_url_by_github_repo_with_tags(
         self, repository: str, artifact_name: str, branch: str = None
     ) -> (str, dict):
         response = self._fetch_presigned_url(PresignedUrlMethod.DOWNLOAD, repository, artifact_name, branch=branch)
@@ -110,6 +144,33 @@ class RecceCloud:
             )
         return response.json()
 
+    def _fetch_presigned_url_by_share_id(
+        self,
+        method: PresignedUrlMethod,
+        share_id: str,
+        metadata: dict = None,
+    ):
+        api_url = f"{self.base_url}/shares/{share_id}/presigned/{method}"
+        data = None
+        # Only provide metadata for upload requests
+        if method == PresignedUrlMethod.UPLOAD:
+            # Covert metadata values to strings to ensure JSON serializability
+            data = {"metadata": {key: str(value) for key, value in metadata.items()}} if metadata else None
+        response = self._request(
+            "POST",
+            api_url,
+            json=data,
+        )
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to {method} artifact {preposition} Recce Cloud.".format(
+                    method=method, preposition="from" if method == PresignedUrlMethod.DOWNLOAD else "to"
+                ),
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        return response.json()
+
     def get_artifact_metadata(self, pr_info: PullRequestInfo) -> dict:
         api_url = f"{self.base_url}/{pr_info.repository}/pulls/{pr_info.id}/metadata"
         response = self._request("GET", api_url)
@@ -123,12 +184,22 @@ class RecceCloud:
             )
         return response.json()
 
-    def purge_artifacts(self, pr_info: PullRequestInfo):
-        api_url = f"{self.base_url}/{pr_info.repository}/pulls/{pr_info.id}/artifacts"
+    def purge_artifacts(self, repository: str, pr_id: int = None, branch: str = None):
+        if pr_id is not None:
+            api_url = f"{self.base_url}/{repository}/pulls/{pr_id}/artifacts"
+            error_message = "Failed to purge artifacts from Recce Cloud."
+        elif branch is not None:
+            api_url = f"{self.base_url}/{repository}/commits/{branch}/artifacts"
+            error_message = "Failed to delete artifacts from Recce Cloud."
+        else:
+            raise ValueError(
+                "Please either run this command from within a pull request context "
+                "or specify a branch using the --branch option."
+            )
         response = self._request("DELETE", api_url)
         if response.status_code != 204:
             raise RecceCloudException(
-                message="Failed to purge artifacts from Recce Cloud.",
+                message=error_message,
                 reason=response.text,
                 status_code=response.status_code,
             )
@@ -188,8 +259,161 @@ class RecceCloud:
             logger.warning(f"Failed to set Onboarding State in Recce Cloud. Reason: {str(e)}")
         return
 
+    def get_session(self, session_id: str):
+        api_url = f"{self.base_url_v2}/sessions/{session_id}"
+        response = self._request("GET", api_url)
+        if response.status_code == 403:
+            return {"status": "error", "message": response.json().get("detail")}
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to get session from Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        if data["success"] is not True:
+            raise RecceCloudException(
+                message="Failed to get session from Recce Cloud.",
+                reason=data.get("message", "Unknown error"),
+                status_code=response.status_code,
+            )
+        return data["session"]
+
+    def update_session(self, org_id: str, project_id: str, session_id: str, adapter_type: str):
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions/{session_id}"
+        data = {"adapter_type": adapter_type}
+        response = self._request("PATCH", api_url, json=data)
+        if response.status_code == 403:
+            return {"status": "error", "message": response.json().get("detail")}
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to update session in Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        return response.json()
+
+    def get_download_urls_by_session_id(self, org_id: str, project_id: str, session_id: str) -> dict[str, str]:
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions/{session_id}/download-url"
+        response = self._request("GET", api_url)
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to download session from Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        if data["presigned_urls"] is None:
+            raise RecceCloudException(
+                message="No presigned URLs returned from the server.",
+                reason="",
+                status_code=404,
+            )
+
+        presigned_urls = data["presigned_urls"]
+        for key, url in presigned_urls.items():
+            presigned_urls[key] = self._replace_localhost_with_docker_internal(url)
+        return presigned_urls
+
+    def get_base_session_download_urls(self, org_id: str, project_id: str) -> dict[str, str]:
+        """Get download URLs for the base session of a project."""
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/base-session/download-url"
+        response = self._request("GET", api_url)
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to download base session from Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        if data["presigned_urls"] is None:
+            raise RecceCloudException(
+                message="No presigned URLs returned from the server.",
+                reason="",
+                status_code=404,
+            )
+
+        presigned_urls = data["presigned_urls"]
+        for key, url in presigned_urls.items():
+            presigned_urls[key] = self._replace_localhost_with_docker_internal(url)
+        return presigned_urls
+
+    def get_upload_urls_by_session_id(self, org_id: str, project_id: str, session_id: str) -> dict[str, str]:
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions/{session_id}/upload-url"
+        response = self._request("GET", api_url)
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to get upload URLs for session from Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        if data["presigned_urls"] is None:
+            raise RecceCloudException(
+                message="No presigned URLs returned from the server.",
+                reason="",
+                status_code=404,
+            )
+
+        presigned_urls = data["presigned_urls"]
+        for key, url in presigned_urls.items():
+            presigned_urls[key] = self._replace_localhost_with_docker_internal(url)
+        return presigned_urls
+
+    def post_recce_state_uploaded_by_session_id(self, org_id: str, project_id: str, session_id: str):
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions/{session_id}/recce-state-uploaded"
+        response = self._request("POST", api_url)
+        if response.status_code != 204:
+            raise RecceCloudException(
+                message="Failed to notify state uploaded for session in Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+    def list_organizations(self) -> list:
+        """List all organizations the user has access to."""
+        api_url = f"{self.base_url_v2}/organizations"
+        response = self._request("GET", api_url)
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to list organizations from Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        return data.get("organizations", [])
+
+    def list_projects(self, org_id: str) -> list:
+        """List all projects in an organization."""
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects"
+        response = self._request("GET", api_url)
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to list projects from Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        return data.get("projects", [])
+
+    def list_sessions(self, org_id: str, project_id: str) -> list:
+        """List all sessions in a project."""
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions"
+        response = self._request("GET", api_url)
+        if response.status_code != 200:
+            raise RecceCloudException(
+                message="Failed to list sessions from Recce Cloud.",
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        return data.get("sessions", [])
+
 
 def get_recce_cloud_onboarding_state(token: str) -> str:
+    if token and token.startswith("rct-"):
+        return "undefined"
+
     try:
         recce_cloud = RecceCloud(token)
         user_info = recce_cloud.get_user_info()

recce/yaml/__init__.py

@@ -34,7 +34,7 @@ def dump(data, stream: Any = None, *, transform: Any = None) -> Any:
 
 def safe_load_yaml(file_path):
     try:
-        with open(file_path, "r") as f:
+        with open(file_path, "r", encoding="utf-8") as f:
             payload = safe_load(f)
     except yaml.YAMLError as e:
         print(e)
@@ -45,7 +45,7 @@ def safe_load_yaml(file_path):
 
 
 def round_trip_load_yaml(file_path):
-    with open(file_path, "r") as f:
+    with open(file_path, "r", encoding="utf-8") as f:
         try:
             payload = load(f)
         except yaml.YAMLError as e:

recce_cloud/__init__.py

@@ -0,0 +1,15 @@
+"""Recce Cloud - Lightweight CLI for Recce Cloud operations."""
+
+import os
+
+
+def get_version():
+    """Get version from main recce VERSION file."""
+    # Reference the VERSION file from main recce package
+    version_file = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "recce", "VERSION"))
+    with open(version_file) as fh:
+        version = fh.read().strip()
+        return version
+
+
+__version__ = get_version()

recce_cloud/api/__init__.py

@@ -0,0 +1,17 @@
+"""Recce Cloud API client module."""
+
+from recce_cloud.api.base import BaseRecceCloudClient
+from recce_cloud.api.client import RecceCloudClient
+from recce_cloud.api.exceptions import RecceCloudException
+from recce_cloud.api.factory import create_platform_client
+from recce_cloud.api.github import GitHubRecceCloudClient
+from recce_cloud.api.gitlab import GitLabRecceCloudClient
+
+__all__ = [
+    "BaseRecceCloudClient",
+    "RecceCloudClient",
+    "RecceCloudException",
+    "create_platform_client",
+    "GitHubRecceCloudClient",
+    "GitLabRecceCloudClient",
+]

recce_cloud/api/base.py

@@ -0,0 +1,104 @@
+"""
+Base API client for Recce Cloud.
+"""
+
+import os
+from abc import ABC, abstractmethod
+from typing import Dict, Optional
+
+import requests
+
+from recce_cloud.api.exceptions import RecceCloudException
+
+
+class BaseRecceCloudClient(ABC):
+    """Abstract base class for platform-specific Recce Cloud API clients."""
+
+    def __init__(self, token: str, api_host: Optional[str] = None):
+        """
+        Initialize the API client.
+
+        Args:
+            token: Authentication token (GITHUB_TOKEN, CI_JOB_TOKEN, or RECCE_API_TOKEN)
+            api_host: Recce Cloud API host (defaults to RECCE_CLOUD_API_HOST or https://cloud.datarecce.io)
+        """
+        self.token = token
+        self.api_host = api_host or os.getenv("RECCE_CLOUD_API_HOST", "https://cloud.datarecce.io")
+
+    def _make_request(self, method: str, url: str, **kwargs) -> Dict:
+        """
+        Make an HTTP request to Recce Cloud API.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, etc.)
+            url: Full URL for the request
+            **kwargs: Additional arguments passed to requests
+
+        Returns:
+            Response JSON as dictionary
+
+        Raises:
+            RecceCloudException: If the request fails
+        """
+        headers = kwargs.pop("headers", {})
+        headers.update(
+            {
+                "Authorization": f"Bearer {self.token}",
+                "Content-Type": "application/json",
+            }
+        )
+
+        try:
+            response = requests.request(method, url, headers=headers, **kwargs)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            reason = str(e)
+            if e.response is not None:
+                try:
+                    error_detail = e.response.json()
+                    reason = error_detail.get("message", str(e))
+                except Exception:
+                    reason = e.response.text or str(e)
+            raise RecceCloudException(reason=reason, status_code=e.response.status_code if e.response else None)
+        except requests.exceptions.RequestException as e:
+            raise RecceCloudException(reason=str(e))
+
+    @abstractmethod
+    def touch_recce_session(
+        self,
+        branch: str,
+        adapter_type: str,
+        cr_number: Optional[int] = None,
+        commit_sha: Optional[str] = None,
+    ) -> Dict:
+        """
+        Create or touch a Recce session.
+
+        Args:
+            branch: Branch name
+            adapter_type: DBT adapter type (e.g., 'postgres', 'snowflake', 'bigquery')
+            cr_number: Change request number (PR/MR number) for CR sessions
+            commit_sha: Commit SHA (GitLab requires this)
+
+        Returns:
+            Dictionary containing:
+                - session_id: Session ID
+                - manifest_upload_url: Presigned URL for manifest.json upload
+                - catalog_upload_url: Presigned URL for catalog.json upload
+        """
+        pass
+
+    @abstractmethod
+    def upload_completed(self, session_id: str, commit_sha: Optional[str] = None) -> Dict:
+        """
+        Notify Recce Cloud that upload is complete.
+
+        Args:
+            session_id: Session ID from touch_recce_session
+            commit_sha: Commit SHA (GitLab requires this)
+
+        Returns:
+            Empty dictionary or acknowledgement
+        """
+        pass

recce_cloud/api/client.py

@@ -0,0 +1,150 @@
+"""
+Recce Cloud API client for lightweight operations.
+
+Simplified version of recce.util.recce_cloud.RecceCloud with only
+the methods needed for upload-session functionality.
+"""
+
+import os
+
+import requests
+
+from recce_cloud.api.exceptions import RecceCloudException
+
+RECCE_CLOUD_API_HOST = os.environ.get("RECCE_CLOUD_API_HOST", "https://cloud.datarecce.io")
+
+DOCKER_INTERNAL_URL_PREFIX = "http://host.docker.internal"
+LOCALHOST_URL_PREFIX = "http://localhost"
+
+
+class RecceCloudClient:
+    """
+    Lightweight Recce Cloud API client.
+
+    Supports authentication with Recce Cloud API token (starts with "rct-").
+    """
+
+    def __init__(self, token: str):
+        if token is None:
+            raise ValueError("Token cannot be None.")
+        self.token = token
+        self.base_url_v2 = f"{RECCE_CLOUD_API_HOST}/api/v2"
+
+    def _request(self, method: str, url: str, headers: dict = None, **kwargs):
+        """Make authenticated HTTP request to Recce Cloud API."""
+        headers = {
+            **(headers or {}),
+            "Authorization": f"Bearer {self.token}",
+        }
+        return requests.request(method, url, headers=headers, **kwargs)
+
+    def _replace_localhost_with_docker_internal(self, url: str) -> str:
+        """Convert localhost URLs to docker internal URLs if running in Docker."""
+        if url is None:
+            return None
+        if (
+            os.environ.get("RECCE_SHARE_INSTANCE_ENV") == "docker"
+            or os.environ.get("RECCE_TASK_INSTANCE_ENV") == "docker"
+            or os.environ.get("RECCE_INSTANCE_ENV") == "docker"
+        ):
+            # For local development, convert the presigned URL from localhost to host.docker.internal
+            if url.startswith(LOCALHOST_URL_PREFIX):
+                return url.replace(LOCALHOST_URL_PREFIX, DOCKER_INTERNAL_URL_PREFIX)
+        return url
+
+    def get_session(self, session_id: str) -> dict:
+        """
+        Get session information from Recce Cloud.
+
+        Args:
+            session_id: The session ID to retrieve
+
+        Returns:
+            dict containing session information with keys:
+                - org_id: Organization ID
+                - project_id: Project ID
+                - ... other session fields
+
+        Raises:
+            RecceCloudException: If the request fails
+        """
+        api_url = f"{self.base_url_v2}/sessions/{session_id}"
+        response = self._request("GET", api_url)
+        if response.status_code == 403:
+            return {"status": "error", "message": response.json().get("detail")}
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        if data["success"] is not True:
+            raise RecceCloudException(
+                reason=data.get("message", "Unknown error"),
+                status_code=response.status_code,
+            )
+        return data["session"]
+
+    def get_upload_urls_by_session_id(self, org_id: str, project_id: str, session_id: str) -> dict:
+        """
+        Get presigned S3 upload URLs for a session.
+
+        Args:
+            org_id: Organization ID
+            project_id: Project ID
+            session_id: Session ID
+
+        Returns:
+            dict with keys:
+                - manifest_url: Presigned URL for uploading manifest.json
+                - catalog_url: Presigned URL for uploading catalog.json
+
+        Raises:
+            RecceCloudException: If the request fails
+        """
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions/{session_id}/upload-url"
+        response = self._request("GET", api_url)
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        data = response.json()
+        if data["presigned_urls"] is None:
+            raise RecceCloudException(
+                reason="No presigned URLs returned from the server.",
+                status_code=404,
+            )
+
+        presigned_urls = data["presigned_urls"]
+        for key, url in presigned_urls.items():
+            presigned_urls[key] = self._replace_localhost_with_docker_internal(url)
+        return presigned_urls
+
+    def update_session(self, org_id: str, project_id: str, session_id: str, adapter_type: str) -> dict:
+        """
+        Update session metadata with adapter type.
+
+        Args:
+            org_id: Organization ID
+            project_id: Project ID
+            session_id: Session ID
+            adapter_type: dbt adapter type (e.g., "postgres", "snowflake", "bigquery")
+
+        Returns:
+            dict containing updated session information
+
+        Raises:
+            RecceCloudException: If the request fails
+        """
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions/{session_id}"
+        data = {"adapter_type": adapter_type}
+        response = self._request("PATCH", api_url, json=data)
+        if response.status_code == 403:
+            return {"status": "error", "message": response.json().get("detail")}
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+        return response.json()