vellum-ai 0.3.23__py3-none-any.whl → 0.5.1__py3-none-any.whl

vellum/core/__init__.py

@@ -6,6 +6,7 @@ from .datetime_utils import serialize_datetime
 from .file import File, convert_file_dict_to_httpx_tuples
 from .http_client import AsyncHttpClient, HttpClient
 from .jsonable_encoder import jsonable_encoder
+from .pydantic_utilities import pydantic_v1
 from .remove_none_from_dict import remove_none_from_dict
 from .request_options import RequestOptions
 
@@ -20,6 +21,7 @@ __all__ = [
     "SyncClientWrapper",
     "convert_file_dict_to_httpx_tuples",
     "jsonable_encoder",
+    "pydantic_v1",
     "remove_none_from_dict",
     "serialize_datetime",
 ]

vellum/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.3.23",
+            "X-Fern-SDK-Version": "0.5.1",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/core/jsonable_encoder.py

@@ -16,12 +16,8 @@ from pathlib import PurePath
 from types import GeneratorType
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
-
 from .datetime_utils import serialize_datetime
+from .pydantic_utilities import pydantic_v1
 
 SetIntStr = Set[Union[int, str]]
 DictIntStrAny = Dict[Union[int, str], Any]
@@ -36,7 +32,7 @@ def generate_encoders_by_class_tuples(
     return encoders_by_class_tuples
 
 
-encoders_by_class_tuples = generate_encoders_by_class_tuples(pydantic.json.ENCODERS_BY_TYPE)
+encoders_by_class_tuples = generate_encoders_by_class_tuples(pydantic_v1.json.ENCODERS_BY_TYPE)
 
 
 def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None) -> Any:
@@ -48,7 +44,7 @@ def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any]
             for encoder_type, encoder_instance in custom_encoder.items():
                 if isinstance(obj, encoder_type):
                     return encoder_instance(obj)
-    if isinstance(obj, pydantic.BaseModel):
+    if isinstance(obj, pydantic_v1.BaseModel):
         encoder = getattr(obj.__config__, "json_encoders", {})
         if custom_encoder:
             encoder.update(custom_encoder)
@@ -84,8 +80,8 @@ def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any]
             encoded_list.append(jsonable_encoder(item, custom_encoder=custom_encoder))
         return encoded_list
 
-    if type(obj) in pydantic.json.ENCODERS_BY_TYPE:
-        return pydantic.json.ENCODERS_BY_TYPE[type(obj)](obj)
+    if type(obj) in pydantic_v1.json.ENCODERS_BY_TYPE:
+        return pydantic_v1.json.ENCODERS_BY_TYPE[type(obj)](obj)
     for encoder, classes_tuple in encoders_by_class_tuples.items():
         if isinstance(obj, classes_tuple):
             return encoder(obj)

vellum/core/pydantic_utilities.py

@@ -0,0 +1,12 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import pydantic
+
+IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+
+if IS_PYDANTIC_V2:
+    import pydantic.v1 as pydantic_v1  # type: ignore  # nopycln: import
+else:
+    import pydantic as pydantic_v1  # type: ignore  # nopycln: import
+
+__all__ = ["pydantic_v1"]

vellum/errors/__init__.py

@@ -1,9 +1,8 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from .bad_request_error import BadRequestError
-from .conflict_error import ConflictError
 from .forbidden_error import ForbiddenError
 from .internal_server_error import InternalServerError
 from .not_found_error import NotFoundError
 
-__all__ = ["BadRequestError", "ConflictError", "ForbiddenError", "InternalServerError", "NotFoundError"]
+__all__ = ["BadRequestError", "ForbiddenError", "InternalServerError", "NotFoundError"]

vellum/lib/__init__.py

@@ -0,0 +1,5 @@
+from .test_suites import VellumTestSuite
+
+__all__ = [
+    "VellumTestSuite",
+]

vellum/lib/test_suites/__init__.py

@@ -0,0 +1,5 @@
+from .resources import VellumTestSuite
+
+__all__ = [
+    "VellumTestSuite",
+]

vellum/lib/test_suites/constants.py

@@ -0,0 +1,2 @@
+DEFAULT_POLLING_INTERVAL_MS = 500  # Half a second
+DEFAULT_MAX_POLLING_DURATION_MS = 30 * 60 * 1000  # Half an hour

vellum/lib/test_suites/exceptions.py

@@ -0,0 +1,2 @@
+class TestSuiteRunResultsException(Exception):
+    pass

vellum/lib/test_suites/resources.py

@@ -0,0 +1,331 @@
+from __future__ import annotations
+
+import logging
+import time
+from functools import cached_property
+from typing import Callable, Generator, List, Any
+
+from vellum import TestSuiteRunRead, TestSuiteRunMetricOutput_Number
+from vellum.client import Vellum
+from vellum.lib.test_suites.constants import (
+    DEFAULT_MAX_POLLING_DURATION_MS,
+    DEFAULT_POLLING_INTERVAL_MS,
+)
+from vellum.lib.test_suites.exceptions import TestSuiteRunResultsException
+from vellum.lib.utils.env import get_api_key
+from vellum.lib.utils.paginator import PaginatedResults, get_all_results
+from vellum.types import (
+    ExternalTestCaseExecutionRequest,
+    NamedTestCaseVariableValueRequest,
+    TestCaseVariableValue,
+    TestSuiteRunExecConfigRequest_External,
+    TestSuiteRunExecution,
+    TestSuiteRunExternalExecConfigDataRequest,
+    TestSuiteRunMetricOutput,
+    TestSuiteRunState,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class VellumTestSuiteRunExecution(TestSuiteRunExecution):
+    @classmethod
+    def from_api(cls, execution: TestSuiteRunExecution) -> VellumTestSuiteRunExecution:
+        return cls(
+            id=execution.id,
+            test_case_id=execution.test_case_id,
+            outputs=execution.outputs,
+            metric_results=execution.metric_results,
+        )
+
+    def get_metric_output(
+        self,
+        metric_identifier: str | None = None,
+        output_identifier: str | None = None,
+    ) -> TestSuiteRunMetricOutput:
+        """Retrieve a metric's output by specifying the info needed to uniquely identify that metric and output.
+
+        metric_identifier: Anything that uniquely identifies the metric to retrieve (e.g. it's label, name or id)
+        output_identifier: Anything that uniquely identifies the output to retrieve (e.g. it's name)
+        """
+
+        metric_outputs = self.get_metric_outputs(metric_identifier)
+
+        filtered_metric_outputs = [
+            metric_output
+            for metric_output in metric_outputs
+            if output_identifier is None or metric_output.name == output_identifier
+        ]
+
+        if len(filtered_metric_outputs) == 0:
+            raise TestSuiteRunResultsException(
+                f"No metric outputs found with identifier: {output_identifier}"
+            )
+
+        if len(filtered_metric_outputs) > 1:
+            raise TestSuiteRunResultsException(
+                f"Multiple metric outputs found with identifier: {output_identifier}"
+            )
+
+        return filtered_metric_outputs[0]
+
+    def get_metric_outputs(
+        self,
+        metric_identifier: str | None = None,
+    ) -> List[TestSuiteRunMetricOutput]:
+        """Return a metric's output across all executions by providing the info needed to uniquely identify it.
+
+        metric_identifier: Anything that uniquely identifies the metric to retrieve (e.g. it's label, name or id).
+        """
+
+        filtered_metric_results = [
+            metric_output
+            for metric_output in self.metric_results
+            if metric_identifier is None
+            or (metric_output.metric_id == metric_identifier)
+            or (metric_output.metric_label == metric_identifier)
+            or (
+                metric_output.metric_definition
+                and metric_output.metric_definition.id == metric_identifier
+            )
+            or (
+                metric_output.metric_definition
+                and metric_output.metric_definition.name == metric_identifier
+            )
+            or (
+                metric_output.metric_definition
+                and metric_output.metric_definition.label == metric_identifier
+            )
+        ]
+
+        if len(filtered_metric_results) == 0:
+            raise TestSuiteRunResultsException(
+                f"No metric results found with identifier: {metric_identifier}"
+            )
+
+        if len(filtered_metric_results) > 1:
+            raise TestSuiteRunResultsException(
+                f"Multiple metric results found with identifier: {metric_identifier}"
+            )
+
+        return filtered_metric_results[0].outputs
+
+
+class VellumTestSuiteRunResults:
+    """A utility class with methods for conveniently operating on a Test Suite Run and its results."""
+
+    def __init__(
+        self,
+        test_suite_run: TestSuiteRunRead,
+        *,
+        client: Vellum | None = None,
+        polling_interval: int = DEFAULT_POLLING_INTERVAL_MS,
+        max_polling_duration: int = DEFAULT_MAX_POLLING_DURATION_MS,
+    ) -> None:
+        self._test_suite_run = test_suite_run
+        self._client = client or Vellum(
+            api_key=get_api_key(),
+        )
+        self._executions: Generator[VellumTestSuiteRunExecution, None, None] | None = (
+            None
+        )
+        self._polling_interval = polling_interval
+        self._max_polling_duration = max_polling_duration
+
+    @property
+    def state(self) -> TestSuiteRunState:
+        return self._test_suite_run.state
+
+    @cached_property
+    def all_executions(self) -> list[VellumTestSuiteRunExecution]:
+        return list(self._get_test_suite_run_executions())
+
+    def get_metric_outputs(
+        self, metric_identifier: str | None = None, output_identifier: str | None = None
+    ) -> List[TestSuiteRunMetricOutput]:
+        """Retrieve a metric's output across all executions by providing the info needed to uniquely identify it."""
+
+        return [
+            execution.get_metric_output(
+                metric_identifier=metric_identifier, output_identifier=output_identifier
+            )
+            for execution in self.all_executions
+        ]
+
+    def get_count_metric_outputs(
+        self,
+        metric_identifier: str | None = None,
+        output_identifier: str | None = None,
+        *,
+        predicate: Callable[[TestSuiteRunMetricOutput], bool] | None = None,
+    ) -> int:
+        """Returns the count of all metric outputs that match the given criteria."""
+
+        metric_outputs = self.get_metric_outputs(
+            metric_identifier=metric_identifier, output_identifier=output_identifier
+        )
+
+        if predicate is None:
+            return len(metric_outputs)
+
+        return len([output for output in metric_outputs if predicate(output)])
+
+    def get_numeric_metric_output_values(
+        self,
+        metric_identifier: str | None = None,
+        output_identifier: str | None = None,
+    ) -> List[float]:
+        """Returns the values of a numeric metric output that match the given criteria."""
+
+        metric_outputs: list[TestSuiteRunMetricOutput_Number] = []
+
+        for output in self.get_metric_outputs(
+            metric_identifier=metric_identifier, output_identifier=output_identifier
+        ):
+            if output.type != "NUMBER":
+                raise TestSuiteRunResultsException(
+                    f"Expected a numeric metric output, but got a {output.type} output instead."
+                )
+
+            metric_outputs.append(output)
+
+        return [output.value for output in metric_outputs]
+
+    def get_mean_metric_output(
+        self, metric_identifier: str | None = None, output_identifier: str | None = None
+    ) -> float:
+        """Returns the mean of all metric outputs that match the given criteria."""
+        output_values = self.get_numeric_metric_output_values(
+            metric_identifier=metric_identifier, output_identifier=output_identifier
+        )
+        return sum(output_values) / len(output_values)
+
+    def get_min_metric_output(
+        self, metric_identifier: str | None = None, output_identifier: str | None = None
+    ) -> float:
+        """Returns the min value across= all metric outputs that match the given criteria."""
+        output_values = self.get_numeric_metric_output_values(
+            metric_identifier=metric_identifier, output_identifier=output_identifier
+        )
+        return min(output_values)
+
+    def get_max_metric_output(
+        self, metric_identifier: str | None = None, output_identifier: str | None = None
+    ) -> float:
+        """Returns the max value across all metric outputs that match the given criteria."""
+        output_values = self.get_numeric_metric_output_values(
+            metric_identifier=metric_identifier, output_identifier=output_identifier
+        )
+        return max(output_values)
+
+    def wait_until_complete(self) -> None:
+        """Wait until the Test Suite Run is no longer in a QUEUED or RUNNING state."""
+
+        start_time = time.time_ns()
+        while True:
+            logger.debug("Polling for latest test suite run state...")
+            self._refresh_test_suite_run()
+            if self.state not in {"QUEUED", "RUNNING"}:
+                break
+
+            current_time = time.time_ns()
+            if ((current_time - start_time) / 1e6) > self._max_polling_duration:
+                raise TestSuiteRunResultsException(
+                    "Test suite run timed out polling for executions"
+                )
+
+            time.sleep(self._polling_interval / 1000.0)
+
+        if self.state == "FAILED":
+            raise TestSuiteRunResultsException("Test suite run failed")
+
+        if self.state == "CANCELLED":
+            raise TestSuiteRunResultsException("Test suite run was cancelled")
+
+    def _refresh_test_suite_run(self):
+        test_suite_run = self._client.test_suite_runs.retrieve(self._test_suite_run.id)
+        self._test_suite_run = test_suite_run
+
+    def _list_paginated_executions(
+        self, offset: int | None, limit: int | None
+    ) -> PaginatedResults[TestSuiteRunExecution]:
+        response = self._client.test_suite_runs.list_executions(
+            self._test_suite_run.id,
+            offset=offset,
+            limit=limit,
+            expand=[
+                "results.metric_results.metric_definition",
+                "results.metric_results.metric_label",
+            ],
+        )
+        return PaginatedResults(results=response.results, count=response.count)
+
+    def _wrap_api_executions(
+        self, executions: Generator[TestSuiteRunExecution, None, None]
+    ) -> Generator[VellumTestSuiteRunExecution, None, None]:
+        for execution in executions:
+            yield VellumTestSuiteRunExecution.from_api(execution)
+
+    def _get_test_suite_run_executions(
+        self,
+    ) -> Generator[VellumTestSuiteRunExecution, None, None]:
+        if self._executions is not None:
+            return self._executions
+
+        self.wait_until_complete()
+
+        raw_api_executions = get_all_results(self._list_paginated_executions)
+        self._executions = self._wrap_api_executions(raw_api_executions)
+        return self._executions
+
+
+class VellumTestSuite:
+    """A utility class that provides methods for running a Vellum Test Suite and interacting with its results."""
+
+    def __init__(
+        self,
+        test_suite_id: str,
+        *,
+        client: Vellum | None = None,
+    ) -> None:
+        self.client = client or Vellum(
+            api_key=get_api_key(),
+        )
+        self._test_suite_id = test_suite_id
+
+    def run_external(
+        self,
+        executable: Callable[
+            [List[TestCaseVariableValue]], List[NamedTestCaseVariableValueRequest]
+        ],
+    ) -> VellumTestSuiteRunResults:
+        """
+        Runs this Vellum Test Suite on any executable function defined external to Vellum.
+
+        Returns a wrapper that polls the generated Test Suite Run until it's done running and returns its results.
+        """
+        test_cases = self.client.test_suites.list_test_suite_test_cases(
+            id=self._test_suite_id
+        )
+        executions: List[ExternalTestCaseExecutionRequest] = []
+
+        for test_case in test_cases.results:
+            outputs = executable(test_case.input_values)
+
+            executions.append(
+                ExternalTestCaseExecutionRequest(
+                    test_case_id=test_case.id,  # type: ignore[arg-type]
+                    outputs=outputs,
+                )
+            )
+
+        test_suite_run = self.client.test_suite_runs.create(
+            test_suite_id=self._test_suite_id,
+            exec_config=TestSuiteRunExecConfigRequest_External(
+                type="EXTERNAL",
+                data=TestSuiteRunExternalExecConfigDataRequest(
+                    executions=executions,
+                ),
+            ),
+        )
+        return VellumTestSuiteRunResults(test_suite_run, client=self.client)

vellum/lib/utils/env.py

@@ -0,0 +1,13 @@
+import os
+
+from .exceptions import VellumClientException
+
+
+def get_api_key() -> str:
+    api_key = os.environ.get("VELLUM_API_KEY")
+    if api_key is None:
+        raise VellumClientException(
+            "`VELLUM_API_KEY` environment variable is required to be set."
+        )
+
+    return api_key

vellum/lib/utils/exceptions.py

@@ -0,0 +1,2 @@
+class VellumClientException(Exception):
+    pass

vellum/lib/utils/paginator.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+from typing import Callable, Generator, Generic, List, TypeVar, Union
+
+
+Result = TypeVar("Result")
+
+
+@dataclass
+class PaginatedResults(Generic[Result]):
+    count: int
+    results: List[Result]
+
+
+def get_all_results(
+    paginated_api: Callable[[int, Union[int, None]], PaginatedResults[Result]],
+    page_size: Union[int, None] = None,
+) -> Generator[Result, None, None]:
+    offset = 0
+    count = 0
+    while True:
+        paginated_results = paginated_api(offset, page_size)
+        for result in paginated_results.results:
+            yield result
+            count += 1
+
+        if paginated_results.count <= count:
+            break
+
+        offset = count

vellum/resources/__init__.py

@@ -5,8 +5,6 @@ from . import (
     document_indexes,
     documents,
     folder_entities,
-    model_versions,
-    registered_prompts,
     sandboxes,
     test_suite_runs,
     test_suites,
@@ -24,8 +22,6 @@ __all__ = [
     "document_indexes",
     "documents",
     "folder_entities",
-    "model_versions",
-    "registered_prompts",
     "sandboxes",
     "test_suite_runs",
     "test_suites",

vellum/resources/deployments/client.py

@@ -7,6 +7,7 @@ from json.decoder import JSONDecodeError
 from ...core.api_error import ApiError
 from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ...core.jsonable_encoder import jsonable_encoder
+from ...core.pydantic_utilities import pydantic_v1
 from ...core.remove_none_from_dict import remove_none_from_dict
 from ...core.request_options import RequestOptions
 from ...errors.bad_request_error import BadRequestError
@@ -19,11 +20,6 @@ from ...types.paginated_slim_deployment_read_list import PaginatedSlimDeployment
 from ...types.prompt_deployment_input_request import PromptDeploymentInputRequest
 from .types.deployments_list_request_status import DeploymentsListRequestStatus
 
-try:
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
-
 # this is used as the default value for optional parameters
 OMIT = typing.cast(typing.Any, ...)
 
@@ -61,8 +57,8 @@ class DeploymentsClient:
         client.deployments.list()
         """
         _response = self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_environment().default}/", "v1/deployments"),
+            method="GET",
+            url=urllib.parse.urljoin(f"{self._client_wrapper.get_environment().default}/", "v1/deployments"),
             params=jsonable_encoder(
                 remove_none_from_dict(
                     {
@@ -93,7 +89,7 @@ class DeploymentsClient:
             max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(PaginatedSlimDeploymentReadList, _response.json())  # type: ignore
+            return pydantic_v1.parse_obj_as(PaginatedSlimDeploymentReadList, _response.json())  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError:
@@ -119,8 +115,8 @@ class DeploymentsClient:
         )
         """
         _response = self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(
+            method="GET",
+            url=urllib.parse.urljoin(
                 f"{self._client_wrapper.get_environment().default}/", f"v1/deployments/{jsonable_encoder(id)}"
             ),
             params=jsonable_encoder(
@@ -141,7 +137,7 @@ class DeploymentsClient:
             max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(DeploymentRead, _response.json())  # type: ignore
+            return pydantic_v1.parse_obj_as(DeploymentRead, _response.json())  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError:
@@ -186,8 +182,8 @@ class DeploymentsClient:
         if release_tag is not OMIT:
             _request["release_tag"] = release_tag
         _response = self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(
+            method="POST",
+            url=urllib.parse.urljoin(
                 f"{self._client_wrapper.get_environment().default}/", "v1/deployments/provider-payload"
             ),
             params=jsonable_encoder(
@@ -214,15 +210,15 @@ class DeploymentsClient:
             max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(DeploymentProviderPayloadResponse, _response.json())  # type: ignore
+            return pydantic_v1.parse_obj_as(DeploymentProviderPayloadResponse, _response.json())  # type: ignore
         if _response.status_code == 400:
-            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+            raise BadRequestError(pydantic_v1.parse_obj_as(typing.Any, _response.json()))  # type: ignore
         if _response.status_code == 403:
-            raise ForbiddenError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+            raise ForbiddenError(pydantic_v1.parse_obj_as(typing.Any, _response.json()))  # type: ignore
         if _response.status_code == 404:
-            raise NotFoundError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+            raise NotFoundError(pydantic_v1.parse_obj_as(typing.Any, _response.json()))  # type: ignore
         if _response.status_code == 500:
-            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+            raise InternalServerError(pydantic_v1.parse_obj_as(typing.Any, _response.json()))  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError:
@@ -263,8 +259,8 @@ class AsyncDeploymentsClient:
         await client.deployments.list()
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(f"{self._client_wrapper.get_environment().default}/", "v1/deployments"),
+            method="GET",
+            url=urllib.parse.urljoin(f"{self._client_wrapper.get_environment().default}/", "v1/deployments"),
             params=jsonable_encoder(
                 remove_none_from_dict(
                     {
@@ -295,7 +291,7 @@ class AsyncDeploymentsClient:
             max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(PaginatedSlimDeploymentReadList, _response.json())  # type: ignore
+            return pydantic_v1.parse_obj_as(PaginatedSlimDeploymentReadList, _response.json())  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError:
@@ -321,8 +317,8 @@ class AsyncDeploymentsClient:
         )
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(
+            method="GET",
+            url=urllib.parse.urljoin(
                 f"{self._client_wrapper.get_environment().default}/", f"v1/deployments/{jsonable_encoder(id)}"
             ),
             params=jsonable_encoder(
@@ -343,7 +339,7 @@ class AsyncDeploymentsClient:
             max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(DeploymentRead, _response.json())  # type: ignore
+            return pydantic_v1.parse_obj_as(DeploymentRead, _response.json())  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError:
@@ -388,8 +384,8 @@ class AsyncDeploymentsClient:
         if release_tag is not OMIT:
             _request["release_tag"] = release_tag
         _response = await self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(
+            method="POST",
+            url=urllib.parse.urljoin(
                 f"{self._client_wrapper.get_environment().default}/", "v1/deployments/provider-payload"
             ),
             params=jsonable_encoder(
@@ -416,15 +412,15 @@ class AsyncDeploymentsClient:
             max_retries=request_options.get("max_retries") if request_options is not None else 0,  # type: ignore
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(DeploymentProviderPayloadResponse, _response.json())  # type: ignore
+            return pydantic_v1.parse_obj_as(DeploymentProviderPayloadResponse, _response.json())  # type: ignore
         if _response.status_code == 400:
-            raise BadRequestError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+            raise BadRequestError(pydantic_v1.parse_obj_as(typing.Any, _response.json()))  # type: ignore
         if _response.status_code == 403:
-            raise ForbiddenError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+            raise ForbiddenError(pydantic_v1.parse_obj_as(typing.Any, _response.json()))  # type: ignore
         if _response.status_code == 404:
-            raise NotFoundError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+            raise NotFoundError(pydantic_v1.parse_obj_as(typing.Any, _response.json()))  # type: ignore
         if _response.status_code == 500:
-            raise InternalServerError(pydantic.parse_obj_as(typing.Any, _response.json()))  # type: ignore
+            raise InternalServerError(pydantic_v1.parse_obj_as(typing.Any, _response.json()))  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError: