recce-cloud 1.33.1__py3-none-any.whl → 1.34.0__py3-none-any.whl

recce_cloud/review.py

@@ -0,0 +1,541 @@
+"""
+Data review helper functions for recce-cloud CLI.
+
+Handles the business logic for generating and retrieving data reviews.
+"""
+
+import json
+import os
+import sys
+import time
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from recce_cloud.api.client import RecceCloudClient
+from recce_cloud.api.exceptions import RecceCloudException
+
+# Cloud UI configuration - use same defaults as auth/login.py
+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)
+
+
+class ReviewStatus(Enum):
+    """Status of the data review generation.
+
+    These align with Recce Cloud UI/backend task statuses where applicable.
+    """
+
+    # Terminal states (align with backend RecceTaskStatus)
+    SUCCEEDED = "SUCCEEDED"
+    FAILED = "FAILED"
+
+    # CLI-specific states
+    ALREADY_EXISTS = "ALREADY_EXISTS"
+    TIMEOUT = "TIMEOUT"
+
+    # In-progress states (align with backend RecceTaskStatus)
+    QUEUED = "QUEUED"
+    SCHEDULED = "SCHEDULED"
+    RUNNING = "RUNNING"
+
+
+@dataclass
+class ReviewResult:
+    """Result of a data review operation."""
+
+    status: ReviewStatus
+    session_id: Optional[str] = None
+    session_name: Optional[str] = None
+    review_url: Optional[str] = None
+    task_id: Optional[str] = None
+    error_message: Optional[str] = None
+    summary: Optional[str] = None
+
+
+# Default polling configuration
+DEFAULT_POLL_INTERVAL_SECONDS = 5
+DEFAULT_TIMEOUT_SECONDS = 300  # 5 minutes
+
+
+def generate_review_url(
+    org_id: str,
+    project_id: str,
+    session_id: str,
+    client: Optional[RecceCloudClient] = None,
+) -> str:
+    """
+    Generate the URL to view the data review.
+
+    Args:
+        org_id: Organization ID.
+        project_id: Project ID.
+        session_id: Session ID.
+        client: Optional RecceCloudClient to fetch current slugs from API.
+                If provided, the URL will use current slugs (handles renames).
+                If not provided, falls back to using IDs directly.
+
+    Returns:
+        URL string to view the data review.
+    """
+    # Default to using IDs
+    org_slug = org_id
+    project_slug = project_id
+
+    # If client provided, fetch current slugs from API
+    if client:
+        try:
+            org = client.get_organization(org_id)
+            if org:
+                org_slug = org.get("name") or org.get("slug") or org_id
+
+            project = client.get_project(org_id, project_id)
+            if project:
+                project_slug = project.get("name") or project.get("slug") or project_id
+        except Exception:
+            # If API call fails, fall back to using IDs
+            pass
+
+    # Use the Recce Cloud web UI URL (respects RECCE_CLOUD_BASE_URL env var)
+    return f"{RECCE_CLOUD_BASE_URL}/{org_slug}/{project_slug}/{session_id}/review"
+
+
+def check_prerequisites(
+    client: RecceCloudClient,
+    org_id: str,
+    project_id: str,
+    session_name: Optional[str] = None,
+    session_id: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Check prerequisites for data review generation.
+
+    This function calls the backend API which verifies:
+    1. Session must exist
+    2. Session must have artifacts uploaded
+    3. Base session must exist
+    4. Base session must have artifacts uploaded
+
+    Args:
+        client: RecceCloudClient instance.
+        org_id: Organization ID or slug.
+        project_id: Project ID or slug.
+        session_name: Session name to check (used if session_id not provided).
+        session_id: Session ID to check directly (takes precedence over session_name).
+
+    Returns:
+        dict with:
+            - success: bool indicating if all prerequisites are met
+            - session: session dict if found (with id, name, adapter_type)
+            - error: error message if prerequisites not met
+    """
+    result = {
+        "success": False,
+        "session": None,
+        "error": None,
+    }
+
+    # If session_id is not provided, look up by session_name
+    if not session_id:
+        if not session_name:
+            result["error"] = "Either session_id or session_name must be provided"
+            return result
+
+        try:
+            session = client.get_session_by_name(org_id, project_id, session_name)
+            if not session:
+                result["error"] = f"Session '{session_name}' not found in project"
+                return result
+            session_id = session.get("id")
+        except RecceCloudException as e:
+            result["error"] = f"Failed to find session: {e.reason}"
+            return result
+
+    # Call the backend API to check all prerequisites
+    try:
+        prereq_response = client.check_prerequisites(org_id, project_id, session_id)
+
+        # Build session dict from the response
+        result["session"] = {
+            "id": prereq_response.get("session_id"),
+            "name": prereq_response.get("session_name"),
+            "adapter_type": prereq_response.get("adapter_type"),
+        }
+
+        if prereq_response.get("is_ready"):
+            result["success"] = True
+        else:
+            result["error"] = prereq_response.get("reason", "Prerequisites not met")
+
+        return result
+
+    except RecceCloudException as e:
+        result["error"] = f"Failed to check prerequisites: {e.reason}"
+        return result
+
+
+def poll_task_status(
+    client: RecceCloudClient,
+    org_id: str,
+    task_id: str,
+    poll_interval: int = DEFAULT_POLL_INTERVAL_SECONDS,
+    timeout: int = DEFAULT_TIMEOUT_SECONDS,
+    progress_callback=None,
+) -> Dict[str, Any]:
+    """
+    Poll task status until completion or timeout.
+
+    Args:
+        client: RecceCloudClient instance.
+        org_id: Organization ID or slug.
+        task_id: Task ID to poll.
+        poll_interval: Seconds between polls.
+        timeout: Maximum seconds to wait.
+        progress_callback: Optional callback(status_dict) called on each poll.
+
+    Returns:
+        dict with:
+            - success: bool indicating if task completed successfully
+            - status: final task status string
+            - error: error message if failed
+            - task: full task status dict
+    """
+    start_time = time.time()
+    last_status = None
+
+    while True:
+        elapsed = time.time() - start_time
+        if elapsed > timeout:
+            return {
+                "success": False,
+                "status": "timeout",
+                "error": f"Task timed out after {timeout} seconds",
+                "task": None,
+            }
+
+        try:
+            task_status = client.get_task_status(org_id, task_id)
+        except RecceCloudException as e:
+            return {
+                "success": False,
+                "status": "error",
+                "error": f"Failed to get task status: {e.reason}",
+                "task": None,
+            }
+
+        status = task_status.get("status", "unknown")
+
+        # Call progress callback if status changed
+        if progress_callback and status != last_status:
+            progress_callback(task_status)
+            last_status = status
+
+        # Check terminal states (handle both lowercase and uppercase from backend)
+        if status.lower() in ["completed", "succeeded"]:
+            return {
+                "success": True,
+                "status": status,
+                "error": None,
+                "task": task_status,
+            }
+        elif status.lower() in ["failed", "error", "cancelled"]:
+            error_msg = task_status.get("metadata", {}).get("error", f"Task {status}")
+            return {
+                "success": False,
+                "status": status,
+                "error": error_msg,
+                "task": task_status,
+            }
+
+        # Still running, wait and poll again
+        time.sleep(poll_interval)
+
+
+def generate_data_review(
+    console,
+    client: RecceCloudClient,
+    org_id: str,
+    project_id: str,
+    session: Dict[str, Any],
+    regenerate: bool = False,
+    timeout: int = DEFAULT_TIMEOUT_SECONDS,
+    json_output: bool = False,
+) -> ReviewResult:
+    """
+    Generate data review for a session.
+
+    This function handles:
+    1. Checking if a review already exists
+    2. Checking if a task is already running
+    3. Triggering new review generation
+    4. Polling for completion
+
+    Args:
+        console: Rich console for output.
+        client: RecceCloudClient instance.
+        org_id: Organization ID or slug.
+        project_id: Project ID or slug.
+        session: Session dict from API.
+        regenerate: If True, regenerate even if review exists.
+        timeout: Maximum seconds to wait for generation.
+        json_output: If True, suppress progress output.
+
+    Returns:
+        ReviewResult with status and details.
+    """
+    session_id = session["id"]
+    session_name = session.get("name", session_id)
+
+    # 1. Check if review already exists (skip if regenerating)
+    # Note: get_data_review() returns None for 404 (no review), so we don't need try-except for that case.
+    # Let other errors (403, 500) propagate - they indicate real problems that would also fail generation.
+    if not regenerate:
+        existing_review = client.get_data_review(org_id, project_id, session_id)
+        if existing_review and existing_review.get("summary"):
+            return ReviewResult(
+                status=ReviewStatus.ALREADY_EXISTS,
+                session_id=session_id,
+                session_name=session_name,
+                review_url=generate_review_url(org_id, project_id, session_id, client),
+                summary=existing_review.get("summary"),
+            )
+
+    # 2. Check if a task is already running
+    # Note: get_running_task() returns None for 404 (no running task), so we don't need try-except.
+    # Let other errors (403, 500) propagate - they indicate real problems.
+    running_task = client.get_running_task(org_id, project_id, session_id)
+    if running_task:
+        task_id = running_task["task_id"]
+        if not json_output:
+            console.print(f"[yellow]Task already running:[/yellow] {task_id}")
+            console.print("Waiting for completion...")
+    else:
+        task_id = None
+
+    # 3. Trigger new generation if no task running
+    if not task_id:
+        if not json_output:
+            action = "Regenerating" if regenerate else "Generating"
+            console.print(f"[cyan]{action} data review...[/cyan]")
+
+        try:
+            response = client.generate_data_review(org_id, project_id, session_id, regenerate=regenerate)
+            task_id = response.get("task_id")
+
+            if not task_id:
+                # Review was already generated and no new task needed
+                existing_review = client.get_data_review(org_id, project_id, session_id)
+                if existing_review and existing_review.get("summary"):
+                    return ReviewResult(
+                        status=ReviewStatus.ALREADY_EXISTS,
+                        session_id=session_id,
+                        session_name=session_name,
+                        review_url=generate_review_url(org_id, project_id, session_id, client),
+                        summary=existing_review.get("summary"),
+                    )
+                else:
+                    return ReviewResult(
+                        status=ReviewStatus.FAILED,
+                        session_id=session_id,
+                        session_name=session_name,
+                        error_message="No task created and no existing review found",
+                    )
+
+        except RecceCloudException as e:
+            return ReviewResult(
+                status=ReviewStatus.FAILED,
+                session_id=session_id,
+                session_name=session_name,
+                error_message=f"Failed to trigger review generation: {e.reason}",
+            )
+
+    # 4. Poll for completion
+    def progress_callback(task_status):
+        if not json_output:
+            # Display status as-is from backend (aligned with Recce Cloud UI)
+            status = task_status.get("status", "unknown")
+            console.print(f"  Status: [cyan]{status}[/cyan]")
+
+    if not json_output:
+        console.print(f"[cyan]Task ID:[/cyan] {task_id}")
+        console.print("Waiting for review generation to complete...")
+
+    poll_result = poll_task_status(
+        client,
+        org_id,
+        task_id,
+        timeout=timeout,
+        progress_callback=progress_callback if not json_output else None,
+    )
+
+    if poll_result["success"]:
+        # Fetch the generated review
+        try:
+            review = client.get_data_review(org_id, project_id, session_id)
+            return ReviewResult(
+                status=ReviewStatus.SUCCEEDED,
+                session_id=session_id,
+                session_name=session_name,
+                review_url=generate_review_url(org_id, project_id, session_id, client),
+                task_id=task_id,
+                summary=review.get("summary") if review else None,
+            )
+        except RecceCloudException as e:
+            return ReviewResult(
+                status=ReviewStatus.FAILED,
+                session_id=session_id,
+                session_name=session_name,
+                task_id=task_id,
+                error_message=f"Review generated but failed to fetch: {e.reason}",
+            )
+    elif poll_result["status"] == "timeout":
+        return ReviewResult(
+            status=ReviewStatus.TIMEOUT,
+            session_id=session_id,
+            session_name=session_name,
+            task_id=task_id,
+            error_message=poll_result["error"],
+        )
+    else:
+        return ReviewResult(
+            status=ReviewStatus.FAILED,
+            session_id=session_id,
+            session_name=session_name,
+            task_id=task_id,
+            error_message=poll_result["error"],
+        )
+
+
+def run_review_command(
+    console,
+    token: str,
+    org_id: str,
+    project_id: str,
+    session_name: Optional[str] = None,
+    session_id: Optional[str] = None,
+    regenerate: bool = False,
+    timeout: int = DEFAULT_TIMEOUT_SECONDS,
+    json_output: bool = False,
+):
+    """
+    Main entry point for the review command.
+
+    This orchestrates the full review workflow:
+    1. Initialize client
+    2. Check prerequisites
+    3. Generate review
+    4. Display results
+
+    Args:
+        console: Rich console for output.
+        token: API token.
+        org_id: Organization ID or slug.
+        project_id: Project ID or slug.
+        session_name: Session name to generate review for (used if session_id not provided).
+        session_id: Session ID to generate review for (takes precedence over session_name).
+        regenerate: If True, regenerate even if review exists.
+        timeout: Maximum seconds to wait for generation.
+        json_output: If True, output JSON instead of human-readable text.
+    """
+    # 1. Initialize client
+    try:
+        client = RecceCloudClient(token)
+    except Exception as e:
+        if json_output:
+            print(json.dumps({"success": False, "error": f"Failed to initialize client: {e}"}))
+        else:
+            console.print("[red]Error:[/red] Failed to initialize API client")
+            console.print(f"Reason: {e}")
+        sys.exit(2)
+
+    # 2. Check prerequisites
+    if not json_output:
+        console.rule("Checking Prerequisites", style="blue")
+
+    prereq = check_prerequisites(client, org_id, project_id, session_name=session_name, session_id=session_id)
+
+    if not prereq["success"]:
+        if json_output:
+            output = {
+                "success": False,
+                "error": prereq["error"],
+            }
+            if session_name:
+                output["session_name"] = session_name
+            if session_id:
+                output["session_id"] = session_id
+            print(json.dumps(output))
+        else:
+            console.print(f"[red]Error:[/red] {prereq['error']}")
+        sys.exit(3)
+
+    session = prereq["session"]
+    resolved_session_id = session["id"]
+    resolved_session_name = session.get("name") or session_id or "(unnamed)"
+
+    if not json_output:
+        console.print(f"[green]✓[/green] Session found: {resolved_session_name}")
+        console.print(f"  Session ID: {resolved_session_id}")
+        console.print(f"  Adapter: {session.get('adapter_type', 'unknown')}")
+        console.print("[green]✓[/green] Base session available")
+
+    # 3. Generate review
+    if not json_output:
+        console.rule("Generating Data Review", style="blue")
+
+    result = generate_data_review(
+        console=console,
+        client=client,
+        org_id=org_id,
+        project_id=project_id,
+        session=session,
+        regenerate=regenerate,
+        timeout=timeout,
+        json_output=json_output,
+    )
+
+    # 4. Display results
+    if json_output:
+        output = {
+            "success": result.status in [ReviewStatus.SUCCEEDED, ReviewStatus.ALREADY_EXISTS],
+            "status": result.status.value,
+            "session_id": result.session_id,
+            "session_name": result.session_name,
+            "review_url": result.review_url,
+        }
+        if result.task_id:
+            output["task_id"] = result.task_id
+        if result.error_message:
+            output["error"] = result.error_message
+        print(json.dumps(output))
+    else:
+        if result.status == ReviewStatus.SUCCEEDED:
+            console.rule("Review Generated Successfully", style="green")
+            console.print(f"[green]✓[/green] Data review generated for session '{result.session_name}'")
+            console.print()
+            console.print(f"[cyan]View review at:[/cyan] {result.review_url}")
+        elif result.status == ReviewStatus.ALREADY_EXISTS:
+            console.rule("Review Already Exists", style="green")
+            console.print(f"[green]✓[/green] Data review already exists for session '{result.session_name}'")
+            console.print()
+            console.print(f"[cyan]View review at:[/cyan] {result.review_url}")
+            console.print()
+            console.print("[dim]Tip: Use --regenerate to create a new review[/dim]")
+        elif result.status == ReviewStatus.TIMEOUT:
+            console.rule("Review Generation Timeout", style="yellow")
+            console.print("[yellow]Warning:[/yellow] Review generation is still in progress")
+            console.print(f"Task ID: {result.task_id}")
+            console.print("The review will be available shortly. Check the web UI for status.")
+            console.print()
+            console.print(f"[cyan]Check status at:[/cyan] {result.review_url}")
+        else:
+            console.rule("Review Generation Failed", style="red")
+            console.print(f"[red]Error:[/red] {result.error_message}")
+
+    # Exit with appropriate code
+    if result.status in [ReviewStatus.SUCCEEDED, ReviewStatus.ALREADY_EXISTS]:
+        sys.exit(0)
+    elif result.status == ReviewStatus.TIMEOUT:
+        sys.exit(0)  # Timeout is not a hard failure - task is still running
+    else:
+        sys.exit(4)

recce_cloud/services/diagnostic_service.py

@@ -172,18 +172,18 @@ class DiagnosticService:
         binding = get_project_binding()
 
         if binding:
-            self._org = binding.get("org")
-            self._project = binding.get("project")
+            self._org = binding.get("org_id")
+            self._project = binding.get("project_id")
             return CheckResult(
                 status=CheckStatus.PASS,
                 details={
-                    "org": self._org,
-                    "project": self._project,
+                    "org_id": self._org,
+                    "project_id": self._project,
                     "source": "config_file",
                 },
             )
 
-        # Check environment variables as fallback
+        # Check environment variables as fallback (accept both slugs and IDs)
         env_org = os.environ.get("RECCE_ORG")
         env_project = os.environ.get("RECCE_PROJECT")
 
@@ -193,8 +193,8 @@ class DiagnosticService:
             return CheckResult(
                 status=CheckStatus.PASS,
                 details={
-                    "org": self._org,
-                    "project": self._project,
+                    "org_id": self._org,
+                    "project_id": self._project,
                     "source": "env_vars",
                 },
             )

recce_cloud/upload.py

@@ -159,7 +159,7 @@ def upload_with_platform_apis(
         session_response = client.touch_recce_session(
             branch=ci_info.source_branch or ci_info.base_branch or "main",
             adapter_type=adapter_type,
-            cr_number=ci_info.cr_number,
+            pr_number=ci_info.pr_number,
             commit_sha=ci_info.commit_sha,
             session_type=ci_info.session_type,
         )
@@ -226,8 +226,8 @@ def upload_with_platform_apis(
     console.print(f'Uploaded dbt artifacts to Recce Cloud for session ID "{session_id}"')
     console.print(f'Artifacts from: "{os.path.abspath(target_path)}"')
 
-    if ci_info.cr_url:
-        console.print(f"Change request: {ci_info.cr_url}")
+    if ci_info.pr_url:
+        console.print(f"Pull request: {ci_info.pr_url}")
 
     sys.exit(0)
 
@@ -256,8 +256,8 @@ def upload_with_session_name(
     console.rule("Session Name Resolution", style="blue")
     try:
         config = resolve_config()
-        org = config.org
-        project = config.project
+        org = config.org_id
+        project = config.project_id
         console.print(f"[cyan]Organization:[/cyan] {org}")
         console.print(f"[cyan]Project:[/cyan] {project}")
         console.print(f"[cyan]Config Source:[/cyan] {config.source}")

{recce_cloud-1.33.1.dist-info → recce_cloud-1.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: recce-cloud
-Version: 1.33.1
+Version: 1.34.0
 Summary: Lightweight CLI for Recce Cloud operations
 Project-URL: Bug Tracker, https://github.com/InfuseAI/recce/issues
 Author-email: InfuseAI Dev Team <dev@infuseai.io>
@@ -159,7 +159,7 @@ recce-cloud upload
 recce-cloud upload --target-path custom-target
 
 # With manual overrides
-recce-cloud upload --cr 123 --type cr
+recce-cloud upload --pr 123 --type pr
 ```
 
 **Requirements:**
@@ -355,8 +355,8 @@ Upload dbt artifacts to Recce Cloud session.
 | --------------- | ------- | -------- | --------------------------------------------- |
 | `--target-path` | path    | `target` | Path to dbt target directory                  |
 | `--session-id`  | string  | -        | Session ID for generic workflow (optional)    |
-| `--cr`          | integer | -        | Override PR/MR number                         |
-| `--type`        | choice  | -        | Override session type: `cr`, `prod`, `dev`    |
+| `--pr`          | integer | -        | Override PR/MR number                         |
+| `--type`        | choice  | -        | Override session type: `pr`, `prod`, `dev`    |
 | `--dry-run`     | flag    | false    | Show what would be uploaded without uploading |
 
 **Environment Variables:**
@@ -492,13 +492,13 @@ You can override auto-detected values:
 
 ```bash
 # Override PR/MR number
-recce-cloud upload --cr 456
+recce-cloud upload --pr 456
 
 # Override session type
 recce-cloud upload --type prod
 
 # Multiple overrides
-recce-cloud upload --cr 789 --type cr
+recce-cloud upload --pr 789 --type pr
 
 # Dry run - preview what would be uploaded
 recce-cloud upload --dry-run

recce_cloud-1.34.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+recce_cloud/VERSION,sha256=xBVSUVA8aWplLFRKB0ZS35rrhaZQwe68qZ7iCifdheg,7
+recce_cloud/__init__.py,sha256=2Zlm9V1IBJ9DxovzHIUJB0QDl6ergO5ktY09baQ-Kxc,907
+recce_cloud/artifact.py,sha256=C6q1i8d0JdTIVLcJY1ZEmJJ0uBz-0g3zVZD8ss0K1iI,1458
+recce_cloud/cli.py,sha256=eFS4WQkL-1K7gdSe4Cc9g6y-8QbcTc-5CgaKJMFGfe4,56652
+recce_cloud/delete.py,sha256=sZSJkCLcTkiI2qVRUZwV5vqqV3BRzzuRUKdTLlVZfr0,3751
+recce_cloud/download.py,sha256=bNBkh2tKLdFoQIuZNXG_wcP46VPCO_WlVszSmHAseGE,8482
+recce_cloud/report.py,sha256=MRlT-CGV-SBzzYepp1zzoFuHqomC2vhpn7s5ACoNyyQ,10214
+recce_cloud/review.py,sha256=0r4AT0Y7y-VjSs2Xxm1A79WChbreY9FYQKu-8oBcCXs,19059
+recce_cloud/upload.py,sha256=SYYb4bJ4tfgXYUGSqvMMwLCgnmE2to02L2c1-z_5btQ,17543
+recce_cloud/api/__init__.py,sha256=HrGOh7wp_U3G3gOXyGjJo1WoDXrMvhwjw8VGO2aKNTw,562
+recce_cloud/api/base.py,sha256=aSjxqKuyrT5YHxP_NzwGqoBwwK0pXDEPu9DdHUdNm2I,4857
+recce_cloud/api/client.py,sha256=qd3NqcTrm7WvTtmAqhE1pigGkNsMeBD7kX_CF6s1bXs,33096
+recce_cloud/api/exceptions.py,sha256=BSfuh7dGZsx1qDkr2ZhRIAoPo_eXkAIhyho5PrUX2yo,634
+recce_cloud/api/factory.py,sha256=0hdo2jTdTlvd8cU7YTZFJJ2q3ybSssA2JKLr0bO1QmQ,2081
+recce_cloud/api/github.py,sha256=tMvUSq47aCdS8xgbgDmfUUD_JcGkdTslnWk5GemyMxE,4362
+recce_cloud/api/gitlab.py,sha256=z9CobQUYwXkE8ke0yPRLsfRSfFPrd2y6UWJh9UiA5d4,4593
+recce_cloud/auth/__init__.py,sha256=UP4yCMSmLNm9UhJBt80ybduZdPrAE3S2FYaZUocdh7E,453
+recce_cloud/auth/callback_server.py,sha256=F2ph89mfdUMJYeTd9Nt5Jd-j7FECCRhn9cQcotIFlN0,3861
+recce_cloud/auth/login.py,sha256=9t5AU1e8F7zNxfpjAQampxUkGhAV_9GwjKOG25QEo_U,7704
+recce_cloud/auth/profile.py,sha256=hLQzPlIDb5MDUkxWZyheXVjaC4vCCL4PyqGsEm5FVvQ,3145
+recce_cloud/auth/templates/error.html,sha256=MlirKaUGIc89QPPjqI3uQ-4sMbEy6k4JwS3YsDhzFFg,95074
+recce_cloud/auth/templates/success.html,sha256=7tZttX6oFJWNW9R3y5xlOzNcECINj-lJvN_NcgW8puI,95092
+recce_cloud/ci_providers/__init__.py,sha256=cB2bydn4QOMurJVfWhIN9uTD9gIyiBcYOloN-0TvMW4,328
+recce_cloud/ci_providers/base.py,sha256=0R5M6GNV-9u2gPkeB9fmV0WgTC0U8-WUkB9Io33eGQs,2589
+recce_cloud/ci_providers/detector.py,sha256=kyJx1Tkt6HXz8ZGwm4lcIeLMo0uXo8R1T2s0Fu4JNsY,5060
+recce_cloud/ci_providers/github_actions.py,sha256=8Be3FcnHBUHwXpfdtuKFJNVlZYEe5oxiF-nUBGBhN34,4302
+recce_cloud/ci_providers/gitlab_ci.py,sha256=vMFdqbdk2yxGnDEtsjeEbjIdqFZeai47W_NLLZA0NSQ,4175
+recce_cloud/commands/__init__.py,sha256=H5LHyMEOc2mrFxu56lQlvrG_AJ_rxj0gnHjT2efGb2w,36
+recce_cloud/commands/diagnostics.py,sha256=NqH8l0Xx90dwNVMvGKtFvszHvtQOcyFrWTDDf-Q3oXI,6073
+recce_cloud/config/__init__.py,sha256=-26T9sXcsfHi1mAFCz6t19hy2WaK7ZYQlcGSPKhpcHU,423
+recce_cloud/config/project_config.py,sha256=sfToZjP1TZNnSr31x0pwpLc_2DBZywrcqNpYqG1Wj3s,5269
+recce_cloud/config/resolver.py,sha256=EYsWX0dwKHVKYf6kftekrbWd17vrALMUMl-T26up4VM,4712
+recce_cloud/services/__init__.py,sha256=GMxN0Wtf166qvSSMGmU5jwqfly5b3K0vsIe8PkX7AKo,36
+recce_cloud/services/diagnostic_service.py,sha256=X3YBHFTkB31WRIH9MCKpZxbl4drw9evD6bBiD8cDIkw,13049
+recce_cloud-1.34.0.dist-info/METADATA,sha256=4TjurNAzv-MoZrNEVnzMS1JPm4juK9EqzaL_ZavJdjo,22589
+recce_cloud-1.34.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+recce_cloud-1.34.0.dist-info/entry_points.txt,sha256=MVzgsEDWaQ4fWf33zlyPF83wg5Rgg5Axq2hlLEf0Yxg,58
+recce_cloud-1.34.0.dist-info/RECORD,,