@datarecce/ui 0.1.41 → 0.2.1-nightly.20260402

package/recce-source/recce_cloud/artifact.py

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

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

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

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

@@ -1,82 +0,0 @@
-"""
-Base CI provider interface.
-"""
-
-import subprocess
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Optional
-
-
-@dataclass
-class CIInfo:
-    """Information extracted from CI environment."""
-
-    platform: Optional[str] = None  # "github-actions", "gitlab-ci", etc.
-    cr_number: Optional[int] = None  # Change request number (PR/MR)
-    cr_url: Optional[str] = None  # Change request URL (for session linking)
-    session_type: Optional[str] = None  # "cr", "prod", "dev"
-    commit_sha: Optional[str] = None  # Full commit SHA
-    base_branch: Optional[str] = None  # Target/base branch
-    source_branch: Optional[str] = None  # Source/head branch
-    repository: Optional[str] = None  # Repository path (owner/repo or group/project)
-    access_token: Optional[str] = None  # CI-provided access token (GITHUB_TOKEN, CI_JOB_TOKEN)
-
-
-class BaseCIProvider(ABC):
-    """Abstract base class for CI provider detection and info extraction."""
-
-    @abstractmethod
-    def can_handle(self) -> bool:
-        """
-        Check if this provider can handle the current environment.
-
-        Returns:
-            True if the provider's CI platform is detected
-        """
-        pass
-
-    @abstractmethod
-    def extract_ci_info(self) -> CIInfo:
-        """
-        Extract CI information from environment variables.
-
-        Returns:
-            CIInfo object with extracted information
-        """
-        pass
-
-    @staticmethod
-    def run_git_command(command: list[str]) -> Optional[str]:
-        """
-        Run a git command and return output.
-
-        Args:
-            command: Git command as list (e.g., ['git', 'rev-parse', 'HEAD'])
-
-        Returns:
-            Command output stripped of whitespace, or None if command fails
-        """
-        try:
-            result = subprocess.run(command, capture_output=True, text=True, check=True, timeout=5)
-            return result.stdout.strip()
-        except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
-            return None
-
-    @staticmethod
-    def determine_session_type(cr_number: Optional[int], source_branch: Optional[str]) -> str:
-        """
-        Determine session type based on context.
-
-        Args:
-            cr_number: Change request number (PR/MR)
-            source_branch: Source branch name
-
-        Returns:
-            Session type: "cr", "prod", or "dev"
-        """
-        if cr_number is not None:
-            return "cr"
-        if source_branch in ["main", "master"]:
-            return "prod"
-        return "dev"

package/recce-source/recce_cloud/ci_providers/detector.py

@@ -1,147 +0,0 @@
-"""
-CI provider detection and orchestration.
-"""
-
-import logging
-import os
-from typing import Optional
-
-from recce_cloud.ci_providers.base import BaseCIProvider, CIInfo
-from recce_cloud.ci_providers.github_actions import GitHubActionsProvider
-from recce_cloud.ci_providers.gitlab_ci import GitLabCIProvider
-
-logger = logging.getLogger(__name__)
-
-
-class CIDetector:
-    """
-    Detects CI platform and extracts information.
-
-    Supports:
-    - GitHub Actions
-    - GitLab CI/CD
-    - Generic fallback (git commands)
-    """
-
-    # Order matters: check in priority order
-    PROVIDERS = [
-        GitHubActionsProvider,
-        GitLabCIProvider,
-    ]
-
-    @classmethod
-    def detect(cls) -> CIInfo:
-        """
-        Detect CI platform and extract information.
-
-        Returns:
-            CIInfo object with detected information
-        """
-        # Try each provider in order
-        for provider_class in cls.PROVIDERS:
-            provider = provider_class()
-            if provider.can_handle():
-                logger.info(f"CI Platform: {provider_class.__name__.replace('Provider', '')}")
-                ci_info = provider.extract_ci_info()
-                cls._log_detected_values(ci_info)
-                return ci_info
-
-        # No CI platform detected, use generic fallback
-        logger.info("No CI platform detected, using git fallback")
-        ci_info = cls._fallback_detection()
-        cls._log_detected_values(ci_info)
-        return ci_info
-
-    @classmethod
-    def apply_overrides(
-        cls,
-        ci_info: CIInfo,
-        cr: Optional[int] = None,
-        session_type: Optional[str] = None,
-    ) -> CIInfo:
-        """
-        Apply manual overrides to detected CI information.
-
-        Args:
-            ci_info: Detected CI information
-            cr: Manual change request number override
-            session_type: Manual session type override
-
-        Returns:
-            CIInfo with overrides applied
-        """
-        # Log overrides
-        if cr is not None and cr != ci_info.cr_number:
-            logger.info(f"Using manual override: --cr {cr} (detected: {ci_info.cr_number})")
-            ci_info.cr_number = cr
-            # Rebuild CR URL if we have repository info
-            if ci_info.repository:
-                if ci_info.platform == "github-actions":
-                    ci_info.cr_url = f"https://github.com/{ci_info.repository}/pull/{cr}"
-                elif ci_info.platform == "gitlab-ci":
-                    server_url = os.getenv("CI_SERVER_URL", "https://gitlab.com")
-                    ci_info.cr_url = f"{server_url}/{ci_info.repository}/-/merge_requests/{cr}"
-
-        if session_type is not None and session_type != ci_info.session_type:
-            logger.info(f"Using manual override: --type {session_type} (detected: {ci_info.session_type})")
-            ci_info.session_type = session_type
-
-        # Re-determine session type if CR was overridden
-        if cr is not None:
-            if session_type is None:  # Only if not manually overridden
-                ci_info.session_type = BaseCIProvider.determine_session_type(ci_info.cr_number, ci_info.source_branch)
-
-        return ci_info
-
-    @classmethod
-    def _fallback_detection(cls) -> CIInfo:
-        """
-        Fallback detection using git commands when no CI platform is detected.
-
-        Returns:
-            CIInfo with basic git information
-        """
-        commit_sha = BaseCIProvider.run_git_command(["git", "rev-parse", "HEAD"])
-        source_branch = BaseCIProvider.run_git_command(["git", "branch", "--show-current"])
-
-        session_type = BaseCIProvider.determine_session_type(None, source_branch)
-
-        return CIInfo(
-            platform=None,
-            cr_number=None,
-            session_type=session_type,
-            commit_sha=commit_sha,
-            base_branch="main",  # Default
-            source_branch=source_branch,
-            repository=None,
-        )
-
-    @classmethod
-    def _log_detected_values(cls, ci_info: CIInfo) -> None:
-        """
-        Log detected values for transparency.
-
-        Args:
-            ci_info: Detected CI information
-        """
-        if ci_info.cr_number is not None:
-            if ci_info.platform == "github-actions":
-                logger.info(f"Detected PR number: {ci_info.cr_number}")
-            elif ci_info.platform == "gitlab-ci":
-                logger.info(f"Detected MR number: {ci_info.cr_number}")
-            else:
-                logger.info(f"Detected CR number: {ci_info.cr_number}")
-        else:
-            logger.info("No CR number detected")
-
-        if ci_info.commit_sha:
-            logger.info(f"Detected commit SHA: {ci_info.commit_sha[:8]}...")
-        else:
-            logger.warning("Could not detect commit SHA")
-
-        logger.info(f"Detected base branch: {ci_info.base_branch}")
-        logger.info(f"Detected source branch: {ci_info.source_branch}")
-        logger.info(f"Session type: {ci_info.session_type}")
-
-        if ci_info.repository:
-            logger.info(f"Repository: {ci_info.repository}")

package/recce-source/recce_cloud/ci_providers/github_actions.py

@@ -1,136 +0,0 @@
-"""
-GitHub Actions CI provider.
-"""
-
-import json
-import os
-from typing import Optional
-
-from recce_cloud.ci_providers.base import BaseCIProvider, CIInfo
-
-
-class GitHubActionsProvider(BaseCIProvider):
-    """GitHub Actions CI provider implementation."""
-
-    def can_handle(self) -> bool:
-        """
-        Check if running in GitHub Actions.
-
-        Returns:
-            True if GITHUB_ACTIONS environment variable is 'true'
-        """
-        return os.getenv("GITHUB_ACTIONS") == "true"
-
-    def extract_ci_info(self) -> CIInfo:
-        """
-        Extract CI information from GitHub Actions environment.
-
-        Environment variables used:
-        - GITHUB_EVENT_PATH: Path to event payload JSON (for PR number)
-        - GITHUB_SHA: Commit SHA
-        - GITHUB_BASE_REF: Base/target branch (PR only)
-        - GITHUB_HEAD_REF: Source/head branch (PR only)
-        - GITHUB_REF_NAME: Branch name (fallback)
-        - GITHUB_REPOSITORY: Repository (owner/repo)
-        - GITHUB_TOKEN: Default access token (automatically provided by GitHub Actions)
-
-        Returns:
-            CIInfo object with extracted information
-        """
-        cr_number = self._extract_pr_number()
-        commit_sha = self._extract_commit_sha()
-        base_branch = self._extract_base_branch()
-        source_branch = self._extract_source_branch()
-        repository = os.getenv("GITHUB_REPOSITORY")
-        access_token = os.getenv("GITHUB_TOKEN")
-
-        # Build CR URL (PR URL) if we have the necessary information
-        cr_url = None
-        if cr_number is not None and repository:
-            cr_url = f"https://github.com/{repository}/pull/{cr_number}"
-
-        session_type = self.determine_session_type(cr_number, source_branch)
-
-        return CIInfo(
-            platform="github-actions",
-            cr_number=cr_number,
-            cr_url=cr_url,
-            session_type=session_type,
-            commit_sha=commit_sha,
-            base_branch=base_branch,
-            source_branch=source_branch,
-            repository=repository,
-            access_token=access_token,
-        )
-
-    def _extract_pr_number(self) -> Optional[int]:
-        """
-        Extract PR number from GitHub event payload.
-
-        Returns:
-            PR number if detected, None otherwise
-        """
-        event_path = os.getenv("GITHUB_EVENT_PATH")
-        if not event_path or not os.path.exists(event_path):
-            return None
-
-        try:
-            with open(event_path, "r") as f:
-                event_data = json.load(f)
-                pr_data = event_data.get("pull_request", {})
-                pr_number = pr_data.get("number")
-                if pr_number is not None:
-                    return int(pr_number)
-        except (json.JSONDecodeError, ValueError, OSError):
-            pass
-
-        return None
-
-    def _extract_commit_sha(self) -> Optional[str]:
-        """
-        Extract commit SHA from GitHub Actions environment.
-
-        Returns:
-            Commit SHA if detected, falls back to git command
-        """
-        commit_sha = os.getenv("GITHUB_SHA")
-        if commit_sha:
-            return commit_sha
-
-        # Fallback to git command
-        return self.run_git_command(["git", "rev-parse", "HEAD"])
-
-    def _extract_base_branch(self) -> str:
-        """
-        Extract base/target branch from GitHub Actions environment.
-
-        Returns:
-            Base branch name, defaults to 'main' if not detected
-        """
-        # GITHUB_BASE_REF is only set for pull_request events
-        base_branch = os.getenv("GITHUB_BASE_REF")
-        if base_branch:
-            return base_branch
-
-        # Default to main
-        return "main"
-
-    def _extract_source_branch(self) -> Optional[str]:
-        """
-        Extract source/head branch from GitHub Actions environment.
-
-        Returns:
-            Source branch name if detected
-        """
-        # GITHUB_HEAD_REF is only set for pull_request events
-        source_branch = os.getenv("GITHUB_HEAD_REF")
-        if source_branch:
-            return source_branch
-
-        # Fallback to GITHUB_REF_NAME
-        source_branch = os.getenv("GITHUB_REF_NAME")
-        if source_branch:
-            return source_branch
-
-        # Fallback to git command
-        return self.run_git_command(["git", "branch", "--show-current"])

package/recce-source/recce_cloud/ci_providers/gitlab_ci.py

@@ -1,130 +0,0 @@
-"""
-GitLab CI/CD provider.
-"""
-
-import os
-from typing import Optional
-
-from recce_cloud.ci_providers.base import BaseCIProvider, CIInfo
-
-
-class GitLabCIProvider(BaseCIProvider):
-    """GitLab CI/CD provider implementation."""
-
-    def can_handle(self) -> bool:
-        """
-        Check if running in GitLab CI.
-
-        Returns:
-            True if GITLAB_CI environment variable is 'true'
-        """
-        return os.getenv("GITLAB_CI") == "true"
-
-    def extract_ci_info(self) -> CIInfo:
-        """
-        Extract CI information from GitLab CI environment.
-
-        Environment variables used:
-        - CI_MERGE_REQUEST_IID: Merge request number
-        - CI_COMMIT_SHA: Commit SHA
-        - CI_MERGE_REQUEST_TARGET_BRANCH_NAME: Target branch (MR only)
-        - CI_MERGE_REQUEST_SOURCE_BRANCH_NAME: Source branch (MR only)
-        - CI_COMMIT_REF_NAME: Branch name (fallback)
-        - CI_PROJECT_PATH: Repository path (group/project)
-        - CI_SERVER_URL: GitLab instance URL (defaults to https://gitlab.com)
-        - CI_JOB_TOKEN: Default access token (automatically provided by GitLab CI)
-
-        Returns:
-            CIInfo object with extracted information
-        """
-        cr_number = self._extract_mr_number()
-        commit_sha = self._extract_commit_sha()
-        base_branch = self._extract_base_branch()
-        source_branch = self._extract_source_branch()
-        repository = os.getenv("CI_PROJECT_PATH")
-        access_token = os.getenv("CI_JOB_TOKEN")
-
-        # Build CR URL (MR URL) if we have the necessary information
-        cr_url = None
-        if cr_number is not None and repository:
-            server_url = os.getenv("CI_SERVER_URL", "https://gitlab.com")
-            cr_url = f"{server_url}/{repository}/-/merge_requests/{cr_number}"
-
-        session_type = self.determine_session_type(cr_number, source_branch)
-
-        return CIInfo(
-            platform="gitlab-ci",
-            cr_number=cr_number,
-            cr_url=cr_url,
-            session_type=session_type,
-            commit_sha=commit_sha,
-            base_branch=base_branch,
-            source_branch=source_branch,
-            repository=repository,
-            access_token=access_token,
-        )
-
-    def _extract_mr_number(self) -> Optional[int]:
-        """
-        Extract MR number from GitLab CI environment.
-
-        Returns:
-            MR number if detected, None otherwise
-        """
-        mr_iid = os.getenv("CI_MERGE_REQUEST_IID")
-        if mr_iid:
-            try:
-                return int(mr_iid)
-            except ValueError:
-                pass
-
-        return None
-
-    def _extract_commit_sha(self) -> Optional[str]:
-        """
-        Extract commit SHA from GitLab CI environment.
-
-        Returns:
-            Commit SHA if detected, falls back to git command
-        """
-        commit_sha = os.getenv("CI_COMMIT_SHA")
-        if commit_sha:
-            return commit_sha
-
-        # Fallback to git command
-        return self.run_git_command(["git", "rev-parse", "HEAD"])
-
-    def _extract_base_branch(self) -> str:
-        """
-        Extract base/target branch from GitLab CI environment.
-
-        Returns:
-            Base branch name, defaults to 'main' if not detected
-        """
-        # CI_MERGE_REQUEST_TARGET_BRANCH_NAME is only set for merge request pipelines
-        base_branch = os.getenv("CI_MERGE_REQUEST_TARGET_BRANCH_NAME")
-        if base_branch:
-            return base_branch
-
-        # Default to main
-        return "main"
-
-    def _extract_source_branch(self) -> Optional[str]:
-        """
-        Extract source branch from GitLab CI environment.
-
-        Returns:
-            Source branch name if detected
-        """
-        # CI_MERGE_REQUEST_SOURCE_BRANCH_NAME is only set for merge request pipelines
-        source_branch = os.getenv("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME")
-        if source_branch:
-            return source_branch
-
-        # Fallback to CI_COMMIT_REF_NAME
-        source_branch = os.getenv("CI_COMMIT_REF_NAME")
-        if source_branch:
-            return source_branch
-
-        # Fallback to git command
-        return self.run_git_command(["git", "branch", "--show-current"])