recce-cloud-nightly 1.26.0.20251124.post1__py3-none-any.whl

recce_cloud/VERSION

@@ -0,0 +1 @@
+1.26.0.20251124-post1

recce_cloud/__init__.py

@@ -0,0 +1,24 @@
+"""Recce Cloud - Lightweight CLI for Recce Cloud operations."""
+
+import os
+
+
+def get_version():
+    """Get version from VERSION file."""
+    # Try recce_cloud/VERSION first (for standalone package)
+    version_file = os.path.join(os.path.dirname(__file__), "VERSION")
+    if os.path.exists(version_file):
+        with open(version_file) as fh:
+            return fh.read().strip()
+
+    # Fallback to ../recce/VERSION (for development)
+    version_file = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "recce", "VERSION"))
+    if os.path.exists(version_file):
+        with open(version_file) as fh:
+            return fh.read().strip()
+
+    # Last resort
+    return "unknown"
+
+
+__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,111 @@
+"""
+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()
+
+            # Handle empty responses (e.g., 204 No Content)
+            if response.status_code == 204 or not response.content:
+                return {}
+
+            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,
+        session_type: 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)
+            session_type: Session type ("cr", "prod", "dev") - determines if cr_number is used
+
+        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()

recce_cloud/api/exceptions.py

@@ -0,0 +1,26 @@
+"""
+Exceptions for Recce Cloud API.
+"""
+
+import json
+
+
+class RecceCloudException(Exception):
+    """Exception raised when Recce Cloud API returns an error."""
+
+    def __init__(self, reason: str, status_code: int = None):
+        """
+        Initialize exception.
+
+        Args:
+            reason: Error reason/message
+            status_code: HTTP status code (optional)
+        """
+        try:
+            reason = json.loads(reason).get("detail", reason)
+        except (json.JSONDecodeError, AttributeError):
+            pass
+
+        super().__init__(reason)
+        self.reason = reason
+        self.status_code = status_code

recce_cloud/api/factory.py

@@ -0,0 +1,63 @@
+"""
+Factory for creating platform-specific API clients.
+"""
+
+import os
+from typing import Optional
+
+from recce_cloud.api.github import GitHubRecceCloudClient
+from recce_cloud.api.gitlab import GitLabRecceCloudClient
+from recce_cloud.ci_providers import CIDetector
+from recce_cloud.ci_providers.base import CIInfo
+
+
+def create_platform_client(
+    token: str,
+    ci_info: Optional[CIInfo] = None,
+    api_host: Optional[str] = None,
+):
+    """
+    Create a platform-specific Recce Cloud API client based on CI environment.
+
+    Args:
+        token: Authentication token (GITHUB_TOKEN, CI_JOB_TOKEN, or RECCE_API_TOKEN)
+        ci_info: CI information (auto-detected if not provided)
+        api_host: Recce Cloud API host (optional)
+
+    Returns:
+        GitHubRecceCloudClient or GitLabRecceCloudClient
+
+    Raises:
+        ValueError: If platform is not supported or required information is missing
+    """
+    # Auto-detect CI info if not provided
+    if ci_info is None:
+        ci_info = CIDetector.detect()
+
+    if ci_info.platform == "github-actions":
+        repository = ci_info.repository or os.getenv("GITHUB_REPOSITORY")
+        if not repository:
+            raise ValueError("GitHub repository information is required but not detected")
+
+        return GitHubRecceCloudClient(token=token, repository=repository, api_host=api_host)
+
+    elif ci_info.platform == "gitlab-ci":
+        project_path = ci_info.repository or os.getenv("CI_PROJECT_PATH")
+        repository_url = os.getenv("CI_PROJECT_URL")
+
+        if not project_path:
+            raise ValueError("GitLab project path is required but not detected")
+        if not repository_url:
+            raise ValueError("GitLab project URL is required but not detected")
+
+        return GitLabRecceCloudClient(
+            token=token,
+            project_path=project_path,
+            repository_url=repository_url,
+            api_host=api_host,
+        )
+
+    else:
+        raise ValueError(
+            f"Unsupported platform: {ci_info.platform}. " "Only GitHub Actions and GitLab CI are supported."
+        )

recce_cloud/api/github.py

@@ -0,0 +1,76 @@
+"""
+GitHub-specific API client for Recce Cloud.
+"""
+
+from typing import Dict, Optional
+
+from recce_cloud.api.base import BaseRecceCloudClient
+
+
+class GitHubRecceCloudClient(BaseRecceCloudClient):
+    """GitHub Actions-specific implementation of Recce Cloud API client."""
+
+    def __init__(self, token: str, repository: str, api_host: Optional[str] = None):
+        """
+        Initialize GitHub API client.
+
+        Args:
+            token: GitHub token (GITHUB_TOKEN or RECCE_API_TOKEN)
+            repository: Repository in format "owner/repo"
+            api_host: Recce Cloud API host
+        """
+        super().__init__(token, api_host)
+        self.repository = repository
+
+    def touch_recce_session(
+        self,
+        branch: str,
+        adapter_type: str,
+        cr_number: Optional[int] = None,
+        session_type: Optional[str] = None,
+    ) -> Dict:
+        """
+        Create or touch a Recce session for GitHub Actions.
+
+        Args:
+            branch: Branch name
+            adapter_type: DBT adapter type
+            cr_number: PR number for pull request sessions (None for prod sessions)
+            commit_sha: Not used for GitHub (optional for compatibility)
+            session_type: Session type ("cr", "prod", "dev") - determines if pr_number is passed
+
+        Returns:
+            Dictionary containing session_id, manifest_upload_url, catalog_upload_url
+        """
+        url = f"{self.api_host}/api/v2/github/{self.repository}/touch-recce-session"
+
+        payload = {
+            "branch": branch,
+            "adapter_type": adapter_type,
+        }
+
+        # Only include pr_number for "cr" type sessions
+        # For "prod" type, omit pr_number even if cr_number is detected
+        if session_type == "cr" and cr_number is not None:
+            payload["pr_number"] = cr_number
+
+        return self._make_request("POST", url, json=payload)
+
+    def upload_completed(self, session_id: str, commit_sha: Optional[str] = None) -> Dict:
+        """
+        Notify Recce Cloud that upload is complete for GitHub.
+
+        Args:
+            session_id: Session ID from touch_recce_session
+            commit_sha: Not used for GitHub (optional for compatibility)
+
+        Returns:
+            Empty dictionary or acknowledgement
+        """
+        url = f"{self.api_host}/api/v2/github/{self.repository}/upload-completed"
+
+        payload = {
+            "session_id": session_id,
+        }
+
+        return self._make_request("POST", url, json=payload)

recce_cloud/api/gitlab.py

@@ -0,0 +1,82 @@
+"""
+GitLab-specific API client for Recce Cloud.
+"""
+
+from typing import Dict, Optional
+
+from recce_cloud.api.base import BaseRecceCloudClient
+
+
+class GitLabRecceCloudClient(BaseRecceCloudClient):
+    """GitLab CI-specific implementation of Recce Cloud API client."""
+
+    def __init__(self, token: str, project_path: str, repository_url: str, api_host: Optional[str] = None):
+        """
+        Initialize GitLab API client.
+
+        Args:
+            token: GitLab token (CI_JOB_TOKEN or RECCE_API_TOKEN)
+            project_path: Project path in format "group/project"
+            repository_url: Full repository URL (e.g., https://gitlab.com/group/project)
+            api_host: Recce Cloud API host
+        """
+        super().__init__(token, api_host)
+        self.project_path = project_path
+        self.repository_url = repository_url
+
+    def touch_recce_session(
+        self,
+        branch: str,
+        adapter_type: str,
+        cr_number: Optional[int] = None,
+        commit_sha: Optional[str] = None,
+        session_type: Optional[str] = None,
+    ) -> Dict:
+        """
+        Create or touch a Recce session for GitLab CI.
+
+        Args:
+            branch: Branch name
+            adapter_type: DBT adapter type
+            cr_number: MR IID for merge request sessions (None for prod sessions)
+            commit_sha: Commit SHA (required for GitLab)
+            session_type: Session type ("cr", "prod", "dev") - determines if mr_iid is passed
+
+        Returns:
+            Dictionary containing session_id, manifest_upload_url, catalog_upload_url
+        """
+        url = f"{self.api_host}/api/v2/gitlab/{self.project_path}/touch-recce-session"
+
+        payload = {
+            "branch": branch,
+            "adapter_type": adapter_type,
+            "commit_sha": commit_sha,
+            "repository_url": self.repository_url,
+        }
+
+        # Only include mr_iid for "cr" type sessions
+        # For "prod" type, omit mr_iid even if cr_number is detected
+        if session_type == "cr" and cr_number is not None:
+            payload["mr_iid"] = cr_number
+
+        return self._make_request("POST", url, json=payload)
+
+    def upload_completed(self, session_id: str, commit_sha: Optional[str] = None) -> Dict:
+        """
+        Notify Recce Cloud that upload is complete for GitLab.
+
+        Args:
+            session_id: Session ID from touch_recce_session
+            commit_sha: Commit SHA (required for GitLab)
+
+        Returns:
+            Empty dictionary or acknowledgement
+        """
+        url = f"{self.api_host}/api/v2/gitlab/{self.project_path}/upload-completed"
+
+        payload = {
+            "session_id": session_id,
+            "commit_sha": commit_sha,
+        }
+
+        return self._make_request("POST", url, json=payload)

recce_cloud/artifact.py

@@ -0,0 +1,57 @@
+"""
+Artifact utilities for recce-cloud.
+
+Simplified version of recce.artifact with only the functions needed
+for upload-session functionality.
+"""
+
+import json
+import os
+
+
+def verify_artifacts_path(target_path: str) -> bool:
+    """
+    Verify if the target path contains valid dbt artifacts.
+
+    Args:
+        target_path: Path to the directory containing artifacts
+
+    Returns:
+        True if the target path contains manifest.json and catalog.json
+    """
+    if not target_path:
+        return False
+
+    if not os.path.exists(target_path):
+        return False
+
+    if not os.path.isdir(target_path):
+        return False
+
+    required_artifacts_files = ["manifest.json", "catalog.json"]
+
+    if all(f in os.listdir(target_path) for f in required_artifacts_files):
+        return True
+
+    return False
+
+
+def get_adapter_type(manifest_path: str) -> str:
+    """
+    Extract adapter type from manifest.json.
+
+    Args:
+        manifest_path: Path to manifest.json file
+
+    Returns:
+        Adapter type string (e.g., "postgres", "snowflake", "bigquery")
+
+    Raises:
+        Exception: If adapter type cannot be found in manifest
+    """
+    with open(manifest_path, "r", encoding="utf-8") as f:
+        manifest_data = json.load(f)
+        adapter_type = manifest_data.get("metadata", {}).get("adapter_type")
+        if adapter_type is None:
+            raise Exception("Failed to parse adapter type from manifest.json")
+        return adapter_type

recce_cloud/ci_providers/__init__.py

@@ -0,0 +1,9 @@
+"""
+CI/CD Provider detection and information extraction.
+"""
+
+from recce_cloud.ci_providers.detector import CIDetector
+from recce_cloud.ci_providers.github_actions import GitHubActionsProvider
+from recce_cloud.ci_providers.gitlab_ci import GitLabCIProvider
+
+__all__ = ["CIDetector", "GitHubActionsProvider", "GitLabCIProvider"]