notionary 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

notionary/data_source/http/data_source_instance_client.py

@@ -3,14 +3,25 @@ from __future__ import annotations
 from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING, Any, override
 
-from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
 from notionary.data_source.query.schema import DataSourceQueryParams
-from notionary.data_source.schemas import DataSourceDto, QueryDataSourceResponse, UpdateDataSourceDto
+from notionary.data_source.schemas import (
+    DataSourceDto,
+    QueryDataSourceResponse,
+    UpdateDataSourceDto,
+)
 from notionary.http.client import NotionHttpClient
 from notionary.page.schemas import NotionPageDto
-from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
+from notionary.shared.entity.entity_metadata_update_client import (
+    EntityMetadataUpdateClient,
+)
 from notionary.shared.typings import JsonDict
-from notionary.utils.pagination import paginate_notion_api, paginate_notion_api_generator
+from notionary.utils.pagination import (
+    paginate_notion_api,
+    paginate_notion_api_generator,
+)
 
 if TYPE_CHECKING:
     from notionary import NotionPage
@@ -22,9 +33,15 @@ class DataSourceInstanceClient(NotionHttpClient, EntityMetadataUpdateClient):
         self._data_source_id = data_source_id
 
     @override
-    async def patch_metadata(self, update_data_source_dto: UpdateDataSourceDto) -> DataSourceDto:
-        update_data_source_dto_dict = update_data_source_dto.model_dump(exclude_none=True)
-        response = await self.patch(f"data_sources/{self._data_source_id}", data=update_data_source_dto_dict)
+    async def patch_metadata(
+        self, update_data_source_dto: UpdateDataSourceDto
+    ) -> DataSourceDto:
+        update_data_source_dto_dict = update_data_source_dto.model_dump(
+            exclude_none=True
+        )
+        response = await self.patch(
+            f"data_sources/{self._data_source_id}", data=update_data_source_dto_dict
+        )
         return DataSourceDto.model_validate(response)
 
     async def update_title(self, title: str) -> DataSourceDto:
@@ -40,28 +57,38 @@ class DataSourceInstanceClient(NotionHttpClient, EntityMetadataUpdateClient):
         await self.patch_metadata(update_data_source_dto)
 
     async def update_description(self, description: str) -> str:
-        from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+        from notionary.blocks.rich_text.markdown_rich_text_converter import (
+            MarkdownRichTextConverter,
+        )
 
         markdown_rich_text_converter = MarkdownRichTextConverter()
-        rich_text_description = await markdown_rich_text_converter.to_rich_text(description)
+        rich_text_description = await markdown_rich_text_converter.to_rich_text(
+            description
+        )
         update_data_source_dto = UpdateDataSourceDto(description=rich_text_description)
 
         updated_data_source_dto = await self.patch_metadata(update_data_source_dto)
 
         markdown_rich_text_converter = RichTextToMarkdownConverter()
         updated_markdown_description = (
-            await markdown_rich_text_converter.to_markdown(updated_data_source_dto.description)
+            await markdown_rich_text_converter.to_markdown(
+                updated_data_source_dto.description
+            )
             if updated_data_source_dto.description
             else None
         )
         return updated_markdown_description
 
-    async def query(self, query_params: DataSourceQueryParams | None = None) -> QueryDataSourceResponse:
+    async def query(
+        self, query_params: DataSourceQueryParams | None = None
+    ) -> QueryDataSourceResponse:
         query_params_dict = query_params.to_api_params() if query_params else {}
         total_result_limit = query_params.total_results_limit if query_params else None
 
         all_results = await paginate_notion_api(
-            self._make_query_request, query_data=query_params_dict or {}, total_result_limit=total_result_limit
+            self._make_query_request,
+            query_data=query_params_dict or {},
+            total_result_limit=total_result_limit,
         )
 
         return QueryDataSourceResponse(
@@ -70,17 +97,24 @@ class DataSourceInstanceClient(NotionHttpClient, EntityMetadataUpdateClient):
             has_more=False,
         )
 
-    async def query_stream(self, query_params: DataSourceQueryParams | None = None) -> AsyncIterator[Any]:
+    async def query_stream(
+        self, query_params: DataSourceQueryParams | None = None
+    ) -> AsyncIterator[Any]:
         query_params_dict = query_params.model_dump() if query_params else {}
         total_result_limit = query_params.total_results_limit if query_params else None
 
         async for result in paginate_notion_api_generator(
-            self._make_query_request, query_data=query_params_dict or {}, total_results_limit=total_result_limit
+            self._make_query_request,
+            query_data=query_params_dict or {},
+            total_results_limit=total_result_limit,
         ):
             yield result
 
     async def _make_query_request(
-        self, query_data: JsonDict, start_cursor: str | None = None, page_size: int | None = None
+        self,
+        query_data: JsonDict,
+        start_cursor: str | None = None,
+        page_size: int | None = None,
     ) -> QueryDataSourceResponse:
         current_query_data = query_data.copy()
         if start_cursor:
@@ -88,13 +122,21 @@ class DataSourceInstanceClient(NotionHttpClient, EntityMetadataUpdateClient):
         if page_size:
             current_query_data["page_size"] = page_size
 
-        response = await self.post(f"data_sources/{self._data_source_id}/query", data=current_query_data)
+        response = await self.post(
+            f"data_sources/{self._data_source_id}/query", data=current_query_data
+        )
         return QueryDataSourceResponse.model_validate(response)
 
     async def create_blank_page(self, title: str | None = None) -> NotionPage:
         from notionary import NotionPage
 
-        data = {"parent": {"type": "data_source_id", "data_source_id": self._data_source_id}, "properties": {}}
+        data = {
+            "parent": {
+                "type": "data_source_id",
+                "data_source_id": self._data_source_id,
+            },
+            "properties": {},
+        }
 
         if title:
             data["properties"]["Name"] = {"title": [{"text": {"content": title}}]}

notionary/data_source/properties/schemas.py

@@ -163,7 +163,9 @@ class DataSourceMultiSelectConfig(BaseModel):
 
 class DataSourceMultiSelectProperty(DataSourceProperty):
     type: Literal[PropertyType.MULTI_SELECT] = PropertyType.MULTI_SELECT
-    multi_select: DataSourceMultiSelectConfig = Field(default_factory=DataSourceMultiSelectConfig)
+    multi_select: DataSourceMultiSelectConfig = Field(
+        default_factory=DataSourceMultiSelectConfig
+    )
 
     @property
     def option_names(self) -> list[str]:
@@ -199,7 +201,9 @@ class DataSourceCreatedTimeConfig(BaseModel): ...
 
 class DataSourceCreatedTimeProperty(DataSourceProperty):
     type: Literal[PropertyType.CREATED_TIME] = PropertyType.CREATED_TIME
-    created_time: DataSourceCreatedTimeConfig = Field(default_factory=DataSourceCreatedTimeConfig)
+    created_time: DataSourceCreatedTimeConfig = Field(
+        default_factory=DataSourceCreatedTimeConfig
+    )
 
 
 class DataSourceCreatedByConfig(BaseModel): ...
@@ -207,7 +211,9 @@ class DataSourceCreatedByConfig(BaseModel): ...
 
 class DataSourceCreatedByProperty(DataSourceProperty):
     type: Literal[PropertyType.CREATED_BY] = PropertyType.CREATED_BY
-    created_by: DataSourceCreatedByConfig = Field(default_factory=DataSourceCreatedByConfig)
+    created_by: DataSourceCreatedByConfig = Field(
+        default_factory=DataSourceCreatedByConfig
+    )
 
 
 class DataSourceLastEditedTimeConfig(BaseModel): ...
@@ -215,7 +221,9 @@ class DataSourceLastEditedTimeConfig(BaseModel): ...
 
 class DataSourceLastEditedTimeProperty(DataSourceProperty):
     type: Literal[PropertyType.LAST_EDITED_TIME] = PropertyType.LAST_EDITED_TIME
-    last_edited_time: DataSourceLastEditedTimeConfig = Field(default_factory=DataSourceLastEditedTimeConfig)
+    last_edited_time: DataSourceLastEditedTimeConfig = Field(
+        default_factory=DataSourceLastEditedTimeConfig
+    )
 
 
 class DataSourceLastEditedByConfig(BaseModel): ...
@@ -223,7 +231,9 @@ class DataSourceLastEditedByConfig(BaseModel): ...
 
 class DataSourceLastEditedByProperty(DataSourceProperty):
     type: Literal[PropertyType.LAST_EDITED_BY] = PropertyType.LAST_EDITED_BY
-    last_edited_by: DataSourceLastEditedByConfig = Field(default_factory=DataSourceLastEditedByConfig)
+    last_edited_by: DataSourceLastEditedByConfig = Field(
+        default_factory=DataSourceLastEditedByConfig
+    )
 
 
 class DataSourceLastVisitedTimeConfig(BaseModel): ...
@@ -231,7 +241,9 @@ class DataSourceLastVisitedTimeConfig(BaseModel): ...
 
 class DataSourceLastVisitedTimeProperty(DataSourceProperty):
     type: Literal[PropertyType.LAST_VISITED_TIME] = PropertyType.LAST_VISITED_TIME
-    last_visited_time: DataSourceLastVisitedTimeConfig = Field(default_factory=DataSourceLastVisitedTimeConfig)
+    last_visited_time: DataSourceLastVisitedTimeConfig = Field(
+        default_factory=DataSourceLastVisitedTimeConfig
+    )
 
 
 class DataSourceTitleConfig(BaseModel): ...
@@ -247,7 +259,9 @@ class DataSourceRichTextConfig(BaseModel): ...
 
 class DataSourceRichTextProperty(DataSourceProperty):
     type: Literal[PropertyType.RICH_TEXT] = PropertyType.RICH_TEXT
-    rich_text: DataSourceRichTextConfig = Field(default_factory=DataSourceRichTextConfig)
+    rich_text: DataSourceRichTextConfig = Field(
+        default_factory=DataSourceRichTextConfig
+    )
 
 
 class DataSourceURLConfig(BaseModel): ...
@@ -300,7 +314,9 @@ class DataSourcePhoneNumberConfig(BaseModel): ...
 
 class DataSourcePhoneNumberProperty(DataSourceProperty):
     type: Literal[PropertyType.PHONE_NUMBER] = PropertyType.PHONE_NUMBER
-    phone_number: DataSourcePhoneNumberConfig = Field(default_factory=DataSourcePhoneNumberConfig)
+    phone_number: DataSourcePhoneNumberConfig = Field(
+        default_factory=DataSourcePhoneNumberConfig
+    )
 
 
 class DataSourceFilesConfig(BaseModel): ...
@@ -347,7 +363,9 @@ class DataSourceUniqueIdConfig(BaseModel):
 
 class DataSourceUniqueIdProperty(DataSourceProperty):
     type: Literal[PropertyType.UNIQUE_ID] = PropertyType.UNIQUE_ID
-    unique_id: DataSourceUniqueIdConfig = Field(default_factory=DataSourceUniqueIdConfig)
+    unique_id: DataSourceUniqueIdConfig = Field(
+        default_factory=DataSourceUniqueIdConfig
+    )
 
     @property
     def prefix(self) -> str | None:
@@ -383,7 +401,9 @@ class DataSourceVerificationConfig(BaseModel): ...
 
 class DataSourceVerificationProperty(DataSourceProperty):
     type: Literal[PropertyType.VERIFICATION] = PropertyType.VERIFICATION
-    verification: DataSourceVerificationConfig = Field(default_factory=DataSourceVerificationConfig)
+    verification: DataSourceVerificationConfig = Field(
+        default_factory=DataSourceVerificationConfig
+    )
 
 
 class DataSourceUnknownProperty(BaseModel):

notionary/data_source/query/builder.py

@@ -160,7 +160,9 @@ class DataSourceQueryBuilder:
     def people_is_empty(self) -> Self:
         return self._add_filter(ArrayOperator.IS_EMPTY, None)
 
-    def order_by(self, property_name: str, direction: SortDirection = SortDirection.ASCENDING) -> Self:
+    def order_by(
+        self, property_name: str, direction: SortDirection = SortDirection.ASCENDING
+    ) -> Self:
         self._ensure_property_exists(property_name)
         sort = PropertySort(property=property_name, direction=direction)
         self._sorts.append(sort)
@@ -178,7 +180,9 @@ class DataSourceQueryBuilder:
     def order_by_created_time_descending(self) -> Self:
         return self._order_by_created_time(SortDirection.DESCENDING)
 
-    def _order_by_created_time(self, direction: SortDirection = SortDirection.DESCENDING) -> Self:
+    def _order_by_created_time(
+        self, direction: SortDirection = SortDirection.DESCENDING
+    ) -> Self:
         sort = TimestampSort(timestamp=TimestampType.CREATED_TIME, direction=direction)
         self._sorts.append(sort)
         return self
@@ -189,8 +193,12 @@ class DataSourceQueryBuilder:
     def order_by_last_edited_time_descending(self) -> Self:
         return self._order_by_last_edited_time(SortDirection.DESCENDING)
 
-    def _order_by_last_edited_time(self, direction: SortDirection = SortDirection.DESCENDING) -> Self:
-        sort = TimestampSort(timestamp=TimestampType.LAST_EDITED_TIME, direction=direction)
+    def _order_by_last_edited_time(
+        self, direction: SortDirection = SortDirection.DESCENDING
+    ) -> Self:
+        sort = TimestampSort(
+            timestamp=TimestampType.LAST_EDITED_TIME, direction=direction
+        )
         self._sorts.append(sort)
         return self
 
@@ -211,7 +219,10 @@ class DataSourceQueryBuilder:
         notion_filter = self._create_notion_filter_if_needed()
         sorts = self._create_sorts_if_needed()
         return DataSourceQueryParams(
-            filter=notion_filter, sorts=sorts, page_size=self._page_size, total_results_limit=self._total_results_limit
+            filter=notion_filter,
+            sorts=sorts,
+            page_size=self._page_size,
+            total_results_limit=self._total_results_limit,
         )
 
     def _select_property_without_negation(self, property_name: str) -> None:
@@ -264,7 +275,9 @@ class DataSourceQueryBuilder:
     def _has_no_filters(self) -> bool:
         return not self._filters
 
-    def _is_regular_filter_condition(self, filter_item: InternalFilterCondition) -> bool:
+    def _is_regular_filter_condition(
+        self, filter_item: InternalFilterCondition
+    ) -> bool:
         return isinstance(filter_item, FilterCondition)
 
     def _finalize_current_or_group(self) -> None:
@@ -284,7 +297,11 @@ class DataSourceQueryBuilder:
 
     def _add_filter(
         self,
-        operator: StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator,
+        operator: StringOperator
+        | NumberOperator
+        | BooleanOperator
+        | DateOperator
+        | ArrayOperator,
         value: str | int | float | list[str | int | float] | None,
     ) -> Self:
         self._ensure_property_is_selected()
@@ -301,7 +318,9 @@ class DataSourceQueryBuilder:
 
         property_obj = self._properties.get(self._current_property)
         if property_obj:
-            self._query_validator.validate_operator_for_property(self._current_property, property_obj, operator)
+            self._query_validator.validate_operator_for_property(
+                self._current_property, property_obj, operator
+            )
         return self
 
     def _ensure_property_is_selected(self) -> None:
@@ -313,8 +332,14 @@ class DataSourceQueryBuilder:
 
     def _apply_negation_if_needed(
         self,
-        operator: StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator,
-    ) -> StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator:
+        operator: StringOperator
+        | NumberOperator
+        | BooleanOperator
+        | DateOperator
+        | ArrayOperator,
+    ) -> (
+        StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator
+    ):
         if not self._negate_next:
             return operator
 
@@ -324,7 +349,11 @@ class DataSourceQueryBuilder:
 
     def _create_filter_condition(
         self,
-        operator: StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator,
+        operator: StringOperator
+        | NumberOperator
+        | BooleanOperator
+        | DateOperator
+        | ArrayOperator,
         value: str | int | float | list[str | int | float] | None,
     ) -> FilterCondition:
         field_type = self._determine_field_type_from_operator(operator)
@@ -372,13 +401,17 @@ class DataSourceQueryBuilder:
         property_filters = [self._build_filter(f) for f in self._filters]
         return CompoundFilter(operator=LogicalOperator.AND, filters=property_filters)
 
-    def _build_filter(self, condition: InternalFilterCondition) -> PropertyFilter | CompoundFilter:
+    def _build_filter(
+        self, condition: InternalFilterCondition
+    ) -> PropertyFilter | CompoundFilter:
         if isinstance(condition, OrGroupMarker):
             return self._build_or_compound_filter(condition)
         return self._build_property_filter(condition)
 
     def _build_or_compound_filter(self, or_marker: OrGroupMarker) -> CompoundFilter:
-        property_filters = [self._build_property_filter(c) for c in or_marker.conditions]
+        property_filters = [
+            self._build_property_filter(c) for c in or_marker.conditions
+        ]
         return CompoundFilter(operator=LogicalOperator.OR, filters=property_filters)
 
     def _build_property_filter(self, condition: FilterCondition) -> PropertyFilter:
@@ -398,8 +431,14 @@ class DataSourceQueryBuilder:
 
     def _negate_operator(
         self,
-        operator: StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator,
-    ) -> StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator:
+        operator: StringOperator
+        | NumberOperator
+        | BooleanOperator
+        | DateOperator
+        | ArrayOperator,
+    ) -> (
+        StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator
+    ):
         negation_map = {
             StringOperator.EQUALS: StringOperator.DOES_NOT_EQUAL,
             StringOperator.DOES_NOT_EQUAL: StringOperator.EQUALS,
@@ -436,13 +475,23 @@ class DataSourceQueryBuilder:
 
     def _raise_operator_cannot_be_negated_error(
         self,
-        operator: StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator,
+        operator: StringOperator
+        | NumberOperator
+        | BooleanOperator
+        | DateOperator
+        | ArrayOperator,
     ) -> None:
-        raise ValueError(f"Operator '{operator}' cannot be negated. This should not happen - please report this issue.")
+        raise ValueError(
+            f"Operator '{operator}' cannot be negated. This should not happen - please report this issue."
+        )
 
     def _determine_field_type_from_operator(
         self,
-        operator: StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator,
+        operator: StringOperator
+        | NumberOperator
+        | BooleanOperator
+        | DateOperator
+        | ArrayOperator,
     ) -> FieldType:
         if isinstance(operator, StringOperator):
             return FieldType.STRING

notionary/data_source/query/resolver.py

@@ -14,7 +14,10 @@ from notionary.utils.mixins.logging import LoggingMixin
 
 
 class QueryResolver(LoggingMixin):
-    UUID_PATTERN = re.compile(r"^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$", re.IGNORECASE)
+    UUID_PATTERN = re.compile(
+        r"^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$",
+        re.IGNORECASE,
+    )
 
     def __init__(
         self,
@@ -24,7 +27,9 @@ class QueryResolver(LoggingMixin):
         self._user_resolver = user_resolver or PersonNameIdResolver()
         self._page_resolver = page_resolver or PageNameIdResolver()
 
-    async def resolve_params(self, params: DataSourceQueryParams) -> DataSourceQueryParams:
+    async def resolve_params(
+        self, params: DataSourceQueryParams
+    ) -> DataSourceQueryParams:
         if not params.filter:
             return params
 
@@ -38,7 +43,9 @@ class QueryResolver(LoggingMixin):
             return await self._resolve_compound_filter(filter)
         return filter
 
-    async def _resolve_compound_filter(self, compound: CompoundFilter) -> CompoundFilter:
+    async def _resolve_compound_filter(
+        self, compound: CompoundFilter
+    ) -> CompoundFilter:
         resolved_filters = []
         for filter in compound.filters:
             resolved = await self._resolve_filter(filter)
@@ -46,7 +53,9 @@ class QueryResolver(LoggingMixin):
 
         return CompoundFilter(operator=compound.operator, filters=resolved_filters)
 
-    async def _resolve_property_filter(self, prop_filter: PropertyFilter) -> PropertyFilter:
+    async def _resolve_property_filter(
+        self, prop_filter: PropertyFilter
+    ) -> PropertyFilter:
         if not self._is_resolvable_property_type(prop_filter.property_type):
             return prop_filter
 
@@ -56,7 +65,9 @@ class QueryResolver(LoggingMixin):
         if self._is_uuid(prop_filter.value):
             return prop_filter
 
-        resolved_value = await self._resolve_value(prop_filter.value, prop_filter.property_type)
+        resolved_value = await self._resolve_value(
+            prop_filter.value, prop_filter.property_type
+        )
 
         return PropertyFilter(
             property=prop_filter.property,

notionary/data_source/query/schema.py

@@ -3,7 +3,13 @@ from __future__ import annotations
 from enum import StrEnum
 from typing import Self
 
-from pydantic import BaseModel, ValidationInfo, field_validator, model_serializer, model_validator
+from pydantic import (
+    BaseModel,
+    ValidationInfo,
+    field_validator,
+    model_serializer,
+    model_validator,
+)
 
 from notionary.shared.properties.type import PropertyType
 from notionary.shared.typings import JsonDict
@@ -93,7 +99,9 @@ class TimeUnit(StrEnum):
     YEARS = "years"
 
 
-type Operator = StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator
+type Operator = (
+    StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator
+)
 type FilterValue = str | int | float | bool | list[str | int | float]
 
 
@@ -156,7 +164,10 @@ class FilterCondition(BaseModel):
             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 (
+        elif self.field_type in (
+            FieldType.DATE,
+            FieldType.DATETIME,
+        ) or self.field_type in (
             FieldType.ARRAY,
             FieldType.RELATION,
             FieldType.PEOPLE,
@@ -196,7 +207,9 @@ class FilterCondition(BaseModel):
         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}'")
+            raise ValueError(
+                f"Operator '{operator_value}' is not valid for field type '{field_type}'"
+            )
 
         return value
 
@@ -234,7 +247,10 @@ class PropertyFilter(BaseModel):
         if self.value is None:
             return self
 
-        if self.property_type in (PropertyType.PEOPLE, PropertyType.RELATION) and not isinstance(self.value, str):
+        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__}"
@@ -254,7 +270,9 @@ class PropertyFilter(BaseModel):
 
         return {
             "property": self.property,
-            property_type_str: {operator_str: filter_value if filter_value is not None else True},
+            property_type_str: {
+                operator_str: filter_value if filter_value is not None else True
+            },
         }
 
 

notionary/data_source/query/validator.py

@@ -39,7 +39,9 @@ class QueryValidator:
         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)
+            valid_operators = self._get_valid_operators_for_property_type(
+                property_obj.type
+            )
             raise InvalidOperatorForPropertyType(
                 property_name=property_name,
                 property_type=property_obj.type,
@@ -47,23 +49,33 @@ class QueryValidator:
                 valid_operators=valid_operators,
             )
 
-    def _is_operator_valid_for_property_type(self, property_type: PropertyType, operator: Operator) -> bool:
+    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)
+        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]:
+    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]:
+    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]:
+    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))