lightningrod-ai 0.1.6__py3-none-any.whl

lightningrod/_generated/models/gdelt_seed_generator.py

@@ -0,0 +1,103 @@
+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="GdeltSeedGenerator")
+
+
+@_attrs_define
+class GdeltSeedGenerator:
+    """
+    Attributes:
+        start_date (datetime.datetime): Start date for seed search
+        end_date (datetime.datetime): End date for seed search
+        config_type (Literal['GDELT_SEED_GENERATOR'] | Unset): Type of transform configuration Default:
+            'GDELT_SEED_GENERATOR'.
+        interval_duration_days (int | Unset): Duration of each interval in days Default: 7.
+        articles_per_interval (int | Unset): Number of articles to fetch per interval from BigQuery Default: 1000.
+    """
+
+    start_date: datetime.datetime
+    end_date: datetime.datetime
+    config_type: Literal["GDELT_SEED_GENERATOR"] | Unset = "GDELT_SEED_GENERATOR"
+    interval_duration_days: int | Unset = 7
+    articles_per_interval: int | Unset = 1000
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        start_date = self.start_date.isoformat()
+
+        end_date = self.end_date.isoformat()
+
+        config_type = self.config_type
+
+        interval_duration_days = self.interval_duration_days
+
+        articles_per_interval = self.articles_per_interval
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "start_date": start_date,
+                "end_date": end_date,
+            }
+        )
+        if config_type is not UNSET:
+            field_dict["config_type"] = config_type
+        if interval_duration_days is not UNSET:
+            field_dict["interval_duration_days"] = interval_duration_days
+        if articles_per_interval is not UNSET:
+            field_dict["articles_per_interval"] = articles_per_interval
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        start_date = isoparse(d.pop("start_date"))
+
+        end_date = isoparse(d.pop("end_date"))
+
+        config_type = cast(Literal["GDELT_SEED_GENERATOR"] | Unset, d.pop("config_type", UNSET))
+        if config_type != "GDELT_SEED_GENERATOR" and not isinstance(config_type, Unset):
+            raise ValueError(f"config_type must match const 'GDELT_SEED_GENERATOR', got '{config_type}'")
+
+        interval_duration_days = d.pop("interval_duration_days", UNSET)
+
+        articles_per_interval = d.pop("articles_per_interval", UNSET)
+
+        gdelt_seed_generator = cls(
+            start_date=start_date,
+            end_date=end_date,
+            config_type=config_type,
+            interval_duration_days=interval_duration_days,
+            articles_per_interval=articles_per_interval,
+        )
+
+        gdelt_seed_generator.additional_properties = d
+        return gdelt_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/http_validation_error.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.validation_error import ValidationError
+
+
+T = TypeVar("T", bound="HTTPValidationError")
+
+
+@_attrs_define
+class HTTPValidationError:
+    """
+    Attributes:
+        detail (list[ValidationError] | Unset):
+    """
+
+    detail: list[ValidationError] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        detail: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.detail, Unset):
+            detail = []
+            for detail_item_data in self.detail:
+                detail_item = detail_item_data.to_dict()
+                detail.append(detail_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.validation_error import ValidationError
+
+        d = dict(src_dict)
+        _detail = d.pop("detail", UNSET)
+        detail: list[ValidationError] | Unset = UNSET
+        if _detail is not UNSET:
+            detail = []
+            for detail_item_data in _detail:
+                detail_item = ValidationError.from_dict(detail_item_data)
+
+                detail.append(detail_item)
+
+        http_validation_error = cls(
+            detail=detail,
+        )
+
+        http_validation_error.additional_properties = d
+        return http_validation_error
+
+    @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/job_usage.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, 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.job_usage_by_step_type_0 import JobUsageByStepType0
+    from ..models.usage_summary import UsageSummary
+
+
+T = TypeVar("T", bound="JobUsage")
+
+
+@_attrs_define
+class JobUsage:
+    """Aggregated usage statistics for a transform job with step breakdown.
+
+    Attributes:
+        total (None | Unset | UsageSummary):
+        by_step (JobUsageByStepType0 | None | Unset):
+        max_cost_dollars (float | None | Unset):
+        current_cost_dollars (float | None | Unset):
+        estimated_cost_dollars (float | None | Unset):
+    """
+
+    total: None | Unset | UsageSummary = UNSET
+    by_step: JobUsageByStepType0 | None | Unset = UNSET
+    max_cost_dollars: float | None | Unset = UNSET
+    current_cost_dollars: float | None | Unset = UNSET
+    estimated_cost_dollars: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.job_usage_by_step_type_0 import JobUsageByStepType0
+        from ..models.usage_summary import UsageSummary
+
+        total: dict[str, Any] | None | Unset
+        if isinstance(self.total, Unset):
+            total = UNSET
+        elif isinstance(self.total, UsageSummary):
+            total = self.total.to_dict()
+        else:
+            total = self.total
+
+        by_step: dict[str, Any] | None | Unset
+        if isinstance(self.by_step, Unset):
+            by_step = UNSET
+        elif isinstance(self.by_step, JobUsageByStepType0):
+            by_step = self.by_step.to_dict()
+        else:
+            by_step = self.by_step
+
+        max_cost_dollars: float | None | Unset
+        if isinstance(self.max_cost_dollars, Unset):
+            max_cost_dollars = UNSET
+        else:
+            max_cost_dollars = self.max_cost_dollars
+
+        current_cost_dollars: float | None | Unset
+        if isinstance(self.current_cost_dollars, Unset):
+            current_cost_dollars = UNSET
+        else:
+            current_cost_dollars = self.current_cost_dollars
+
+        estimated_cost_dollars: float | None | Unset
+        if isinstance(self.estimated_cost_dollars, Unset):
+            estimated_cost_dollars = UNSET
+        else:
+            estimated_cost_dollars = self.estimated_cost_dollars
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if total is not UNSET:
+            field_dict["total"] = total
+        if by_step is not UNSET:
+            field_dict["by_step"] = by_step
+        if max_cost_dollars is not UNSET:
+            field_dict["max_cost_dollars"] = max_cost_dollars
+        if current_cost_dollars is not UNSET:
+            field_dict["current_cost_dollars"] = current_cost_dollars
+        if estimated_cost_dollars is not UNSET:
+            field_dict["estimated_cost_dollars"] = estimated_cost_dollars
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.job_usage_by_step_type_0 import JobUsageByStepType0
+        from ..models.usage_summary import UsageSummary
+
+        d = dict(src_dict)
+
+        def _parse_total(data: object) -> None | Unset | UsageSummary:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                total_type_0 = UsageSummary.from_dict(data)
+
+                return total_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UsageSummary, data)
+
+        total = _parse_total(d.pop("total", UNSET))
+
+        def _parse_by_step(data: object) -> JobUsageByStepType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                by_step_type_0 = JobUsageByStepType0.from_dict(data)
+
+                return by_step_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(JobUsageByStepType0 | None | Unset, data)
+
+        by_step = _parse_by_step(d.pop("by_step", UNSET))
+
+        def _parse_max_cost_dollars(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        max_cost_dollars = _parse_max_cost_dollars(d.pop("max_cost_dollars", UNSET))
+
+        def _parse_current_cost_dollars(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        current_cost_dollars = _parse_current_cost_dollars(d.pop("current_cost_dollars", UNSET))
+
+        def _parse_estimated_cost_dollars(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        estimated_cost_dollars = _parse_estimated_cost_dollars(d.pop("estimated_cost_dollars", UNSET))
+
+        job_usage = cls(
+            total=total,
+            by_step=by_step,
+            max_cost_dollars=max_cost_dollars,
+            current_cost_dollars=current_cost_dollars,
+            estimated_cost_dollars=estimated_cost_dollars,
+        )
+
+        job_usage.additional_properties = d
+        return job_usage
+
+    @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/job_usage_by_step_type_0.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.usage_summary import UsageSummary
+
+
+T = TypeVar("T", bound="JobUsageByStepType0")
+
+
+@_attrs_define
+class JobUsageByStepType0:
+    """ """
+
+    additional_properties: dict[str, UsageSummary] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.usage_summary import UsageSummary
+
+        d = dict(src_dict)
+        job_usage_by_step_type_0 = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = UsageSummary.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        job_usage_by_step_type_0.additional_properties = additional_properties
+        return job_usage_by_step_type_0
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> UsageSummary:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: UsageSummary) -> 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/label.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, 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="Label")
+
+
+@_attrs_define
+class Label:
+    """
+    Attributes:
+        label (str):
+        label_confidence (float):
+        resolution_date (datetime.datetime | None | Unset):
+        reasoning (None | str | Unset):
+        answer_sources (None | str | Unset):
+    """
+
+    label: str
+    label_confidence: float
+    resolution_date: datetime.datetime | None | Unset = UNSET
+    reasoning: None | str | Unset = UNSET
+    answer_sources: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        label = self.label
+
+        label_confidence = self.label_confidence
+
+        resolution_date: None | str | Unset
+        if isinstance(self.resolution_date, Unset):
+            resolution_date = UNSET
+        elif isinstance(self.resolution_date, datetime.datetime):
+            resolution_date = self.resolution_date.isoformat()
+        else:
+            resolution_date = self.resolution_date
+
+        reasoning: None | str | Unset
+        if isinstance(self.reasoning, Unset):
+            reasoning = UNSET
+        else:
+            reasoning = self.reasoning
+
+        answer_sources: None | str | Unset
+        if isinstance(self.answer_sources, Unset):
+            answer_sources = UNSET
+        else:
+            answer_sources = self.answer_sources
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "label": label,
+                "label_confidence": label_confidence,
+            }
+        )
+        if resolution_date is not UNSET:
+            field_dict["resolution_date"] = resolution_date
+        if reasoning is not UNSET:
+            field_dict["reasoning"] = reasoning
+        if answer_sources is not UNSET:
+            field_dict["answer_sources"] = answer_sources
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        label = d.pop("label")
+
+        label_confidence = d.pop("label_confidence")
+
+        def _parse_resolution_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()
+                resolution_date_type_0 = isoparse(data)
+
+                return resolution_date_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        resolution_date = _parse_resolution_date(d.pop("resolution_date", UNSET))
+
+        def _parse_reasoning(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        reasoning = _parse_reasoning(d.pop("reasoning", UNSET))
+
+        def _parse_answer_sources(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        answer_sources = _parse_answer_sources(d.pop("answer_sources", UNSET))
+
+        label = cls(
+            label=label,
+            label_confidence=label_confidence,
+            resolution_date=resolution_date,
+            reasoning=reasoning,
+            answer_sources=answer_sources,
+        )
+
+        label.additional_properties = d
+        return label
+
+    @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/list_file_set_files_response.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, 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_file import FileSetFile
+
+
+T = TypeVar("T", bound="ListFileSetFilesResponse")
+
+
+@_attrs_define
+class ListFileSetFilesResponse:
+    """
+    Attributes:
+        files (list[FileSetFile]):
+        has_more (bool):
+        total (int):
+        next_cursor (None | str | Unset):
+    """
+
+    files: list[FileSetFile]
+    has_more: bool
+    total: int
+    next_cursor: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        files = []
+        for files_item_data in self.files:
+            files_item = files_item_data.to_dict()
+            files.append(files_item)
+
+        has_more = self.has_more
+
+        total = self.total
+
+        next_cursor: None | str | Unset
+        if isinstance(self.next_cursor, Unset):
+            next_cursor = UNSET
+        else:
+            next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "files": files,
+                "has_more": has_more,
+                "total": total,
+            }
+        )
+        if next_cursor is not UNSET:
+            field_dict["next_cursor"] = next_cursor
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.file_set_file import FileSetFile
+
+        d = dict(src_dict)
+        files = []
+        _files = d.pop("files")
+        for files_item_data in _files:
+            files_item = FileSetFile.from_dict(files_item_data)
+
+            files.append(files_item)
+
+        has_more = d.pop("has_more")
+
+        total = d.pop("total")
+
+        def _parse_next_cursor(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor", UNSET))
+
+        list_file_set_files_response = cls(
+            files=files,
+            has_more=has_more,
+            total=total,
+            next_cursor=next_cursor,
+        )
+
+        list_file_set_files_response.additional_properties = d
+        return list_file_set_files_response
+
+    @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