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

recce/apis/check_func.py

@@ -5,13 +5,13 @@ from fastapi import HTTPException
 
 from recce.apis.run_func import generate_run_name
 from recce.core import default_context
-from recce.models import RunDAO, RunType, Check, CheckDAO
+from recce.models import Check, CheckDAO, RunDAO, RunType
 
 
 def validate_schema_diff_check(params):
-    node_id = params.get('node_id')
+    node_id = params.get("node_id")
     if node_id is None:
-        raise HTTPException(status_code=400, detail='node_id is required for schema diff')
+        raise HTTPException(status_code=400, detail="node_id is required for schema diff")
     node_name = default_context().get_node_name_by_id(node_id)
     if node_name is None:
         raise HTTPException(status_code=400, detail=f"node_id '{node_id}' not found in dbt manifest")
@@ -45,8 +45,8 @@ def _get_ref_model(sql_template: str) -> Optional[str]:
 def _generate_check_name(check_type, params, view_options):
     now = datetime.utcnow().strftime("%d %b %Y")
     if check_type == RunType.SCHEMA_DIFF:
-        if params.get('node_id'):
-            nodeIds = params.get('node_id') if isinstance(params.get('node_id'), list) else [params.get('node_id')]
+        if params.get("node_id"):
+            nodeIds = params.get("node_id") if isinstance(params.get("node_id"), list) else [params.get("node_id")]
             if len(nodeIds) == 1:
                 node_name = get_node_name_by_id(nodeIds[0])
                 return f"schema diff of {node_name}".capitalize()
@@ -54,7 +54,7 @@ def _generate_check_name(check_type, params, view_options):
                 return f"schema diff of {len(nodeIds)} nodes".capitalize()
         return f"{'schema diff'.capitalize()} - {now}"
     elif check_type == RunType.LINEAGE_DIFF:
-        nodes = view_options.get('node_ids') if view_options else params.get('node_ids')
+        nodes = view_options.get("node_ids") if view_options else params.get("node_ids")
         if nodes is not None:
             return f"lineage diff of {len(nodes)} nodes".capitalize()
         return f"{'lineage diff'.capitalize()} - {now}"
@@ -62,10 +62,11 @@ def _generate_check_name(check_type, params, view_options):
         return f"{'check'.capitalize()} - {now}"
 
 
-def create_check_from_run(run_id, check_name=None, check_description='', check_view_options=None, is_preset=False,
-                          is_checked=False):
+def create_check_from_run(
+    run_id, check_name=None, check_description="", check_view_options=None, is_preset=False, is_checked=False
+):
     if run_id is None:
-        raise ValueError('run_id is required')
+        raise ValueError("run_id is required")
 
     run = RunDAO().find_run_by_id(run_id)
     if run is None:
@@ -76,31 +77,36 @@ def create_check_from_run(run_id, check_name=None, check_description='', check_v
 
     _validate_check(run_type, run_params)
     name = check_name if check_name is not None else generate_run_name(run)
-    check = Check(name=name,
-                  description=check_description,
-                  type=run_type,
-                  params=run_params,
-                  view_options=check_view_options,
-                  is_preset=is_preset,
-                  is_checked=is_checked)
-    CheckDAO().create(check)
-    run.check_id = check.check_id
-
-    return check
-
-
-def create_check_without_run(check_name, check_description, check_type, params, check_view_options, is_preset=False,
-                             is_checked=False):
+    check = Check(
+        name=name,
+        description=check_description,
+        type=run_type,
+        params=run_params,
+        view_options=check_view_options,
+        is_preset=is_preset,
+        is_checked=is_checked,
+    )
+    new_check = CheckDAO().create(check)
+    run.check_id = new_check.check_id
+
+    return new_check
+
+
+def create_check_without_run(
+    check_name, check_description, check_type, params, check_view_options, is_preset=False, is_checked=False
+):
     name = check_name if check_name is not None else _generate_check_name(check_type, params, check_view_options)
-    check = Check(name=name,
-                  description=check_description,
-                  type=check_type,
-                  params=params,
-                  view_options=check_view_options,
-                  is_preset=is_preset,
-                  is_checked=is_checked)
-    CheckDAO().create(check)
-    return check
+    check = Check(
+        name=name,
+        description=check_description,
+        type=check_type,
+        params=params,
+        view_options=check_view_options,
+        is_preset=is_preset,
+        is_checked=is_checked,
+    )
+    new_check = CheckDAO().create(check)
+    return new_check
 
 
 def purge_preset_checks():
@@ -119,6 +125,6 @@ def export_persistent_state():
     if state_loader is not None:
         is_conflict = state_loader.check_conflict()
         if is_conflict:
-            ctx.sync_state('merge')
+            ctx.sync_state("merge")
         else:
-            ctx.sync_state('overwrite')
+            ctx.sync_state("overwrite")

recce/apis/run_api.py

@@ -1,16 +1,16 @@
 import asyncio
-from typing import Optional, List
+from typing import List, Optional
 from uuid import UUID
 
 from fastapi import APIRouter, HTTPException, Query
 from pydantic import BaseModel
 
-from recce.apis.run_func import submit_run, cancel_run, materialize_run_results
+from recce.apis.run_func import cancel_run, materialize_run_results, submit_run
 from recce.event import log_api_event
 from recce.exceptions import RecceException
 from recce.models import RunDAO
 
-run_router = APIRouter(tags=['run'])
+run_router = APIRouter(tags=["run"])
 
 
 class CreateRunIn(BaseModel):
@@ -23,10 +23,13 @@ class CreateRunIn(BaseModel):
 
 @run_router.post("/runs", status_code=201)
 async def create_run_handler(input: CreateRunIn):
-    log_api_event('create_run', dict(
-        type=input.type,
-        track_props=input.track_props,
-    ))
+    log_api_event(
+        "create_run",
+        dict(
+            type=input.type,
+            track_props=input.track_props,
+        ),
+    )
     try:
         run, future = submit_run(input.type, input.params)
     except RecceException as e:
@@ -51,7 +54,7 @@ async def cancel_run_handler(run_id: UUID):
 async def wait_run_handler(run_id: UUID, timeout: int = Query(None, description="Maximum number of seconds to wait")):
     run = RunDAO().find_run_by_id(run_id)
     if run is None:
-        raise HTTPException(status_code=404, detail='Not Found')
+        raise HTTPException(status_code=404, detail="Not Found")
 
     start_time = asyncio.get_event_loop().time()
     while run.result is None and run.error is None:
@@ -65,18 +68,21 @@ async def wait_run_handler(run_id: UUID, timeout: int = Query(None, description=
 async def list_run_handler():
     runs = RunDAO().list() or []
 
-    result = [{
-        'run_id': run.run_id,
-        'run_at': run.run_at,
-        'name': run.name,
-        'type': run.type,
-        'params': run.params,
-        'status': run.status,
-        'check_id': run.check_id,
-    } for run in runs]
+    result = [
+        {
+            "run_id": run.run_id,
+            "run_at": run.run_at,
+            "name": run.name,
+            "type": run.type,
+            "params": run.params,
+            "status": run.status,
+            "check_id": run.check_id,
+        }
+        for run in runs
+    ]
 
     # sort by run_at
-    result = sorted(result, key=lambda x: x['run_at'], reverse=True)
+    result = sorted(result, key=lambda x: x["run_at"], reverse=True)
 
     return result
 
@@ -101,7 +107,7 @@ async def search_runs_handler(search: SearchRunsIn):
         result.append(run)
 
     if search.limit:
-        return result[-search.limit:]
+        return result[-search.limit :]
 
     return result
 

recce/apis/run_func.py

@@ -4,11 +4,11 @@ from typing import List, Optional
 
 from recce.core import default_context
 from recce.exceptions import RecceException
-from recce.models import RunType, Run, RunDAO
+from recce.models import Run, RunDAO, RunType
 from recce.models.types import RunStatus
 
 running_tasks = {}
-logger = logging.getLogger('uvicorn')
+logger = logging.getLogger("uvicorn")
 
 
 def _get_ref_model(sql_template: str) -> Optional[str]:
@@ -33,26 +33,26 @@ def generate_run_name(run):
     now = dateutil.parser.parse(run.run_at)
 
     if run_type == RunType.QUERY:
-        ref = _get_ref_model(params.get('sql_template'))
+        ref = _get_ref_model(params.get("sql_template"))
         if ref:
             return f"query of {ref}".capitalize()
         return f"{'query'.capitalize()} - {now}"
     elif run_type == RunType.QUERY_DIFF:
-        ref = _get_ref_model(params.get('sql_template'))
+        ref = _get_ref_model(params.get("sql_template"))
         if ref:
             return f"query diff of {ref}".capitalize()
         return f"{'query diff'.capitalize()} - {now}"
     elif run_type == RunType.VALUE_DIFF:
-        model = params.get('model')
+        model = params.get("model")
         return f"value diff of {model}".capitalize()
     elif run_type == RunType.VALUE_DIFF_DETAIL:
-        model = params.get('model')
+        model = params.get("model")
         return f"value diff detail of {model}".capitalize()
     elif run_type == RunType.PROFILE_DIFF:
-        model = params.get('model')
+        model = params.get("model")
         return f"profile diff of {model}".capitalize()
     elif run_type == RunType.ROW_COUNT_DIFF:
-        nodes = params.get('node_names')
+        nodes = params.get("node_names")
         if nodes:
             if len(nodes) == 1:
                 node = nodes[0]
@@ -62,23 +62,27 @@ def generate_run_name(run):
         else:
             return "row count of multiple nodes".capitalize()
     elif run_type == RunType.TOP_K_DIFF:
-        model = params.get('model')
-        column = params.get('column_name')
+        model = params.get("model")
+        column = params.get("column_name")
         return f"top-k diff of {model}.{column} ".capitalize()
     elif run_type == RunType.HISTOGRAM_DIFF:
-        model = params.get('model')
-        column = params.get('column_name')
+        model = params.get("model")
+        column = params.get("column_name")
         return f"histogram diff of {model}.{column} ".capitalize()
     else:
         return f"{'run'.capitalize()} - {now}"
 
 
 def create_task(run_type: RunType, params: dict):
-    if default_context().adapter_type == 'sqlmesh':
-        from recce.adapter.sqlmesh_adapter import sqlmesh_supported_registry as sqlmesh_registry
+    if default_context().adapter_type == "sqlmesh":
+        from recce.adapter.sqlmesh_adapter import (
+            sqlmesh_supported_registry as sqlmesh_registry,
+        )
+
         registry = sqlmesh_registry
     else:
         from recce.adapter.dbt_adapter import dbt_supported_registry as dbt_registry
+
         registry = dbt_registry
 
     taskClz = registry.get(run_type)
@@ -101,6 +105,7 @@ def submit_run(type, params, check_id=None):
     context = default_context()
     if context.review_mode is True:
         from recce.adapter.dbt_adapter import DbtAdapter
+
         dbt_adaptor: DbtAdapter = context.adapter
         if dbt_adaptor.adapter is None:
             raise RecceException("Recce Server is not launched under DBT project folder.")
@@ -113,18 +118,23 @@ def submit_run(type, params, check_id=None):
     running_tasks[run.run_id] = task
 
     def progress_listener(message=None, percentage=None):
-        run.progress = {'message': message, 'percentage': percentage}
+        run.progress = {"message": message, "percentage": percentage}
 
     task.progress_listener = progress_listener
 
-    async def update_run_result(run_id, result, error):
+    async def update_run_result(run, result, error, updated_params=None):
+        """Update run with result, error, and optionally updated params."""
         if run is None:
             return
         if result is not None:
             run.result = result
             run.status = RunStatus.FINISHED
+        if updated_params is not None:
+            # Merge updated params (preserves any fields not in updated_params)
+            run.params.update(updated_params)
         if error is not None:
-            run.error = str(error)
+            failed_reason = str(error) if str(error) != "None" else repr(error)
+            run.error = failed_reason
             if run.status != RunStatus.CANCELLED:
                 run.status = RunStatus.FAILED
         run.progress = None
@@ -132,13 +142,42 @@ def submit_run(type, params, check_id=None):
     def fn():
         try:
             result = task.execute()
-            asyncio.run_coroutine_threadsafe(update_run_result(run.run_id, result, None), loop)
+
+            # Extract updated params from task after execution
+            updated_params = None
+            if hasattr(task, "params") and task.params is not None:
+                # Serialization logic:
+                # - Most tasks use Pydantic models (v2: model_dump, v1: dict)
+                # - Some tasks may use plain dicts
+                # - If params is an unexpected type, log a warning for debugging
+                # - Handle the case where model_dump() or dict() raises an exception.
+                try:
+                    if hasattr(task.params, "model_dump"):
+                        updated_params = task.params.model_dump()
+                    elif hasattr(task.params, "dict"):
+                        updated_params = task.params.dict()
+                    elif isinstance(task.params, dict):
+                        updated_params = task.params
+                    else:
+                        logger.warning(
+                            f"Could not serialize task.params for run_id={run.run_id}: "
+                            f"unexpected type {type(task.params)} with value {repr(task.params)}"
+                        )
+                except Exception as e:
+                    logger.warning(f"Failed to serialize task.params: {e}")
+                    updated_params = None
+
+            asyncio.run_coroutine_threadsafe(update_run_result(run, result, None, updated_params), loop)
             return result
         except BaseException as e:
-            asyncio.run_coroutine_threadsafe(update_run_result(run.run_id, None, e), loop)
+            asyncio.run_coroutine_threadsafe(update_run_result(run, None, e, None), loop)
             if isinstance(e, RecceException) and e.is_raise is False:
                 return None
-            failed_reason = str(e).replace('. ', ".\n")
+            import sentry_sdk
+
+            sentry_sdk.capture_exception(e)
+            failed_reason = str(e) if str(e) != "None" else repr(e)
+            failed_reason = failed_reason.replace(". ", ".\n")
             logger.error(f"Failed to execute {run_type} task: {failed_reason}")
             return None
 
@@ -160,7 +199,7 @@ def cancel_run(run_id):
 
 
 def materialize_run_results(runs: List[Run], nodes: List[str] = None):
-    '''
+    """
     Materialize the run results for nodes. It walks through all runs and get the last results for primary run types.
 
     The result format
@@ -176,11 +215,11 @@ def materialize_run_results(runs: List[Run], nodes: List[str] = None):
           },
        },
     }
-    '''
+    """
 
     context = default_context()
     if context:
-        mame_to_unique_id = context.build_name_to_unique_id_index(excluded_types={'semantic_model', 'metric'})
+        mame_to_unique_id = context.build_name_to_unique_id_index(excluded_types={"semantic_model", "metric"})
     else:
         mame_to_unique_id = {}
 
@@ -201,7 +240,7 @@ def materialize_run_results(runs: List[Run], nodes: List[str] = None):
                     node_result = result[key] = {}
                 else:
                     node_result = result.get(key)
-                node_result['row_count_diff'] = {'run_id': run.run_id, 'result': node_run_result}
+                node_result["row_count_diff"] = {"run_id": run.run_id, "result": node_run_result}
         elif run.type == RunType.ROW_COUNT:
             for model_name, node_run_result in run.result.items():
                 key = mame_to_unique_id.get(model_name, model_name)
@@ -214,5 +253,5 @@ def materialize_run_results(runs: List[Run], nodes: List[str] = None):
                     node_result = result[key] = {}
                 else:
                     node_result = result.get(key)
-                node_result['row_count'] = {'run_id': run.run_id, 'result': node_run_result}
+                node_result["row_count"] = {"run_id": run.run_id, "result": node_run_result}
     return result