notionary 0.2.27__py3-none-any.whl → 0.2.28__py3-none-any.whl

notionary/data_source/query/schema.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Any, Self
+
+from pydantic import BaseModel, ValidationInfo, field_validator, model_serializer, model_validator
+
+from notionary.shared.properties.type import PropertyType
+
+
+class FieldType(StrEnum):
+    STRING = "string"
+    NUMBER = "number"
+    BOOLEAN = "boolean"
+    DATE = "date"
+    DATETIME = "datetime"
+    ARRAY = "array"
+    RELATION = "relation"
+    PEOPLE = "people"
+
+
+class StringOperator(StrEnum):
+    EQUALS = "equals"
+    DOES_NOT_EQUAL = "does_not_equal"
+    CONTAINS = "contains"
+    DOES_NOT_CONTAIN = "does_not_contain"
+    STARTS_WITH = "starts_with"
+    ENDS_WITH = "ends_with"
+    IS_EMPTY = "is_empty"
+    IS_NOT_EMPTY = "is_not_empty"
+
+
+class NumberOperator(StrEnum):
+    EQUALS = "equals"
+    DOES_NOT_EQUAL = "does_not_equal"
+    GREATER_THAN = "greater_than"
+    GREATER_THAN_OR_EQUAL_TO = "greater_than_or_equal_to"
+    LESS_THAN = "less_than"
+    LESS_THAN_OR_EQUAL_TO = "less_than_or_equal_to"
+    IS_EMPTY = "is_empty"
+    IS_NOT_EMPTY = "is_not_empty"
+
+
+class BooleanOperator(StrEnum):
+    IS_TRUE = "is_true"
+    IS_FALSE = "is_false"
+
+
+class StatusOperator(StrEnum):
+    EQUALS = "equals"
+    DOES_NOT_EQUAL = "does_not_equal"
+    IS_EMPTY = "is_empty"
+    IS_NOT_EMPTY = "is_not_empty"
+
+
+class DateOperator(StrEnum):
+    EQUALS = "equals"
+    BEFORE = "before"
+    AFTER = "after"
+    ON_OR_BEFORE = "on_or_before"
+    ON_OR_AFTER = "on_or_after"
+    IS_EMPTY = "is_empty"
+    IS_NOT_EMPTY = "is_not_empty"
+
+
+class ArrayOperator(StrEnum):
+    CONTAINS = "contains"
+    DOES_NOT_CONTAIN = "does_not_contain"
+    IS_EMPTY = "is_empty"
+    IS_NOT_EMPTY = "is_not_empty"
+
+
+RelationOperator = ArrayOperator
+PeopleOperator = ArrayOperator
+
+
+class LogicalOperator(StrEnum):
+    AND = "and"
+    OR = "or"
+
+
+class SortDirection(StrEnum):
+    ASCENDING = "ascending"
+    DESCENDING = "descending"
+
+
+class TimestampType(StrEnum):
+    CREATED_TIME = "created_time"
+    LAST_EDITED_TIME = "last_edited_time"
+
+
+class TimeUnit(StrEnum):
+    DAYS = "days"
+    WEEKS = "weeks"
+    MONTHS = "months"
+    YEARS = "years"
+
+
+type Operator = StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator
+type FilterValue = str | int | float | bool | list[str | int | float]
+
+
+class FilterCondition(BaseModel):
+    field: str
+    field_type: FieldType
+    operator: Operator
+    value: FilterValue | None = None
+    time_value: int | None = None
+    time_unit: TimeUnit | None = None
+
+    @model_validator(mode="after")
+    def validate_operator_and_value(self) -> Self:
+        self._validate_no_value_operators()
+        self._validate_value_required_operators()
+        self._validate_value_type_matches_field_type()
+        return self
+
+    def _validate_no_value_operators(self) -> None:
+        no_value_ops = {
+            StringOperator.IS_EMPTY,
+            StringOperator.IS_NOT_EMPTY,
+            NumberOperator.IS_EMPTY,
+            NumberOperator.IS_NOT_EMPTY,
+            BooleanOperator.IS_TRUE,
+            BooleanOperator.IS_FALSE,
+            DateOperator.IS_EMPTY,
+            DateOperator.IS_NOT_EMPTY,
+            ArrayOperator.IS_EMPTY,
+            ArrayOperator.IS_NOT_EMPTY,
+        }
+        if self.operator in no_value_ops and self.value is not None:
+            raise ValueError(f"Operator '{self.operator}' does not expect a value")
+
+    def _validate_value_required_operators(self) -> None:
+        operators_to_skip = {
+            StringOperator.IS_EMPTY,
+            StringOperator.IS_NOT_EMPTY,
+            NumberOperator.IS_EMPTY,
+            NumberOperator.IS_NOT_EMPTY,
+            BooleanOperator.IS_TRUE,
+            BooleanOperator.IS_FALSE,
+            DateOperator.IS_EMPTY,
+            DateOperator.IS_NOT_EMPTY,
+            ArrayOperator.IS_EMPTY,
+            ArrayOperator.IS_NOT_EMPTY,
+        }
+
+        is_skipped_operator = self.operator in operators_to_skip
+        if not is_skipped_operator and self.value is None:
+            raise ValueError(f"Operator '{self.operator}' requires a value")
+
+    def _validate_value_type_matches_field_type(self) -> None:
+        if self.value is None:
+            return
+
+        if self.field_type == FieldType.STRING:
+            self._ensure_value_is_string()
+        elif self.field_type == FieldType.NUMBER:
+            self._ensure_value_is_number()
+        elif self.field_type == FieldType.BOOLEAN:
+            self._ensure_value_is_boolean()
+        elif self.field_type in (FieldType.DATE, FieldType.DATETIME) or self.field_type in (
+            FieldType.ARRAY,
+            FieldType.RELATION,
+            FieldType.PEOPLE,
+        ):
+            self._ensure_value_is_string()
+
+    def _ensure_value_is_string(self) -> None:
+        if not isinstance(self.value, str):
+            raise ValueError(
+                f"Value for field type '{self.field_type}' must be a string, got {type(self.value).__name__}"
+            )
+
+    def _ensure_value_is_number(self) -> None:
+        if not isinstance(self.value, (int, float)):
+            raise ValueError(
+                f"Value for field type '{self.field_type}' must be a number (int or float), "
+                f"got {type(self.value).__name__}"
+            )
+
+    def _ensure_value_is_boolean(self) -> None:
+        if not isinstance(self.value, bool):
+            raise ValueError(
+                f"Value for field type '{self.field_type}' must be a boolean, got {type(self.value).__name__}"
+            )
+
+    @field_validator("operator")
+    @classmethod
+    def validate_operator_for_field_type(
+        cls,
+        value: Operator,
+        info: ValidationInfo,
+    ) -> Operator:
+        if "field_type" not in info.data:
+            return value
+
+        field_type: FieldType = info.data["field_type"]
+        operator_value = value if isinstance(value, str) else value.value
+
+        if not cls._is_operator_valid_for_field_type(operator_value, field_type):
+            raise ValueError(f"Operator '{operator_value}' is not valid for field type '{field_type}'")
+
+        return value
+
+    @staticmethod
+    def _is_operator_valid_for_field_type(operator: str, field_type: FieldType) -> bool:
+        valid_operators: dict[FieldType, list[str]] = {
+            FieldType.STRING: [op.value for op in StringOperator],
+            FieldType.NUMBER: [op.value for op in NumberOperator],
+            FieldType.BOOLEAN: [op.value for op in BooleanOperator],
+            FieldType.DATE: [op.value for op in DateOperator],
+            FieldType.DATETIME: [op.value for op in DateOperator],
+            FieldType.ARRAY: [op.value for op in ArrayOperator],
+            FieldType.RELATION: [op.value for op in ArrayOperator],
+            FieldType.PEOPLE: [op.value for op in ArrayOperator],
+        }
+
+        return operator in valid_operators.get(field_type, [])
+
+
+class OrGroupMarker(BaseModel):
+    conditions: list[FilterCondition]
+
+
+type InternalFilterCondition = FilterCondition | OrGroupMarker
+
+
+class PropertyFilter(BaseModel):
+    property: str
+    property_type: PropertyType
+    operator: Operator
+    value: FilterValue | None = None
+
+    @model_validator(mode="after")
+    def validate_value_type(self) -> Self:
+        if self.value is None:
+            return self
+
+        if self.property_type in (PropertyType.PEOPLE, PropertyType.RELATION) and not isinstance(self.value, str):
+            raise ValueError(
+                f"Value for property type '{self.property_type.value}' must be a string, "
+                f"got {type(self.value).__name__}"
+            )
+
+        return self
+
+    @model_serializer
+    def serialize_model(self) -> dict[str, Any]:
+        property_type_str = self.property_type.value
+        operator_str = self.operator.value
+        filter_value = self.value
+
+        if isinstance(self.operator, BooleanOperator):
+            operator_str = "equals"
+            filter_value = self.operator == BooleanOperator.IS_TRUE
+
+        return {
+            "property": self.property,
+            property_type_str: {operator_str: filter_value if filter_value is not None else True},
+        }
+
+
+class CompoundFilter(BaseModel):
+    operator: LogicalOperator
+    filters: list[PropertyFilter | CompoundFilter]
+
+    @model_serializer
+    def serialize_model(self) -> dict[str, Any]:
+        operator_str = self.operator.value
+        return {operator_str: [f.model_dump() for f in self.filters]}
+
+
+type NotionFilter = PropertyFilter | CompoundFilter
+
+
+class PropertySort(BaseModel):
+    property: str
+    direction: SortDirection
+
+
+class TimestampSort(BaseModel):
+    timestamp: TimestampType
+    direction: SortDirection
+
+
+type NotionSort = PropertySort | TimestampSort
+
+
+class DataSourceQueryParams(BaseModel):
+    filter: NotionFilter | None = None
+    sorts: list[NotionSort] | None = None
+
+    @model_serializer
+    def serialize_model(self) -> dict[str, Any]:
+        result: dict[str, Any] = {}
+
+        if self.filter is not None:
+            result["filter"] = self.filter.model_dump()
+
+        if self.sorts is not None and len(self.sorts) > 0:
+            result["sorts"] = [sort.model_dump() for sort in self.sorts]
+
+        return result

notionary/data_source/query/validator.py

@@ -0,0 +1,73 @@
+from typing import ClassVar
+
+from notionary.data_source.properties.models import DataSourceProperty
+from notionary.data_source.query.schema import (
+    ArrayOperator,
+    BooleanOperator,
+    DateOperator,
+    NumberOperator,
+    Operator,
+    StatusOperator,
+    StringOperator,
+)
+from notionary.exceptions.data_source.builder import InvalidOperatorForPropertyType
+from notionary.shared.properties.type import PropertyType
+
+
+class OperatorValidator:
+    _PROPERTY_TYPE_OPERATORS: ClassVar[dict[PropertyType, list[type[Operator]]]] = {
+        PropertyType.TITLE: [StringOperator],
+        PropertyType.RICH_TEXT: [StringOperator],
+        PropertyType.NUMBER: [NumberOperator],
+        PropertyType.SELECT: [StringOperator],
+        PropertyType.MULTI_SELECT: [ArrayOperator],
+        PropertyType.STATUS: [StatusOperator],
+        PropertyType.DATE: [DateOperator],
+        PropertyType.PEOPLE: [ArrayOperator],
+        PropertyType.CHECKBOX: [BooleanOperator],
+        PropertyType.URL: [StringOperator],
+        PropertyType.EMAIL: [StringOperator],
+        PropertyType.PHONE_NUMBER: [StringOperator],
+        PropertyType.CREATED_TIME: [DateOperator],
+        PropertyType.CREATED_BY: [ArrayOperator],
+        PropertyType.LAST_EDITED_TIME: [DateOperator],
+        PropertyType.LAST_EDITED_BY: [ArrayOperator],
+        PropertyType.RELATION: [ArrayOperator],
+    }
+
+    def validate_operator_for_property(
+        self, property_name: str, property_obj: DataSourceProperty, operator: Operator
+    ) -> None:
+        if not self._is_operator_valid_for_property_type(property_obj.type, operator):
+            valid_operators = self._get_valid_operators_for_property_type(property_obj.type)
+            raise InvalidOperatorForPropertyType(
+                property_name=property_name,
+                property_type=property_obj.type,
+                operator=operator,
+                valid_operators=valid_operators,
+            )
+
+    def _is_operator_valid_for_property_type(self, property_type: PropertyType, operator: Operator) -> bool:
+        allowed_operator_types = self._PROPERTY_TYPE_OPERATORS.get(property_type, [])
+        valid_operator_values = self._get_operator_values_from_types(allowed_operator_types)
+        return operator.value in valid_operator_values
+
+    def _get_operator_values_from_types(self, operator_types: list[type[Operator]]) -> set[str]:
+        values: set[str] = set()
+        for operator_type in operator_types:
+            for operator in operator_type:
+                values.add(operator.value)
+        return values
+
+    def _get_valid_operators_for_property_type(self, property_type: PropertyType) -> list[Operator]:
+        allowed_operator_types = self._PROPERTY_TYPE_OPERATORS.get(property_type, [])
+        return self._collect_all_operators_from_types(allowed_operator_types)
+
+    def _collect_all_operators_from_types(self, operator_types: list[type[Operator]]) -> list[Operator]:
+        operators: list[Operator] = []
+        for operator_type in operator_types:
+            operators.extend(self._get_all_enum_values(operator_type))
+        return operators
+
+    def _get_all_enum_values(self, operator_type: type[Operator]) -> list[Operator]:
+        return list(operator_type)

notionary/data_source/schemas.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel
+
+from notionary.blocks.rich_text.models import RichText
+from notionary.data_source.properties.models import DiscriminatedDataSourceProperty
+from notionary.page.schemas import NotionPageDto
+from notionary.shared.entity.schemas import EntityResponseDto, NotionEntityUpdateDto
+from notionary.shared.models.parent import Parent
+
+
+class UpdateDataSourceDto(NotionEntityUpdateDto):
+    title: list[RichText]
+    description: list[RichText]
+    archived: bool
+
+
+class QueryDataSourceResponse(BaseModel):
+    results: list[NotionPageDto]
+    next_cursor: str | None = None
+    has_more: bool
+
+
+class DataSourceDto(EntityResponseDto):
+    database_parent: Parent
+    title: list[RichText]
+    description: list[RichText]
+    archived: bool
+    properties: dict[str, DiscriminatedDataSourceProperty]