lightningrod-ai 0.1.6__py3-none-any.whl

lightningrod/_generated/models/question_pipeline.py

@@ -0,0 +1,417 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.file_set_query_seed_generator import FileSetQuerySeedGenerator
+    from ..models.file_set_seed_generator import FileSetSeedGenerator
+    from ..models.forward_looking_question_generator import ForwardLookingQuestionGenerator
+    from ..models.gdelt_seed_generator import GdeltSeedGenerator
+    from ..models.mock_transform_config import MockTransformConfig
+    from ..models.news_context_generator import NewsContextGenerator
+    from ..models.news_seed_generator import NewsSeedGenerator
+    from ..models.question_and_label_generator import QuestionAndLabelGenerator
+    from ..models.question_generator import QuestionGenerator
+    from ..models.question_renderer import QuestionRenderer
+    from ..models.rollout_generator import RolloutGenerator
+    from ..models.web_search_labeler import WebSearchLabeler
+
+
+T = TypeVar("T", bound="QuestionPipeline")
+
+
+@_attrs_define
+class QuestionPipeline:
+    """
+    Attributes:
+        seed_generator (FileSetQuerySeedGenerator | FileSetSeedGenerator | GdeltSeedGenerator | MockTransformConfig |
+            NewsSeedGenerator): Configuration for seed generation
+        question_generator (ForwardLookingQuestionGenerator | MockTransformConfig | QuestionAndLabelGenerator |
+            QuestionGenerator): Configuration for question generation
+        config_type (Literal['QUESTION_PIPELINE'] | Unset): Type of transform configuration Default:
+            'QUESTION_PIPELINE'.
+        labeler (MockTransformConfig | None | Unset | WebSearchLabeler): Configuration for labeling. Not needed when
+            using QuestionAndLabelGenerator.
+        context_generators (list[MockTransformConfig | NewsContextGenerator] | None | Unset): Optional list of context
+            generators to run before rendering
+        renderer (MockTransformConfig | None | QuestionRenderer | Unset): Optional configuration for rendering the final
+            prompt
+        rollout_generator (MockTransformConfig | None | RolloutGenerator | Unset): Optional configuration for generating
+            rollouts from multiple models
+    """
+
+    seed_generator: (
+        FileSetQuerySeedGenerator | FileSetSeedGenerator | GdeltSeedGenerator | MockTransformConfig | NewsSeedGenerator
+    )
+    question_generator: (
+        ForwardLookingQuestionGenerator | MockTransformConfig | QuestionAndLabelGenerator | QuestionGenerator
+    )
+    config_type: Literal["QUESTION_PIPELINE"] | Unset = "QUESTION_PIPELINE"
+    labeler: MockTransformConfig | None | Unset | WebSearchLabeler = UNSET
+    context_generators: list[MockTransformConfig | NewsContextGenerator] | None | Unset = UNSET
+    renderer: MockTransformConfig | None | QuestionRenderer | Unset = UNSET
+    rollout_generator: MockTransformConfig | None | RolloutGenerator | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.file_set_query_seed_generator import FileSetQuerySeedGenerator
+        from ..models.file_set_seed_generator import FileSetSeedGenerator
+        from ..models.forward_looking_question_generator import ForwardLookingQuestionGenerator
+        from ..models.gdelt_seed_generator import GdeltSeedGenerator
+        from ..models.mock_transform_config import MockTransformConfig
+        from ..models.news_context_generator import NewsContextGenerator
+        from ..models.news_seed_generator import NewsSeedGenerator
+        from ..models.question_and_label_generator import QuestionAndLabelGenerator
+        from ..models.question_generator import QuestionGenerator
+        from ..models.question_renderer import QuestionRenderer
+        from ..models.rollout_generator import RolloutGenerator
+        from ..models.web_search_labeler import WebSearchLabeler
+
+        seed_generator: dict[str, Any]
+        if isinstance(self.seed_generator, NewsSeedGenerator):
+            seed_generator = self.seed_generator.to_dict()
+        elif isinstance(self.seed_generator, GdeltSeedGenerator):
+            seed_generator = self.seed_generator.to_dict()
+        elif isinstance(self.seed_generator, FileSetSeedGenerator):
+            seed_generator = self.seed_generator.to_dict()
+        elif isinstance(self.seed_generator, FileSetQuerySeedGenerator):
+            seed_generator = self.seed_generator.to_dict()
+        else:
+            seed_generator = self.seed_generator.to_dict()
+
+        question_generator: dict[str, Any]
+        if isinstance(self.question_generator, QuestionGenerator):
+            question_generator = self.question_generator.to_dict()
+        elif isinstance(self.question_generator, ForwardLookingQuestionGenerator):
+            question_generator = self.question_generator.to_dict()
+        elif isinstance(self.question_generator, QuestionAndLabelGenerator):
+            question_generator = self.question_generator.to_dict()
+        else:
+            question_generator = self.question_generator.to_dict()
+
+        config_type = self.config_type
+
+        labeler: dict[str, Any] | None | Unset
+        if isinstance(self.labeler, Unset):
+            labeler = UNSET
+        elif isinstance(self.labeler, WebSearchLabeler):
+            labeler = self.labeler.to_dict()
+        elif isinstance(self.labeler, MockTransformConfig):
+            labeler = self.labeler.to_dict()
+        else:
+            labeler = self.labeler
+
+        context_generators: list[dict[str, Any]] | None | Unset
+        if isinstance(self.context_generators, Unset):
+            context_generators = UNSET
+        elif isinstance(self.context_generators, list):
+            context_generators = []
+            for context_generators_type_0_item_data in self.context_generators:
+                context_generators_type_0_item: dict[str, Any]
+                if isinstance(context_generators_type_0_item_data, NewsContextGenerator):
+                    context_generators_type_0_item = context_generators_type_0_item_data.to_dict()
+                else:
+                    context_generators_type_0_item = context_generators_type_0_item_data.to_dict()
+
+                context_generators.append(context_generators_type_0_item)
+
+        else:
+            context_generators = self.context_generators
+
+        renderer: dict[str, Any] | None | Unset
+        if isinstance(self.renderer, Unset):
+            renderer = UNSET
+        elif isinstance(self.renderer, QuestionRenderer):
+            renderer = self.renderer.to_dict()
+        elif isinstance(self.renderer, MockTransformConfig):
+            renderer = self.renderer.to_dict()
+        else:
+            renderer = self.renderer
+
+        rollout_generator: dict[str, Any] | None | Unset
+        if isinstance(self.rollout_generator, Unset):
+            rollout_generator = UNSET
+        elif isinstance(self.rollout_generator, RolloutGenerator):
+            rollout_generator = self.rollout_generator.to_dict()
+        elif isinstance(self.rollout_generator, MockTransformConfig):
+            rollout_generator = self.rollout_generator.to_dict()
+        else:
+            rollout_generator = self.rollout_generator
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "seed_generator": seed_generator,
+                "question_generator": question_generator,
+            }
+        )
+        if config_type is not UNSET:
+            field_dict["config_type"] = config_type
+        if labeler is not UNSET:
+            field_dict["labeler"] = labeler
+        if context_generators is not UNSET:
+            field_dict["context_generators"] = context_generators
+        if renderer is not UNSET:
+            field_dict["renderer"] = renderer
+        if rollout_generator is not UNSET:
+            field_dict["rollout_generator"] = rollout_generator
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.file_set_query_seed_generator import FileSetQuerySeedGenerator
+        from ..models.file_set_seed_generator import FileSetSeedGenerator
+        from ..models.forward_looking_question_generator import ForwardLookingQuestionGenerator
+        from ..models.gdelt_seed_generator import GdeltSeedGenerator
+        from ..models.mock_transform_config import MockTransformConfig
+        from ..models.news_context_generator import NewsContextGenerator
+        from ..models.news_seed_generator import NewsSeedGenerator
+        from ..models.question_and_label_generator import QuestionAndLabelGenerator
+        from ..models.question_generator import QuestionGenerator
+        from ..models.question_renderer import QuestionRenderer
+        from ..models.rollout_generator import RolloutGenerator
+        from ..models.web_search_labeler import WebSearchLabeler
+
+        d = dict(src_dict)
+
+        def _parse_seed_generator(
+            data: object,
+        ) -> (
+            FileSetQuerySeedGenerator
+            | FileSetSeedGenerator
+            | GdeltSeedGenerator
+            | MockTransformConfig
+            | NewsSeedGenerator
+        ):
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                seed_generator_type_0 = NewsSeedGenerator.from_dict(data)
+
+                return seed_generator_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                seed_generator_type_1 = GdeltSeedGenerator.from_dict(data)
+
+                return seed_generator_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                seed_generator_type_2 = FileSetSeedGenerator.from_dict(data)
+
+                return seed_generator_type_2
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                seed_generator_type_3 = FileSetQuerySeedGenerator.from_dict(data)
+
+                return seed_generator_type_3
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            seed_generator_type_4 = MockTransformConfig.from_dict(data)
+
+            return seed_generator_type_4
+
+        seed_generator = _parse_seed_generator(d.pop("seed_generator"))
+
+        def _parse_question_generator(
+            data: object,
+        ) -> ForwardLookingQuestionGenerator | MockTransformConfig | QuestionAndLabelGenerator | QuestionGenerator:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                question_generator_type_0 = QuestionGenerator.from_dict(data)
+
+                return question_generator_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                question_generator_type_1 = ForwardLookingQuestionGenerator.from_dict(data)
+
+                return question_generator_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                question_generator_type_2 = QuestionAndLabelGenerator.from_dict(data)
+
+                return question_generator_type_2
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            question_generator_type_3 = MockTransformConfig.from_dict(data)
+
+            return question_generator_type_3
+
+        question_generator = _parse_question_generator(d.pop("question_generator"))
+
+        config_type = cast(Literal["QUESTION_PIPELINE"] | Unset, d.pop("config_type", UNSET))
+        if config_type != "QUESTION_PIPELINE" and not isinstance(config_type, Unset):
+            raise ValueError(f"config_type must match const 'QUESTION_PIPELINE', got '{config_type}'")
+
+        def _parse_labeler(data: object) -> MockTransformConfig | None | Unset | WebSearchLabeler:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                labeler_type_0_type_0 = WebSearchLabeler.from_dict(data)
+
+                return labeler_type_0_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                labeler_type_0_type_1 = MockTransformConfig.from_dict(data)
+
+                return labeler_type_0_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(MockTransformConfig | None | Unset | WebSearchLabeler, data)
+
+        labeler = _parse_labeler(d.pop("labeler", UNSET))
+
+        def _parse_context_generators(data: object) -> list[MockTransformConfig | NewsContextGenerator] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                context_generators_type_0 = []
+                _context_generators_type_0 = data
+                for context_generators_type_0_item_data in _context_generators_type_0:
+
+                    def _parse_context_generators_type_0_item(
+                        data: object,
+                    ) -> MockTransformConfig | NewsContextGenerator:
+                        try:
+                            if not isinstance(data, dict):
+                                raise TypeError()
+                            context_generators_type_0_item_type_0 = NewsContextGenerator.from_dict(data)
+
+                            return context_generators_type_0_item_type_0
+                        except (TypeError, ValueError, AttributeError, KeyError):
+                            pass
+                        if not isinstance(data, dict):
+                            raise TypeError()
+                        context_generators_type_0_item_type_1 = MockTransformConfig.from_dict(data)
+
+                        return context_generators_type_0_item_type_1
+
+                    context_generators_type_0_item = _parse_context_generators_type_0_item(
+                        context_generators_type_0_item_data
+                    )
+
+                    context_generators_type_0.append(context_generators_type_0_item)
+
+                return context_generators_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[MockTransformConfig | NewsContextGenerator] | None | Unset, data)
+
+        context_generators = _parse_context_generators(d.pop("context_generators", UNSET))
+
+        def _parse_renderer(data: object) -> MockTransformConfig | None | QuestionRenderer | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                renderer_type_0_type_0 = QuestionRenderer.from_dict(data)
+
+                return renderer_type_0_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                renderer_type_0_type_1 = MockTransformConfig.from_dict(data)
+
+                return renderer_type_0_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(MockTransformConfig | None | QuestionRenderer | Unset, data)
+
+        renderer = _parse_renderer(d.pop("renderer", UNSET))
+
+        def _parse_rollout_generator(data: object) -> MockTransformConfig | None | RolloutGenerator | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                rollout_generator_type_0_type_0 = RolloutGenerator.from_dict(data)
+
+                return rollout_generator_type_0_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                rollout_generator_type_0_type_1 = MockTransformConfig.from_dict(data)
+
+                return rollout_generator_type_0_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(MockTransformConfig | None | RolloutGenerator | Unset, data)
+
+        rollout_generator = _parse_rollout_generator(d.pop("rollout_generator", UNSET))
+
+        question_pipeline = cls(
+            seed_generator=seed_generator,
+            question_generator=question_generator,
+            config_type=config_type,
+            labeler=labeler,
+            context_generators=context_generators,
+            renderer=renderer,
+            rollout_generator=rollout_generator,
+        )
+
+        question_pipeline.additional_properties = d
+        return question_pipeline
+
+    @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

lightningrod/_generated/models/question_renderer.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.answer_type import AnswerType
+
+
+T = TypeVar("T", bound="QuestionRenderer")
+
+
+@_attrs_define
+class QuestionRenderer:
+    """
+    Attributes:
+        config_type (Literal['QUESTION_RENDERER'] | Unset): Type of transform configuration Default:
+            'QUESTION_RENDERER'.
+        template (None | str | Unset): Custom template for rendering the prompt. If not provided, dynamically builds
+            based on available content. Supports placeholders like {question_text}, {context}, {answer_instructions}.
+        answer_type (AnswerType | None | Unset): The type of answer expected, used to render answer instructions
+    """
+
+    config_type: Literal["QUESTION_RENDERER"] | Unset = "QUESTION_RENDERER"
+    template: None | str | Unset = UNSET
+    answer_type: AnswerType | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.answer_type import AnswerType
+
+        config_type = self.config_type
+
+        template: None | str | Unset
+        if isinstance(self.template, Unset):
+            template = UNSET
+        else:
+            template = self.template
+
+        answer_type: dict[str, Any] | None | Unset
+        if isinstance(self.answer_type, Unset):
+            answer_type = UNSET
+        elif isinstance(self.answer_type, AnswerType):
+            answer_type = self.answer_type.to_dict()
+        else:
+            answer_type = self.answer_type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if config_type is not UNSET:
+            field_dict["config_type"] = config_type
+        if template is not UNSET:
+            field_dict["template"] = template
+        if answer_type is not UNSET:
+            field_dict["answer_type"] = answer_type
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.answer_type import AnswerType
+
+        d = dict(src_dict)
+        config_type = cast(Literal["QUESTION_RENDERER"] | Unset, d.pop("config_type", UNSET))
+        if config_type != "QUESTION_RENDERER" and not isinstance(config_type, Unset):
+            raise ValueError(f"config_type must match const 'QUESTION_RENDERER', got '{config_type}'")
+
+        def _parse_template(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        template = _parse_template(d.pop("template", UNSET))
+
+        def _parse_answer_type(data: object) -> AnswerType | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                answer_type_type_0 = AnswerType.from_dict(data)
+
+                return answer_type_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(AnswerType | None | Unset, data)
+
+        answer_type = _parse_answer_type(d.pop("answer_type", UNSET))
+
+        question_renderer = cls(
+            config_type=config_type,
+            template=template,
+            answer_type=answer_type,
+        )
+
+        question_renderer.additional_properties = d
+        return question_renderer
+
+    @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

lightningrod/_generated/models/rag_context.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RAGContext")
+
+
+@_attrs_define
+class RAGContext:
+    """
+    Attributes:
+        rendered_context (str):
+        document_id (str):
+        context_type (Literal['RAG_CONTEXT'] | Unset):  Default: 'RAG_CONTEXT'.
+    """
+
+    rendered_context: str
+    document_id: str
+    context_type: Literal["RAG_CONTEXT"] | Unset = "RAG_CONTEXT"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        rendered_context = self.rendered_context
+
+        document_id = self.document_id
+
+        context_type = self.context_type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "rendered_context": rendered_context,
+                "document_id": document_id,
+            }
+        )
+        if context_type is not UNSET:
+            field_dict["context_type"] = context_type
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        rendered_context = d.pop("rendered_context")
+
+        document_id = d.pop("document_id")
+
+        context_type = cast(Literal["RAG_CONTEXT"] | Unset, d.pop("context_type", UNSET))
+        if context_type != "RAG_CONTEXT" and not isinstance(context_type, Unset):
+            raise ValueError(f"context_type must match const 'RAG_CONTEXT', got '{context_type}'")
+
+        rag_context = cls(
+            rendered_context=rendered_context,
+            document_id=document_id,
+            context_type=context_type,
+        )
+
+        rag_context.additional_properties = d
+        return rag_context
+
+    @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

lightningrod/_generated/models/response_message.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ResponseMessage")
+
+
+@_attrs_define
+class ResponseMessage:
+    """
+    Attributes:
+        role (str): The role of the message author
+        content (str): The content of the message
+    """
+
+    role: str
+    content: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        role = self.role
+
+        content = self.content
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+                "content": content,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        role = d.pop("role")
+
+        content = d.pop("content")
+
+        response_message = cls(
+            role=role,
+            content=content,
+        )
+
+        response_message.additional_properties = d
+        return response_message
+
+    @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