lightningrod-ai 0.1.6__py3-none-any.whl

lightningrod/_generated/models/file_set_query_seed_generator.py

@@ -0,0 +1,136 @@
+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="FileSetQuerySeedGenerator")
+
+
+@_attrs_define
+class FileSetQuerySeedGenerator:
+    """Configuration for FileSet Query Seed Generator transform.
+
+    Attributes:
+        file_set_id (str): FileSet ID to query
+        prompts (list[str]): List of queries to run against the fileset
+        config_type (Literal['FILESET_QUERY_SEED_GENERATOR'] | Unset): Type of transform configuration Default:
+            'FILESET_QUERY_SEED_GENERATOR'.
+        metadata_filters (list[str] | None | Unset): Optional list of AIP-160 metadata filters to select which documents
+            to process. Documents matching ANY filter will be included. (e.g., ["ticker='AAL'", "ticker='MSFT'"])
+        system_instruction (None | str | Unset): Optional system instruction for the Gemini model
+    """
+
+    file_set_id: str
+    prompts: list[str]
+    config_type: Literal["FILESET_QUERY_SEED_GENERATOR"] | Unset = "FILESET_QUERY_SEED_GENERATOR"
+    metadata_filters: list[str] | None | Unset = UNSET
+    system_instruction: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        file_set_id = self.file_set_id
+
+        prompts = self.prompts
+
+        config_type = self.config_type
+
+        metadata_filters: list[str] | None | Unset
+        if isinstance(self.metadata_filters, Unset):
+            metadata_filters = UNSET
+        elif isinstance(self.metadata_filters, list):
+            metadata_filters = self.metadata_filters
+
+        else:
+            metadata_filters = self.metadata_filters
+
+        system_instruction: None | str | Unset
+        if isinstance(self.system_instruction, Unset):
+            system_instruction = UNSET
+        else:
+            system_instruction = self.system_instruction
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "file_set_id": file_set_id,
+                "prompts": prompts,
+            }
+        )
+        if config_type is not UNSET:
+            field_dict["config_type"] = config_type
+        if metadata_filters is not UNSET:
+            field_dict["metadata_filters"] = metadata_filters
+        if system_instruction is not UNSET:
+            field_dict["system_instruction"] = system_instruction
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        file_set_id = d.pop("file_set_id")
+
+        prompts = cast(list[str], d.pop("prompts"))
+
+        config_type = cast(Literal["FILESET_QUERY_SEED_GENERATOR"] | Unset, d.pop("config_type", UNSET))
+        if config_type != "FILESET_QUERY_SEED_GENERATOR" and not isinstance(config_type, Unset):
+            raise ValueError(f"config_type must match const 'FILESET_QUERY_SEED_GENERATOR', got '{config_type}'")
+
+        def _parse_metadata_filters(data: object) -> list[str] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                metadata_filters_type_0 = cast(list[str], data)
+
+                return metadata_filters_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[str] | None | Unset, data)
+
+        metadata_filters = _parse_metadata_filters(d.pop("metadata_filters", UNSET))
+
+        def _parse_system_instruction(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        system_instruction = _parse_system_instruction(d.pop("system_instruction", UNSET))
+
+        file_set_query_seed_generator = cls(
+            file_set_id=file_set_id,
+            prompts=prompts,
+            config_type=config_type,
+            metadata_filters=metadata_filters,
+            system_instruction=system_instruction,
+        )
+
+        file_set_query_seed_generator.additional_properties = d
+        return file_set_query_seed_generator
+
+    @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/file_set_seed_generator.py

@@ -0,0 +1,126 @@
+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="FileSetSeedGenerator")
+
+
+@_attrs_define
+class FileSetSeedGenerator:
+    """Configuration for FileSet Seed Generator transform.
+
+    Attributes:
+        file_set_id (str): FileSet ID to read files from
+        config_type (Literal['FILESET_SEED_GENERATOR'] | Unset): Type of transform configuration Default:
+            'FILESET_SEED_GENERATOR'.
+        chunk_size (int | Unset): Number of characters per chunk Default: 4000.
+        chunk_overlap (int | Unset): Number of overlapping characters between consecutive chunks Default: 200.
+        metadata_filters (list[str] | None | Unset): Optional list of metadata filters to select which files to process.
+            Files matching ANY filter will be included. (e.g., ["ticker='AAL'", "ticker='MSFT'"])
+    """
+
+    file_set_id: str
+    config_type: Literal["FILESET_SEED_GENERATOR"] | Unset = "FILESET_SEED_GENERATOR"
+    chunk_size: int | Unset = 4000
+    chunk_overlap: int | Unset = 200
+    metadata_filters: list[str] | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        file_set_id = self.file_set_id
+
+        config_type = self.config_type
+
+        chunk_size = self.chunk_size
+
+        chunk_overlap = self.chunk_overlap
+
+        metadata_filters: list[str] | None | Unset
+        if isinstance(self.metadata_filters, Unset):
+            metadata_filters = UNSET
+        elif isinstance(self.metadata_filters, list):
+            metadata_filters = self.metadata_filters
+
+        else:
+            metadata_filters = self.metadata_filters
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "file_set_id": file_set_id,
+            }
+        )
+        if config_type is not UNSET:
+            field_dict["config_type"] = config_type
+        if chunk_size is not UNSET:
+            field_dict["chunk_size"] = chunk_size
+        if chunk_overlap is not UNSET:
+            field_dict["chunk_overlap"] = chunk_overlap
+        if metadata_filters is not UNSET:
+            field_dict["metadata_filters"] = metadata_filters
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        file_set_id = d.pop("file_set_id")
+
+        config_type = cast(Literal["FILESET_SEED_GENERATOR"] | Unset, d.pop("config_type", UNSET))
+        if config_type != "FILESET_SEED_GENERATOR" and not isinstance(config_type, Unset):
+            raise ValueError(f"config_type must match const 'FILESET_SEED_GENERATOR', got '{config_type}'")
+
+        chunk_size = d.pop("chunk_size", UNSET)
+
+        chunk_overlap = d.pop("chunk_overlap", UNSET)
+
+        def _parse_metadata_filters(data: object) -> list[str] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                metadata_filters_type_0 = cast(list[str], data)
+
+                return metadata_filters_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[str] | None | Unset, data)
+
+        metadata_filters = _parse_metadata_filters(d.pop("metadata_filters", UNSET))
+
+        file_set_seed_generator = cls(
+            file_set_id=file_set_id,
+            config_type=config_type,
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            metadata_filters=metadata_filters,
+        )
+
+        file_set_seed_generator.additional_properties = d
+        return file_set_seed_generator
+
+    @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/filter_criteria.py

@@ -0,0 +1,83 @@
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="FilterCriteria")
+
+
+@_attrs_define
+class FilterCriteria:
+    """Reusable filter criteria for LLM-based content scoring and filtering.
+
+    Attributes:
+        rubric (str): Scoring rubric/prompt for evaluating content
+        min_score (float | Unset): Minimum score threshold Default: 0.5.
+        model_name (str | Unset): Name of the model (in openrouter) to use for scoring Default: 'google/gemini-3-flash-
+            preview'.
+    """
+
+    rubric: str
+    min_score: float | Unset = 0.5
+    model_name: str | Unset = "google/gemini-3-flash-preview"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        rubric = self.rubric
+
+        min_score = self.min_score
+
+        model_name = self.model_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "rubric": rubric,
+            }
+        )
+        if min_score is not UNSET:
+            field_dict["min_score"] = min_score
+        if model_name is not UNSET:
+            field_dict["model_name"] = model_name
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        rubric = d.pop("rubric")
+
+        min_score = d.pop("min_score", UNSET)
+
+        model_name = d.pop("model_name", UNSET)
+
+        filter_criteria = cls(
+            rubric=rubric,
+            min_score=min_score,
+            model_name=model_name,
+        )
+
+        filter_criteria.additional_properties = d
+        return filter_criteria
+
+    @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/forward_looking_question.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ForwardLookingQuestion")
+
+
+@_attrs_define
+class ForwardLookingQuestion:
+    """
+    Attributes:
+        question_text (str):
+        date_close (datetime.datetime):
+        event_date (datetime.datetime):
+        resolution_criteria (str):
+        question_type (Literal['FORWARD_LOOKING_QUESTION'] | Unset):  Default: 'FORWARD_LOOKING_QUESTION'.
+        prediction_date (datetime.datetime | None | Unset):
+    """
+
+    question_text: str
+    date_close: datetime.datetime
+    event_date: datetime.datetime
+    resolution_criteria: str
+    question_type: Literal["FORWARD_LOOKING_QUESTION"] | Unset = "FORWARD_LOOKING_QUESTION"
+    prediction_date: datetime.datetime | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        question_text = self.question_text
+
+        date_close = self.date_close.isoformat()
+
+        event_date = self.event_date.isoformat()
+
+        resolution_criteria = self.resolution_criteria
+
+        question_type = self.question_type
+
+        prediction_date: None | str | Unset
+        if isinstance(self.prediction_date, Unset):
+            prediction_date = UNSET
+        elif isinstance(self.prediction_date, datetime.datetime):
+            prediction_date = self.prediction_date.isoformat()
+        else:
+            prediction_date = self.prediction_date
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "question_text": question_text,
+                "date_close": date_close,
+                "event_date": event_date,
+                "resolution_criteria": resolution_criteria,
+            }
+        )
+        if question_type is not UNSET:
+            field_dict["question_type"] = question_type
+        if prediction_date is not UNSET:
+            field_dict["prediction_date"] = prediction_date
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        question_text = d.pop("question_text")
+
+        date_close = isoparse(d.pop("date_close"))
+
+        event_date = isoparse(d.pop("event_date"))
+
+        resolution_criteria = d.pop("resolution_criteria")
+
+        question_type = cast(Literal["FORWARD_LOOKING_QUESTION"] | Unset, d.pop("question_type", UNSET))
+        if question_type != "FORWARD_LOOKING_QUESTION" and not isinstance(question_type, Unset):
+            raise ValueError(f"question_type must match const 'FORWARD_LOOKING_QUESTION', got '{question_type}'")
+
+        def _parse_prediction_date(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                prediction_date_type_0 = isoparse(data)
+
+                return prediction_date_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        prediction_date = _parse_prediction_date(d.pop("prediction_date", UNSET))
+
+        forward_looking_question = cls(
+            question_text=question_text,
+            date_close=date_close,
+            event_date=event_date,
+            resolution_criteria=resolution_criteria,
+            question_type=question_type,
+            prediction_date=prediction_date,
+        )
+
+        forward_looking_question.additional_properties = d
+        return forward_looking_question
+
+    @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/forward_looking_question_generator.py

@@ -0,0 +1,217 @@
+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
+    from ..models.filter_criteria import FilterCriteria
+
+
+T = TypeVar("T", bound="ForwardLookingQuestionGenerator")
+
+
+@_attrs_define
+class ForwardLookingQuestionGenerator:
+    """
+    Attributes:
+        config_type (Literal['FORWARD_LOOKING_QUESTION_GENERATOR'] | Unset): Type of transform configuration Default:
+            'FORWARD_LOOKING_QUESTION_GENERATOR'.
+        instructions (None | str | Unset): Instructions for question generation. If not provided, uses sensible
+            defaults.
+        examples (list[str] | Unset): Example questions to guide generation
+        bad_examples (list[str] | Unset): Examples of questions to avoid
+        filter_ (FilterCriteria | list[FilterCriteria] | None | Unset): Optional filter criteria to apply after question
+            generation
+        questions_per_seed (int | Unset): Number of questions to generate per seed Default: 1.
+        include_default_filter (bool | Unset): Whether to include the default filter for generated questions Default:
+            False.
+        answer_type (AnswerType | None | Unset): The type of answer expected for generated questions
+    """
+
+    config_type: Literal["FORWARD_LOOKING_QUESTION_GENERATOR"] | Unset = "FORWARD_LOOKING_QUESTION_GENERATOR"
+    instructions: None | str | Unset = UNSET
+    examples: list[str] | Unset = UNSET
+    bad_examples: list[str] | Unset = UNSET
+    filter_: FilterCriteria | list[FilterCriteria] | None | Unset = UNSET
+    questions_per_seed: int | Unset = 1
+    include_default_filter: bool | Unset = False
+    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
+        from ..models.filter_criteria import FilterCriteria
+
+        config_type = self.config_type
+
+        instructions: None | str | Unset
+        if isinstance(self.instructions, Unset):
+            instructions = UNSET
+        else:
+            instructions = self.instructions
+
+        examples: list[str] | Unset = UNSET
+        if not isinstance(self.examples, Unset):
+            examples = self.examples
+
+        bad_examples: list[str] | Unset = UNSET
+        if not isinstance(self.bad_examples, Unset):
+            bad_examples = self.bad_examples
+
+        filter_: dict[str, Any] | list[dict[str, Any]] | None | Unset
+        if isinstance(self.filter_, Unset):
+            filter_ = UNSET
+        elif isinstance(self.filter_, FilterCriteria):
+            filter_ = self.filter_.to_dict()
+        elif isinstance(self.filter_, list):
+            filter_ = []
+            for filter_type_1_item_data in self.filter_:
+                filter_type_1_item = filter_type_1_item_data.to_dict()
+                filter_.append(filter_type_1_item)
+
+        else:
+            filter_ = self.filter_
+
+        questions_per_seed = self.questions_per_seed
+
+        include_default_filter = self.include_default_filter
+
+        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 instructions is not UNSET:
+            field_dict["instructions"] = instructions
+        if examples is not UNSET:
+            field_dict["examples"] = examples
+        if bad_examples is not UNSET:
+            field_dict["bad_examples"] = bad_examples
+        if filter_ is not UNSET:
+            field_dict["filter"] = filter_
+        if questions_per_seed is not UNSET:
+            field_dict["questions_per_seed"] = questions_per_seed
+        if include_default_filter is not UNSET:
+            field_dict["include_default_filter"] = include_default_filter
+        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
+        from ..models.filter_criteria import FilterCriteria
+
+        d = dict(src_dict)
+        config_type = cast(Literal["FORWARD_LOOKING_QUESTION_GENERATOR"] | Unset, d.pop("config_type", UNSET))
+        if config_type != "FORWARD_LOOKING_QUESTION_GENERATOR" and not isinstance(config_type, Unset):
+            raise ValueError(f"config_type must match const 'FORWARD_LOOKING_QUESTION_GENERATOR', got '{config_type}'")
+
+        def _parse_instructions(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        instructions = _parse_instructions(d.pop("instructions", UNSET))
+
+        examples = cast(list[str], d.pop("examples", UNSET))
+
+        bad_examples = cast(list[str], d.pop("bad_examples", UNSET))
+
+        def _parse_filter_(data: object) -> FilterCriteria | list[FilterCriteria] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                filter_type_0 = FilterCriteria.from_dict(data)
+
+                return filter_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                filter_type_1 = []
+                _filter_type_1 = data
+                for filter_type_1_item_data in _filter_type_1:
+                    filter_type_1_item = FilterCriteria.from_dict(filter_type_1_item_data)
+
+                    filter_type_1.append(filter_type_1_item)
+
+                return filter_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(FilterCriteria | list[FilterCriteria] | None | Unset, data)
+
+        filter_ = _parse_filter_(d.pop("filter", UNSET))
+
+        questions_per_seed = d.pop("questions_per_seed", UNSET)
+
+        include_default_filter = d.pop("include_default_filter", 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))
+
+        forward_looking_question_generator = cls(
+            config_type=config_type,
+            instructions=instructions,
+            examples=examples,
+            bad_examples=bad_examples,
+            filter_=filter_,
+            questions_per_seed=questions_per_seed,
+            include_default_filter=include_default_filter,
+            answer_type=answer_type,
+        )
+
+        forward_looking_question_generator.additional_properties = d
+        return forward_looking_question_generator
+
+    @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