vellum-ai 0.0.20__py3-none-any.whl → 0.0.25__py3-none-any.whl

vellum/resources/deployments/client.py

@@ -3,25 +3,35 @@
 import urllib.parse
 from json.decoder import JSONDecodeError
 
-import httpx
 import pydantic
 
 from ...core.api_error import ApiError
-from ...core.remove_none_from_headers import remove_none_from_headers
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ...environment import VellumEnvironment
 from ...types.deployment_read import DeploymentRead
 
 
 class DeploymentsClient:
-    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+    def __init__(
+        self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, client_wrapper: SyncClientWrapper
+    ):
         self._environment = environment
-        self.api_key = api_key
+        self._client_wrapper = client_wrapper
 
     def retrieve(self, id: str) -> DeploymentRead:
-        _response = httpx.request(
+        """
+
+        <strong style="background-color:#ffc107; color:white; padding:4px; border-radius:4px">Unstable</strong>
+
+        Used to retrieve a deployment given its ID or name.
+
+        Parameters:
+            - id: str. Either the Deployment's ID or its unique name
+        """
+        _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(f"{self._environment.default}/", f"v1/deployments/{id}"),
-            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            headers=self._client_wrapper.get_headers(),
             timeout=None,
         )
         if 200 <= _response.status_code < 300:
@@ -34,18 +44,28 @@ class DeploymentsClient:
 
 
 class AsyncDeploymentsClient:
-    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+    def __init__(
+        self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, client_wrapper: AsyncClientWrapper
+    ):
         self._environment = environment
-        self.api_key = api_key
+        self._client_wrapper = client_wrapper
 
     async def retrieve(self, id: str) -> DeploymentRead:
-        async with httpx.AsyncClient() as _client:
-            _response = await _client.request(
-                "GET",
-                urllib.parse.urljoin(f"{self._environment.default}/", f"v1/deployments/{id}"),
-                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
-                timeout=None,
-            )
+        """
+
+        <strong style="background-color:#ffc107; color:white; padding:4px; border-radius:4px">Unstable</strong>
+
+        Used to retrieve a deployment given its ID or name.
+
+        Parameters:
+            - id: str. Either the Deployment's ID or its unique name
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._environment.default}/", f"v1/deployments/{id}"),
+            headers=self._client_wrapper.get_headers(),
+            timeout=None,
+        )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(DeploymentRead, _response.json())  # type: ignore
         try:

vellum/resources/document_indexes/client.py

@@ -4,12 +4,11 @@ import typing
 import urllib.parse
 from json.decoder import JSONDecodeError
 
-import httpx
 import pydantic
 
 from ...core.api_error import ApiError
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ...core.jsonable_encoder import jsonable_encoder
-from ...core.remove_none_from_headers import remove_none_from_headers
 from ...environment import VellumEnvironment
 from ...types.document_index_read import DocumentIndexRead
 from ...types.document_index_status import DocumentIndexStatus
@@ -20,9 +19,11 @@ OMIT = typing.cast(typing.Any, ...)
 
 
 class DocumentIndexesClient:
-    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+    def __init__(
+        self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, client_wrapper: SyncClientWrapper
+    ):
         self._environment = environment
-        self.api_key = api_key
+        self._client_wrapper = client_wrapper
 
     def create(
         self,
@@ -34,6 +35,29 @@ class DocumentIndexesClient:
         indexing_config: typing.Dict[str, typing.Any],
         copy_documents_from_index_id: typing.Optional[str] = OMIT,
     ) -> DocumentIndexRead:
+        """
+        <strong style="background-color:#ffc107; color:white; padding:4px; border-radius:4px">Unstable</strong>
+
+        Creates a new document index.
+
+        Parameters:
+            - label: str. A human-readable label for the document index <span style="white-space: nowrap">`non-empty`</span> <span style="white-space: nowrap">`<= 150 characters`</span>
+
+            - name: str. A name that uniquely identifies this index within its workspace <span style="white-space: nowrap">`non-empty`</span> <span style="white-space: nowrap">`<= 150 characters`</span>
+
+            - status: typing.Optional[DocumentIndexStatus]. The current status of the document index
+
+                                                            * `ACTIVE` - Active
+                                                            * `ARCHIVED` - Archived
+            - environment: typing.Optional[EnvironmentEnum]. The environment this document index is used in
+
+                                                             * `DEVELOPMENT` - Development
+                                                             * `STAGING` - Staging
+                                                             * `PRODUCTION` - Production
+            - indexing_config: typing.Dict[str, typing.Any]. Configuration representing how documents should be indexed
+
+            - copy_documents_from_index_id: typing.Optional[str]. Optionally specify the id of a document index from which you'd like to copy and re-index its documents into this newly created index
+        """
         _request: typing.Dict[str, typing.Any] = {"label": label, "name": name, "indexing_config": indexing_config}
         if status is not OMIT:
             _request["status"] = status
@@ -41,11 +65,11 @@ class DocumentIndexesClient:
             _request["environment"] = environment
         if copy_documents_from_index_id is not OMIT:
             _request["copy_documents_from_index_id"] = copy_documents_from_index_id
-        _response = httpx.request(
+        _response = self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(f"{self._environment.default}/", "v1/document-indexes"),
             json=jsonable_encoder(_request),
-            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            headers=self._client_wrapper.get_headers(),
             timeout=None,
         )
         if 200 <= _response.status_code < 300:
@@ -58,9 +82,11 @@ class DocumentIndexesClient:
 
 
 class AsyncDocumentIndexesClient:
-    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+    def __init__(
+        self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, client_wrapper: AsyncClientWrapper
+    ):
         self._environment = environment
-        self.api_key = api_key
+        self._client_wrapper = client_wrapper
 
     async def create(
         self,
@@ -72,6 +98,29 @@ class AsyncDocumentIndexesClient:
         indexing_config: typing.Dict[str, typing.Any],
         copy_documents_from_index_id: typing.Optional[str] = OMIT,
     ) -> DocumentIndexRead:
+        """
+        <strong style="background-color:#ffc107; color:white; padding:4px; border-radius:4px">Unstable</strong>
+
+        Creates a new document index.
+
+        Parameters:
+            - label: str. A human-readable label for the document index <span style="white-space: nowrap">`non-empty`</span> <span style="white-space: nowrap">`<= 150 characters`</span>
+
+            - name: str. A name that uniquely identifies this index within its workspace <span style="white-space: nowrap">`non-empty`</span> <span style="white-space: nowrap">`<= 150 characters`</span>
+
+            - status: typing.Optional[DocumentIndexStatus]. The current status of the document index
+
+                                                            * `ACTIVE` - Active
+                                                            * `ARCHIVED` - Archived
+            - environment: typing.Optional[EnvironmentEnum]. The environment this document index is used in
+
+                                                             * `DEVELOPMENT` - Development
+                                                             * `STAGING` - Staging
+                                                             * `PRODUCTION` - Production
+            - indexing_config: typing.Dict[str, typing.Any]. Configuration representing how documents should be indexed
+
+            - copy_documents_from_index_id: typing.Optional[str]. Optionally specify the id of a document index from which you'd like to copy and re-index its documents into this newly created index
+        """
         _request: typing.Dict[str, typing.Any] = {"label": label, "name": name, "indexing_config": indexing_config}
         if status is not OMIT:
             _request["status"] = status
@@ -79,14 +128,13 @@ class AsyncDocumentIndexesClient:
             _request["environment"] = environment
         if copy_documents_from_index_id is not OMIT:
             _request["copy_documents_from_index_id"] = copy_documents_from_index_id
-        async with httpx.AsyncClient() as _client:
-            _response = await _client.request(
-                "POST",
-                urllib.parse.urljoin(f"{self._environment.default}/", "v1/document-indexes"),
-                json=jsonable_encoder(_request),
-                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
-                timeout=None,
-            )
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._environment.default}/", "v1/document-indexes"),
+            json=jsonable_encoder(_request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=None,
+        )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(DocumentIndexRead, _response.json())  # type: ignore
         try:

vellum/resources/documents/client.py

@@ -4,12 +4,12 @@ import typing
 import urllib.parse
 from json.decoder import JSONDecodeError
 
-import httpx
 import pydantic
 
 from ...core.api_error import ApiError
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ...core.jsonable_encoder import jsonable_encoder
-from ...core.remove_none_from_headers import remove_none_from_headers
+from ...core.remove_none_from_dict import remove_none_from_dict
 from ...environment import VellumEnvironment
 from ...errors.bad_request_error import BadRequestError
 from ...errors.internal_server_error import InternalServerError
@@ -17,11 +17,16 @@ from ...errors.not_found_error import NotFoundError
 from ...types.paginated_slim_document_list import PaginatedSlimDocumentList
 from ...types.upload_document_response import UploadDocumentResponse
 
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
 
 class DocumentsClient:
-    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+    def __init__(
+        self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, client_wrapper: SyncClientWrapper
+    ):
         self._environment = environment
-        self.api_key = api_key
+        self._client_wrapper = client_wrapper
 
     def list(
         self,
@@ -31,11 +36,28 @@ class DocumentsClient:
         offset: typing.Optional[int] = None,
         ordering: typing.Optional[str] = None,
     ) -> PaginatedSlimDocumentList:
-        _response = httpx.request(
+        """
+
+        <strong style="background-color:#4caf50; color:white; padding:4px; border-radius:4px">Stable</strong>
+
+        Used to list documents. Optionally filter on supported fields.
+
+        Parameters:
+            - document_index_id: typing.Optional[str]. Filter down to only those documents that are included in the specified index. You may provide either the Vellum-generated ID or the unique name of the index specified upon initial creation.
+
+            - limit: typing.Optional[int]. Number of results to return per page.
+
+            - offset: typing.Optional[int]. The initial index from which to return the results.
+
+            - ordering: typing.Optional[str]. Which field to use when ordering the results.
+        """
+        _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(f"{self._environment.default}/", "v1/documents"),
-            params={"document_index_id": document_index_id, "limit": limit, "offset": offset, "ordering": ordering},
-            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            params=remove_none_from_dict(
+                {"document_index_id": document_index_id, "limit": limit, "offset": offset, "ordering": ordering}
+            ),
+            headers=self._client_wrapper.get_headers(),
             timeout=None,
         )
         if 200 <= _response.status_code < 300:
@@ -55,7 +77,25 @@ class DocumentsClient:
         contents: typing.IO,
         keywords: typing.Optional[typing.List[str]] = None,
     ) -> UploadDocumentResponse:
-        _response = httpx.request(
+        """
+        <strong style="background-color:#4caf50; color:white; padding:4px; border-radius:4px">Stable</strong>
+
+        Upload a document to be indexed and used for search.
+
+        **Note:** Uses a base url of `https://documents.vellum.ai`.
+
+        Parameters:
+            - add_to_index_names: typing.Optional[typing.List[str]].
+
+            - external_id: typing.Optional[str].
+
+            - label: str.
+
+            - contents: typing.IO.
+
+            - keywords: typing.Optional[typing.List[str]].
+        """
+        _response = self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(f"{self._environment.documents}/", "v1/upload-document"),
             data=jsonable_encoder(
@@ -67,7 +107,7 @@ class DocumentsClient:
                 }
             ),
             files={"contents": contents},
-            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            headers=self._client_wrapper.get_headers(),
             timeout=None,
         )
         if 200 <= _response.status_code < 300:
@@ -86,9 +126,11 @@ class DocumentsClient:
 
 
 class AsyncDocumentsClient:
-    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+    def __init__(
+        self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, client_wrapper: AsyncClientWrapper
+    ):
         self._environment = environment
-        self.api_key = api_key
+        self._client_wrapper = client_wrapper
 
     async def list(
         self,
@@ -98,14 +140,30 @@ class AsyncDocumentsClient:
         offset: typing.Optional[int] = None,
         ordering: typing.Optional[str] = None,
     ) -> PaginatedSlimDocumentList:
-        async with httpx.AsyncClient() as _client:
-            _response = await _client.request(
-                "GET",
-                urllib.parse.urljoin(f"{self._environment.default}/", "v1/documents"),
-                params={"document_index_id": document_index_id, "limit": limit, "offset": offset, "ordering": ordering},
-                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
-                timeout=None,
-            )
+        """
+
+        <strong style="background-color:#4caf50; color:white; padding:4px; border-radius:4px">Stable</strong>
+
+        Used to list documents. Optionally filter on supported fields.
+
+        Parameters:
+            - document_index_id: typing.Optional[str]. Filter down to only those documents that are included in the specified index. You may provide either the Vellum-generated ID or the unique name of the index specified upon initial creation.
+
+            - limit: typing.Optional[int]. Number of results to return per page.
+
+            - offset: typing.Optional[int]. The initial index from which to return the results.
+
+            - ordering: typing.Optional[str]. Which field to use when ordering the results.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._environment.default}/", "v1/documents"),
+            params=remove_none_from_dict(
+                {"document_index_id": document_index_id, "limit": limit, "offset": offset, "ordering": ordering}
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=None,
+        )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(PaginatedSlimDocumentList, _response.json())  # type: ignore
         try:
@@ -123,22 +181,39 @@ class AsyncDocumentsClient:
         contents: typing.IO,
         keywords: typing.Optional[typing.List[str]] = None,
     ) -> UploadDocumentResponse:
-        async with httpx.AsyncClient() as _client:
-            _response = await _client.request(
-                "POST",
-                urllib.parse.urljoin(f"{self._environment.documents}/", "v1/upload-document"),
-                data=jsonable_encoder(
-                    {
-                        "add_to_index_names": add_to_index_names,
-                        "external_id": external_id,
-                        "label": label,
-                        "keywords": keywords,
-                    }
-                ),
-                files={"contents": contents},
-                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
-                timeout=None,
-            )
+        """
+        <strong style="background-color:#4caf50; color:white; padding:4px; border-radius:4px">Stable</strong>
+
+        Upload a document to be indexed and used for search.
+
+        **Note:** Uses a base url of `https://documents.vellum.ai`.
+
+        Parameters:
+            - add_to_index_names: typing.Optional[typing.List[str]].
+
+            - external_id: typing.Optional[str].
+
+            - label: str.
+
+            - contents: typing.IO.
+
+            - keywords: typing.Optional[typing.List[str]].
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._environment.documents}/", "v1/upload-document"),
+            data=jsonable_encoder(
+                {
+                    "add_to_index_names": add_to_index_names,
+                    "external_id": external_id,
+                    "label": label,
+                    "keywords": keywords,
+                }
+            ),
+            files={"contents": contents},
+            headers=self._client_wrapper.get_headers(),
+            timeout=None,
+        )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(UploadDocumentResponse, _response.json())  # type: ignore
         if _response.status_code == 400:

vellum/resources/model_versions/client.py

@@ -4,27 +4,40 @@ import typing
 import urllib.parse
 from json.decoder import JSONDecodeError
 
-import httpx
 import pydantic
 
 from ...core.api_error import ApiError
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ...core.jsonable_encoder import jsonable_encoder
-from ...core.remove_none_from_headers import remove_none_from_headers
 from ...environment import VellumEnvironment
 from ...types.model_version_compile_prompt_response import ModelVersionCompilePromptResponse
 from ...types.model_version_read import ModelVersionRead
 
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
 
 class ModelVersionsClient:
-    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+    def __init__(
+        self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, client_wrapper: SyncClientWrapper
+    ):
         self._environment = environment
-        self.api_key = api_key
+        self._client_wrapper = client_wrapper
 
     def retrieve(self, id: str) -> ModelVersionRead:
-        _response = httpx.request(
+        """
+
+        <strong style="background-color:#ffc107; color:white; padding:4px; border-radius:4px">Unstable</strong>
+
+        Used to retrieve a model version given its ID.
+
+        Parameters:
+            - id: str. A UUID string identifying this model version.
+        """
+        _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(f"{self._environment.default}/", f"v1/model-versions/{id}"),
-            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            headers=self._client_wrapper.get_headers(),
             timeout=None,
         )
         if 200 <= _response.status_code < 300:
@@ -38,11 +51,21 @@ class ModelVersionsClient:
     def model_version_compile_prompt(
         self, id: str, *, input_values: typing.Dict[str, typing.Any]
     ) -> ModelVersionCompilePromptResponse:
-        _response = httpx.request(
+        """
+        <strong style="background-color:#ffc107; color:white; padding:4px; border-radius:4px">Unstable</strong>
+
+        Compiles the prompt backing the model version using the provided input values.
+
+        Parameters:
+            - id: str. A UUID string identifying this model version.
+
+            - input_values: typing.Dict[str, typing.Any]. Key/value pairs for each variable found within the model version's prompt template.
+        """
+        _response = self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(f"{self._environment.default}/", f"v1/model-versions/{id}/compile-prompt"),
             json=jsonable_encoder({"input_values": input_values}),
-            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            headers=self._client_wrapper.get_headers(),
             timeout=None,
         )
         if 200 <= _response.status_code < 300:
@@ -55,18 +78,28 @@ class ModelVersionsClient:
 
 
 class AsyncModelVersionsClient:
-    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+    def __init__(
+        self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, client_wrapper: AsyncClientWrapper
+    ):
         self._environment = environment
-        self.api_key = api_key
+        self._client_wrapper = client_wrapper
 
     async def retrieve(self, id: str) -> ModelVersionRead:
-        async with httpx.AsyncClient() as _client:
-            _response = await _client.request(
-                "GET",
-                urllib.parse.urljoin(f"{self._environment.default}/", f"v1/model-versions/{id}"),
-                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
-                timeout=None,
-            )
+        """
+
+        <strong style="background-color:#ffc107; color:white; padding:4px; border-radius:4px">Unstable</strong>
+
+        Used to retrieve a model version given its ID.
+
+        Parameters:
+            - id: str. A UUID string identifying this model version.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(f"{self._environment.default}/", f"v1/model-versions/{id}"),
+            headers=self._client_wrapper.get_headers(),
+            timeout=None,
+        )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(ModelVersionRead, _response.json())  # type: ignore
         try:
@@ -78,14 +111,23 @@ class AsyncModelVersionsClient:
     async def model_version_compile_prompt(
         self, id: str, *, input_values: typing.Dict[str, typing.Any]
     ) -> ModelVersionCompilePromptResponse:
-        async with httpx.AsyncClient() as _client:
-            _response = await _client.request(
-                "POST",
-                urllib.parse.urljoin(f"{self._environment.default}/", f"v1/model-versions/{id}/compile-prompt"),
-                json=jsonable_encoder({"input_values": input_values}),
-                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
-                timeout=None,
-            )
+        """
+        <strong style="background-color:#ffc107; color:white; padding:4px; border-radius:4px">Unstable</strong>
+
+        Compiles the prompt backing the model version using the provided input values.
+
+        Parameters:
+            - id: str. A UUID string identifying this model version.
+
+            - input_values: typing.Dict[str, typing.Any]. Key/value pairs for each variable found within the model version's prompt template.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._environment.default}/", f"v1/model-versions/{id}/compile-prompt"),
+            json=jsonable_encoder({"input_values": input_values}),
+            headers=self._client_wrapper.get_headers(),
+            timeout=None,
+        )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(ModelVersionCompilePromptResponse, _response.json())  # type: ignore
         try: