convexity-api-client 0.4.3.dev153__tar.gz → 0.5.0.dev155__tar.gz

{convexity_api_client-0.4.3.dev153 → convexity_api_client-0.5.0.dev155}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: convexity_api_client
-Version: 0.4.3.dev153
+Version: 0.5.0.dev155
 Summary: A client library for accessing Convexity API
 Requires-Dist: httpx>=0.23.0,<0.29.0
 Requires-Dist: attrs>=22.2.0

convexity_api_client-0.5.0.dev155/convexity_api_client/api/v1/cancel_refresh_task_v1_datasets_dataset_id_refresh_task_id_cancel_post.py

@@ -0,0 +1,183 @@
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.http_validation_error import HTTPValidationError
+from ...models.worker_task_response import WorkerTaskResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    dataset_id: str,
+    task_id: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/v1/datasets/{dataset_id}/refresh/{task_id}/cancel".format(
+            dataset_id=quote(str(dataset_id), safe=""),
+            task_id=quote(str(task_id), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> HTTPValidationError | WorkerTaskResponse | None:
+    if response.status_code == 200:
+        response_200 = WorkerTaskResponse.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 422:
+        response_422 = HTTPValidationError.from_dict(response.json())
+
+        return response_422
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[HTTPValidationError | WorkerTaskResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    dataset_id: str,
+    task_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[HTTPValidationError | WorkerTaskResponse]:
+    """Cancel Refresh Task
+
+     Cancel a pending or running refresh task for a dataset. Requires member role.
+
+    Args:
+        dataset_id (str):
+        task_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[HTTPValidationError | WorkerTaskResponse]
+    """
+
+    kwargs = _get_kwargs(
+        dataset_id=dataset_id,
+        task_id=task_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    dataset_id: str,
+    task_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+) -> HTTPValidationError | WorkerTaskResponse | None:
+    """Cancel Refresh Task
+
+     Cancel a pending or running refresh task for a dataset. Requires member role.
+
+    Args:
+        dataset_id (str):
+        task_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        HTTPValidationError | WorkerTaskResponse
+    """
+
+    return sync_detailed(
+        dataset_id=dataset_id,
+        task_id=task_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    dataset_id: str,
+    task_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+) -> Response[HTTPValidationError | WorkerTaskResponse]:
+    """Cancel Refresh Task
+
+     Cancel a pending or running refresh task for a dataset. Requires member role.
+
+    Args:
+        dataset_id (str):
+        task_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[HTTPValidationError | WorkerTaskResponse]
+    """
+
+    kwargs = _get_kwargs(
+        dataset_id=dataset_id,
+        task_id=task_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    dataset_id: str,
+    task_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+) -> HTTPValidationError | WorkerTaskResponse | None:
+    """Cancel Refresh Task
+
+     Cancel a pending or running refresh task for a dataset. Requires member role.
+
+    Args:
+        dataset_id (str):
+        task_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        HTTPValidationError | WorkerTaskResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            dataset_id=dataset_id,
+            task_id=task_id,
+            client=client,
+        )
+    ).parsed

{convexity_api_client-0.4.3.dev153 → convexity_api_client-0.5.0.dev155}/convexity_api_client/models/__init__.py

@@ -139,6 +139,7 @@ from .date_range_value import DateRangeValue
 from .delete_connection_v1_connections_connection_id_delete_response_delete_connection_v1_connections_connection_id_delete import (
     DeleteConnectionV1ConnectionsConnectionIdDeleteResponseDeleteConnectionV1ConnectionsConnectionIdDelete,
 )
+from .delete_dataset_payload import DeleteDatasetPayload
 from .delete_file_request import DeleteFileRequest
 from .delete_file_response import DeleteFileResponse
 from .delete_run_response import DeleteRunResponse
@@ -223,6 +224,8 @@ from .public_dashboard_response import PublicDashboardResponse
 from .public_dashboard_response_filters_type_0_item import PublicDashboardResponseFiltersType0Item
 from .read_file_request import ReadFileRequest
 from .read_file_response import ReadFileResponse
+from .refresh_dataset_payload import RefreshDatasetPayload
+from .refresh_dataset_payload_parameters_type_0 import RefreshDatasetPayloadParametersType0
 from .refresh_mode import RefreshMode
 from .refresh_task import RefreshTask
 from .refresh_task_list_response import RefreshTaskListResponse
@@ -261,6 +264,7 @@ from .sql_query_response_rows_item import SqlQueryResponseRowsItem
 from .start_run_response import StartRunResponse
 from .static_dataset_config import StaticDatasetConfig
 from .static_dataset_config_data_item import StaticDatasetConfigDataItem
+from .sync_catalog_to_s3_payload import SyncCatalogToS3Payload
 from .table_info import TableInfo
 from .table_list_response import TableListResponse
 from .task_connection import TaskConnection
@@ -297,6 +301,7 @@ from .update_share_request import UpdateShareRequest
 from .update_task_request import UpdateTaskRequest
 from .update_task_request_parameter_schema_type_0 import UpdateTaskRequestParameterSchemaType0
 from .update_webhook_connection_request import UpdateWebhookConnectionRequest
+from .vacuum_ducklake_payload import VacuumDucklakePayload
 from .validation_error import ValidationError
 from .verify_result import VerifyResult
 from .visual_encoding_config import VisualEncodingConfig
@@ -453,6 +458,7 @@ __all__ = (
     "DatasetType",
     "DateRangeValue",
     "DeleteConnectionV1ConnectionsConnectionIdDeleteResponseDeleteConnectionV1ConnectionsConnectionIdDelete",
+    "DeleteDatasetPayload",
     "DeleteFileRequest",
     "DeleteFileResponse",
     "DeleteRunResponse",
@@ -537,6 +543,8 @@ __all__ = (
     "PublicDashboardResponseFiltersType0Item",
     "ReadFileRequest",
     "ReadFileResponse",
+    "RefreshDatasetPayload",
+    "RefreshDatasetPayloadParametersType0",
     "RefreshMode",
     "RefreshTask",
     "RefreshTaskListResponse",
@@ -575,6 +583,7 @@ __all__ = (
     "StartRunResponse",
     "StaticDatasetConfig",
     "StaticDatasetConfigDataItem",
+    "SyncCatalogToS3Payload",
     "TableInfo",
     "TableListResponse",
     "TaskConnection",
@@ -611,6 +620,7 @@ __all__ = (
     "UpdateTaskRequest",
     "UpdateTaskRequestParameterSchemaType0",
     "UpdateWebhookConnectionRequest",
+    "VacuumDucklakePayload",
     "ValidationError",
     "VerifyResult",
     "VisualEncodingConfig",

convexity_api_client-0.5.0.dev155/convexity_api_client/models/delete_dataset_payload.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="DeleteDatasetPayload")
+
+
+@_attrs_define
+class DeleteDatasetPayload:
+    """Payload for deleting a dataset's DuckLake table.
+
+    Drops the DuckLake table associated with the dataset.
+    Parquet data files remain on S3 until VACUUM is run.
+
+        Attributes:
+            dataset_id (str): ID of the dataset whose DuckLake table to delete
+            project_id (str): Project the dataset belongs to
+            type_ (Literal['delete_dataset'] | Unset):  Default: 'delete_dataset'.
+    """
+
+    dataset_id: str
+    project_id: str
+    type_: Literal["delete_dataset"] | Unset = "delete_dataset"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        dataset_id = self.dataset_id
+
+        project_id = self.project_id
+
+        type_ = self.type_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "datasetId": dataset_id,
+                "projectId": project_id,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        dataset_id = d.pop("datasetId")
+
+        project_id = d.pop("projectId")
+
+        type_ = cast(Literal["delete_dataset"] | Unset, d.pop("type", UNSET))
+        if type_ != "delete_dataset" and not isinstance(type_, Unset):
+            raise ValueError(f"type must match const 'delete_dataset', got '{type_}'")
+
+        delete_dataset_payload = cls(
+            dataset_id=dataset_id,
+            project_id=project_id,
+            type_=type_,
+        )
+
+        delete_dataset_payload.additional_properties = d
+        return delete_dataset_payload
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

convexity_api_client-0.5.0.dev155/convexity_api_client/models/refresh_dataset_payload.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.refresh_dataset_payload_parameters_type_0 import RefreshDatasetPayloadParametersType0
+
+
+T = TypeVar("T", bound="RefreshDatasetPayload")
+
+
+@_attrs_define
+class RefreshDatasetPayload:
+    """Payload for a dataset refresh task.
+
+    Extracts data from the dataset's connection and writes it into the
+    DuckLake table, using either overwrite or upsert mode depending on
+    whether primary_keys are configured.
+
+        Attributes:
+            dataset_id (str): ID of the dataset to refresh
+            project_id (str): Project the dataset belongs to
+            user_id (str): User who initiated the refresh
+            type_ (Literal['refresh_dataset'] | Unset):  Default: 'refresh_dataset'.
+            parameters (None | RefreshDatasetPayloadParametersType0 | Unset): Optional query parameters for parameterized
+                datasets
+            dataset_name (None | str | Unset): Display name of the dataset being refreshed
+            row_count (int | None | Unset): Number of rows written during refresh
+            progress_message (None | str | Unset): Human-readable progress message
+    """
+
+    dataset_id: str
+    project_id: str
+    user_id: str
+    type_: Literal["refresh_dataset"] | Unset = "refresh_dataset"
+    parameters: None | RefreshDatasetPayloadParametersType0 | Unset = UNSET
+    dataset_name: None | str | Unset = UNSET
+    row_count: int | None | Unset = UNSET
+    progress_message: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.refresh_dataset_payload_parameters_type_0 import RefreshDatasetPayloadParametersType0
+
+        dataset_id = self.dataset_id
+
+        project_id = self.project_id
+
+        user_id = self.user_id
+
+        type_ = self.type_
+
+        parameters: dict[str, Any] | None | Unset
+        if isinstance(self.parameters, Unset):
+            parameters = UNSET
+        elif isinstance(self.parameters, RefreshDatasetPayloadParametersType0):
+            parameters = self.parameters.to_dict()
+        else:
+            parameters = self.parameters
+
+        dataset_name: None | str | Unset
+        if isinstance(self.dataset_name, Unset):
+            dataset_name = UNSET
+        else:
+            dataset_name = self.dataset_name
+
+        row_count: int | None | Unset
+        if isinstance(self.row_count, Unset):
+            row_count = UNSET
+        else:
+            row_count = self.row_count
+
+        progress_message: None | str | Unset
+        if isinstance(self.progress_message, Unset):
+            progress_message = UNSET
+        else:
+            progress_message = self.progress_message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "datasetId": dataset_id,
+                "projectId": project_id,
+                "userId": user_id,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if parameters is not UNSET:
+            field_dict["parameters"] = parameters
+        if dataset_name is not UNSET:
+            field_dict["datasetName"] = dataset_name
+        if row_count is not UNSET:
+            field_dict["rowCount"] = row_count
+        if progress_message is not UNSET:
+            field_dict["progressMessage"] = progress_message
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.refresh_dataset_payload_parameters_type_0 import RefreshDatasetPayloadParametersType0
+
+        d = dict(src_dict)
+        dataset_id = d.pop("datasetId")
+
+        project_id = d.pop("projectId")
+
+        user_id = d.pop("userId")
+
+        type_ = cast(Literal["refresh_dataset"] | Unset, d.pop("type", UNSET))
+        if type_ != "refresh_dataset" and not isinstance(type_, Unset):
+            raise ValueError(f"type must match const 'refresh_dataset', got '{type_}'")
+
+        def _parse_parameters(data: object) -> None | RefreshDatasetPayloadParametersType0 | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                parameters_type_0 = RefreshDatasetPayloadParametersType0.from_dict(data)
+
+                return parameters_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | RefreshDatasetPayloadParametersType0 | Unset, data)
+
+        parameters = _parse_parameters(d.pop("parameters", UNSET))
+
+        def _parse_dataset_name(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        dataset_name = _parse_dataset_name(d.pop("datasetName", UNSET))
+
+        def _parse_row_count(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        row_count = _parse_row_count(d.pop("rowCount", UNSET))
+
+        def _parse_progress_message(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        progress_message = _parse_progress_message(d.pop("progressMessage", UNSET))
+
+        refresh_dataset_payload = cls(
+            dataset_id=dataset_id,
+            project_id=project_id,
+            user_id=user_id,
+            type_=type_,
+            parameters=parameters,
+            dataset_name=dataset_name,
+            row_count=row_count,
+            progress_message=progress_message,
+        )
+
+        refresh_dataset_payload.additional_properties = d
+        return refresh_dataset_payload
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

convexity_api_client-0.5.0.dev155/convexity_api_client/models/refresh_dataset_payload_parameters_type_0.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="RefreshDatasetPayloadParametersType0")
+
+
+@_attrs_define
+class RefreshDatasetPayloadParametersType0:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        refresh_dataset_payload_parameters_type_0 = cls()
+
+        refresh_dataset_payload_parameters_type_0.additional_properties = d
+        return refresh_dataset_payload_parameters_type_0
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

convexity_api_client-0.5.0.dev155/convexity_api_client/models/sync_catalog_to_s3_payload.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SyncCatalogToS3Payload")
+
+
+@_attrs_define
+class SyncCatalogToS3Payload:
+    """Payload for syncing the DuckLake catalog to S3.
+
+    Exports the PostgreSQL catalog metadata to a DuckDB file on S3
+    so that the frontend DuckDB WASM can attach it as a read-only
+    catalog for direct data access.
+
+        Attributes:
+            project_id (str): Project whose catalog to sync
+            type_ (Literal['sync_catalog_to_s3'] | Unset):  Default: 'sync_catalog_to_s3'.
+    """
+
+    project_id: str
+    type_: Literal["sync_catalog_to_s3"] | Unset = "sync_catalog_to_s3"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        project_id = self.project_id
+
+        type_ = self.type_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "projectId": project_id,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        project_id = d.pop("projectId")
+
+        type_ = cast(Literal["sync_catalog_to_s3"] | Unset, d.pop("type", UNSET))
+        if type_ != "sync_catalog_to_s3" and not isinstance(type_, Unset):
+            raise ValueError(f"type must match const 'sync_catalog_to_s3', got '{type_}'")
+
+        sync_catalog_to_s3_payload = cls(
+            project_id=project_id,
+            type_=type_,
+        )
+
+        sync_catalog_to_s3_payload.additional_properties = d
+        return sync_catalog_to_s3_payload
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties