vellum-ai 0.0.1__py3-none-any.whl

vellum/resources/model_versions/client.py

@@ -0,0 +1,53 @@
+# This file was auto-generated by Fern from our API Definition.
+
+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 ...environment import VellumEnvironment
+from ...types.model_version_read import ModelVersionRead
+
+
+class ModelVersionsClient:
+    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+        self._environment = environment
+        self.api_key = api_key
+
+    def retrieve(self, id: str) -> ModelVersionRead:
+        _response = httpx.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}),
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(ModelVersionRead, _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 AsyncModelVersionsClient:
+    def __init__(self, *, environment: VellumEnvironment = VellumEnvironment.PRODUCTION, api_key: str):
+        self._environment = environment
+        self.api_key = api_key
+
+    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}),
+            )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(ModelVersionRead, _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/types/__init__.py

@@ -0,0 +1,91 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from .block_type_enum import BlockTypeEnum
+from .chat_role_enum import ChatRoleEnum
+from .document import Document
+from .document_document_to_document_index import DocumentDocumentToDocumentIndex
+from .enriched_normalized_completion import EnrichedNormalizedCompletion
+from .finish_reason_enum import FinishReasonEnum
+from .generate_error_response import GenerateErrorResponse
+from .generate_options_request import GenerateOptionsRequest
+from .generate_request_request import GenerateRequestRequest
+from .generate_response import GenerateResponse
+from .generate_result import GenerateResult
+from .generate_result_data import GenerateResultData
+from .generate_result_error import GenerateResultError
+from .indexing_state_enum import IndexingStateEnum
+from .logprobs_enum import LogprobsEnum
+from .model_type_enum import ModelTypeEnum
+from .model_version_build_config import ModelVersionBuildConfig
+from .model_version_exec_config_parameters import ModelVersionExecConfigParameters
+from .model_version_exec_config_read import ModelVersionExecConfigRead
+from .model_version_read import ModelVersionRead
+from .model_version_read_status_enum import ModelVersionReadStatusEnum
+from .model_version_sandbox_snapshot import ModelVersionSandboxSnapshot
+from .normalized_log_probs import NormalizedLogProbs
+from .normalized_token_log_probs import NormalizedTokenLogProbs
+from .paginated_slim_document_list import PaginatedSlimDocumentList
+from .processing_state_enum import ProcessingStateEnum
+from .prompt_template_block import PromptTemplateBlock
+from .prompt_template_block_data import PromptTemplateBlockData
+from .prompt_template_block_properties import PromptTemplateBlockProperties
+from .provider_enum import ProviderEnum
+from .search_error_response import SearchErrorResponse
+from .search_filters_request import SearchFiltersRequest
+from .search_request_options_request import SearchRequestOptionsRequest
+from .search_response import SearchResponse
+from .search_result import SearchResult
+from .search_result_merging_request import SearchResultMergingRequest
+from .search_weights_request import SearchWeightsRequest
+from .slim_document import SlimDocument
+from .slim_document_status_enum import SlimDocumentStatusEnum
+from .submit_completion_actual_request import SubmitCompletionActualRequest
+from .submit_completion_actuals_error_response import SubmitCompletionActualsErrorResponse
+from .upload_document_error_response import UploadDocumentErrorResponse
+from .upload_document_response import 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",
+]

vellum/types/block_type_enum.py

@@ -0,0 +1,29 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class BlockTypeEnum(str, enum.Enum):
+    CHAT_MESSAGE = "CHAT_MESSAGE"
+    CHAT_HISTORY = "CHAT_HISTORY"
+    TEXT = "TEXT"
+    VARIABLE = "VARIABLE"
+
+    def visit(
+        self,
+        chat_message: typing.Callable[[], T_Result],
+        chat_history: typing.Callable[[], T_Result],
+        text: typing.Callable[[], T_Result],
+        variable: typing.Callable[[], T_Result],
+    ) -> T_Result:
+        if self is BlockTypeEnum.CHAT_MESSAGE:
+            return chat_message()
+        if self is BlockTypeEnum.CHAT_HISTORY:
+            return chat_history()
+        if self is BlockTypeEnum.TEXT:
+            return text()
+        if self is BlockTypeEnum.VARIABLE:
+            return variable()

vellum/types/chat_role_enum.py

@@ -0,0 +1,25 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class ChatRoleEnum(str, enum.Enum):
+    SYSTEM = "SYSTEM"
+    ASSISTANT = "ASSISTANT"
+    USER = "USER"
+
+    def visit(
+        self,
+        system: typing.Callable[[], T_Result],
+        assistant: typing.Callable[[], T_Result],
+        user: typing.Callable[[], T_Result],
+    ) -> T_Result:
+        if self is ChatRoleEnum.SYSTEM:
+            return system()
+        if self is ChatRoleEnum.ASSISTANT:
+            return assistant()
+        if self is ChatRoleEnum.USER:
+            return user()

vellum/types/document.py

@@ -0,0 +1,30 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+
+
+class Document(pydantic.BaseModel):
+    id: str = pydantic.Field(description=("The ID of the document.\n"))
+    label: str = pydantic.Field(description=("The human-readable name for the document.\n"))
+    external_id: typing.Optional[str] = pydantic.Field(
+        description=(
+            "The unique ID of the document as represented in an external system and specified when it was originally uploaded.\n"
+        )
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/document_document_to_document_index.py

@@ -0,0 +1,31 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+from .indexing_state_enum import IndexingStateEnum
+
+
+class DocumentDocumentToDocumentIndex(pydantic.BaseModel):
+    id: str = pydantic.Field(description=("Vellum-generated ID that uniquely identifies this link.\n"))
+    document_index_id: str = pydantic.Field(
+        description=("Vellum-generated ID that uniquely identifies the index this document is included in.\n")
+    )
+    indexing_state: typing.Optional[IndexingStateEnum] = pydantic.Field(
+        description=("An enum value representing where this document is along its indexing lifecycle for this index.\n")
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/enriched_normalized_completion.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+from .finish_reason_enum import FinishReasonEnum
+from .normalized_log_probs import NormalizedLogProbs
+
+
+class EnrichedNormalizedCompletion(pydantic.BaseModel):
+    id: str = pydantic.Field(description=("The Vellum-generated ID of the completion.\n"))
+    external_id: typing.Optional[str] = pydantic.Field(
+        description=(
+            "The external ID that was originally provided along with the generation request, which uniquely identifies this generation in an external system.\n"
+        )
+    )
+    text: str = pydantic.Field(description=("The text generated by the LLM.\n"))
+    finish_reason: FinishReasonEnum = pydantic.Field(description=("The reason the generation finished.\n"))
+    logprobs: typing.Optional[NormalizedLogProbs] = pydantic.Field(
+        description=("The logprobs of the completion. Only present if specified in the original request options.\n")
+    )
+    model_version_id: str = pydantic.Field(
+        description=("The ID of the model version used to generate this completion.\n")
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/finish_reason_enum.py

@@ -0,0 +1,25 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class FinishReasonEnum(str, enum.Enum):
+    LENGTH = "LENGTH"
+    STOP = "STOP"
+    UNKNOWN = "UNKNOWN"
+
+    def visit(
+        self,
+        length: typing.Callable[[], T_Result],
+        stop: typing.Callable[[], T_Result],
+        unknown: typing.Callable[[], T_Result],
+    ) -> T_Result:
+        if self is FinishReasonEnum.LENGTH:
+            return length()
+        if self is FinishReasonEnum.STOP:
+            return stop()
+        if self is FinishReasonEnum.UNKNOWN:
+            return unknown()

vellum/types/generate_error_response.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+
+
+class GenerateErrorResponse(pydantic.BaseModel):
+    detail: str = pydantic.Field(description=("Details about why the request failed.\n"))
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/generate_options_request.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+from .logprobs_enum import LogprobsEnum
+
+
+class GenerateOptionsRequest(pydantic.BaseModel):
+    logprobs: typing.Optional[LogprobsEnum] = pydantic.Field(
+        description=("Which logprobs to include, if any. Defaults to NONE.\n")
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/generate_request_request.py

@@ -0,0 +1,31 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+
+
+class GenerateRequestRequest(pydantic.BaseModel):
+    input_values: typing.Dict[str, typing.Any] = pydantic.Field(
+        description=("Key/value pairs for each template variable defined in the deployment's prompt.\n")
+    )
+    external_ids: typing.Optional[typing.List[str]] = pydantic.Field(
+        description=(
+            "Optionally include a unique identifier for each generation, as represented outside of Vellum. Note that this should generally be a list of length one.\n"
+        )
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/generate_response.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+from .generate_result import GenerateResult
+
+
+class GenerateResponse(pydantic.BaseModel):
+    results: typing.List[GenerateResult]
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    @property
+    def texts(self) -> typing.List[str]:
+        return [
+            completion.text
+            for result in self.results
+            for completion in (result.data.completions if result.data else [])
+        ]
+
+    @property
+    def text(self) -> str:
+        if len(self.texts) != 1:
+            raise ValueError(f"Expected exactly one completion, but got {len(self.texts)}")
+        return self.texts[0]
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/generate_result.py

@@ -0,0 +1,35 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+from .generate_result_data import GenerateResultData
+from .generate_result_error import GenerateResultError
+
+
+class GenerateResult(pydantic.BaseModel):
+    data: typing.Optional[GenerateResultData] = pydantic.Field(
+        description=(
+            "An object containing the resulting generation. This key will be absent if the LLM provider experienced an error.\n"
+        )
+    )
+    error: typing.Optional[GenerateResultError] = pydantic.Field(
+        description=(
+            "An object containing details about the error that occurred. This key will be absent if the LLM provider did not experience an error.\n"
+        )
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/generate_result_data.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+from .enriched_normalized_completion import EnrichedNormalizedCompletion
+
+
+class GenerateResultData(pydantic.BaseModel):
+    completions: typing.List[EnrichedNormalizedCompletion] = pydantic.Field(
+        description=("The generated completions. This will generally be a list of length one.\n")
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/generate_result_error.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+
+
+class GenerateResultError(pydantic.BaseModel):
+    message: str = pydantic.Field(description=("The error message returned by the LLM provider.\n"))
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}

vellum/types/indexing_state_enum.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class IndexingStateEnum(str, enum.Enum):
+    AWAITING_PROCESSING = "AWAITING_PROCESSING"
+    QUEUED = "QUEUED"
+    INDEXING = "INDEXING"
+    INDEXED = "INDEXED"
+    FAILED = "FAILED"
+
+    def visit(
+        self,
+        awaiting_processing: typing.Callable[[], T_Result],
+        queued: typing.Callable[[], T_Result],
+        indexing: typing.Callable[[], T_Result],
+        indexed: typing.Callable[[], T_Result],
+        failed: typing.Callable[[], T_Result],
+    ) -> T_Result:
+        if self is IndexingStateEnum.AWAITING_PROCESSING:
+            return awaiting_processing()
+        if self is IndexingStateEnum.QUEUED:
+            return queued()
+        if self is IndexingStateEnum.INDEXING:
+            return indexing()
+        if self is IndexingStateEnum.INDEXED:
+            return indexed()
+        if self is IndexingStateEnum.FAILED:
+            return failed()

vellum/types/logprobs_enum.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class LogprobsEnum(str, enum.Enum):
+    ALL = "ALL"
+    NONE = "NONE"
+
+    def visit(self, all: typing.Callable[[], T_Result], none: typing.Callable[[], T_Result]) -> T_Result:
+        if self is LogprobsEnum.ALL:
+            return all()
+        if self is LogprobsEnum.NONE:
+            return none()

vellum/types/model_type_enum.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import enum
+import typing
+
+T_Result = typing.TypeVar("T_Result")
+
+
+class ModelTypeEnum(str, enum.Enum):
+    GENERATE = "GENERATE"
+    CLASSIFY = "CLASSIFY"
+
+    def visit(self, generate: typing.Callable[[], T_Result], classify: typing.Callable[[], T_Result]) -> T_Result:
+        if self is ModelTypeEnum.GENERATE:
+            return generate()
+        if self is ModelTypeEnum.CLASSIFY:
+            return classify()

vellum/types/model_version_build_config.py

@@ -0,0 +1,34 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import pydantic
+
+from ..core.datetime_utils import serialize_datetime
+from .model_version_sandbox_snapshot import ModelVersionSandboxSnapshot
+
+
+class ModelVersionBuildConfig(pydantic.BaseModel):
+    base_model: str = pydantic.Field(
+        description=(
+            "The name of the base model used to create this model version, as identified by the LLM provider.\n"
+        )
+    )
+    sandbox_snapshot: typing.Optional[ModelVersionSandboxSnapshot] = pydantic.Field(
+        description=(
+            "Information about the sandbox snapshot that was used to create this model version, if applicable.\n"
+        )
+    )
+
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
+        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
+        return super().dict(**kwargs_with_defaults)
+
+    class Config:
+        frozen = True
+        json_encoders = {dt.datetime: serialize_datetime}