@datarecce/ui 0.1.40 → 0.2.0

package/recce-source/recce_cloud/VERSION

@@ -1 +0,0 @@
-1.31.0.dev0

package/recce-source/recce_cloud/__init__.py

@@ -1,24 +0,0 @@
-"""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()

package/recce-source/recce_cloud/api/__init__.py

@@ -1,17 +0,0 @@
-"""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",
-]

package/recce-source/recce_cloud/api/base.py

@@ -1,132 +0,0 @@
-"""
-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
-
-    @abstractmethod
-    def get_session_download_urls(
-        self,
-        cr_number: Optional[int] = None,
-        session_type: Optional[str] = None,
-    ) -> Dict:
-        """
-        Get download URLs for artifacts from a session.
-
-        Args:
-            cr_number: Change request number (PR/MR number) for CR sessions
-            session_type: Session type ("cr", "prod", "dev")
-
-        Returns:
-            Dictionary containing:
-                - session_id: Session ID
-                - manifest_url: Presigned URL for manifest.json download
-                - catalog_url: Presigned URL for catalog.json download
-        """
-        pass

package/recce-source/recce_cloud/api/client.py

@@ -1,186 +0,0 @@
-"""
-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 get_download_urls_by_session_id(self, org_id: str, project_id: str, session_id: str) -> dict:
-        """
-        Get presigned S3 download 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 downloading manifest.json
-                - catalog_url: Presigned URL for downloading catalog.json
-
-        Raises:
-            RecceCloudException: If the request fails
-        """
-        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(
-                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()

package/recce-source/recce_cloud/api/exceptions.py

@@ -1,26 +0,0 @@
-"""
-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

package/recce-source/recce_cloud/api/factory.py

@@ -1,63 +0,0 @@
-"""
-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."
-        )

package/recce-source/recce_cloud/api/github.py

@@ -1,106 +0,0 @@
-"""
-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,
-        commit_sha: Optional[str] = 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)
-
-    def get_session_download_urls(
-        self,
-        cr_number: Optional[int] = None,
-        session_type: Optional[str] = None,
-    ) -> Dict:
-        """
-        Get download URLs for artifacts from a GitHub session.
-
-        Args:
-            cr_number: PR number for pull request sessions
-            session_type: Session type ("cr", "prod", "dev")
-
-        Returns:
-            Dictionary containing session_id, manifest_url, catalog_url
-        """
-        url = f"{self.api_host}/api/v2/github/{self.repository}/session-download-url"
-
-        # Build query parameters
-        params = {}
-
-        # For prod session, set base=true
-        if session_type == "prod":
-            params["base"] = "true"
-        # For CR session, include pr_number
-        elif session_type == "cr" and cr_number is not None:
-            params["pr_number"] = cr_number
-
-        return self._make_request("GET", url, params=params)

package/recce-source/recce_cloud/api/gitlab.py

@@ -1,111 +0,0 @@
-"""
-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)
-
-    def get_session_download_urls(
-        self,
-        cr_number: Optional[int] = None,
-        session_type: Optional[str] = None,
-    ) -> Dict:
-        """
-        Get download URLs for artifacts from a GitLab session.
-
-        Args:
-            cr_number: MR IID for merge request sessions
-            session_type: Session type ("cr", "prod", "dev")
-
-        Returns:
-            Dictionary containing session_id, manifest_url, catalog_url
-        """
-        url = f"{self.api_host}/api/v2/gitlab/{self.project_path}/session-download-url"
-
-        # Build query parameters
-        params = {}
-
-        # For prod session, set base=true
-        if session_type == "prod":
-            params["base"] = "true"
-        # For CR session, include mr_iid
-        elif session_type == "cr" and cr_number is not None:
-            params["mr_iid"] = cr_number
-
-        return self._make_request("GET", url, params=params)