orca-sdk 0.0.97__py3-none-any.whl → 0.0.100__py3-none-any.whl

orca_sdk/_generated_api_client/models/memory_metrics.py

@@ -1,263 +0,0 @@
-"""
-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, List, Type, TypeVar, Union, cast
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="MemoryMetrics")
-
-
-@_attrs_define
-class MemoryMetrics:
-    """
-    Attributes:
-        is_duplicate (Union[Unset, bool]):
-        duplicate_memory_ids (Union[Unset, List[str]]):
-        has_potential_duplicates (Union[Unset, bool]):
-        potential_duplicate_memory_ids (Union[List[str], None, Unset]):
-        cluster (Union[Unset, int]):
-        embedding_2d (Union[Unset, List[float]]):
-        anomaly_score (Union[Unset, float]):
-        neighbor_label_logits (Union[Unset, List[float]]):
-        neighbor_predicted_label (Union[Unset, int]):
-        neighbor_predicted_label_ambiguity (Union[Unset, float]):
-        neighbor_predicted_label_confidence (Union[Unset, float]):
-        current_label_neighbor_confidence (Union[Unset, float]):
-        normalized_neighbor_label_entropy (Union[Unset, float]):
-        neighbor_predicted_label_matches_current_label (Union[None, Unset, bool]):
-        spread (Union[Unset, float]):
-        uniformity (Union[Unset, float]):
-    """
-
-    is_duplicate: Union[Unset, bool] = UNSET
-    duplicate_memory_ids: Union[Unset, List[str]] = UNSET
-    has_potential_duplicates: Union[Unset, bool] = UNSET
-    potential_duplicate_memory_ids: Union[List[str], None, Unset] = UNSET
-    cluster: Union[Unset, int] = UNSET
-    embedding_2d: Union[Unset, List[float]] = UNSET
-    anomaly_score: Union[Unset, float] = UNSET
-    neighbor_label_logits: Union[Unset, List[float]] = UNSET
-    neighbor_predicted_label: Union[Unset, int] = UNSET
-    neighbor_predicted_label_ambiguity: Union[Unset, float] = UNSET
-    neighbor_predicted_label_confidence: Union[Unset, float] = UNSET
-    current_label_neighbor_confidence: Union[Unset, float] = UNSET
-    normalized_neighbor_label_entropy: Union[Unset, float] = UNSET
-    neighbor_predicted_label_matches_current_label: Union[None, Unset, bool] = UNSET
-    spread: Union[Unset, float] = UNSET
-    uniformity: Union[Unset, float] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        is_duplicate = self.is_duplicate
-
-        duplicate_memory_ids: Union[Unset, List[str]] = UNSET
-        if not isinstance(self.duplicate_memory_ids, Unset):
-            duplicate_memory_ids = self.duplicate_memory_ids
-
-        has_potential_duplicates = self.has_potential_duplicates
-
-        potential_duplicate_memory_ids: Union[List[str], None, Unset]
-        if isinstance(self.potential_duplicate_memory_ids, Unset):
-            potential_duplicate_memory_ids = UNSET
-        elif isinstance(self.potential_duplicate_memory_ids, list):
-            potential_duplicate_memory_ids = self.potential_duplicate_memory_ids
-
-        else:
-            potential_duplicate_memory_ids = self.potential_duplicate_memory_ids
-
-        cluster = self.cluster
-
-        embedding_2d: Union[Unset, List[float]] = UNSET
-        if not isinstance(self.embedding_2d, Unset):
-            embedding_2d = []
-            for embedding_2d_item_data in self.embedding_2d:
-                embedding_2d_item: float
-                embedding_2d_item = embedding_2d_item_data
-                embedding_2d.append(embedding_2d_item)
-
-        anomaly_score = self.anomaly_score
-
-        neighbor_label_logits: Union[Unset, List[float]] = UNSET
-        if not isinstance(self.neighbor_label_logits, Unset):
-            neighbor_label_logits = self.neighbor_label_logits
-
-        neighbor_predicted_label = self.neighbor_predicted_label
-
-        neighbor_predicted_label_ambiguity = self.neighbor_predicted_label_ambiguity
-
-        neighbor_predicted_label_confidence = self.neighbor_predicted_label_confidence
-
-        current_label_neighbor_confidence = self.current_label_neighbor_confidence
-
-        normalized_neighbor_label_entropy = self.normalized_neighbor_label_entropy
-
-        neighbor_predicted_label_matches_current_label: Union[None, Unset, bool]
-        if isinstance(self.neighbor_predicted_label_matches_current_label, Unset):
-            neighbor_predicted_label_matches_current_label = UNSET
-        else:
-            neighbor_predicted_label_matches_current_label = self.neighbor_predicted_label_matches_current_label
-
-        spread = self.spread
-
-        uniformity = self.uniformity
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if is_duplicate is not UNSET:
-            field_dict["is_duplicate"] = is_duplicate
-        if duplicate_memory_ids is not UNSET:
-            field_dict["duplicate_memory_ids"] = duplicate_memory_ids
-        if has_potential_duplicates is not UNSET:
-            field_dict["has_potential_duplicates"] = has_potential_duplicates
-        if potential_duplicate_memory_ids is not UNSET:
-            field_dict["potential_duplicate_memory_ids"] = potential_duplicate_memory_ids
-        if cluster is not UNSET:
-            field_dict["cluster"] = cluster
-        if embedding_2d is not UNSET:
-            field_dict["embedding_2d"] = embedding_2d
-        if anomaly_score is not UNSET:
-            field_dict["anomaly_score"] = anomaly_score
-        if neighbor_label_logits is not UNSET:
-            field_dict["neighbor_label_logits"] = neighbor_label_logits
-        if neighbor_predicted_label is not UNSET:
-            field_dict["neighbor_predicted_label"] = neighbor_predicted_label
-        if neighbor_predicted_label_ambiguity is not UNSET:
-            field_dict["neighbor_predicted_label_ambiguity"] = neighbor_predicted_label_ambiguity
-        if neighbor_predicted_label_confidence is not UNSET:
-            field_dict["neighbor_predicted_label_confidence"] = neighbor_predicted_label_confidence
-        if current_label_neighbor_confidence is not UNSET:
-            field_dict["current_label_neighbor_confidence"] = current_label_neighbor_confidence
-        if normalized_neighbor_label_entropy is not UNSET:
-            field_dict["normalized_neighbor_label_entropy"] = normalized_neighbor_label_entropy
-        if neighbor_predicted_label_matches_current_label is not UNSET:
-            field_dict["neighbor_predicted_label_matches_current_label"] = (
-                neighbor_predicted_label_matches_current_label
-            )
-        if spread is not UNSET:
-            field_dict["spread"] = spread
-        if uniformity is not UNSET:
-            field_dict["uniformity"] = uniformity
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
-        d = src_dict.copy()
-        is_duplicate = d.pop("is_duplicate", UNSET)
-
-        duplicate_memory_ids = cast(List[str], d.pop("duplicate_memory_ids", UNSET))
-
-        has_potential_duplicates = d.pop("has_potential_duplicates", UNSET)
-
-        def _parse_potential_duplicate_memory_ids(data: object) -> Union[List[str], None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, list):
-                    raise TypeError()
-                potential_duplicate_memory_ids_type_0 = cast(List[str], data)
-
-                return potential_duplicate_memory_ids_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union[List[str], None, Unset], data)
-
-        potential_duplicate_memory_ids = _parse_potential_duplicate_memory_ids(
-            d.pop("potential_duplicate_memory_ids", UNSET)
-        )
-
-        cluster = d.pop("cluster", UNSET)
-
-        embedding_2d = []
-        _embedding_2d = d.pop("embedding_2d", UNSET)
-        for embedding_2d_item_data in _embedding_2d or []:
-
-            def _parse_embedding_2d_item(data: object) -> float:
-                return cast(float, data)
-
-            embedding_2d_item = _parse_embedding_2d_item(embedding_2d_item_data)
-
-            embedding_2d.append(embedding_2d_item)
-
-        anomaly_score = d.pop("anomaly_score", UNSET)
-
-        neighbor_label_logits = cast(List[float], d.pop("neighbor_label_logits", UNSET))
-
-        neighbor_predicted_label = d.pop("neighbor_predicted_label", UNSET)
-
-        neighbor_predicted_label_ambiguity = d.pop("neighbor_predicted_label_ambiguity", UNSET)
-
-        neighbor_predicted_label_confidence = d.pop("neighbor_predicted_label_confidence", UNSET)
-
-        current_label_neighbor_confidence = d.pop("current_label_neighbor_confidence", UNSET)
-
-        normalized_neighbor_label_entropy = d.pop("normalized_neighbor_label_entropy", UNSET)
-
-        def _parse_neighbor_predicted_label_matches_current_label(data: object) -> Union[None, Unset, bool]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, bool], data)
-
-        neighbor_predicted_label_matches_current_label = _parse_neighbor_predicted_label_matches_current_label(
-            d.pop("neighbor_predicted_label_matches_current_label", UNSET)
-        )
-
-        spread = d.pop("spread", UNSET)
-
-        uniformity = d.pop("uniformity", UNSET)
-
-        memory_metrics = cls(
-            is_duplicate=is_duplicate,
-            duplicate_memory_ids=duplicate_memory_ids,
-            has_potential_duplicates=has_potential_duplicates,
-            potential_duplicate_memory_ids=potential_duplicate_memory_ids,
-            cluster=cluster,
-            embedding_2d=embedding_2d,
-            anomaly_score=anomaly_score,
-            neighbor_label_logits=neighbor_label_logits,
-            neighbor_predicted_label=neighbor_predicted_label,
-            neighbor_predicted_label_ambiguity=neighbor_predicted_label_ambiguity,
-            neighbor_predicted_label_confidence=neighbor_predicted_label_confidence,
-            current_label_neighbor_confidence=current_label_neighbor_confidence,
-            normalized_neighbor_label_entropy=normalized_neighbor_label_entropy,
-            neighbor_predicted_label_matches_current_label=neighbor_predicted_label_matches_current_label,
-            spread=spread,
-            uniformity=uniformity,
-        )
-
-        memory_metrics.additional_properties = d
-        return memory_metrics
-
-    @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/memory_type.py

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

orca_sdk/_generated_api_client/models/memoryset_analysis_configs.py

@@ -1,245 +0,0 @@
-"""
-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, Dict, Type, TypeVar, Union, cast
-
-from attrs import define as _attrs_define
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.memoryset_class_patterns_analysis_config import MemorysetClassPatternsAnalysisConfig
-    from ..models.memoryset_cluster_analysis_config import MemorysetClusterAnalysisConfig
-    from ..models.memoryset_duplicate_analysis_config import MemorysetDuplicateAnalysisConfig
-    from ..models.memoryset_label_analysis_config import MemorysetLabelAnalysisConfig
-    from ..models.memoryset_neighbor_analysis_config import MemorysetNeighborAnalysisConfig
-    from ..models.memoryset_projection_analysis_config import MemorysetProjectionAnalysisConfig
-
-
-T = TypeVar("T", bound="MemorysetAnalysisConfigs")
-
-
-@_attrs_define
-class MemorysetAnalysisConfigs:
-    """
-    Attributes:
-        neighbor (Union['MemorysetNeighborAnalysisConfig', None, Unset]):
-        label (Union['MemorysetLabelAnalysisConfig', None, Unset]):
-        duplicate (Union['MemorysetDuplicateAnalysisConfig', None, Unset]):
-        projection (Union['MemorysetProjectionAnalysisConfig', None, Unset]):
-        cluster (Union['MemorysetClusterAnalysisConfig', None, Unset]):
-        class_patterns (Union['MemorysetClassPatternsAnalysisConfig', None, Unset]):
-    """
-
-    neighbor: Union["MemorysetNeighborAnalysisConfig", None, Unset] = UNSET
-    label: Union["MemorysetLabelAnalysisConfig", None, Unset] = UNSET
-    duplicate: Union["MemorysetDuplicateAnalysisConfig", None, Unset] = UNSET
-    projection: Union["MemorysetProjectionAnalysisConfig", None, Unset] = UNSET
-    cluster: Union["MemorysetClusterAnalysisConfig", None, Unset] = UNSET
-    class_patterns: Union["MemorysetClassPatternsAnalysisConfig", None, Unset] = UNSET
-
-    def to_dict(self) -> dict[str, Any]:
-        from ..models.memoryset_class_patterns_analysis_config import MemorysetClassPatternsAnalysisConfig
-        from ..models.memoryset_cluster_analysis_config import MemorysetClusterAnalysisConfig
-        from ..models.memoryset_duplicate_analysis_config import MemorysetDuplicateAnalysisConfig
-        from ..models.memoryset_label_analysis_config import MemorysetLabelAnalysisConfig
-        from ..models.memoryset_neighbor_analysis_config import MemorysetNeighborAnalysisConfig
-        from ..models.memoryset_projection_analysis_config import MemorysetProjectionAnalysisConfig
-
-        neighbor: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.neighbor, Unset):
-            neighbor = UNSET
-        elif isinstance(self.neighbor, MemorysetNeighborAnalysisConfig):
-            neighbor = self.neighbor.to_dict()
-        else:
-            neighbor = self.neighbor
-
-        label: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.label, Unset):
-            label = UNSET
-        elif isinstance(self.label, MemorysetLabelAnalysisConfig):
-            label = self.label.to_dict()
-        else:
-            label = self.label
-
-        duplicate: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.duplicate, Unset):
-            duplicate = UNSET
-        elif isinstance(self.duplicate, MemorysetDuplicateAnalysisConfig):
-            duplicate = self.duplicate.to_dict()
-        else:
-            duplicate = self.duplicate
-
-        projection: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.projection, Unset):
-            projection = UNSET
-        elif isinstance(self.projection, MemorysetProjectionAnalysisConfig):
-            projection = self.projection.to_dict()
-        else:
-            projection = self.projection
-
-        cluster: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.cluster, Unset):
-            cluster = UNSET
-        elif isinstance(self.cluster, MemorysetClusterAnalysisConfig):
-            cluster = self.cluster.to_dict()
-        else:
-            cluster = self.cluster
-
-        class_patterns: Union[Dict[str, Any], None, Unset]
-        if isinstance(self.class_patterns, Unset):
-            class_patterns = UNSET
-        elif isinstance(self.class_patterns, MemorysetClassPatternsAnalysisConfig):
-            class_patterns = self.class_patterns.to_dict()
-        else:
-            class_patterns = self.class_patterns
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update({})
-        if neighbor is not UNSET:
-            field_dict["neighbor"] = neighbor
-        if label is not UNSET:
-            field_dict["label"] = label
-        if duplicate is not UNSET:
-            field_dict["duplicate"] = duplicate
-        if projection is not UNSET:
-            field_dict["projection"] = projection
-        if cluster is not UNSET:
-            field_dict["cluster"] = cluster
-        if class_patterns is not UNSET:
-            field_dict["class_patterns"] = class_patterns
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
-        from ..models.memoryset_class_patterns_analysis_config import MemorysetClassPatternsAnalysisConfig
-        from ..models.memoryset_cluster_analysis_config import MemorysetClusterAnalysisConfig
-        from ..models.memoryset_duplicate_analysis_config import MemorysetDuplicateAnalysisConfig
-        from ..models.memoryset_label_analysis_config import MemorysetLabelAnalysisConfig
-        from ..models.memoryset_neighbor_analysis_config import MemorysetNeighborAnalysisConfig
-        from ..models.memoryset_projection_analysis_config import MemorysetProjectionAnalysisConfig
-
-        d = src_dict.copy()
-
-        def _parse_neighbor(data: object) -> Union["MemorysetNeighborAnalysisConfig", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                neighbor_type_0 = MemorysetNeighborAnalysisConfig.from_dict(data)
-
-                return neighbor_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["MemorysetNeighborAnalysisConfig", None, Unset], data)
-
-        neighbor = _parse_neighbor(d.pop("neighbor", UNSET))
-
-        def _parse_label(data: object) -> Union["MemorysetLabelAnalysisConfig", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                label_type_0 = MemorysetLabelAnalysisConfig.from_dict(data)
-
-                return label_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["MemorysetLabelAnalysisConfig", None, Unset], data)
-
-        label = _parse_label(d.pop("label", UNSET))
-
-        def _parse_duplicate(data: object) -> Union["MemorysetDuplicateAnalysisConfig", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                duplicate_type_0 = MemorysetDuplicateAnalysisConfig.from_dict(data)
-
-                return duplicate_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["MemorysetDuplicateAnalysisConfig", None, Unset], data)
-
-        duplicate = _parse_duplicate(d.pop("duplicate", UNSET))
-
-        def _parse_projection(data: object) -> Union["MemorysetProjectionAnalysisConfig", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                projection_type_0 = MemorysetProjectionAnalysisConfig.from_dict(data)
-
-                return projection_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["MemorysetProjectionAnalysisConfig", None, Unset], data)
-
-        projection = _parse_projection(d.pop("projection", UNSET))
-
-        def _parse_cluster(data: object) -> Union["MemorysetClusterAnalysisConfig", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                cluster_type_0 = MemorysetClusterAnalysisConfig.from_dict(data)
-
-                return cluster_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["MemorysetClusterAnalysisConfig", None, Unset], data)
-
-        cluster = _parse_cluster(d.pop("cluster", UNSET))
-
-        def _parse_class_patterns(data: object) -> Union["MemorysetClassPatternsAnalysisConfig", None, Unset]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                class_patterns_type_0 = MemorysetClassPatternsAnalysisConfig.from_dict(data)
-
-                return class_patterns_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["MemorysetClassPatternsAnalysisConfig", None, Unset], data)
-
-        class_patterns = _parse_class_patterns(d.pop("class_patterns", UNSET))
-
-        memoryset_analysis_configs = cls(
-            neighbor=neighbor,
-            label=label,
-            duplicate=duplicate,
-            projection=projection,
-            cluster=cluster,
-            class_patterns=class_patterns,
-        )
-
-        return memoryset_analysis_configs

orca_sdk/_generated_api_client/models/memoryset_analysis_request.py

@@ -1,105 +0,0 @@
-"""
-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, Type, TypeVar, Union
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.memoryset_analysis_configs import MemorysetAnalysisConfigs
-
-
-T = TypeVar("T", bound="MemorysetAnalysisRequest")
-
-
-@_attrs_define
-class MemorysetAnalysisRequest:
-    """
-    Attributes:
-        configs (MemorysetAnalysisConfigs):
-        lookup_count (Union[Unset, int]):  Default: 15.
-        batch_size (Union[Unset, int]):  Default: 32.
-        clear_metrics (Union[Unset, bool]):  Default: False.
-    """
-
-    configs: "MemorysetAnalysisConfigs"
-    lookup_count: Union[Unset, int] = 15
-    batch_size: Union[Unset, int] = 32
-    clear_metrics: Union[Unset, bool] = False
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        configs = self.configs.to_dict()
-
-        lookup_count = self.lookup_count
-
-        batch_size = self.batch_size
-
-        clear_metrics = self.clear_metrics
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "configs": configs,
-            }
-        )
-        if lookup_count is not UNSET:
-            field_dict["lookup_count"] = lookup_count
-        if batch_size is not UNSET:
-            field_dict["batch_size"] = batch_size
-        if clear_metrics is not UNSET:
-            field_dict["clear_metrics"] = clear_metrics
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
-        from ..models.memoryset_analysis_configs import MemorysetAnalysisConfigs
-
-        d = src_dict.copy()
-        configs = MemorysetAnalysisConfigs.from_dict(d.pop("configs"))
-
-        lookup_count = d.pop("lookup_count", UNSET)
-
-        batch_size = d.pop("batch_size", UNSET)
-
-        clear_metrics = d.pop("clear_metrics", UNSET)
-
-        memoryset_analysis_request = cls(
-            configs=configs,
-            lookup_count=lookup_count,
-            batch_size=batch_size,
-            clear_metrics=clear_metrics,
-        )
-
-        memoryset_analysis_request.additional_properties = d
-        return memoryset_analysis_request
-
-    @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