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

recce_cloud/VERSION

@@ -1 +1 @@
-1.31.0
+1.33.1

recce_cloud/__init__.py

@@ -1,18 +1,22 @@
 """Recce Cloud - Lightweight CLI for Recce Cloud operations."""
 
 import os
+from importlib.metadata import PackageNotFoundError, version
 
 
 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()
+    """Get version from package metadata or VERSION file."""
+    # Try importlib.metadata first (works for installed packages)
+    # Try both package names (nightly and official)
+    for pkg_name in ["recce-cloud-nightly", "recce-cloud"]:
+        try:
+            return version(pkg_name)
+        except PackageNotFoundError:
+            pass
 
-    # Fallback to ../recce/VERSION (for development)
-    version_file = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "recce", "VERSION"))
+    # Fallback to VERSION file (for development with editable install)
+    # VERSION is now at recce_cloud/recce_cloud/VERSION (same dir as __init__.py)
+    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()

recce_cloud/api/client.py

@@ -1,13 +1,13 @@
 """
 Recce Cloud API clients for lightweight operations.
 
-Provides clients for session management and report generation.
+Provides clients for session management, organization/project listing, and report generation.
 """
 
 import json
 import logging
 import os
-from typing import Optional
+from typing import Any, Dict, List, Optional
 
 import requests
 
@@ -224,6 +224,285 @@ class RecceCloudClient:
             status_code=response.status_code,
         )
 
+    def upload_completed(self, session_id: str) -> dict:
+        """
+        Notify Recce Cloud that upload is complete for a session.
+
+        This triggers post-upload processing such as AI summary generation.
+
+        Args:
+            session_id: Session ID to notify completion for
+
+        Returns:
+            dict containing acknowledgement or empty dict
+
+        Raises:
+            RecceCloudException: If the request fails
+        """
+        api_url = f"{self.base_url_v2}/sessions/{session_id}/upload-completed"
+        response = self._request("POST", api_url)
+        if response.status_code in [200, 204]:
+            if response.status_code == 204 or not response.content:
+                return {}
+            return response.json()
+        if response.status_code == 403:
+            raise RecceCloudException(
+                reason=response.json().get("detail", "Permission denied"),
+                status_code=response.status_code,
+            )
+        if response.status_code == 404:
+            raise RecceCloudException(
+                reason="Session not found",
+                status_code=response.status_code,
+            )
+        raise RecceCloudException(
+            reason=response.text,
+            status_code=response.status_code,
+        )
+
+    def list_organizations(self) -> List[Dict[str, Any]]:
+        """
+        List all organizations the user has access to.
+
+        Returns:
+            List of organization dictionaries with id, name, slug fields.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        api_url = f"{self.base_url_v2}/organizations"
+        response = self._request("GET", api_url)
+
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+        data = response.json()
+        return data.get("organizations", [])
+
+    def list_projects(self, org_id: str) -> List[Dict[str, Any]]:
+        """
+        List all projects in an organization.
+
+        Args:
+            org_id: Organization ID or slug.
+
+        Returns:
+            List of project dictionaries with id, name, slug fields.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects"
+        response = self._request("GET", api_url)
+
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+        data = response.json()
+        return data.get("projects", [])
+
+    def get_organization(self, org_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a specific organization by ID or slug.
+
+        Args:
+            org_id: Organization ID or slug.
+
+        Returns:
+            Organization dictionary, or None if not found.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        orgs = self.list_organizations()
+        for org in orgs:
+            # Compare as strings to handle both int and str IDs
+            if str(org.get("id")) == str(org_id) or org.get("slug") == org_id or org.get("name") == org_id:
+                return org
+        return None
+
+    def get_project(self, org_id: str, project_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a specific project by ID or slug.
+
+        Args:
+            org_id: Organization ID or slug.
+            project_id: Project ID or slug.
+
+        Returns:
+            Project dictionary, or None if not found.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        projects = self.list_projects(org_id)
+        for project in projects:
+            # Compare as strings to handle both int and str IDs
+            if (
+                str(project.get("id")) == str(project_id)
+                or project.get("slug") == project_id
+                or project.get("name") == project_id
+            ):
+                return project
+        return None
+
+    def list_sessions(
+        self,
+        org_id: str,
+        project_id: str,
+        session_name: Optional[str] = None,
+        session_type: Optional[str] = None,
+        branch: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        List sessions in a project with optional filtering.
+
+        Args:
+            org_id: Organization ID or slug.
+            project_id: Project ID or slug.
+            session_name: Filter by session name (exact match).
+            session_type: Filter by session type (e.g., "pr", "prod", "manual").
+            branch: Filter by branch name (exact match).
+            limit: Maximum number of results to return (1-1000).
+            offset: Number of results to skip for pagination.
+
+        Returns:
+            List of session dictionaries.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions"
+        params = {}
+        if session_name:
+            params["name"] = session_name
+        if session_type:
+            params["type"] = session_type
+        if branch:
+            params["branch"] = branch
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+
+        response = self._request("GET", api_url, params=params if params else None)
+
+        if response.status_code == 404:
+            raise RecceCloudException(
+                reason="Organization or project not found",
+                status_code=response.status_code,
+            )
+        if response.status_code != 200:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+        data = response.json()
+        return data.get("sessions", [])
+
+    def get_session_by_name(
+        self,
+        org_id: str,
+        project_id: str,
+        session_name: str,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get a session by its name.
+
+        Uses the list sessions endpoint with filtering to find a session
+        by name, which is unique within a project.
+
+        Args:
+            org_id: Organization ID or slug.
+            project_id: Project ID or slug.
+            session_name: The session name to look up.
+
+        Returns:
+            Session dictionary if found, None otherwise.
+
+        Raises:
+            RecceCloudException: If the API call fails.
+        """
+        sessions = self.list_sessions(
+            org_id=org_id,
+            project_id=project_id,
+            session_name=session_name,
+            limit=1,
+        )
+        if sessions:
+            return sessions[0]
+        return None
+
+    def create_session(
+        self,
+        org_id: str,
+        project_id: str,
+        session_name: str,
+        adapter_type: Optional[str] = None,
+        session_type: str = "manual",
+    ) -> Dict[str, Any]:
+        """
+        Create a new session with the given name.
+
+        Args:
+            org_id: Organization ID or slug.
+            project_id: Project ID or slug.
+            session_name: The name for the new session.
+            adapter_type: dbt adapter type (e.g., "postgres", "snowflake").
+            session_type: Session type (default: "manual").
+
+        Returns:
+            Created session dictionary with id, name, and other fields.
+
+        Raises:
+            RecceCloudException: If the API call fails or session creation fails.
+        """
+        api_url = f"{self.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions"
+        data = {
+            "name": session_name,
+            "type": session_type,
+        }
+        if adapter_type:
+            data["adapter_type"] = adapter_type
+
+        response = self._request("POST", api_url, json=data)
+
+        if response.status_code == 404:
+            raise RecceCloudException(
+                reason="Organization or project not found",
+                status_code=response.status_code,
+            )
+        if response.status_code == 409:
+            raise RecceCloudException(
+                reason=f"Session with name '{session_name}' already exists",
+                status_code=response.status_code,
+            )
+        if response.status_code == 403:
+            raise RecceCloudException(
+                reason=response.json().get("detail", "Permission denied"),
+                status_code=response.status_code,
+            )
+        if response.status_code not in [200, 201]:
+            raise RecceCloudException(
+                reason=response.text,
+                status_code=response.status_code,
+            )
+
+        result = response.json()
+        # Handle both direct session response and wrapped response
+        if "session" in result:
+            return result["session"]
+        return result
+
 
 class ReportClient:
     """Client for fetching reports from Recce Cloud API."""

recce_cloud/auth/__init__.py

@@ -0,0 +1,21 @@
+"""
+Authentication module for Recce Cloud CLI.
+
+This module provides browser-based OAuth authentication and credential management.
+It is designed to be standalone (duplicated from Recce OSS) to support future
+repository separation.
+"""
+
+from recce_cloud.auth.profile import (
+    get_api_token,
+    get_user_id,
+    load_profile,
+    update_api_token,
+)
+
+__all__ = [
+    "get_api_token",
+    "get_user_id",
+    "load_profile",
+    "update_api_token",
+]

recce_cloud/auth/callback_server.py

@@ -0,0 +1,128 @@
+"""
+One-time HTTP callback server for OAuth authentication.
+
+This server receives the encrypted token from Recce Cloud after
+browser-based authentication.
+"""
+
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from typing import Optional
+from urllib.parse import parse_qs, urlparse
+
+
+class CallbackResult:
+    """Container for callback result."""
+
+    def __init__(self):
+        self.code: Optional[str] = None
+        self.error: Optional[str] = None
+
+
+def make_callback_handler(result: CallbackResult, on_success_html: str, on_error_html: str):
+    """
+    Create a one-time HTTP request handler.
+
+    Args:
+        result: CallbackResult object to store the received code.
+        on_success_html: HTML content to return on success.
+        on_error_html: HTML content to return on error.
+
+    Returns:
+        HTTP request handler class.
+    """
+
+    class OneTimeHTTPRequestHandler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            try:
+                parsed_url = urlparse(self.path)
+                query_params = parse_qs(parsed_url.query)
+
+                code = query_params.get("code", [None])[0]
+                if not code:
+                    result.error = "Missing 'code' parameter in callback"
+                    self._send_response(400, on_error_html)
+                    return
+
+                result.code = code
+                self._send_response(200, on_success_html)
+
+            except Exception as e:
+                result.error = str(e)
+                self._send_response(500, on_error_html)
+            finally:
+                # Shutdown server after handling the request
+                self.server.server_close()
+                threading.Thread(target=self.server.shutdown, daemon=True).start()
+
+        def _send_response(self, status_code: int, html_content: str):
+            self.send_response(status_code)
+            self.send_header("Content-Type", "text/html")
+            self.send_header("Content-Length", str(len(html_content.encode())))
+            self.end_headers()
+            self.wfile.write(html_content.encode())
+
+        def log_message(self, format, *args):
+            # Suppress default logging
+            pass
+
+    return OneTimeHTTPRequestHandler
+
+
+def run_callback_server(
+    port: int,
+    result: CallbackResult,
+    on_success_html: str,
+    on_error_html: str,
+    timeout: int = 300,
+) -> bool:
+    """
+    Run a one-time HTTP server to receive the OAuth callback.
+
+    Args:
+        port: Port to listen on.
+        result: CallbackResult object to store the received code.
+        on_success_html: HTML content to return on success.
+        on_error_html: HTML content to return on error.
+        timeout: Server timeout in seconds (default 5 minutes).
+
+    Returns:
+        True if callback was received, False if timeout or error.
+    """
+    handler = make_callback_handler(result, on_success_html, on_error_html)
+    server = HTTPServer(("localhost", port), handler)
+    server.timeout = timeout
+
+    try:
+        # Handle a single request
+        server.handle_request()
+        return result.code is not None
+    except Exception:
+        return False
+    finally:
+        server.server_close()
+
+
+def _load_template(filename: str) -> str:
+    """
+    Load HTML template from the templates directory.
+
+    Args:
+        filename: Name of the template file (e.g., 'success.html').
+
+    Returns:
+        HTML content as string.
+
+    Raises:
+        FileNotFoundError: If template file is not found.
+    """
+    templates_dir = Path(__file__).parent / "templates"
+    template_path = templates_dir / filename
+    with open(template_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+# Load HTML templates from separate files
+SUCCESS_HTML = _load_template("success.html")
+ERROR_HTML = _load_template("error.html")