vellum-ai 1.2.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

vellum/__init__.py

@@ -103,9 +103,11 @@ from .client.types import (
     EnvironmentEnum,
     EphemeralPromptCacheConfig,
     EphemeralPromptCacheConfigTypeEnum,
+    ErrorDetailResponse,
     ErrorInput,
     ErrorVellumValue,
     ErrorVellumValueRequest,
+    EventCreateResponse,
     ExecuteApiRequestBearerToken,
     ExecuteApiRequestBody,
     ExecuteApiRequestHeadersValue,
@@ -543,6 +545,7 @@ from .client.types import (
     WorkflowDeploymentReleaseWorkflowDeployment,
     WorkflowDeploymentReleaseWorkflowVersion,
     WorkflowError,
+    WorkflowEvent,
     WorkflowEventError,
     WorkflowEventExecutionRead,
     WorkflowExecutionActual,
@@ -617,7 +620,14 @@ from .client.types import (
     WorkspaceRead,
     WorkspaceSecretRead,
 )
-from .errors import BadRequestError, ForbiddenError, InternalServerError, NotFoundError
+from .errors import (
+    BadRequestError,
+    ForbiddenError,
+    InternalServerError,
+    NotFoundError,
+    TooManyRequestsError,
+    UnauthorizedError,
+)
 from .resources import (
     DeploymentsListRequestStatus,
     DocumentIndexesListRequestStatus,
@@ -631,6 +641,7 @@ from .resources import (
     deployments,
     document_indexes,
     documents,
+    events,
     folder_entities,
     metric_definitions,
     ml_models,
@@ -752,9 +763,11 @@ __all__ = [
     "EnvironmentEnum",
     "EphemeralPromptCacheConfig",
     "EphemeralPromptCacheConfigTypeEnum",
+    "ErrorDetailResponse",
     "ErrorInput",
     "ErrorVellumValue",
     "ErrorVellumValueRequest",
+    "EventCreateResponse",
     "ExecuteApiRequestBearerToken",
     "ExecuteApiRequestBody",
     "ExecuteApiRequestHeadersValue",
@@ -1156,6 +1169,8 @@ __all__ = [
     "TokenOverlappingWindowChunkerConfigRequest",
     "TokenOverlappingWindowChunking",
     "TokenOverlappingWindowChunkingRequest",
+    "TooManyRequestsError",
+    "UnauthorizedError",
     "UnitEnum",
     "UploadDocumentResponse",
     "UpsertTestSuiteTestCaseRequest",
@@ -1202,6 +1217,7 @@ __all__ = [
     "WorkflowDeploymentReleaseWorkflowVersion",
     "WorkflowDeploymentsListRequestStatus",
     "WorkflowError",
+    "WorkflowEvent",
     "WorkflowEventError",
     "WorkflowEventExecutionRead",
     "WorkflowExecutionActual",
@@ -1281,6 +1297,7 @@ __all__ = [
     "deployments",
     "document_indexes",
     "documents",
+    "events",
     "folder_entities",
     "metric_definitions",
     "ml_models",

vellum/client/__init__.py

@@ -14,6 +14,7 @@ from .resources.container_images.client import AsyncContainerImagesClient, Conta
 from .resources.deployments.client import AsyncDeploymentsClient, DeploymentsClient
 from .resources.document_indexes.client import AsyncDocumentIndexesClient, DocumentIndexesClient
 from .resources.documents.client import AsyncDocumentsClient, DocumentsClient
+from .resources.events.client import AsyncEventsClient, EventsClient
 from .resources.folder_entities.client import AsyncFolderEntitiesClient, FolderEntitiesClient
 from .resources.metric_definitions.client import AsyncMetricDefinitionsClient, MetricDefinitionsClient
 from .resources.ml_models.client import AsyncMlModelsClient, MlModelsClient
@@ -128,6 +129,7 @@ class Vellum:
             timeout=_defaulted_timeout,
         )
         self._raw_client = RawVellum(client_wrapper=self._client_wrapper)
+        self.events = EventsClient(client_wrapper=self._client_wrapper)
         self.ad_hoc = AdHocClient(client_wrapper=self._client_wrapper)
         self.container_images = ContainerImagesClient(client_wrapper=self._client_wrapper)
         self.deployments = DeploymentsClient(client_wrapper=self._client_wrapper)
@@ -991,6 +993,7 @@ class AsyncVellum:
             timeout=_defaulted_timeout,
         )
         self._raw_client = AsyncRawVellum(client_wrapper=self._client_wrapper)
+        self.events = AsyncEventsClient(client_wrapper=self._client_wrapper)
         self.ad_hoc = AsyncAdHocClient(client_wrapper=self._client_wrapper)
         self.container_images = AsyncContainerImagesClient(client_wrapper=self._client_wrapper)
         self.deployments = AsyncDeploymentsClient(client_wrapper=self._client_wrapper)

vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.2.0",
+            "User-Agent": "vellum-ai/1.2.1",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.2.0",
+            "X-Fern-SDK-Version": "1.2.1",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/client/errors/__init__.py

@@ -6,5 +6,14 @@ from .bad_request_error import BadRequestError
 from .forbidden_error import ForbiddenError
 from .internal_server_error import InternalServerError
 from .not_found_error import NotFoundError
+from .too_many_requests_error import TooManyRequestsError
+from .unauthorized_error import UnauthorizedError
 
-__all__ = ["BadRequestError", "ForbiddenError", "InternalServerError", "NotFoundError"]
+__all__ = [
+    "BadRequestError",
+    "ForbiddenError",
+    "InternalServerError",
+    "NotFoundError",
+    "TooManyRequestsError",
+    "UnauthorizedError",
+]

vellum/client/errors/too_many_requests_error.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.api_error import ApiError
+from ..types.error_detail_response import ErrorDetailResponse
+
+
+class TooManyRequestsError(ApiError):
+    def __init__(self, body: ErrorDetailResponse, headers: typing.Optional[typing.Dict[str, str]] = None):
+        super().__init__(status_code=429, headers=headers, body=body)

vellum/client/errors/unauthorized_error.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.api_error import ApiError
+from ..types.error_detail_response import ErrorDetailResponse
+
+
+class UnauthorizedError(ApiError):
+    def __init__(self, body: ErrorDetailResponse, headers: typing.Optional[typing.Dict[str, str]] = None):
+        super().__init__(status_code=401, headers=headers, body=body)

vellum/client/reference.md

@@ -1245,6 +1245,100 @@ client.submit_workflow_execution_actuals(
 </dl>
 
 
+</dd>
+</dl>
+</details>
+
+## Events
+<details><summary><code>client.events.<a href="src/vellum/resources/events/client.py">create</a>(...)</code></summary>
+<dl>
+<dd>
+
+#### 📝 Description
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+Accept an event and publish it to ClickHouse for analytics processing.
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### 🔌 Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```python
+import datetime
+
+from vellum import (
+    NodeExecutionInitiatedBody,
+    NodeExecutionInitiatedEvent,
+    Vellum,
+    VellumCodeResourceDefinition,
+)
+
+client = Vellum(
+    api_version="YOUR_API_VERSION",
+    api_key="YOUR_API_KEY",
+)
+client.events.create(
+    request=NodeExecutionInitiatedEvent(
+        body=NodeExecutionInitiatedBody(
+            node_definition=VellumCodeResourceDefinition(
+                name="name",
+                module=["module", "module"],
+                id="id",
+            ),
+            inputs={"inputs": {"key": "value"}},
+        ),
+        id="id",
+        timestamp=datetime.datetime.fromisoformat(
+            "2024-01-15 09:30:00+00:00",
+        ),
+        trace_id="trace_id",
+        span_id="span_id",
+    ),
+)
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### ⚙️ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**request:** `WorkflowEvent` 
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration.
+    
+</dd>
+</dl>
+</dd>
+</dl>
+
+
 </dd>
 </dl>
 </details>

vellum/client/resources/__init__.py

@@ -8,6 +8,7 @@ from . import (
     deployments,
     document_indexes,
     documents,
+    events,
     folder_entities,
     metric_definitions,
     ml_models,
@@ -42,6 +43,7 @@ __all__ = [
     "deployments",
     "document_indexes",
     "documents",
+    "events",
     "folder_entities",
     "metric_definitions",
     "ml_models",

vellum/client/resources/events/__init__.py

@@ -0,0 +1,4 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+

vellum/client/resources/events/client.py

@@ -0,0 +1,165 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ...core.request_options import RequestOptions
+from ...types.event_create_response import EventCreateResponse
+from ...types.workflow_event import WorkflowEvent
+from .raw_client import AsyncRawEventsClient, RawEventsClient
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class EventsClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawEventsClient(client_wrapper=client_wrapper)
+
+    @property
+    def _client_wrapper(self) -> SyncClientWrapper:
+        return self._raw_client._client_wrapper
+
+    @property
+    def with_raw_response(self) -> RawEventsClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawEventsClient
+        """
+        return self._raw_client
+
+    def create(
+        self, *, request: WorkflowEvent, request_options: typing.Optional[RequestOptions] = None
+    ) -> EventCreateResponse:
+        """
+        Accept an event and publish it to ClickHouse for analytics processing.
+
+        Parameters
+        ----------
+        request : WorkflowEvent
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        EventCreateResponse
+
+
+        Examples
+        --------
+        import datetime
+
+        from vellum import (
+            NodeExecutionInitiatedBody,
+            NodeExecutionInitiatedEvent,
+            Vellum,
+            VellumCodeResourceDefinition,
+        )
+
+        client = Vellum(
+            api_version="YOUR_API_VERSION",
+            api_key="YOUR_API_KEY",
+        )
+        client.events.create(
+            request=NodeExecutionInitiatedEvent(
+                body=NodeExecutionInitiatedBody(
+                    node_definition=VellumCodeResourceDefinition(
+                        name="name",
+                        module=["module", "module"],
+                        id="id",
+                    ),
+                    inputs={"inputs": {"key": "value"}},
+                ),
+                id="id",
+                timestamp=datetime.datetime.fromisoformat(
+                    "2024-01-15 09:30:00+00:00",
+                ),
+                trace_id="trace_id",
+                span_id="span_id",
+            ),
+        )
+        """
+        _response = self._raw_client.create(request=request, request_options=request_options)
+        return _response.data
+
+
+class AsyncEventsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawEventsClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawEventsClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawEventsClient
+        """
+        return self._raw_client
+
+    async def create(
+        self, *, request: WorkflowEvent, request_options: typing.Optional[RequestOptions] = None
+    ) -> EventCreateResponse:
+        """
+        Accept an event and publish it to ClickHouse for analytics processing.
+
+        Parameters
+        ----------
+        request : WorkflowEvent
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        EventCreateResponse
+
+
+        Examples
+        --------
+        import asyncio
+        import datetime
+
+        from vellum import (
+            AsyncVellum,
+            NodeExecutionInitiatedBody,
+            NodeExecutionInitiatedEvent,
+            VellumCodeResourceDefinition,
+        )
+
+        client = AsyncVellum(
+            api_version="YOUR_API_VERSION",
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.events.create(
+                request=NodeExecutionInitiatedEvent(
+                    body=NodeExecutionInitiatedBody(
+                        node_definition=VellumCodeResourceDefinition(
+                            name="name",
+                            module=["module", "module"],
+                            id="id",
+                        ),
+                        inputs={"inputs": {"key": "value"}},
+                    ),
+                    id="id",
+                    timestamp=datetime.datetime.fromisoformat(
+                        "2024-01-15 09:30:00+00:00",
+                    ),
+                    trace_id="trace_id",
+                    span_id="span_id",
+                ),
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.create(request=request, request_options=request_options)
+        return _response.data

vellum/client/resources/events/raw_client.py

@@ -0,0 +1,207 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from json.decoder import JSONDecodeError
+
+from ...core.api_error import ApiError
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ...core.http_response import AsyncHttpResponse, HttpResponse
+from ...core.pydantic_utilities import parse_obj_as
+from ...core.request_options import RequestOptions
+from ...core.serialization import convert_and_respect_annotation_metadata
+from ...errors.bad_request_error import BadRequestError
+from ...errors.forbidden_error import ForbiddenError
+from ...errors.too_many_requests_error import TooManyRequestsError
+from ...errors.unauthorized_error import UnauthorizedError
+from ...types.error_detail_response import ErrorDetailResponse
+from ...types.event_create_response import EventCreateResponse
+from ...types.workflow_event import WorkflowEvent
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RawEventsClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def create(
+        self, *, request: WorkflowEvent, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[EventCreateResponse]:
+        """
+        Accept an event and publish it to ClickHouse for analytics processing.
+
+        Parameters
+        ----------
+        request : WorkflowEvent
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[EventCreateResponse]
+
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "monitoring/v1/events",
+            base_url=self._client_wrapper.get_environment().default,
+            method="POST",
+            json=convert_and_respect_annotation_metadata(object_=request, annotation=WorkflowEvent, direction="write"),
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    EventCreateResponse,
+                    parse_obj_as(
+                        type_=EventCreateResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorDetailResponse,
+                        parse_obj_as(
+                            type_=ErrorDetailResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 429:
+                raise TooManyRequestsError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorDetailResponse,
+                        parse_obj_as(
+                            type_=ErrorDetailResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+
+class AsyncRawEventsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def create(
+        self, *, request: WorkflowEvent, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[EventCreateResponse]:
+        """
+        Accept an event and publish it to ClickHouse for analytics processing.
+
+        Parameters
+        ----------
+        request : WorkflowEvent
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[EventCreateResponse]
+
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "monitoring/v1/events",
+            base_url=self._client_wrapper.get_environment().default,
+            method="POST",
+            json=convert_and_respect_annotation_metadata(object_=request, annotation=WorkflowEvent, direction="write"),
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    EventCreateResponse,
+                    parse_obj_as(
+                        type_=EventCreateResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorDetailResponse,
+                        parse_obj_as(
+                            type_=ErrorDetailResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 429:
+                raise TooManyRequestsError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorDetailResponse,
+                        parse_obj_as(
+                            type_=ErrorDetailResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

vellum/client/types/__init__.py

@@ -107,9 +107,11 @@ from .entity_visibility import EntityVisibility
 from .environment_enum import EnvironmentEnum
 from .ephemeral_prompt_cache_config import EphemeralPromptCacheConfig
 from .ephemeral_prompt_cache_config_type_enum import EphemeralPromptCacheConfigTypeEnum
+from .error_detail_response import ErrorDetailResponse
 from .error_input import ErrorInput
 from .error_vellum_value import ErrorVellumValue
 from .error_vellum_value_request import ErrorVellumValueRequest
+from .event_create_response import EventCreateResponse
 from .execute_api_request_bearer_token import ExecuteApiRequestBearerToken
 from .execute_api_request_body import ExecuteApiRequestBody
 from .execute_api_request_headers_value import ExecuteApiRequestHeadersValue
@@ -567,6 +569,7 @@ from .workflow_deployment_release import WorkflowDeploymentRelease
 from .workflow_deployment_release_workflow_deployment import WorkflowDeploymentReleaseWorkflowDeployment
 from .workflow_deployment_release_workflow_version import WorkflowDeploymentReleaseWorkflowVersion
 from .workflow_error import WorkflowError
+from .workflow_event import WorkflowEvent
 from .workflow_event_error import WorkflowEventError
 from .workflow_event_execution_read import WorkflowEventExecutionRead
 from .workflow_execution_actual import WorkflowExecutionActual
@@ -739,9 +742,11 @@ __all__ = [
     "EnvironmentEnum",
     "EphemeralPromptCacheConfig",
     "EphemeralPromptCacheConfigTypeEnum",
+    "ErrorDetailResponse",
     "ErrorInput",
     "ErrorVellumValue",
     "ErrorVellumValueRequest",
+    "EventCreateResponse",
     "ExecuteApiRequestBearerToken",
     "ExecuteApiRequestBody",
     "ExecuteApiRequestHeadersValue",
@@ -1179,6 +1184,7 @@ __all__ = [
     "WorkflowDeploymentReleaseWorkflowDeployment",
     "WorkflowDeploymentReleaseWorkflowVersion",
     "WorkflowError",
+    "WorkflowEvent",
     "WorkflowEventError",
     "WorkflowEventExecutionRead",
     "WorkflowExecutionActual",