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

notionary/data_source/service.py

@@ -16,27 +16,20 @@ from notionary.data_source.properties.schemas import (
     DataSourceSelectProperty,
     DataSourceStatusProperty,
 )
-from notionary.data_source.query.builder import DataSourceQueryBuilder
-from notionary.data_source.query.resolver import QueryResolver
-from notionary.data_source.query.schema import (
-    DataSourceQueryParams,
-)
+from notionary.data_source.query import DataSourceQueryBuilder, DataSourceQueryParams, QueryResolver
 from notionary.data_source.schema.service import DataSourcePropertySchemaFormatter
 from notionary.data_source.schemas import DataSourceDto
 from notionary.exceptions.data_source.properties import DataSourcePropertyNotFound, DataSourcePropertyTypeError
-from notionary.page.properties.models import PageTitleProperty
+from notionary.file_upload.service import NotionFileUpload
+from notionary.page.properties.schemas import PageTitleProperty
 from notionary.page.schemas import NotionPageDto
 from notionary.shared.entity.dto_parsers import (
-    extract_cover_image_url_from_dto,
-    extract_database_id,
     extract_description,
-    extract_emoji_icon_from_dto,
-    extract_external_icon_url_from_dto,
     extract_title,
 )
 from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
 from notionary.shared.entity.service import Entity
-from notionary.user.schemas import PartialUserDto
+from notionary.user.service import UserService
 from notionary.workspace.query.service import WorkspaceQueryService
 
 if TYPE_CHECKING:
@@ -46,45 +39,23 @@ if TYPE_CHECKING:
 class NotionDataSource(Entity):
     def __init__(
         self,
-        id: str,
+        dto: DataSourceDto,
         title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        archived: bool,
-        in_trash: bool,
-        url: str,
+        description: str | None,
         properties: dict[str, DataSourceProperty],
-        parent_database_id: str | None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
-        description: str | None = None,
-        public_url: str | None = None,
-        data_source_instance_client: DataSourceInstanceClient | None = None,
+        data_source_instance_client: DataSourceInstanceClient,
         query_resolver: QueryResolver | None = None,
+        user_service: UserService | None = None,
+        file_upload_service: NotionFileUpload | None = None,
     ) -> None:
-        super().__init__(
-            id=id,
-            created_time=created_time,
-            created_by=created_by,
-            last_edited_time=last_edited_time,
-            last_edited_by=last_edited_by,
-            in_trash=in_trash,
-            emoji_icon=emoji_icon,
-            external_icon_url=external_icon_url,
-            cover_image_url=cover_image_url,
-        )
-        self._parent_database_id = parent_database_id
+        super().__init__(dto=dto, user_service=user_service, file_upload_service=file_upload_service)
+
         self._parent_database: NotionDatabase | None = None
         self._title = title
-        self._archived = archived
-        self._url = url
-        self._public_url = public_url
+        self._archived = dto.archived
         self._description = description
         self._properties = properties or {}
-        self._data_source_client = data_source_instance_client or DataSourceInstanceClient(data_source_id=id)
+        self._data_source_client = data_source_instance_client
         self.query_resolver = query_resolver or QueryResolver()
 
     @classmethod
@@ -111,73 +82,21 @@ class NotionDataSource(Entity):
     @classmethod
     async def _create_from_dto(
         cls,
-        response: DataSourceDto,
+        dto: DataSourceDto,
         rich_text_converter: RichTextToMarkdownConverter,
     ) -> Self:
         title, description = await asyncio.gather(
-            extract_title(response, rich_text_converter),
-            extract_description(response, rich_text_converter),
+            extract_title(dto, rich_text_converter),
+            extract_description(dto, rich_text_converter),
         )
 
-        parent_database_id = extract_database_id(response)
-
-        return cls._create(
-            id=response.id,
-            title=title,
-            description=description,
-            created_time=response.created_time,
-            created_by=response.created_by,
-            last_edited_time=response.last_edited_time,
-            last_edited_by=response.last_edited_by,
-            archived=response.archived,
-            in_trash=response.in_trash,
-            url=response.url,
-            properties=response.properties,
-            parent_database_id=parent_database_id,
-            emoji_icon=extract_emoji_icon_from_dto(response),
-            external_icon_url=extract_external_icon_url_from_dto(response),
-            cover_image_url=extract_cover_image_url_from_dto(response),
-            public_url=response.url,
-        )
+        data_source_instance_client = DataSourceInstanceClient(data_source_id=dto.id)
 
-    @classmethod
-    def _create(
-        cls,
-        id: str,
-        title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        archived: bool,
-        in_trash: bool,
-        url: str,
-        properties: dict[str, DataSourceProperty],
-        parent_database_id: str | None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
-        description: str | None = None,
-        public_url: str | None = None,
-    ) -> Self:
-        data_source_instance_client = DataSourceInstanceClient(data_source_id=id)
         return cls(
-            id=id,
+            dto=dto,
             title=title,
-            created_time=created_time,
-            created_by=created_by,
-            last_edited_time=last_edited_time,
-            last_edited_by=last_edited_by,
-            archived=archived,
-            in_trash=in_trash,
-            url=url,
-            parent_database_id=parent_database_id,
-            emoji_icon=emoji_icon,
-            external_icon_url=external_icon_url,
-            cover_image_url=cover_image_url,
             description=description,
-            public_url=public_url,
-            properties=properties,
+            properties=dto.properties,
             data_source_instance_client=data_source_instance_client,
         )
 
@@ -202,17 +121,8 @@ class NotionDataSource(Entity):
         return self._properties
 
     @property
-    def url(self) -> str:
-        return self._url
-
-    @property
-    def public_url(self) -> str | None:
-        return self._public_url
-
-    async def get_parent_database(self) -> NotionDatabase | None:
-        if self._parent_database is None and self._parent_database_id:
-            self._parent_database = await NotionDatabase.from_id(self._parent_database_id)
-        return self._parent_database
+    def data_source_query_builder(self) -> DataSourceQueryBuilder:
+        return DataSourceQueryBuilder(properties=self._properties)
 
     async def create_blank_page(self, title: str | None = None) -> NotionPage:
         return await self._data_source_client.create_blank_page(title=title)
@@ -320,44 +230,45 @@ class NotionDataSource(Entity):
 
         return prop
 
-    def filter(self) -> DataSourceQueryBuilder:
+    def get_query_builder(self) -> DataSourceQueryBuilder:
         return DataSourceQueryBuilder(properties=self._properties)
 
-    async def query_pages(
-        self, filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]
-    ) -> list[NotionPage]:
-        builder = DataSourceQueryBuilder(properties=self._properties)
-        configured_builder = filter_fn(builder)
-        query_params = configured_builder.build()
-
-        return await self.get_pages(query_params)
-
-    async def query_pages_stream(
-        self, filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]
-    ) -> AsyncIterator[NotionPage]:
-        builder = DataSourceQueryBuilder(properties=self._properties)
-        configured_builder = filter_fn(builder)
-        query_params = configured_builder.build()
-
-        async for page in self.get_pages_stream(query_params):
-            yield page
-
     async def get_pages(
         self,
+        *,
+        filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder] | None = None,
         query_params: DataSourceQueryParams | None = None,
     ) -> list[NotionPage]:
         from notionary import NotionPage
 
+        if filter_fn is not None and query_params is not None:
+            raise ValueError("Use either filter_fn OR query_params, not both")
+
+        if filter_fn is not None:
+            builder = DataSourceQueryBuilder(properties=self._properties)
+            configured_builder = filter_fn(builder)
+            query_params = configured_builder.build()
+
         resolved_params = await self._resolve_query_params_if_needed(query_params)
         query_response = await self._data_source_client.query(query_params=resolved_params)
         return [await NotionPage.from_id(page.id) for page in query_response.results]
 
-    async def get_pages_stream(
+    async def iter_pages(
         self,
+        *,
+        filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder] | None = None,
         query_params: DataSourceQueryParams | None = None,
     ) -> AsyncIterator[NotionPage]:
         from notionary import NotionPage
 
+        if filter_fn is not None and query_params is not None:
+            raise ValueError("Use either filter_fn OR query_params, not both")
+
+        if filter_fn is not None:
+            builder = DataSourceQueryBuilder(properties=self._properties)
+            configured_builder = filter_fn(builder)
+            query_params = configured_builder.build()
+
         resolved_params = await self._resolve_query_params_if_needed(query_params)
 
         async for page in self._data_source_client.query_stream(query_params=resolved_params):

notionary/database/schemas.py

@@ -2,7 +2,7 @@ from pydantic import BaseModel, Field
 
 from notionary.blocks.rich_text.models import RichText
 from notionary.shared.entity.schemas import EntityResponseDto
-from notionary.shared.models.cover import NotionCover
+from notionary.shared.models.file import File
 from notionary.shared.models.icon import Icon
 
 
@@ -24,6 +24,6 @@ class NotionDatabaseDto(EntityResponseDto):
 class NotionDatabaseUpdateDto(BaseModel):
     title: list[RichText] | None = None
     icon: Icon | None = None
-    cover: NotionCover | None = None
+    cover: File | None = None
     archived: bool | None = None
     description: list[RichText] | None = None

notionary/database/service.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import asyncio
 from collections.abc import Awaitable, Callable
 from typing import Self
@@ -10,62 +8,36 @@ from notionary.database.client import NotionDatabaseHttpClient
 from notionary.database.database_metadata_update_client import DatabaseMetadataUpdateClient
 from notionary.database.schemas import NotionDatabaseDto
 from notionary.shared.entity.dto_parsers import (
-    extract_cover_image_url_from_dto,
     extract_description,
-    extract_emoji_icon_from_dto,
-    extract_external_icon_url_from_dto,
     extract_title,
 )
 from notionary.shared.entity.service import Entity
-from notionary.user.schemas import PartialUserDto
 from notionary.workspace.query.service import WorkspaceQueryService
 
-type DataSourceFactory = Callable[[str], Awaitable[NotionDataSource]]
+type _DataSourceFactory = Callable[[str], Awaitable[NotionDataSource]]
 
 
 class NotionDatabase(Entity):
     def __init__(
         self,
-        id: str,
+        dto: NotionDatabaseDto,
         title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        url: str,
-        in_trash: bool,
-        is_inline: bool,
+        description: str | None,
         data_source_ids: list[str],
-        public_url: str | None = None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
-        description: str | None = None,
-        client: NotionDatabaseHttpClient | None = None,
-        metadata_update_client: DatabaseMetadataUpdateClient | None = None,
+        client: NotionDatabaseHttpClient,
+        metadata_update_client: DatabaseMetadataUpdateClient,
     ) -> None:
-        super().__init__(
-            id=id,
-            created_time=created_time,
-            created_by=created_by,
-            last_edited_time=last_edited_time,
-            last_edited_by=last_edited_by,
-            in_trash=in_trash,
-            emoji_icon=emoji_icon,
-            external_icon_url=external_icon_url,
-            cover_image_url=cover_image_url,
-        )
+        super().__init__(dto=dto)
+
         self._title = title
-        self._url = url
-        self._public_url = public_url
         self._description = description
-        self._is_inline = is_inline
+        self._is_inline = dto.is_inline
 
         self._data_sources: list[NotionDataSource] | None = None
         self._data_source_ids = data_source_ids
 
-        self.client = client or NotionDatabaseHttpClient(database_id=id)
-        self._metadata_update_client = metadata_update_client or DatabaseMetadataUpdateClient(database_id=id)
+        self.client = client
+        self._metadata_update_client = metadata_update_client
 
     @classmethod
     async def from_id(
@@ -94,31 +66,23 @@ class NotionDatabase(Entity):
     @classmethod
     async def _create_from_dto(
         cls,
-        response: NotionDatabaseDto,
+        dto: NotionDatabaseDto,
         rich_text_converter: RichTextToMarkdownConverter,
         client: NotionDatabaseHttpClient,
     ) -> Self:
         title, description = await asyncio.gather(
-            extract_title(response, rich_text_converter), extract_description(response, rich_text_converter)
+            extract_title(dto, rich_text_converter), extract_description(dto, rich_text_converter)
         )
 
+        metadata_update_client = DatabaseMetadataUpdateClient(database_id=dto.id)
+
         return cls(
-            id=response.id,
+            dto=dto,
             title=title,
             description=description,
-            created_time=response.created_time,
-            created_by=response.created_by,
-            last_edited_time=response.last_edited_time,
-            last_edited_by=response.last_edited_by,
-            in_trash=response.in_trash,
-            is_inline=response.is_inline,
-            url=response.url,
-            public_url=response.public_url,
-            emoji_icon=extract_emoji_icon_from_dto(response),
-            external_icon_url=extract_external_icon_url_from_dto(response),
-            cover_image_url=extract_cover_image_url_from_dto(response),
-            data_source_ids=[ds.id for ds in response.data_sources],
+            data_source_ids=[ds.id for ds in dto.data_sources],
             client=client,
+            metadata_update_client=metadata_update_client,
         )
 
     @property
@@ -129,14 +93,6 @@ class NotionDatabase(Entity):
     def title(self) -> str:
         return self._title
 
-    @property
-    def url(self) -> str:
-        return self._url
-
-    @property
-    def public_url(self) -> str | None:
-        return self._public_url
-
     @property
     def is_inline(self) -> bool:
         return self._is_inline
@@ -146,7 +102,7 @@ class NotionDatabase(Entity):
 
     async def get_data_sources(
         self,
-        data_source_factory: DataSourceFactory = NotionDataSource.from_id,
+        data_source_factory: _DataSourceFactory = NotionDataSource.from_id,
     ) -> list[NotionDataSource]:
         if self._data_sources is None:
             self._data_sources = await self._load_data_sources(data_source_factory)
@@ -154,7 +110,7 @@ class NotionDatabase(Entity):
 
     async def _load_data_sources(
         self,
-        data_source_factory: DataSourceFactory,
+        data_source_factory: _DataSourceFactory,
     ) -> list[NotionDataSource]:
         tasks = [data_source_factory(ds_id) for ds_id in self._data_source_ids]
         return list(await asyncio.gather(*tasks))

notionary/exceptions/__init__.py

@@ -7,8 +7,10 @@ from .api import (
     NotionServerError,
     NotionValidationError,
 )
-from .base import NotionaryError
+from .base import NotionaryException
+from .block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError, UnsupportedVideoFormatError
 from .data_source import DataSourcePropertyNotFound, DataSourcePropertyTypeError
+from .file_upload import FileSizeException, NoFileExtensionException, UnsupportedFileTypeException
 from .properties import AccessPagePropertyWithoutDataSourceError, PagePropertyNotFoundError, PagePropertyTypeError
 from .search import DatabaseNotFound, DataSourceNotFound, EntityNotFound, PageNotFound
 
@@ -19,6 +21,10 @@ __all__ = [
     "DataSourcePropertyTypeError",
     "DatabaseNotFound",
     "EntityNotFound",
+    "FileSizeException",
+    "InsufficientColumnsError",
+    "InvalidColumnRatioSumError",
+    "NoFileExtensionException",
     "NotionApiError",
     "NotionAuthenticationError",
     "NotionConnectionError",
@@ -26,8 +32,10 @@ __all__ = [
     "NotionResourceNotFoundError",
     "NotionServerError",
     "NotionValidationError",
-    "NotionaryError",
+    "NotionaryException",
     "PageNotFound",
     "PagePropertyNotFoundError",
     "PagePropertyTypeError",
+    "UnsupportedFileTypeException",
+    "UnsupportedVideoFormatError",
 ]

notionary/exceptions/api.py

@@ -1,7 +1,7 @@
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 
 
-class NotionApiError(NotionaryError):
+class NotionApiError(NotionaryException):
     def __init__(
         self,
         message: str,

notionary/exceptions/base.py

@@ -1,2 +1,2 @@
-class NotionaryError(Exception):
+class NotionaryException(Exception):
     pass

notionary/exceptions/block_parsing.py

@@ -1,16 +1,37 @@
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 
 RATIO_TOLERANCE = 0.0001
 
 
-class InsufficientColumnsError(NotionaryError):
+class InsufficientColumnsError(NotionaryException):
     def __init__(self, column_count: int) -> None:
         self.column_count = column_count
         super().__init__(f"Columns container must contain at least 2 column blocks, but only {column_count} found")
 
 
-class InvalidColumnRatioSumError(NotionaryError):
+class InvalidColumnRatioSumError(NotionaryException):
     def __init__(self, total: float, tolerance: float = RATIO_TOLERANCE) -> None:
         self.total = total
         self.tolerance = tolerance
         super().__init__(f"Width ratios must sum to 1.0 (±{tolerance}), but sum is {total}")
+
+
+class UnsupportedVideoFormatError(ValueError):
+    def __init__(self, url: str, supported_formats: list[str]) -> None:
+        self.url = url
+        self.supported_formats = supported_formats
+        super().__init__(self._create_user_friendly_message())
+
+    def _create_user_friendly_message(self) -> str:
+        formats = ", ".join(self.supported_formats[:5])
+        remaining = len(self.supported_formats) - 5
+
+        if remaining > 0:
+            formats += f" and {remaining} more"
+
+        return (
+            f"The video URL '{self.url}' uses an unsupported format.\n"
+            f"Supported formats include: {formats}.\n"
+            f"YouTube embed and watch URLs are also supported."
+            f"Also see https://developers.notion.com/reference/block#video for more information."
+        )

notionary/exceptions/data_source/builder.py

@@ -8,11 +8,11 @@ from notionary.data_source.query.schema import (
     Operator,
     StringOperator,
 )
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 from notionary.shared.properties.type import PropertyType
 
 
-class QueryBuilderError(NotionaryError):
+class QueryBuilderError(NotionaryException):
     def __init__(self, message: str, property_name: str | None = None) -> None:
         self.property_name = property_name
         super().__init__(message)

notionary/exceptions/data_source/properties.py

@@ -1,9 +1,9 @@
 import difflib
 
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 
 
-class DataSourcePropertyNotFound(NotionaryError):
+class DataSourcePropertyNotFound(NotionaryException):
     def __init__(
         self,
         property_name: str,
@@ -28,7 +28,7 @@ class DataSourcePropertyNotFound(NotionaryError):
         super().__init__(message)
 
 
-class DataSourcePropertyTypeError(NotionaryError):
+class DataSourcePropertyTypeError(NotionaryException):
     def __init__(self, property_name: str, expected_type: str, actual_type: str) -> None:
         message = f"Property '{property_name}' has the wrong type. Expected: '{expected_type}', found: '{actual_type}'."
         super().__init__(message)

notionary/exceptions/file_upload.py

@@ -0,0 +1,67 @@
+from notionary.exceptions.base import NotionaryException
+
+
+class UnsupportedFileTypeException(NotionaryException):
+    def __init__(self, extension: str, filename: str, supported_extensions_by_category: dict[str, list[str]]):
+        supported_exts = []
+        for category, extensions in supported_extensions_by_category.items():
+            supported_exts.append(f"{category}: {', '.join(extensions[:5])}...")
+
+        supported_info = "\n  ".join(supported_exts)
+        super().__init__(
+            f"File '{filename}' has unsupported extension '{extension}'.\n"
+            f"Supported file types by category:\n  {supported_info}"
+        )
+        self.extension = extension
+        self.filename = filename
+
+
+class NoFileExtensionException(NotionaryException):
+    def __init__(self, filename: str):
+        super().__init__(
+            f"File '{filename}' has no extension. Files must have a valid extension to determine their type."
+        )
+        self.filename = filename
+
+
+class FileSizeException(NotionaryException):
+    def __init__(self, filename: str, file_size_bytes: int, max_size_bytes: int):
+        file_size_mb = file_size_bytes / (1024 * 1024)
+        max_size_mb = max_size_bytes / (1024 * 1024)
+        super().__init__(
+            f"File '{filename}' is too large ({file_size_mb:.2f} MB). Maximum allowed size is {max_size_mb:.2f} MB."
+        )
+        self.filename = filename
+        self.file_size_bytes = file_size_bytes
+        self.max_size_bytes = max_size_bytes
+
+
+class FileNotFoundError(NotionaryException):
+    def __init__(self, file_path: str):
+        super().__init__(f"File does not exist: {file_path}")
+        self.file_path = file_path
+
+
+class FilenameTooLongError(NotionaryException):
+    def __init__(self, filename: str, filename_bytes: int, max_filename_bytes: int):
+        super().__init__(f"Filename too long: {filename_bytes} bytes (max {max_filename_bytes}). Filename: {filename}")
+        self.filename = filename
+        self.filename_bytes = filename_bytes
+        self.max_filename_bytes = max_filename_bytes
+
+
+class UploadFailedError(NotionaryException):
+    def __init__(self, file_upload_id: str, reason: str | None = None):
+        message = f"Upload failed for file_upload_id: {file_upload_id}"
+        if reason:
+            message += f". Reason: {reason}"
+        super().__init__(message)
+        self.file_upload_id = file_upload_id
+        self.reason = reason
+
+
+class UploadTimeoutError(NotionaryException):
+    def __init__(self, file_upload_id: str, timeout_seconds: int):
+        super().__init__(f"Upload timeout after {timeout_seconds}s for file_upload_id: {file_upload_id}")
+        self.file_upload_id = file_upload_id
+        self.timeout_seconds = timeout_seconds

notionary/exceptions/properties.py

@@ -1,11 +1,11 @@
 import difflib
 from typing import ClassVar
 
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 from notionary.shared.models.parent import ParentType
 
 
-class PagePropertyNotFoundError(NotionaryError):
+class PagePropertyNotFoundError(NotionaryException):
     def __init__(
         self,
         page_url: str,
@@ -31,7 +31,7 @@ class PagePropertyNotFoundError(NotionaryError):
         super().__init__(message)
 
 
-class PagePropertyTypeError(NotionaryError):
+class PagePropertyTypeError(NotionaryException):
     def __init__(
         self,
         property_name: str,
@@ -41,7 +41,7 @@ class PagePropertyTypeError(NotionaryError):
         super().__init__(message)
 
 
-class AccessPagePropertyWithoutDataSourceError(NotionaryError):
+class AccessPagePropertyWithoutDataSourceError(NotionaryException):
     _PARENT_DESCRIPTIONS: ClassVar[dict[ParentType, str]] = {
         ParentType.WORKSPACE: "the workspace itself",
         ParentType.PAGE_ID: "another page",

notionary/exceptions/search.py

@@ -1,7 +1,7 @@
-from notionary.exceptions.base import NotionaryError
+from notionary.exceptions.base import NotionaryException
 
 
-class EntityNotFound(NotionaryError):
+class EntityNotFound(NotionaryException):
     def __init__(self, entity_type: str, query: str, available_titles: list[str] | None = None) -> None:
         self.entity_type = entity_type
         self.query = query
@@ -33,14 +33,14 @@ class DatabaseNotFound(EntityNotFound):
         super().__init__("database", query, available_titles)
 
 
-class NoUsersInWorkspace(NotionaryError):
+class NoUsersInWorkspace(NotionaryException):
     def __init__(self, user_type: str) -> None:
         self.user_type = user_type
         message = f"No '{user_type}' users found in the workspace."
         super().__init__(message)
 
 
-class UserNotFound(NotionaryError):
+class UserNotFound(NotionaryException):
     def __init__(self, user_type: str, query: str, available_names: list[str] | None = None) -> None:
         self.user_type = user_type
         self.query = query