vellum-ai 0.0.1__py3-none-any.whl

vellum/__init__.py

@@ -0,0 +1,98 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .environment import VellumEnvironment
+from .resources import documents, model_versions
+from .types import (
+    BlockTypeEnum,
+    ChatRoleEnum,
+    Document,
+    DocumentDocumentToDocumentIndex,
+    EnrichedNormalizedCompletion,
+    FinishReasonEnum,
+    GenerateErrorResponse,
+    GenerateOptionsRequest,
+    GenerateRequestRequest,
+    GenerateResponse,
+    GenerateResult,
+    GenerateResultData,
+    GenerateResultError,
+    IndexingStateEnum,
+    LogprobsEnum,
+    ModelTypeEnum,
+    ModelVersionBuildConfig,
+    ModelVersionExecConfigParameters,
+    ModelVersionExecConfigRead,
+    ModelVersionRead,
+    ModelVersionReadStatusEnum,
+    ModelVersionSandboxSnapshot,
+    NormalizedLogProbs,
+    NormalizedTokenLogProbs,
+    PaginatedSlimDocumentList,
+    ProcessingStateEnum,
+    PromptTemplateBlock,
+    PromptTemplateBlockData,
+    PromptTemplateBlockProperties,
+    ProviderEnum,
+    SearchErrorResponse,
+    SearchFiltersRequest,
+    SearchRequestOptionsRequest,
+    SearchResponse,
+    SearchResult,
+    SearchResultMergingRequest,
+    SearchWeightsRequest,
+    SlimDocument,
+    SlimDocumentStatusEnum,
+    SubmitCompletionActualRequest,
+    SubmitCompletionActualsErrorResponse,
+    UploadDocumentErrorResponse,
+    UploadDocumentResponse,
+)
+
+__all__ = [
+    "BlockTypeEnum",
+    "ChatRoleEnum",
+    "Document",
+    "DocumentDocumentToDocumentIndex",
+    "EnrichedNormalizedCompletion",
+    "FinishReasonEnum",
+    "GenerateErrorResponse",
+    "GenerateOptionsRequest",
+    "GenerateRequestRequest",
+    "GenerateResponse",
+    "GenerateResult",
+    "GenerateResultData",
+    "GenerateResultError",
+    "IndexingStateEnum",
+    "LogprobsEnum",
+    "ModelTypeEnum",
+    "ModelVersionBuildConfig",
+    "ModelVersionExecConfigParameters",
+    "ModelVersionExecConfigRead",
+    "ModelVersionRead",
+    "ModelVersionReadStatusEnum",
+    "ModelVersionSandboxSnapshot",
+    "NormalizedLogProbs",
+    "NormalizedTokenLogProbs",
+    "PaginatedSlimDocumentList",
+    "ProcessingStateEnum",
+    "PromptTemplateBlock",
+    "PromptTemplateBlockData",
+    "PromptTemplateBlockProperties",
+    "ProviderEnum",
+    "SearchErrorResponse",
+    "SearchFiltersRequest",
+    "SearchRequestOptionsRequest",
+    "SearchResponse",
+    "SearchResult",
+    "SearchResultMergingRequest",
+    "SearchWeightsRequest",
+    "SlimDocument",
+    "SlimDocumentStatusEnum",
+    "SubmitCompletionActualRequest",
+    "SubmitCompletionActualsErrorResponse",
+    "UploadDocumentErrorResponse",
+    "UploadDocumentResponse",
+    "VellumEnvironment",
+    "documents",
+    "model_versions",
+]

vellum/client.py

@@ -0,0 +1,203 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+import urllib.parse
+from json.decoder import JSONDecodeError
+
+import httpx
+import pydantic
+from backports.cached_property import cached_property
+
+from .core.api_error import ApiError
+from .core.jsonable_encoder import jsonable_encoder
+from .core.remove_none_from_headers import remove_none_from_headers
+from .environment import VellumEnvironment
+from .resources.documents.client import AsyncDocumentsClient, DocumentsClient
+from .resources.model_versions.client import AsyncModelVersionsClient, ModelVersionsClient
+from .types.generate_options_request import GenerateOptionsRequest
+from .types.generate_request_request import GenerateRequestRequest
+from .types.generate_response import GenerateResponse
+from .types.search_request_options_request import SearchRequestOptionsRequest
+from .types.search_response import SearchResponse
+from .types.submit_completion_actual_request import SubmitCompletionActualRequest
+
+
+class Vellum:
+    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+        self._environment = environment
+        self.api_key = api_key
+
+    def generate(
+        self,
+        *,
+        deployment_id: typing.Optional[str] = None,
+        deployment_name: typing.Optional[str] = None,
+        requests: typing.List[GenerateRequestRequest],
+        options: typing.Optional[GenerateOptionsRequest] = None,
+    ) -> GenerateResponse:
+        _response = httpx.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._environment.predict}/", "v1/generate"),
+            json=jsonable_encoder(
+                {
+                    "deployment_id": deployment_id,
+                    "deployment_name": deployment_name,
+                    "requests": requests,
+                    "options": options,
+                }
+            ),
+            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(GenerateResponse, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def search(
+        self,
+        *,
+        index_id: typing.Optional[str] = None,
+        index_name: typing.Optional[str] = None,
+        query: str,
+        options: typing.Optional[SearchRequestOptionsRequest] = None,
+    ) -> SearchResponse:
+        _response = httpx.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._environment.predict}/", "v1/search"),
+            json=jsonable_encoder({"index_id": index_id, "index_name": index_name, "query": query, "options": options}),
+            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(SearchResponse, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def submit_completion_actuals(
+        self,
+        *,
+        deployment_id: typing.Optional[str] = None,
+        deployment_name: typing.Optional[str] = None,
+        actuals: typing.List[SubmitCompletionActualRequest],
+    ) -> None:
+        _response = httpx.request(
+            "POST",
+            urllib.parse.urljoin(f"{self._environment.predict}/", "v1/submit-completion-actuals"),
+            json=jsonable_encoder(
+                {"deployment_id": deployment_id, "deployment_name": deployment_name, "actuals": actuals}
+            ),
+            headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+        )
+        if 200 <= _response.status_code < 300:
+            return
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    @cached_property
+    def documents(self) -> DocumentsClient:
+        return DocumentsClient(environment=self._environment, api_key=self.api_key)
+
+    @cached_property
+    def model_versions(self) -> ModelVersionsClient:
+        return ModelVersionsClient(environment=self._environment, api_key=self.api_key)
+
+
+class AsyncVellum:
+    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+        self._environment = environment
+        self.api_key = api_key
+
+    async def generate(
+        self,
+        *,
+        deployment_id: typing.Optional[str] = None,
+        deployment_name: typing.Optional[str] = None,
+        requests: typing.List[GenerateRequestRequest],
+        options: typing.Optional[GenerateOptionsRequest] = None,
+    ) -> GenerateResponse:
+        async with httpx.AsyncClient() as _client:
+            _response = await _client.request(
+                "POST",
+                urllib.parse.urljoin(f"{self._environment.predict}/", "v1/generate"),
+                json=jsonable_encoder(
+                    {
+                        "deployment_id": deployment_id,
+                        "deployment_name": deployment_name,
+                        "requests": requests,
+                        "options": options,
+                    }
+                ),
+                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(GenerateResponse, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def search(
+        self,
+        *,
+        index_id: typing.Optional[str] = None,
+        index_name: typing.Optional[str] = None,
+        query: str,
+        options: typing.Optional[SearchRequestOptionsRequest] = None,
+    ) -> SearchResponse:
+        async with httpx.AsyncClient() as _client:
+            _response = await _client.request(
+                "POST",
+                urllib.parse.urljoin(f"{self._environment.predict}/", "v1/search"),
+                json=jsonable_encoder(
+                    {"index_id": index_id, "index_name": index_name, "query": query, "options": options}
+                ),
+                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(SearchResponse, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def submit_completion_actuals(
+        self,
+        *,
+        deployment_id: typing.Optional[str] = None,
+        deployment_name: typing.Optional[str] = None,
+        actuals: typing.List[SubmitCompletionActualRequest],
+    ) -> None:
+        async with httpx.AsyncClient() as _client:
+            _response = await _client.request(
+                "POST",
+                urllib.parse.urljoin(f"{self._environment.predict}/", "v1/submit-completion-actuals"),
+                json=jsonable_encoder(
+                    {"deployment_id": deployment_id, "deployment_name": deployment_name, "actuals": actuals}
+                ),
+                headers=remove_none_from_headers({"X_API_KEY": self.api_key}),
+            )
+        if 200 <= _response.status_code < 300:
+            return
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    @cached_property
+    def documents(self) -> AsyncDocumentsClient:
+        return AsyncDocumentsClient(environment=self._environment, api_key=self.api_key)
+
+    @cached_property
+    def model_versions(self) -> AsyncModelVersionsClient:
+        return AsyncModelVersionsClient(environment=self._environment, api_key=self.api_key)

vellum/core/__init__.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .api_error import ApiError
+from .datetime_utils import serialize_datetime
+from .jsonable_encoder import jsonable_encoder
+from .remove_none_from_headers import remove_none_from_headers
+
+__all__ = ["ApiError", "jsonable_encoder", "remove_none_from_headers", "serialize_datetime"]

vellum/core/api_error.py

@@ -0,0 +1,15 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+
+class ApiError(Exception):
+    status_code: typing.Optional[int]
+    body: typing.Any
+
+    def __init__(self, *, status_code: typing.Optional[int] = None, body: typing.Any = None):
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"status_code: {self.status_code}, body: {self.body}"

vellum/core/datetime_utils.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+
+
+def serialize_datetime(v: dt.datetime) -> str:
+    """
+    Serialize a datetime including timezone info.
+
+    Uses the timezone info provided if present, otherwise uses the current runtime's timezone info.
+
+    UTC datetimes end in "Z" while all other timezones are represented as offset from UTC, e.g. +05:00.
+    """
+
+    def _serialize_zoned_datetime(v: dt.datetime) -> str:
+        if v.tzinfo is not None and v.tzinfo.tzname(None) == dt.timezone.utc.tzname(None):
+            # UTC is a special case where we use "Z" at the end instead of "+00:00"
+            return v.isoformat().replace("+00:00", "Z")
+        else:
+            # Delegate to the typical +/- offset format
+            return v.isoformat()
+
+    if v.tzinfo is not None:
+        return _serialize_zoned_datetime(v)
+    else:
+        local_tz = dt.datetime.now().astimezone().tzinfo
+        localized_dt = v.replace(tzinfo=local_tz)
+        return _serialize_zoned_datetime(localized_dt)

vellum/core/jsonable_encoder.py

@@ -0,0 +1,94 @@
+# This file was auto-generated by Fern from our API Definition.
+
+"""
+jsonable_encoder converts a Python object to a JSON-friendly dict
+(e.g. datetimes to strings, Pydantic models to dicts).
+
+Taken from FastAPI, and made a bit simpler
+https://github.com/tiangolo/fastapi/blob/master/fastapi/encoders.py
+"""
+
+import dataclasses
+from collections import defaultdict
+from enum import Enum
+from pathlib import PurePath
+from types import GeneratorType
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+
+from pydantic import BaseModel
+from pydantic.json import ENCODERS_BY_TYPE
+
+SetIntStr = Set[Union[int, str]]
+DictIntStrAny = Dict[Union[int, str], Any]
+
+
+def generate_encoders_by_class_tuples(
+    type_encoder_map: Dict[Any, Callable[[Any], Any]]
+) -> Dict[Callable[[Any], Any], Tuple[Any, ...]]:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(tuple)
+    for type_, encoder in type_encoder_map.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+    return encoders_by_class_tuples
+
+
+encoders_by_class_tuples = generate_encoders_by_class_tuples(ENCODERS_BY_TYPE)
+
+
+def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None) -> Any:
+    custom_encoder = custom_encoder or {}
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if isinstance(obj, BaseModel):
+        encoder = getattr(obj.__config__, "json_encoders", {})
+        if custom_encoder:
+            encoder.update(custom_encoder)
+        obj_dict = obj.dict(by_alias=True)
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        return jsonable_encoder(obj_dict, custom_encoder=encoder)
+    if dataclasses.is_dataclass(obj):
+        obj_dict = dataclasses.asdict(obj)
+        return jsonable_encoder(obj_dict, custom_encoder=custom_encoder)
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        allowed_keys = set(obj.keys())
+        for key, value in obj.items():
+            if key in allowed_keys:
+                encoded_key = jsonable_encoder(key, custom_encoder=custom_encoder)
+                encoded_value = jsonable_encoder(value, custom_encoder=custom_encoder)
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple)):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(jsonable_encoder(item, custom_encoder=custom_encoder))
+        return encoded_list
+
+    if type(obj) in ENCODERS_BY_TYPE:
+        return ENCODERS_BY_TYPE[type(obj)](obj)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+
+    try:
+        data = dict(obj)
+    except Exception as e:
+        errors: List[Exception] = []
+        errors.append(e)
+        try:
+            data = vars(obj)
+        except Exception as e:
+            errors.append(e)
+            raise ValueError(errors) from e
+    return jsonable_encoder(data, custom_encoder=custom_encoder)

vellum/core/remove_none_from_headers.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Dict, Optional
+
+
+def remove_none_from_headers(headers: Dict[str, Optional[str]]) -> Dict[str, str]:
+    new_headers: Dict[str, str] = {}
+    for header_key, header_value in headers.items():
+        if header_value is not None:
+            new_headers[header_key] = header_value
+    return new_headers

vellum/environment.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+
+
+class VellumEnvironment:
+    PRODUCTION: VellumEnvironment
+
+    def __init__(self, *, default: str, predict: str, documents: str):
+        self.default = default
+        self.predict = predict
+        self.documents = documents
+
+
+VellumEnvironment.PRODUCTION = VellumEnvironment(
+    default="https://api.vellum.ai", predict="https://predict.vellum.ai", documents="https://documents.vellum.ai"
+)

vellum/resources/__init__.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from . import documents, model_versions
+
+__all__ = ["documents", "model_versions"]

vellum/resources/documents/__init__.py

@@ -0,0 +1,2 @@
+# This file was auto-generated by Fern from our API Definition.
+

vellum/resources/documents/client.py

@@ -0,0 +1,135 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+import urllib.parse
+from json.decoder import JSONDecodeError
+
+import httpx
+import pydantic
+
+from ...core.api_error import ApiError
+from ...core.jsonable_encoder import jsonable_encoder
+from ...core.remove_none_from_headers import remove_none_from_headers
+from ...environment import VellumEnvironment
+from ...types.paginated_slim_document_list import PaginatedSlimDocumentList
+from ...types.upload_document_response import UploadDocumentResponse
+
+
+class DocumentsClient:
+    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+        self._environment = environment
+        self.api_key = api_key
+
+    def list(
+        self,
+        *,
+        document_index_id: typing.Optional[str] = None,
+        limit: typing.Optional[int] = None,
+        offset: typing.Optional[int] = None,
+        ordering: typing.Optional[str] = None,
+    ) -> PaginatedSlimDocumentList:
+        _response = httpx.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}),
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(PaginatedSlimDocumentList, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def upload(
+        self,
+        *,
+        add_to_index_names: typing.List[str],
+        external_id: str,
+        label: str,
+        contents: typing.IO,
+        keywords: typing.List[str],
+    ) -> UploadDocumentResponse:
+        _response = httpx.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}),
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(UploadDocumentResponse, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+
+class AsyncDocumentsClient:
+    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+        self._environment = environment
+        self.api_key = api_key
+
+    async def list(
+        self,
+        *,
+        document_index_id: typing.Optional[str] = None,
+        limit: typing.Optional[int] = None,
+        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}),
+            )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(PaginatedSlimDocumentList, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def upload(
+        self,
+        *,
+        add_to_index_names: typing.List[str],
+        external_id: str,
+        label: str,
+        contents: typing.IO,
+        keywords: typing.List[str],
+    ) -> 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}),
+            )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(UploadDocumentResponse, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)

vellum/resources/model_versions/__init__.py

@@ -0,0 +1,2 @@
+# This file was auto-generated by Fern from our API Definition.
+