recce-nightly 0.62.0.20250417__py3-none-any.whl → 1.30.0.20251221__py3-none-any.whl

recce/adapter/dbt_adapter/dbt_version.py

@@ -2,6 +2,7 @@ class DbtVersion:
 
     def __init__(self):
         from dbt import version as dbt_version
+
         dbt_version = self.parse(dbt_version.__version__)
         if dbt_version.is_prerelease:
             dbt_version = self.parse(dbt_version.base_version)
@@ -10,10 +11,12 @@ class DbtVersion:
     @staticmethod
     def parse(version: str):
         from packaging import version as v
+
         return v.parse(version)
 
     def as_version(self, other):
         from packaging.version import Version
+
         if isinstance(other, Version):
             return other
         if isinstance(other, str):

recce/adapter/sqlmesh_adapter.py

@@ -1,9 +1,9 @@
 import typing as t
 from dataclasses import dataclass
-from typing import Optional, Dict, Type
+from typing import Dict, Optional, Type
 
 import pandas as pd
-from sqlglot import parse_one, Expression, select
+from sqlglot import Expression, parse_one, select
 from sqlglot.optimizer import traverse_scope
 from sqlmesh.core.context import Context as SqlmeshContext
 from sqlmesh.core.environment import Environment
@@ -11,7 +11,7 @@ from sqlmesh.core.state_sync import StateReader
 
 from recce.adapter.base import BaseAdapter
 from recce.models import RunType
-from recce.tasks import Task, QueryTask, QueryDiffTask, RowCountDiffTask
+from recce.tasks import QueryDiffTask, QueryTask, RowCountDiffTask, Task
 
 sqlmesh_supported_registry: Dict[RunType, Type[Task]] = {
     RunType.QUERY: QueryTask,
@@ -37,7 +37,7 @@ class SqlmeshAdapter(BaseAdapter):
 
         for snapshot in state_reader.get_snapshots(env.snapshots, hydrate_seeds=True).values():
 
-            if snapshot.node_type.lower() != 'model':
+            if snapshot.node_type.lower() != "model":
                 continue
 
             model = snapshot.model
@@ -45,16 +45,16 @@ class SqlmeshAdapter(BaseAdapter):
                 continue
 
             node = {
-                'unique_id': model.name,
-                'name': model.name,
-                'resource_type': snapshot.node_type.lower(),
-                'checksum': {'checksum': snapshot.fingerprint.data_hash},
+                "unique_id": model.name,
+                "name": model.name,
+                "resource_type": snapshot.node_type.lower(),
+                "checksum": {"checksum": snapshot.fingerprint.data_hash},
             }
 
             columns = {}
             for column, type in model.columns_to_types.items():
-                columns[column] = {'name': column, 'type': str(type)}
-            node['columns'] = columns
+                columns[column] = {"name": column, "type": str(type)}
+            node["columns"] = columns
 
             nodes[snapshot.name] = node
             parents = [snapshotId.name for snapshotId in snapshot.parents]
@@ -81,15 +81,15 @@ class SqlmeshAdapter(BaseAdapter):
 
     @classmethod
     def load(cls, **kwargs):
-        sqlmesh_envs = kwargs.get('sqlmesh_envs')
+        sqlmesh_envs = kwargs.get("sqlmesh_envs")
         if sqlmesh_envs is None:
-            raise Exception('\'--sqlmesh-envs SOURCE:TARGET\' is required')
+            raise Exception("'--sqlmesh-envs SOURCE:TARGET' is required")
 
-        envs = sqlmesh_envs.split(':')
+        envs = sqlmesh_envs.split(":")
         if len(envs) != 2:
             raise Exception('sqlmesh_envs must be in the format of "SOURCE:TARGET"')
 
-        sqlmesh_config = kwargs.get('sqlmesh_config', None)
+        sqlmesh_config = kwargs.get("sqlmesh_config", None)
         context = SqlmeshContext(config=sqlmesh_config)
         base_env = context.state_reader.get_environment(envs[0])
         curr_env = context.state_reader.get_environment(envs[1])
@@ -100,18 +100,14 @@ class SqlmeshAdapter(BaseAdapter):
 
         return cls(context=context, base_env=base_env, curr_env=curr_env)
 
-    def replace_virtual_tables(
-        self,
-        sql: t.Union[Expression, str],
-        base: bool = None
-    ) -> Expression:
-        '''
+    def replace_virtual_tables(self, sql: t.Union[Expression, str], base: bool = None) -> Expression:
+        """
         Replace virtual tables based on the env name.
 
         Args:
             sql: SQL expression to replace virtual tables
             base: True: replace virtual tables with base env, False: replace virtual tables with current env, None: no replacement
-        '''
+        """
         if isinstance(sql, str):
             expression = parse_one(sql, dialect=self.context.default_dialect)
         else:
@@ -119,30 +115,23 @@ class SqlmeshAdapter(BaseAdapter):
 
         if base is not None:
             env = self.base_env if base else self.curr_env
-            if env.name != 'prod':
+            if env.name != "prod":
                 model_names = [model.name for model in self.context.models.values()]
                 for scope in traverse_scope(expression):
                     for table in scope.tables:
-                        if f'{table.db}.{table.name}' in model_names:
-                            table.args['db'] = f"{table.args['db']}__{env.name}"
+                        if f"{table.db}.{table.name}" in model_names:
+                            table.args["db"] = f"{table.args['db']}__{env.name}"
 
         return expression
 
     def fetchdf_with_limit(
-        self,
-        sql: t.Union[Expression, str],
-        base: Optional[bool] = None,
-        limit: Optional[int] = None
+        self, sql: t.Union[Expression, str], base: Optional[bool] = None, limit: Optional[int] = None
     ) -> (pd.DataFrame, bool):
         expression = self.replace_virtual_tables(sql, base=base)
         if limit:
-            expression = select(
-                '*'
-            ).from_(
-                '__QUERY'
-            ).with_(
-                '__QUERY', as_=expression
-            ).limit(limit + 1 if limit else None)
+            expression = (
+                select("*").from_("__QUERY").with_("__QUERY", as_=expression).limit(limit + 1 if limit else None)
+            )
         df = self.context.fetchdf(expression)
         if limit and len(df) > limit:
             df = df.head(limit)

recce/apis/check_api.py

@@ -1,24 +1,27 @@
-from datetime import datetime, timezone
 from typing import Optional
 from uuid import UUID
 
-from fastapi import APIRouter, HTTPException, BackgroundTasks
+from fastapi import APIRouter, BackgroundTasks, HTTPException
 from pydantic import BaseModel
 
-from recce.apis.check_func import create_check_without_run, create_check_from_run, export_persistent_state
+from recce.apis.check_func import (
+    create_check_from_run,
+    create_check_without_run,
+    export_persistent_state,
+)
 from recce.apis.run_func import submit_run
 from recce.event import log_api_event
 from recce.exceptions import RecceException
-from recce.models import RunType, RunDAO, Check, CheckDAO, Run
+from recce.models import Check, CheckDAO, Run, RunDAO, RunType
 
-check_router = APIRouter(tags=['check'])
+check_router = APIRouter(tags=["check"])
 
 
 class CreateCheckIn(BaseModel):
     name: Optional[str] = None
-    description: str = ''
+    description: str = ""
     run_id: Optional[str] = None
-    type: Optional[RunType] = None,
+    type: Optional[RunType] = (None,)
     params: Optional[dict] = None
     view_options: Optional[dict] = None
     track_props: Optional[dict] = None
@@ -39,16 +42,17 @@ class CheckOut(BaseModel):
     def from_check(cls, check: Check):
         check_related_runs = RunDAO().list_by_check_id(check.check_id)
         last_run = check_related_runs[-1] if len(check_related_runs) > 0 else None
-        return CheckOut(check_id=check.check_id,
-                        name=check.name,
-                        description=check.description,
-                        type=check.type.value,
-                        params=check.params,
-                        view_options=check.view_options,
-                        is_checked=check.is_checked,
-                        is_preset=check.is_preset,
-                        last_run=last_run,
-                        )
+        return CheckOut(
+            check_id=check.check_id,
+            name=check.name,
+            description=check.description,
+            type=check.type.value,
+            params=check.params,
+            view_options=check.view_options,
+            is_checked=check.is_checked,
+            is_preset=check.is_preset,
+            last_run=last_run,
+        )
 
 
 @check_router.post("/checks", status_code=201, response_model=CheckOut)
@@ -59,7 +63,7 @@ async def create_check(check_in: CreateCheckIn, background_tasks: BackgroundTask
                 check_in.run_id,
                 check_name=check_in.name,
                 check_description=check_in.description,
-                check_view_options=check_in.view_options
+                check_view_options=check_in.view_options,
             )
         else:
             check = create_check_without_run(
@@ -67,12 +71,15 @@ async def create_check(check_in: CreateCheckIn, background_tasks: BackgroundTask
                 check_description=check_in.description,
                 check_type=check_in.type,
                 params=check_in.params,
-                check_view_options=check_in.view_options
+                check_view_options=check_in.view_options,
             )
-        log_api_event('create_check', dict(
-            type=str(check.type),
-            track_props=check_in.track_props,
-        ))
+        log_api_event(
+            "create_check",
+            dict(
+                type=str(check.type),
+                track_props=check_in.track_props,
+            ),
+        )
     except NameError as e:
         raise HTTPException(status_code=404, detail=str(e))
     except ValueError as e:
@@ -93,10 +100,13 @@ async def run_check_handler(check_id: UUID, input: RunCheckIn):
         raise HTTPException(status_code=404, detail=f"Check ID '{check_id}' not found")
 
     try:
-        log_api_event('rerun_check', dict(
-            type=str(check.type),
-            rerun=True,
-        ))
+        log_api_event(
+            "rerun_check",
+            dict(
+                type=str(check.type),
+                rerun=True,
+            ),
+        )
         run, future = submit_run(check.type, check.params, check_id=check_id)
     except RecceException as e:
         raise HTTPException(status_code=400, detail=str(e))
@@ -122,7 +132,7 @@ async def list_checks_handler():
 async def get_check_handler(check_id: UUID):
     check = CheckDAO().find_check_by_id(check_id)
     if check is None:
-        raise HTTPException(status_code=404, detail='Not Found')
+        raise HTTPException(status_code=404, detail="Not Found")
 
     runs = RunDAO().list_by_check_id(check_id)
     last_run = runs[-1] if len(runs) > 0 else None
@@ -142,21 +152,9 @@ class PatchCheckIn(BaseModel):
 
 @check_router.patch("/checks/{check_id}", status_code=200, response_model=CheckOut, response_model_exclude_none=True)
 async def update_check_handler(check_id: UUID, patch: PatchCheckIn, background_tasks: BackgroundTasks):
-    check = CheckDAO().find_check_by_id(check_id)
+    check = CheckDAO().update_check_by_id(check_id, patch)
     if check is None:
-        raise HTTPException(status_code=404, detail='Not Found')
-
-    if patch.name is not None:
-        check.name = patch.name
-    if patch.description is not None:
-        check.description = patch.description
-    if patch.params is not None:
-        check.params = patch.params
-    if patch.view_options is not None:
-        check.view_options = patch.view_options
-    if patch.is_checked is not None:
-        check.is_checked = patch.is_checked
-    check.updated_at = datetime.now(timezone.utc).replace(microsecond=0)
+        raise HTTPException(status_code=404, detail="Not Found")
 
     background_tasks.add_task(export_persistent_state)
     return CheckOut.from_check(check)
@@ -184,3 +182,22 @@ async def reorder_handler(order: ReorderChecksIn):
         CheckDAO().reorder(order.source, order.destination)
     except RecceException as e:
         raise HTTPException(status_code=400, detail=e.message)
+
+
+@check_router.post("/checks/{check_id}/mark-as-preset", status_code=204)
+async def mark_as_preset_check_handler(check_id: UUID, background_tasks: BackgroundTasks):
+    """
+    Mark an existing check as a preset check (cloud users only).
+
+    This creates a preset check from the specified check.
+    Only available for users with cloud mode enabled.
+
+    Returns:
+        204 No Content: Successfully marked check as preset
+        400 Bad Request: Error with detail message (e.g., not in cloud mode, check not found)
+    """
+    try:
+        CheckDAO().mark_as_preset_check(check_id)
+        background_tasks.add_task(export_persistent_state)
+    except RecceException as e:
+        raise HTTPException(status_code=400, detail=e.message)

recce/apis/check_events_api.py

@@ -0,0 +1,353 @@
+"""
+Check Events API endpoints.
+
+This module provides REST endpoints for check events (timeline/conversation),
+proxying requests to Recce Cloud. This feature is only available for cloud users.
+"""
+
+import logging
+from typing import List, Optional
+from uuid import UUID
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from recce.core import default_context
+from recce.event import get_recce_api_token
+from recce.exceptions import RecceException
+from recce.util.cloud.check_events import CheckEventsCloud
+from recce.util.recce_cloud import RecceCloud, RecceCloudException
+
+logger = logging.getLogger("uvicorn")
+
+check_events_router = APIRouter(tags=["check_events"])
+
+
+# ============================================================================
+# Helper Functions
+# ============================================================================
+
+
+def _is_cloud_user() -> bool:
+    """Check if the current user is connected to Recce Cloud."""
+    ctx = default_context()
+    if ctx is None or ctx.state_loader is None:
+        return False
+    return hasattr(ctx.state_loader, "session_id") and ctx.state_loader.session_id is not None
+
+
+def _get_session_info() -> tuple:
+    """
+    Get organization ID, project ID, and session ID from state loader.
+
+    Returns:
+        tuple: (org_id, project_id, session_id)
+
+    Raises:
+        HTTPException: If not in cloud mode or session info unavailable
+    """
+    if not _is_cloud_user():
+        raise HTTPException(
+            status_code=400,
+            detail="Check events are only available when connected to Recce Cloud.",
+        )
+
+    ctx = default_context()
+    state_loader = ctx.state_loader
+
+    session_id = state_loader.session_id
+
+    # Check if org_id and project_id are cached
+    if hasattr(state_loader, "org_id") and hasattr(state_loader, "project_id"):
+        return state_loader.org_id, state_loader.project_id, session_id
+
+    # Fetch from cloud API
+    api_token = get_recce_api_token() or state_loader.token
+    if not api_token:
+        raise HTTPException(
+            status_code=401,
+            detail="Cannot access Recce Cloud: no API token available.",
+        )
+
+    try:
+        recce_cloud = RecceCloud(api_token)
+        session = recce_cloud.get_session(session_id)
+
+        org_id = session.get("org_id")
+        project_id = session.get("project_id")
+
+        if not org_id or not project_id:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Session {session_id} does not belong to a valid organization or project.",
+            )
+
+        # Cache for future use
+        state_loader.org_id = org_id
+        state_loader.project_id = project_id
+
+        return org_id, project_id, session_id
+
+    except RecceCloudException as e:
+        logger.error(f"Failed to get session info: {e}")
+        raise HTTPException(status_code=e.status_code, detail=str(e.reason))
+
+
+def _get_events_client() -> CheckEventsCloud:
+    """
+    Get the CheckEventsCloud client.
+
+    Returns:
+        CheckEventsCloud: Cloud client for event operations
+
+    Raises:
+        HTTPException: If client cannot be initialized
+    """
+    ctx = default_context()
+    api_token = get_recce_api_token() or ctx.state_loader.token
+
+    if not api_token:
+        raise HTTPException(
+            status_code=401,
+            detail="Cannot access Recce Cloud: no API token available.",
+        )
+
+    return CheckEventsCloud(api_token)
+
+
+# ============================================================================
+# Pydantic Models
+# ============================================================================
+
+
+class CheckEventActorOut(BaseModel):
+    """Actor who performed the event."""
+
+    type: str  # "user", "recce_ai", "preset_system"
+    user_id: Optional[int] = None
+    login: Optional[str] = None
+    fullname: Optional[str] = None
+
+
+class CheckEventOut(BaseModel):
+    """Check event response model."""
+
+    id: str
+    check_id: str
+    event_type: str
+    actor: CheckEventActorOut
+    content: Optional[str] = None
+    old_value: Optional[str] = None
+    new_value: Optional[str] = None
+    is_edited: bool = False
+    is_deleted: bool = False
+    created_at: str
+    updated_at: str
+
+
+class CreateCommentIn(BaseModel):
+    """Request body for creating a comment."""
+
+    content: str
+
+
+class UpdateCommentIn(BaseModel):
+    """Request body for updating a comment."""
+
+    content: str
+
+
+# ============================================================================
+# API Endpoints
+# ============================================================================
+
+
+@check_events_router.get(
+    "/checks/{check_id}/events",
+    status_code=200,
+    response_model=List[CheckEventOut],
+)
+async def list_check_events(check_id: UUID):
+    """
+    List all events for a check in chronological order.
+
+    This endpoint returns all events (comments, state changes, etc.) for the
+    specified check. Events are returned in chronological order (oldest first).
+
+    Args:
+        check_id: The check ID
+
+    Returns:
+        List of CheckEventOut objects
+
+    Raises:
+        400: Not connected to Recce Cloud
+        401: No API token available
+        404: Check not found
+    """
+    try:
+        org_id, project_id, session_id = _get_session_info()
+        client = _get_events_client()
+
+        events = client.list_events(org_id, project_id, session_id, str(check_id))
+        return events
+
+    except RecceCloudException as e:
+        logger.error(f"Failed to list check events: {e}")
+        raise HTTPException(status_code=e.status_code, detail=str(e.reason))
+    except RecceException as e:
+        logger.error(f"Failed to list check events: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@check_events_router.get(
+    "/checks/{check_id}/events/{event_id}",
+    status_code=200,
+    response_model=CheckEventOut,
+)
+async def get_check_event(check_id: UUID, event_id: UUID):
+    """
+    Get a specific event by ID.
+
+    Args:
+        check_id: The check ID
+        event_id: The event ID
+
+    Returns:
+        CheckEventOut object
+
+    Raises:
+        400: Not connected to Recce Cloud
+        401: No API token available
+        404: Event not found
+    """
+    try:
+        org_id, project_id, session_id = _get_session_info()
+        client = _get_events_client()
+
+        event = client.get_event(org_id, project_id, session_id, str(check_id), str(event_id))
+        return event
+
+    except RecceCloudException as e:
+        logger.error(f"Failed to get check event: {e}")
+        raise HTTPException(status_code=e.status_code, detail=str(e.reason))
+    except RecceException as e:
+        logger.error(f"Failed to get check event: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@check_events_router.post(
+    "/checks/{check_id}/events",
+    status_code=201,
+    response_model=CheckEventOut,
+)
+async def create_comment(check_id: UUID, body: CreateCommentIn):
+    """
+    Create a new comment on a check.
+
+    Args:
+        check_id: The check ID
+        body: Request body containing comment content
+
+    Returns:
+        Created CheckEventOut object
+
+    Raises:
+        400: Not connected to Recce Cloud or invalid content
+        401: No API token available
+        404: Check not found
+    """
+    if not body.content or not body.content.strip():
+        raise HTTPException(status_code=400, detail="Comment content cannot be empty.")
+
+    try:
+        org_id, project_id, session_id = _get_session_info()
+        client = _get_events_client()
+
+        event = client.create_comment(org_id, project_id, session_id, str(check_id), body.content)
+        return event
+
+    except RecceCloudException as e:
+        logger.error(f"Failed to create comment: {e}")
+        raise HTTPException(status_code=e.status_code, detail=str(e.reason))
+    except RecceException as e:
+        logger.error(f"Failed to create comment: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@check_events_router.patch(
+    "/checks/{check_id}/events/{event_id}",
+    status_code=200,
+    response_model=CheckEventOut,
+)
+async def update_comment(check_id: UUID, event_id: UUID, body: UpdateCommentIn):
+    """
+    Update an existing comment.
+
+    Only the author or an admin can update a comment.
+
+    Args:
+        check_id: The check ID
+        event_id: The event ID of the comment to update
+        body: Request body containing new comment content
+
+    Returns:
+        Updated CheckEventOut object
+
+    Raises:
+        400: Not connected to Recce Cloud or invalid content
+        401: No API token available
+        403: Not authorized to update this comment
+        404: Comment not found
+    """
+    if not body.content or not body.content.strip():
+        raise HTTPException(status_code=400, detail="Comment content cannot be empty.")
+
+    try:
+        org_id, project_id, session_id = _get_session_info()
+        client = _get_events_client()
+
+        event = client.update_comment(org_id, project_id, session_id, str(check_id), str(event_id), body.content)
+        return event
+
+    except RecceCloudException as e:
+        logger.error(f"Failed to update comment: {e}")
+        raise HTTPException(status_code=e.status_code, detail=str(e.reason))
+    except RecceException as e:
+        logger.error(f"Failed to update comment: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@check_events_router.delete(
+    "/checks/{check_id}/events/{event_id}",
+    status_code=204,
+)
+async def delete_comment(check_id: UUID, event_id: UUID):
+    """
+    Delete a comment (soft delete).
+
+    Only the author or an admin can delete a comment. The comment will be
+    marked as deleted but remain in the timeline with a "Comment deleted" indicator.
+
+    Args:
+        check_id: The check ID
+        event_id: The event ID of the comment to delete
+
+    Raises:
+        400: Not connected to Recce Cloud
+        401: No API token available
+        403: Not authorized to delete this comment
+        404: Comment not found
+    """
+    try:
+        org_id, project_id, session_id = _get_session_info()
+        client = _get_events_client()
+
+        client.delete_comment(org_id, project_id, session_id, str(check_id), str(event_id))
+
+    except RecceCloudException as e:
+        logger.error(f"Failed to delete comment: {e}")
+        raise HTTPException(status_code=e.status_code, detail=str(e.reason))
+    except RecceException as e:
+        logger.error(f"Failed to delete comment: {e}")
+        raise HTTPException(status_code=400, detail=str(e))