orca-sdk 0.0.78__py3-none-any.whl

orca_sdk/_generated_api_client/models/__init__.py

@@ -0,0 +1,179 @@
+"""Contains all the data models used in inputs/outputs"""
+
+from .analyze_neighbor_labels_result import AnalyzeNeighborLabelsResult
+from .api_key_metadata import ApiKeyMetadata
+from .api_key_metadata_scope_item import ApiKeyMetadataScopeItem
+from .base_model import BaseModel
+from .body_create_datasource_datasource_post import BodyCreateDatasourceDatasourcePost
+from .classification_evaluation_result import ClassificationEvaluationResult
+from .clone_labeled_memoryset_request import CloneLabeledMemorysetRequest
+from .column_info import ColumnInfo
+from .column_type import ColumnType
+from .conflict_error_response import ConflictErrorResponse
+from .create_api_key_request import CreateApiKeyRequest
+from .create_api_key_request_scope_item import CreateApiKeyRequestScopeItem
+from .create_api_key_response import CreateApiKeyResponse
+from .create_api_key_response_scope_item import CreateApiKeyResponseScopeItem
+from .create_labeled_memoryset_request import CreateLabeledMemorysetRequest
+from .create_rac_model_request import CreateRACModelRequest
+from .datasource_metadata import DatasourceMetadata
+from .delete_memories_request import DeleteMemoriesRequest
+from .embed_request import EmbedRequest
+from .embedding_evaluation_request import EmbeddingEvaluationRequest
+from .embedding_evaluation_response import EmbeddingEvaluationResponse
+from .embedding_evaluation_result import EmbeddingEvaluationResult
+from .embedding_finetuning_method import EmbeddingFinetuningMethod
+from .embedding_model_result import EmbeddingModelResult
+from .evaluation_request import EvaluationRequest
+from .evaluation_response import EvaluationResponse
+from .feedback_type import FeedbackType
+from .field_validation_error import FieldValidationError
+from .filter_item import FilterItem
+from .filter_item_field_type_0_item import FilterItemFieldType0Item
+from .filter_item_field_type_2_item_type_1 import FilterItemFieldType2ItemType1
+from .filter_item_op import FilterItemOp
+from .find_duplicates_analysis_result import FindDuplicatesAnalysisResult
+from .finetune_embedding_model_request import FinetuneEmbeddingModelRequest
+from .finetune_embedding_model_request_training_args import FinetuneEmbeddingModelRequestTrainingArgs
+from .finetuned_embedding_model_metadata import FinetunedEmbeddingModelMetadata
+from .get_memories_request import GetMemoriesRequest
+from .internal_server_error_response import InternalServerErrorResponse
+from .label_class_metrics import LabelClassMetrics
+from .label_prediction_memory_lookup import LabelPredictionMemoryLookup
+from .label_prediction_memory_lookup_metadata import LabelPredictionMemoryLookupMetadata
+from .label_prediction_result import LabelPredictionResult
+from .label_prediction_with_memories_and_feedback import LabelPredictionWithMemoriesAndFeedback
+from .labeled_memory import LabeledMemory
+from .labeled_memory_insert import LabeledMemoryInsert
+from .labeled_memory_insert_metadata import LabeledMemoryInsertMetadata
+from .labeled_memory_lookup import LabeledMemoryLookup
+from .labeled_memory_lookup_metadata import LabeledMemoryLookupMetadata
+from .labeled_memory_metadata import LabeledMemoryMetadata
+from .labeled_memory_metrics import LabeledMemoryMetrics
+from .labeled_memory_update import LabeledMemoryUpdate
+from .labeled_memory_update_metadata_type_0 import LabeledMemoryUpdateMetadataType0
+from .labeled_memoryset_metadata import LabeledMemorysetMetadata
+from .list_analyses_memoryset_name_or_id_analysis_get_type_type_0 import (
+    ListAnalysesMemorysetNameOrIdAnalysisGetTypeType0,
+)
+from .list_memories_request import ListMemoriesRequest
+from .list_predictions_request import ListPredictionsRequest
+from .lookup_request import LookupRequest
+from .memory_metrics import MemoryMetrics
+from .memoryset_analysis_request import MemorysetAnalysisRequest
+from .memoryset_analysis_request_type import MemorysetAnalysisRequestType
+from .memoryset_analysis_response import MemorysetAnalysisResponse
+from .memoryset_analysis_response_config import MemorysetAnalysisResponseConfig
+from .memoryset_analysis_response_type import MemorysetAnalysisResponseType
+from .not_found_error_response import NotFoundErrorResponse
+from .not_found_error_response_resource_type_0 import NotFoundErrorResponseResourceType0
+from .precision_recall_curve import PrecisionRecallCurve
+from .prediction_feedback import PredictionFeedback
+from .prediction_feedback_category import PredictionFeedbackCategory
+from .prediction_feedback_request import PredictionFeedbackRequest
+from .prediction_feedback_result import PredictionFeedbackResult
+from .prediction_request import PredictionRequest
+from .prediction_sort_item_item_type_0 import PredictionSortItemItemType0
+from .prediction_sort_item_item_type_1 import PredictionSortItemItemType1
+from .pretrained_embedding_model_metadata import PretrainedEmbeddingModelMetadata
+from .pretrained_embedding_model_name import PretrainedEmbeddingModelName
+from .rac_head_type import RACHeadType
+from .rac_model_metadata import RACModelMetadata
+from .roc_curve import ROCCurve
+from .service_unavailable_error_response import ServiceUnavailableErrorResponse
+from .task import Task
+from .task_status import TaskStatus
+from .task_status_info import TaskStatusInfo
+from .unauthenticated_error_response import UnauthenticatedErrorResponse
+from .unauthorized_error_response import UnauthorizedErrorResponse
+from .unprocessable_input_error_response import UnprocessableInputErrorResponse
+from .update_prediction_request import UpdatePredictionRequest
+
+__all__ = (
+    "AnalyzeNeighborLabelsResult",
+    "ApiKeyMetadata",
+    "ApiKeyMetadataScopeItem",
+    "BaseModel",
+    "BodyCreateDatasourceDatasourcePost",
+    "ClassificationEvaluationResult",
+    "CloneLabeledMemorysetRequest",
+    "ColumnInfo",
+    "ColumnType",
+    "ConflictErrorResponse",
+    "CreateApiKeyRequest",
+    "CreateApiKeyRequestScopeItem",
+    "CreateApiKeyResponse",
+    "CreateApiKeyResponseScopeItem",
+    "CreateLabeledMemorysetRequest",
+    "CreateRACModelRequest",
+    "DatasourceMetadata",
+    "DeleteMemoriesRequest",
+    "EmbeddingEvaluationRequest",
+    "EmbeddingEvaluationResponse",
+    "EmbeddingEvaluationResult",
+    "EmbeddingFinetuningMethod",
+    "EmbeddingModelResult",
+    "EmbedRequest",
+    "EvaluationRequest",
+    "EvaluationResponse",
+    "FeedbackType",
+    "FieldValidationError",
+    "FilterItem",
+    "FilterItemFieldType0Item",
+    "FilterItemFieldType2ItemType1",
+    "FilterItemOp",
+    "FindDuplicatesAnalysisResult",
+    "FinetunedEmbeddingModelMetadata",
+    "FinetuneEmbeddingModelRequest",
+    "FinetuneEmbeddingModelRequestTrainingArgs",
+    "GetMemoriesRequest",
+    "InternalServerErrorResponse",
+    "LabelClassMetrics",
+    "LabeledMemory",
+    "LabeledMemoryInsert",
+    "LabeledMemoryInsertMetadata",
+    "LabeledMemoryLookup",
+    "LabeledMemoryLookupMetadata",
+    "LabeledMemoryMetadata",
+    "LabeledMemoryMetrics",
+    "LabeledMemorysetMetadata",
+    "LabeledMemoryUpdate",
+    "LabeledMemoryUpdateMetadataType0",
+    "LabelPredictionMemoryLookup",
+    "LabelPredictionMemoryLookupMetadata",
+    "LabelPredictionResult",
+    "LabelPredictionWithMemoriesAndFeedback",
+    "ListAnalysesMemorysetNameOrIdAnalysisGetTypeType0",
+    "ListMemoriesRequest",
+    "ListPredictionsRequest",
+    "LookupRequest",
+    "MemoryMetrics",
+    "MemorysetAnalysisRequest",
+    "MemorysetAnalysisRequestType",
+    "MemorysetAnalysisResponse",
+    "MemorysetAnalysisResponseConfig",
+    "MemorysetAnalysisResponseType",
+    "NotFoundErrorResponse",
+    "NotFoundErrorResponseResourceType0",
+    "PrecisionRecallCurve",
+    "PredictionFeedback",
+    "PredictionFeedbackCategory",
+    "PredictionFeedbackRequest",
+    "PredictionFeedbackResult",
+    "PredictionRequest",
+    "PredictionSortItemItemType0",
+    "PredictionSortItemItemType1",
+    "PretrainedEmbeddingModelMetadata",
+    "PretrainedEmbeddingModelName",
+    "RACHeadType",
+    "RACModelMetadata",
+    "ROCCurve",
+    "ServiceUnavailableErrorResponse",
+    "Task",
+    "TaskStatus",
+    "TaskStatusInfo",
+    "UnauthenticatedErrorResponse",
+    "UnauthorizedErrorResponse",
+    "UnprocessableInputErrorResponse",
+    "UpdatePredictionRequest",
+)

orca_sdk/_generated_api_client/models/analyze_neighbor_labels_result.py

@@ -0,0 +1,116 @@
+"""
+This file is generated by the openapi-python-client tool via the generate_api_client.py script
+
+It is a customized template from the openapi-python-client tool's default template:
+https://github.com/openapi-generators/openapi-python-client/blob/861ef5622f10fc96d240dc9becb0edf94e61446c/openapi_python_client/templates/model.py.jinja
+
+The main change is:
+- Fix typing issues
+"""
+
+# flake8: noqa: C901
+
+from typing import TYPE_CHECKING, Any, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.label_class_metrics import LabelClassMetrics
+
+
+T = TypeVar("T", bound="AnalyzeNeighborLabelsResult")
+
+
+@_attrs_define
+class AnalyzeNeighborLabelsResult:
+    """
+    Attributes:
+        label_metrics (List['LabelClassMetrics']):
+        neighbor_prediction_accuracy (float):
+        mean_neighbor_label_confidence (float):
+        mean_neighbor_label_entropy (float):
+        mean_neighbor_predicted_label_ambiguity (float):
+    """
+
+    label_metrics: List["LabelClassMetrics"]
+    neighbor_prediction_accuracy: float
+    mean_neighbor_label_confidence: float
+    mean_neighbor_label_entropy: float
+    mean_neighbor_predicted_label_ambiguity: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        label_metrics = []
+        for label_metrics_item_data in self.label_metrics:
+            label_metrics_item = label_metrics_item_data.to_dict()
+            label_metrics.append(label_metrics_item)
+
+        neighbor_prediction_accuracy = self.neighbor_prediction_accuracy
+
+        mean_neighbor_label_confidence = self.mean_neighbor_label_confidence
+
+        mean_neighbor_label_entropy = self.mean_neighbor_label_entropy
+
+        mean_neighbor_predicted_label_ambiguity = self.mean_neighbor_predicted_label_ambiguity
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "label_metrics": label_metrics,
+                "neighbor_prediction_accuracy": neighbor_prediction_accuracy,
+                "mean_neighbor_label_confidence": mean_neighbor_label_confidence,
+                "mean_neighbor_label_entropy": mean_neighbor_label_entropy,
+                "mean_neighbor_predicted_label_ambiguity": mean_neighbor_predicted_label_ambiguity,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.label_class_metrics import LabelClassMetrics
+
+        d = src_dict.copy()
+        label_metrics = []
+        _label_metrics = d.pop("label_metrics")
+        for label_metrics_item_data in _label_metrics:
+            label_metrics_item = LabelClassMetrics.from_dict(label_metrics_item_data)
+
+            label_metrics.append(label_metrics_item)
+
+        neighbor_prediction_accuracy = d.pop("neighbor_prediction_accuracy")
+
+        mean_neighbor_label_confidence = d.pop("mean_neighbor_label_confidence")
+
+        mean_neighbor_label_entropy = d.pop("mean_neighbor_label_entropy")
+
+        mean_neighbor_predicted_label_ambiguity = d.pop("mean_neighbor_predicted_label_ambiguity")
+
+        analyze_neighbor_labels_result = cls(
+            label_metrics=label_metrics,
+            neighbor_prediction_accuracy=neighbor_prediction_accuracy,
+            mean_neighbor_label_confidence=mean_neighbor_label_confidence,
+            mean_neighbor_label_entropy=mean_neighbor_label_entropy,
+            mean_neighbor_predicted_label_ambiguity=mean_neighbor_predicted_label_ambiguity,
+        )
+
+        analyze_neighbor_labels_result.additional_properties = d
+        return analyze_neighbor_labels_result
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

orca_sdk/_generated_api_client/models/api_key_metadata.py

@@ -0,0 +1,137 @@
+"""
+This file is generated by the openapi-python-client tool via the generate_api_client.py script
+
+It is a customized template from the openapi-python-client tool's default template:
+https://github.com/openapi-generators/openapi-python-client/blob/861ef5622f10fc96d240dc9becb0edf94e61446c/openapi_python_client/templates/model.py.jinja
+
+The main change is:
+- Fix typing issues
+"""
+
+# flake8: noqa: C901
+
+import datetime
+from enum import Enum
+from typing import Any, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.api_key_metadata_scope_item import ApiKeyMetadataScopeItem
+
+T = TypeVar("T", bound="ApiKeyMetadata")
+
+
+@_attrs_define
+class ApiKeyMetadata:
+    """
+    Attributes:
+        id (str):
+        org_id (str):
+        name (str):
+        created_by (Union[None, str]):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+        scope (List[ApiKeyMetadataScopeItem]):
+    """
+
+    id: str
+    org_id: str
+    name: str
+    created_by: Union[None, str]
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    scope: List[ApiKeyMetadataScopeItem]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        org_id = self.org_id
+
+        name = self.name
+
+        created_by: Union[None, str]
+        created_by = self.created_by
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        scope = []
+        for scope_item_data in self.scope:
+            scope_item = scope_item_data.value if isinstance(scope_item_data, Enum) else scope_item_data
+            scope.append(scope_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "org_id": org_id,
+                "name": name,
+                "created_by": created_by,
+                "created_at": created_at,
+                "updated_at": updated_at,
+                "scope": scope,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        id = d.pop("id")
+
+        org_id = d.pop("org_id")
+
+        name = d.pop("name")
+
+        def _parse_created_by(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        created_by = _parse_created_by(d.pop("created_by"))
+
+        created_at = isoparse(d.pop("created_at"))
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+        scope = []
+        _scope = d.pop("scope")
+        for scope_item_data in _scope:
+            scope_item = ApiKeyMetadataScopeItem(scope_item_data)
+
+            scope.append(scope_item)
+
+        api_key_metadata = cls(
+            id=id,
+            org_id=org_id,
+            name=name,
+            created_by=created_by,
+            created_at=created_at,
+            updated_at=updated_at,
+            scope=scope,
+        )
+
+        api_key_metadata.additional_properties = d
+        return api_key_metadata
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

orca_sdk/_generated_api_client/models/api_key_metadata_scope_item.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ApiKeyMetadataScopeItem(str, Enum):
+    ADMINISTER = "ADMINISTER"
+    PREDICT = "PREDICT"
+
+    def __str__(self) -> str:
+        return str(self.value)

orca_sdk/_generated_api_client/models/base_model.py

@@ -0,0 +1,55 @@
+"""
+This file is generated by the openapi-python-client tool via the generate_api_client.py script
+
+It is a customized template from the openapi-python-client tool's default template:
+https://github.com/openapi-generators/openapi-python-client/blob/861ef5622f10fc96d240dc9becb0edf94e61446c/openapi_python_client/templates/model.py.jinja
+
+The main change is:
+- Fix typing issues
+"""
+
+# flake8: noqa: C901
+
+from typing import Any, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="BaseModel")
+
+
+@_attrs_define
+class BaseModel:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        base_model = cls()
+
+        base_model.additional_properties = d
+        return base_model
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

orca_sdk/_generated_api_client/models/body_create_datasource_datasource_post.py

@@ -0,0 +1,176 @@
+"""
+This file is generated by the openapi-python-client tool via the generate_api_client.py script
+
+It is a customized template from the openapi-python-client tool's default template:
+https://github.com/openapi-generators/openapi-python-client/blob/861ef5622f10fc96d240dc9becb0edf94e61446c/openapi_python_client/templates/model.py.jinja
+
+The main change is:
+- Fix typing issues
+"""
+
+# flake8: noqa: C901
+
+import json
+from io import BytesIO
+from typing import Any, List, Tuple, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, File, FileJsonType, Unset
+
+T = TypeVar("T", bound="BodyCreateDatasourceDatasourcePost")
+
+
+@_attrs_define
+class BodyCreateDatasourceDatasourcePost:
+    """
+    Attributes:
+        name (str):
+        files (Union[List[File], None, Unset]):
+        content (Union[None, Unset, str]):
+    """
+
+    name: str
+    files: Union[List[File], None, Unset] = UNSET
+    content: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        files: Union[List[FileJsonType], None, Unset]
+        if isinstance(self.files, Unset):
+            files = UNSET
+        elif isinstance(self.files, list):
+            files = []
+            for files_type_0_item_data in self.files:
+                files_type_0_item = files_type_0_item_data.to_tuple()
+
+                files.append(files_type_0_item)
+
+        else:
+            files = self.files
+
+        content: Union[None, Unset, str]
+        if isinstance(self.content, Unset):
+            content = UNSET
+        else:
+            content = self.content
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if files is not UNSET:
+            field_dict["files"] = files
+        if content is not UNSET:
+            field_dict["content"] = content
+
+        return field_dict
+
+    def to_multipart(self) -> dict[str, Any]:
+        name = (None, str(self.name).encode(), "text/plain")
+
+        files: Union[Tuple[None, bytes, str], Unset]
+
+        if isinstance(self.files, Unset):
+            files = UNSET
+        elif isinstance(self.files, list):
+            _temp_files = []
+            for files_type_0_item_data in self.files:
+                files_type_0_item = files_type_0_item_data.to_tuple()
+
+                _temp_files.append(files_type_0_item)
+            files = (None, json.dumps(_temp_files).encode(), "application/json")
+        else:
+            files = (None, str(self.files).encode(), "text/plain")
+
+        content: Union[Tuple[None, bytes, str], Unset]
+
+        if isinstance(self.content, Unset):
+            content = UNSET
+        elif isinstance(self.content, str):
+            content = (None, str(self.content).encode(), "text/plain")
+        else:
+            content = (None, str(self.content).encode(), "text/plain")
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = (None, str(prop).encode(), "text/plain")
+
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if files is not UNSET:
+            field_dict["files"] = files
+        if content is not UNSET:
+            field_dict["content"] = content
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        name = d.pop("name")
+
+        def _parse_files(data: object) -> Union[List[File], None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                files_type_0 = []
+                _files_type_0 = data
+                for files_type_0_item_data in _files_type_0:
+                    files_type_0_item = File(payload=BytesIO(files_type_0_item_data))
+
+                    files_type_0.append(files_type_0_item)
+
+                return files_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[List[File], None, Unset], data)
+
+        files = _parse_files(d.pop("files", UNSET))
+
+        def _parse_content(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        content = _parse_content(d.pop("content", UNSET))
+
+        body_create_datasource_datasource_post = cls(
+            name=name,
+            files=files,
+            content=content,
+        )
+
+        body_create_datasource_datasource_post.additional_properties = d
+        return body_create_datasource_datasource_post
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties