convexity-sdk 0.4.3.dev152__tar.gz → 0.5.0.dev154__tar.gz

{convexity_sdk-0.4.3.dev152 → convexity_sdk-0.5.0.dev154}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: convexity-sdk
-Version: 0.4.3.dev152
+Version: 0.5.0.dev154
 Summary: Convexity Python SDK - programmatic access to the Convexity platform
 Requires-Python: >=3.12
-Requires-Dist: convexity-api-client<0.5.0,>=0.4.3.dev0
+Requires-Dist: convexity-api-client<0.6.0,>=0.5.0.dev0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.10.0
 Description-Content-Type: text/markdown

{convexity_sdk-0.4.3.dev152 → convexity_sdk-0.5.0.dev154}/convexity_sdk/client.py

@@ -12,8 +12,14 @@ from .config import SDKConfig, resolve_config
 from .http import AsyncTransport, SyncTransport
 
 if TYPE_CHECKING:
+    from .resources.connections import Connections
+    from .resources.dashboards import Dashboards
+    from .resources.datalake import Datalake
+    from .resources.datasets import Datasets
     from .resources.organizations import Organizations
     from .resources.projects import Projects
+    from .resources.runs import Runs
+    from .resources.tasks import Tasks
 
 
 def _build_api_client(config: SDKConfig) -> AuthenticatedClient | ApiClient:
@@ -100,6 +106,24 @@ class ConvexityClient:
             self._organizations = Organizations(self._api_client)
         return self._organizations
 
+    @property
+    def connections(self) -> Connections:
+        """Access connection operations."""
+        if not hasattr(self, "_connections"):
+            from .resources.connections import Connections
+
+            self._connections = Connections(self._api_client)
+        return self._connections
+
+    @property
+    def datalake(self) -> Datalake:
+        """Access datalake operations."""
+        if not hasattr(self, "_datalake"):
+            from .resources.datalake import Datalake
+
+            self._datalake = Datalake(self._api_client)
+        return self._datalake
+
     @property
     def projects(self) -> Projects:
         """Access project operations."""
@@ -109,6 +133,42 @@ class ConvexityClient:
             self._projects = Projects(self._api_client)
         return self._projects
 
+    @property
+    def datasets(self) -> Datasets:
+        """Access dataset operations."""
+        if not hasattr(self, "_datasets"):
+            from .resources.datasets import Datasets
+
+            self._datasets = Datasets(self._api_client)
+        return self._datasets
+
+    @property
+    def dashboards(self) -> Dashboards:
+        """Access dashboard operations."""
+        if not hasattr(self, "_dashboards"):
+            from .resources.dashboards import Dashboards
+
+            self._dashboards = Dashboards(self._api_client)
+        return self._dashboards
+
+    @property
+    def tasks(self) -> Tasks:
+        """Access task operations."""
+        if not hasattr(self, "_tasks"):
+            from .resources.tasks import Tasks
+
+            self._tasks = Tasks(self._api_client)
+        return self._tasks
+
+    @property
+    def runs(self) -> Runs:
+        """Access run operations."""
+        if not hasattr(self, "_runs"):
+            from .resources.runs import Runs
+
+            self._runs = Runs(self._api_client)
+        return self._runs
+
     # -- context manager ------------------------------------------------------
 
     def __enter__(self) -> ConvexityClient:

convexity_sdk-0.5.0.dev154/convexity_sdk/resources/connections.py

@@ -0,0 +1,68 @@
+"""Connection resource client."""
+
+from __future__ import annotations
+
+from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import (
+    create_databricks_connection_v1_connections_databricks_post as _create_databricks_connection,
+)
+from convexity_api_client.api.v1 import (
+    list_connections_v1_connections_get as _list_connections,
+)
+from convexity_api_client.api.v1 import (
+    verify_databricks_connection_v1_connections_databricks_connection_id_verify_post as _verify_databricks_connection,
+)
+from convexity_api_client.models.connection_list_response import ConnectionListResponse
+from convexity_api_client.models.create_databricks_connection_request import CreateDatabricksConnectionRequest
+from convexity_api_client.models.databricks_connection import DatabricksConnection
+from convexity_api_client.models.verify_result import VerifyResult
+from convexity_api_client.types import UNSET
+
+
+class Connections:
+    """Synchronous sub-client for connection operations."""
+
+    def __init__(self, api_client: AuthenticatedClient | Client) -> None:
+        self._client = api_client
+
+    def list(self, project_id: str) -> ConnectionListResponse:
+        """List all connections for a project."""
+        result = _list_connections.sync(client=self._client, project_id=project_id)
+        if not isinstance(result, ConnectionListResponse):
+            return ConnectionListResponse(connections=[])
+        return result
+
+    def create_databricks(
+        self,
+        *,
+        name: str,
+        project_id: str,
+        server_hostname: str,
+        http_path: str,
+        access_token: str,
+        db_schema: str | None = None,
+        description: str | None = None,
+        catalog: str | None = None,
+    ) -> DatabricksConnection:
+        """Create a Databricks connection."""
+        body = CreateDatabricksConnectionRequest(
+            name=name,
+            project_id=project_id,
+            server_hostname=server_hostname,
+            http_path=http_path,
+            access_token=access_token,
+            db_schema=db_schema if db_schema is not None else UNSET,
+            description=description if description is not None else UNSET,
+            catalog=catalog if catalog is not None else UNSET,
+        )
+        result = _create_databricks_connection.sync(client=self._client, body=body, project_id=project_id)
+        if not isinstance(result, DatabricksConnection):
+            raise ValueError(f"Unexpected response when creating Databricks connection: {result}")
+        return result
+
+    def verify_databricks(self, connection_id: str) -> VerifyResult:
+        """Verify a Databricks connection."""
+        result = _verify_databricks_connection.sync(connection_id, client=self._client)
+        if not isinstance(result, VerifyResult):
+            raise ValueError(f"Unexpected response when verifying Databricks connection: {result}")
+        return result

convexity_sdk-0.5.0.dev154/convexity_sdk/resources/dashboards.py

@@ -0,0 +1,67 @@
+"""Dashboard resource client."""
+
+from __future__ import annotations
+
+from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import (
+    create_dashboard_v1_dashboards_post as _create_dashboard,
+)
+from convexity_api_client.api.v1 import (
+    create_share_v1_dashboards_dashboard_id_share_post as _create_share,
+)
+from convexity_api_client.api.v1 import (
+    get_dashboard_v1_dashboards_dashboard_id_get as _get_dashboard,
+)
+from convexity_api_client.api.v1 import (
+    list_dashboards_v1_dashboards_get as _list_dashboards,
+)
+from convexity_api_client.models.create_dashboard_request import CreateDashboardRequest
+from convexity_api_client.models.create_share_request import CreateShareRequest
+from convexity_api_client.models.dashboard_definition import DashboardDefinition
+from convexity_api_client.models.dashboard_list_response import DashboardListResponse
+from convexity_api_client.models.dashboard_share_response import DashboardShareResponse
+
+
+class Dashboards:
+    """Synchronous sub-client for dashboard operations."""
+
+    def __init__(self, api_client: AuthenticatedClient | Client) -> None:
+        self._client = api_client
+
+    def list(self, project_id: str) -> DashboardListResponse:
+        """List dashboards for a project."""
+        result = _list_dashboards.sync(client=self._client, project_id=project_id)
+        if result is None or not isinstance(result, DashboardListResponse):
+            return DashboardListResponse(dashboards=[])
+        return result
+
+    def get(self, dashboard_id: str) -> DashboardDefinition | None:
+        """Get a single dashboard by ID."""
+        result = _get_dashboard.sync(dashboard_id, client=self._client)
+        if isinstance(result, DashboardDefinition):
+            return result
+        return None
+
+    def create(
+        self,
+        *,
+        project_id: str,
+        body: CreateDashboardRequest,
+    ) -> DashboardDefinition:
+        """Create a new dashboard."""
+        result = _create_dashboard.sync(client=self._client, body=body, project_id=project_id)
+        if not isinstance(result, DashboardDefinition):
+            raise ValueError(f"Unexpected response when creating dashboard: {result}")
+        return result
+
+    def create_share(
+        self,
+        *,
+        dashboard_id: str,
+        body: CreateShareRequest,
+    ) -> DashboardShareResponse:
+        """Create or update a share for a dashboard."""
+        result = _create_share.sync(dashboard_id, client=self._client, body=body)
+        if not isinstance(result, DashboardShareResponse):
+            raise ValueError(f"Unexpected response when creating dashboard share: {result}")
+        return result

convexity_sdk-0.5.0.dev154/convexity_sdk/resources/datalake.py

@@ -0,0 +1,23 @@
+"""Datalake resource client."""
+
+from __future__ import annotations
+
+from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import (
+    get_or_create_datalake_connection_info_v1_datalake_connection_get as _get_datalake_info,
+)
+from convexity_api_client.models.datalake_connection_response import DatalakeConnectionResponse
+
+
+class Datalake:
+    """Synchronous sub-client for datalake operations."""
+
+    def __init__(self, api_client: AuthenticatedClient | Client) -> None:
+        self._client = api_client
+
+    def get_info(self, project_id: str) -> DatalakeConnectionResponse:
+        """Get (or create) DuckLake connection info for a project."""
+        result = _get_datalake_info.sync(client=self._client, project_id=project_id)
+        if not isinstance(result, DatalakeConnectionResponse):
+            return DatalakeConnectionResponse()
+        return result

convexity_sdk-0.5.0.dev154/convexity_sdk/resources/datasets.py

@@ -0,0 +1,177 @@
+"""Dataset resource client."""
+
+from __future__ import annotations
+
+from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import (
+    create_dataset_v1_datasets_post as _create_dataset,
+)
+from convexity_api_client.api.v1 import (
+    delete_dataset_v1_datasets_dataset_id_delete as _delete_dataset,
+)
+from convexity_api_client.api.v1 import (
+    get_dataset_v1_datasets_dataset_id_get as _get_dataset,
+)
+from convexity_api_client.api.v1 import (
+    get_refresh_task_status_v1_datasets_dataset_id_refresh_task_id_get as _get_refresh_status,
+)
+from convexity_api_client.api.v1 import (
+    list_datasets_v1_datasets_get as _list_datasets,
+)
+from convexity_api_client.api.v1 import (
+    list_refresh_tasks_v1_datasets_dataset_id_refresh_history_get as _list_refresh_tasks,
+)
+from convexity_api_client.api.v1 import (
+    refresh_dataset_async_v1_datasets_dataset_id_refresh_async_post as _refresh_dataset,
+)
+from convexity_api_client.api.v1 import (
+    update_dataset_v1_datasets_dataset_id_patch as _update_dataset,
+)
+from convexity_api_client.models.create_dataset_request import CreateDatasetRequest
+from convexity_api_client.models.dataset_config import DatasetConfig
+from convexity_api_client.models.dataset_definition import DatasetDefinition
+from convexity_api_client.models.dataset_list_response import DatasetListResponse
+from convexity_api_client.models.dataset_type import DatasetType
+from convexity_api_client.models.refresh_mode import RefreshMode
+from convexity_api_client.models.refresh_task_list_response import RefreshTaskListResponse
+from convexity_api_client.models.update_dataset_request import UpdateDatasetRequest
+from convexity_api_client.models.worker_task_response import WorkerTaskResponse
+from convexity_api_client.types import UNSET, Unset
+
+
+class Datasets:
+    """Synchronous sub-client for dataset operations."""
+
+    def __init__(self, api_client: AuthenticatedClient | Client) -> None:
+        self._client = api_client
+
+    # -- CRUD -----------------------------------------------------------------
+
+    def list(self, project_id: str) -> DatasetListResponse:
+        """List datasets for a project."""
+        result = _list_datasets.sync(client=self._client, project_id=project_id)
+        if result is None or not isinstance(result, DatasetListResponse):
+            return DatasetListResponse(datasets=[])
+        return result
+
+    def get(self, dataset_id: str) -> DatasetDefinition | None:
+        """Get a single dataset by ID."""
+        result = _get_dataset.sync(dataset_id, client=self._client)
+        if isinstance(result, DatasetDefinition):
+            return result
+        return None
+
+    def create(
+        self,
+        *,
+        project_id: str,
+        name: str,
+        type_: DatasetType,
+        config: DatasetConfig,
+        description: str | None = None,
+        connection_id: str | None = None,
+        refresh_mode: RefreshMode | None = None,
+        refresh_schedule: str | None = None,
+        cache_ttl_seconds: int | None = None,
+        tags: list[str] | None = None,
+    ) -> DatasetDefinition:
+        """Create a new dataset in a project."""
+        body = CreateDatasetRequest(
+            project_id=project_id,
+            name=name,
+            type_=type_,
+            config=config,
+            description=description if description is not None else UNSET,
+            connection_id=connection_id if connection_id is not None else UNSET,
+            refresh_mode=refresh_mode if refresh_mode is not None else UNSET,
+            refresh_schedule=refresh_schedule if refresh_schedule is not None else UNSET,
+            cache_ttl_seconds=cache_ttl_seconds if cache_ttl_seconds is not None else UNSET,
+            tags=tags if tags is not None else UNSET,
+        )
+        result = _create_dataset.sync(client=self._client, body=body, project_id=project_id)
+        if not isinstance(result, DatasetDefinition):
+            raise ValueError(f"Unexpected response when creating dataset: {result}")
+        return result
+
+    def update(
+        self,
+        dataset_id: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        connection_id: str | None = None,
+        config: DatasetConfig | None = None,
+        refresh_mode: RefreshMode | None = None,
+        refresh_schedule: str | None = None,
+        cache_ttl_seconds: int | None = None,
+        tags: list[str] | None = None,
+    ) -> DatasetDefinition:
+        """Update an existing dataset."""
+        body = UpdateDatasetRequest(
+            name=name if name is not None else UNSET,
+            description=description if description is not None else UNSET,
+            connection_id=connection_id if connection_id is not None else UNSET,
+            config=config if config is not None else UNSET,
+            refresh_mode=refresh_mode if refresh_mode is not None else UNSET,
+            refresh_schedule=refresh_schedule if refresh_schedule is not None else UNSET,
+            cache_ttl_seconds=cache_ttl_seconds if cache_ttl_seconds is not None else UNSET,
+            tags=tags if tags is not None else UNSET,
+        )
+        result = _update_dataset.sync(dataset_id, client=self._client, body=body)
+        if not isinstance(result, DatasetDefinition):
+            raise ValueError(f"Unexpected response when updating dataset: {result}")
+        return result
+
+    def delete(self, dataset_id: str) -> None:
+        """Delete a dataset by ID."""
+        _delete_dataset.sync_detailed(dataset_id, client=self._client)
+
+    # -- Refresh --------------------------------------------------------------
+
+    def refresh(self, dataset_id: str) -> WorkerTaskResponse:
+        """Trigger an async refresh for a dataset.
+
+        Returns a ``WorkerTaskResponse`` whose ``id`` field is the task ID.
+        Use :meth:`get_refresh_status` to poll for completion.
+        """
+        result = _refresh_dataset.sync(dataset_id, client=self._client)
+        if not isinstance(result, WorkerTaskResponse):
+            raise ValueError(f"Unexpected response when refreshing dataset: {result}")
+        return result
+
+    def get_refresh_status(self, dataset_id: str, task_id: str) -> WorkerTaskResponse:
+        """Get the status of a refresh task."""
+        result = _get_refresh_status.sync(dataset_id, task_id, client=self._client)
+        if not isinstance(result, WorkerTaskResponse):
+            raise ValueError(f"Unexpected response when fetching refresh status: {result}")
+        return result
+
+    def cancel_refresh(self, dataset_id: str, task_id: str) -> WorkerTaskResponse:
+        """Cancel a pending refresh task for a dataset."""
+        response = self._client.get_httpx_client().request(
+            "post",
+            f"/v1/datasets/{dataset_id}/refresh/{task_id}/cancel",
+        )
+        if response.status_code == 200:
+            return WorkerTaskResponse.from_dict(response.json())
+        raise ValueError(f"Unexpected response when cancelling refresh task: {response.status_code} {response.text}")
+
+    def list_refresh_history(
+        self,
+        dataset_id: str,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> RefreshTaskListResponse:
+        """List refresh task history for a dataset."""
+        limit_arg: int | Unset = UNSET if limit is None else limit
+        offset_arg: int | Unset = UNSET if offset is None else offset
+        result = _list_refresh_tasks.sync(
+            dataset_id,
+            client=self._client,
+            limit=limit_arg,
+            offset=offset_arg,
+        )
+        if not isinstance(result, RefreshTaskListResponse):
+            raise ValueError(f"Unexpected response when listing refresh history: {result}")
+        return result

{convexity_sdk-0.4.3.dev152 → convexity_sdk-0.5.0.dev154}/convexity_sdk/resources/organizations.py

@@ -9,6 +9,9 @@ from convexity_api_client.api.v1 import (
 from convexity_api_client.api.v1 import (
     create_organization_v1_organizations_post as _create_org,
 )
+from convexity_api_client.api.v1 import (
+    get_organization_by_slug_v1_organizations_slug_slug_get as _get_org_by_slug,
+)
 from convexity_api_client.api.v1 import (
     get_organization_v1_organizations_organization_id_get as _get_org,
 )
@@ -40,6 +43,10 @@ class Organizations:
         """Get a single organization by ID."""
         return _get_org.sync(organization_id, client=self._client)
 
+    def get_by_slug(self, slug: str) -> OrganizationResponse | None:
+        """Get a single organization by slug."""
+        return _get_org_by_slug.sync(slug, client=self._client)
+
     def create(
         self,
         *,

{convexity_sdk-0.4.3.dev152 → convexity_sdk-0.5.0.dev154}/convexity_sdk/resources/projects.py

@@ -6,6 +6,9 @@ from convexity_api_client import AuthenticatedClient, Client
 from convexity_api_client.api.v1 import (
     create_project_v1_projects_post as _create_project,
 )
+from convexity_api_client.api.v1 import (
+    get_project_by_slug_v1_organizations_organization_id_projects_slug_slug_get as _get_project_by_slug,
+)
 from convexity_api_client.api.v1 import (
     get_project_v1_projects_project_id_get as _get_project,
 )
@@ -51,6 +54,13 @@ class Projects:
             return result
         return None
 
+    def get_by_slug(self, organization_id: str, slug: str) -> ProjectResponse | None:
+        """Get a single project by slug within an organization."""
+        result = _get_project_by_slug.sync(organization_id, slug, client=self._client)
+        if isinstance(result, ProjectResponse):
+            return result
+        return None
+
     def create(
         self,
         *,

convexity_sdk-0.5.0.dev154/convexity_sdk/resources/runs.py

@@ -0,0 +1,57 @@
+"""Run resource client."""
+
+from __future__ import annotations
+
+from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import (
+    cancel_run_v1_run_cancel_run_id_post as _cancel_run,
+)
+from convexity_api_client.api.v1 import (
+    create_and_start_run_v1_run_create_and_start_post as _create_and_start_run,
+)
+from convexity_api_client.api.v1 import (
+    delete_run_v1_run_delete_run_id_delete as _delete_run,
+)
+from convexity_api_client.api.v1 import (
+    get_run_status_v1_run_status_run_id_get as _get_run_status,
+)
+from convexity_api_client.models.cancel_run_response import CancelRunResponse
+from convexity_api_client.models.create_run_request import CreateRunRequest
+from convexity_api_client.models.create_run_response import CreateRunResponse
+from convexity_api_client.models.delete_run_response import DeleteRunResponse
+from convexity_api_client.models.run import Run
+
+
+class Runs:
+    """Synchronous sub-client for run operations."""
+
+    def __init__(self, api_client: AuthenticatedClient | Client) -> None:
+        self._client = api_client
+
+    def create_and_start(self, *, body: CreateRunRequest) -> CreateRunResponse:
+        """Create a new run and start it immediately."""
+        result = _create_and_start_run.sync(client=self._client, body=body)
+        if not isinstance(result, CreateRunResponse):
+            raise ValueError(f"Unexpected response when creating run: {result}")
+        return result
+
+    def get_status(self, run_id: str) -> Run:
+        """Get the current status of a run."""
+        result = _get_run_status.sync(run_id, client=self._client)
+        if not isinstance(result, Run):
+            raise ValueError(f"Unexpected response when fetching run status: {result}")
+        return result
+
+    def cancel(self, run_id: str) -> CancelRunResponse:
+        """Cancel a running execution."""
+        result = _cancel_run.sync(run_id, client=self._client)
+        if not isinstance(result, CancelRunResponse):
+            raise ValueError(f"Unexpected response when cancelling run: {result}")
+        return result
+
+    def delete(self, run_id: str) -> DeleteRunResponse:
+        """Delete a run (only if not currently running)."""
+        result = _delete_run.sync(run_id, client=self._client)
+        if not isinstance(result, DeleteRunResponse):
+            raise ValueError(f"Unexpected response when deleting run: {result}")
+        return result

convexity_sdk-0.5.0.dev154/convexity_sdk/resources/tasks.py

@@ -0,0 +1,105 @@
+"""Task resource client."""
+
+from __future__ import annotations
+
+from convexity_api_client import AuthenticatedClient, Client
+from convexity_api_client.api.v1 import (
+    create_task_v1_tasks_post as _create_task,
+)
+from convexity_api_client.api.v1 import (
+    delete_task_v1_tasks_task_id_delete as _delete_task,
+)
+from convexity_api_client.api.v1 import (
+    get_task_v1_tasks_task_id_get as _get_task,
+)
+from convexity_api_client.api.v1 import (
+    list_tasks_v1_tasks_get as _list_tasks,
+)
+from convexity_api_client.api.v1 import (
+    update_task_v1_tasks_task_id_patch as _update_task,
+)
+from convexity_api_client.models.create_task_request import CreateTaskRequest
+from convexity_api_client.models.notebook_document import NotebookDocument
+from convexity_api_client.models.task_list_response import TaskListResponse
+from convexity_api_client.models.task_model import TaskModel
+from convexity_api_client.models.task_scenario import TaskScenario
+from convexity_api_client.models.update_task_request import UpdateTaskRequest
+from convexity_api_client.types import UNSET, Unset
+
+
+class Tasks:
+    """Synchronous sub-client for task operations."""
+
+    def __init__(self, api_client: AuthenticatedClient | Client) -> None:
+        self._client = api_client
+
+    def list(
+        self,
+        project_id: str,
+        *,
+        scenario: TaskScenario | None = None,
+    ) -> TaskListResponse:
+        """List tasks for a project, optionally filtered by scenario."""
+        scenario_arg: None | TaskScenario | Unset = UNSET if scenario is None else scenario
+        result = _list_tasks.sync(
+            client=self._client,
+            project_id=project_id,
+            scenario=scenario_arg,
+        )
+        if result is None:
+            return TaskListResponse(tasks=[])
+        if not isinstance(result, TaskListResponse):
+            return TaskListResponse(tasks=[])
+        return result
+
+    def get(self, task_id: str) -> TaskModel | None:
+        """Get a single task by ID."""
+        result = _get_task.sync(task_id, client=self._client)
+        if isinstance(result, TaskModel):
+            return result
+        return None
+
+    def create(
+        self,
+        *,
+        name: str,
+        project_id: str,
+        scenario: TaskScenario,
+        description: str | None = None,
+    ) -> TaskModel:
+        """Create a new task in a project."""
+        body = CreateTaskRequest(
+            name=name,
+            project_id=project_id,
+            scenario=scenario,
+            description=description,
+        )
+        result = _create_task.sync(client=self._client, body=body, project_id=project_id)
+        if not isinstance(result, TaskModel):
+            raise ValueError(f"Unexpected response when creating task: {result}")
+        return result
+
+    def update(
+        self,
+        task_id: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        scenario: TaskScenario | None = None,
+        notebook: NotebookDocument | None = None,
+    ) -> TaskModel:
+        """Update an existing task."""
+        body = UpdateTaskRequest(
+            name=name if name is not None else UNSET,
+            description=description if description is not None else UNSET,
+            scenario=scenario if scenario is not None else UNSET,
+            notebook=notebook if notebook is not None else UNSET,
+        )
+        result = _update_task.sync(task_id, client=self._client, body=body)
+        if not isinstance(result, TaskModel):
+            raise ValueError(f"Unexpected response when updating task: {result}")
+        return result
+
+    def delete(self, task_id: str) -> None:
+        """Delete a task by ID."""
+        _delete_task.sync_detailed(task_id, client=self._client)

{convexity_sdk-0.4.3.dev152 → convexity_sdk-0.5.0.dev154}/pyproject.toml

@@ -7,7 +7,7 @@ requires-python = ">=3.12"
 dependencies = [
     "httpx>=0.27.0",
     "pydantic>=2.10.0",
-    "convexity-api-client>=0.4.3.dev0,<0.5.0",
+    "convexity-api-client>=0.5.0.dev0,<0.6.0",
 ]
 
 [build-system]

{convexity_sdk-0.4.3.dev152 → convexity_sdk-0.5.0.dev154}/samples/README.md

@@ -14,6 +14,7 @@ This directory contains sample scripts demonstrating how to use the Convexity SD
 | [share_dashboard.py](share_dashboard.py)                             | Share a dashboard with other users          |
 | [list_orgs_and_projects.py](list_orgs_and_projects.py)               | List organizations and projects             |
 | [query_datalake.py](query_datalake.py)                               | Query the DuckLake warehouse with DuckDB    |
+| [cancel_refresh_task.py](cancel_refresh_task.py)                     | Cancel a pending dataset refresh task       |
 | [create_forecast_task.py](create_forecast_task.py)                   | Create a demand-forecasting task and run it |
 
 ## Running Samples