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

notionary/schemas/base.py

@@ -1,73 +0,0 @@
-"""
-NotionContentSchema Base Class
-=============================
-
-Base class for all Notion structured output schemas with injected MarkdownBuilder
-"""
-
-from pydantic import BaseModel
-from notionary.blocks.markdown.markdown_builder import MarkdownBuilder
-
-
-class NotionContentSchema(BaseModel):
-    """
-    Base class for all Notion content schemas.
-
-    Inherit from this and implement to_notion_content() to create
-    schemas that work with LLM structured output.
-
-    Example usage:
-
-        class BlogPost(NotionContentSchema):
-            title: str = Field(description="Catchy blog post title")
-            introduction: str = Field(description="Engaging opening paragraph")
-            main_points: List[str] = Field(description="3-5 key takeaways")
-            conclusion: str = Field(description="Summary and call-to-action")
-
-            def to_notion_content(self, builder: MarkdownBuilder) -> str:
-                return (builder
-                    .h1(self.title)
-                    .paragraph(self.introduction)
-                    .h2("Key Points")
-                    .bulleted_list(self.main_points)
-                    .h2("Conclusion")
-                    .paragraph(self.conclusion)
-                    .build()
-                )
-
-        # Usage with LLM:
-        llm = ChatOpenAI(model="gpt-4o")
-        structured_llm = llm.with_structured_output(BlogPost)
-        blog = structured_llm.invoke("Write about Python async/await")
-
-        # Upload to Notion:
-        await blog.append_to_page("My Blog")
-    """
-
-    def to_notion_content(self, builder: MarkdownBuilder) -> str:
-        """
-        Build Notion content using the provided MarkdownBuilder.
-
-        Args:
-            builder: Empty MarkdownBuilder instance to build content with
-
-        Returns:
-            str: The final markdown string (user should call build() on the builder)
-        """
-        raise NotImplementedError("Subclasses must implement to_notion_content()")
-
-    async def append_to_page(self, page_name: str):
-        """
-        Upload this content directly to a Notion page.
-
-        Args:
-            page_name: Name of the target Notion page
-        """
-        from notionary import NotionPage
-
-        # Create fresh builder and let subclass build content
-        builder = MarkdownBuilder()
-        markdown = self.to_notion_content(builder)
-
-        page = await NotionPage.from_page_name(page_name)
-        await page.append_markdown(markdown)

notionary/shared/__init__.py

@@ -1,3 +0,0 @@
-from .name_to_id_resolver import NameIdResolver
-
-__all__ = ["NameIdResolver"]

notionary/shared/name_to_id_resolver.py

@@ -1,203 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional
-
-from notionary.user.notion_user_manager import NotionUserManager
-from notionary.util import format_uuid
-from notionary.util.fuzzy import find_best_match
-
-
-class NameIdResolver:
-    """
-    Bidirectional resolver for Notion page and database names and IDs.
-    """
-
-    def __init__(
-        self,
-        *,
-        token: Optional[str] = None,
-        search_limit: int = 10,
-    ):
-        """
-        Initialize the resolver with a Notion workspace.
-        """
-        from notionary import NotionWorkspace
-
-        self.workspace = NotionWorkspace(token=token)
-        self.notion_user_manager = NotionUserManager(token=token)
-        self.search_limit = search_limit
-
-    async def resolve_page_id(self, name: str) -> Optional[str]:
-        """
-        Convert a page name to its Notion page ID.
-        Specifically searches only pages, not databases.
-        """
-        if not name:
-            return None
-
-        cleaned_name = name.strip()
-
-        # Return if already a valid Notion ID
-        formatted_uuid = format_uuid(cleaned_name)
-        if formatted_uuid:
-            return formatted_uuid
-
-        # Search for page by name
-        return await self._resolve_page_id(cleaned_name)
-
-    async def resolve_database_id(self, name: str) -> Optional[str]:
-        """
-        Convert a database name to its Notion database ID.
-        Specifically searches only databases, not pages.
-        """
-        if not name:
-            return None
-
-        cleaned_name = name.strip()
-
-        formatted_uuid = format_uuid(cleaned_name)
-        if formatted_uuid:
-            return formatted_uuid
-
-        return await self._resolve_database_id(cleaned_name)
-
-    async def resolve_page_name(self, page_id: str) -> Optional[str]:
-        """
-        Convert a Notion page ID to its human-readable title.
-        """
-        if not page_id:
-            return None
-
-        formatted_id = format_uuid(page_id)
-        if not formatted_id:
-            return None
-
-        try:
-            from notionary import NotionPage
-
-            page = await NotionPage.from_page_id(formatted_id)
-            return page.title if page else None
-        except Exception:
-            return None
-
-    async def resolve_database_name(self, database_id: str) -> Optional[str]:
-        """
-        Convert a Notion database ID to its human-readable title.
-        """
-        if not database_id:
-            return None
-
-        # Validate and format UUID
-        formatted_id = format_uuid(database_id)
-        if not formatted_id:
-            return None
-
-        try:
-            from notionary.database import NotionDatabase
-
-            database = await NotionDatabase.from_database_id(formatted_id)
-            return database.title if database else None
-        except Exception:
-            return None
-
-    async def resolve_user_id(self, name: str) -> Optional[str]:
-        """
-        Convert a user name to its Notion user ID.
-        Specifically searches only users.
-        """
-        if not name:
-            return None
-
-        cleaned_name = name.strip()
-
-        # Return if already a valid Notion ID
-        formatted_uuid = format_uuid(cleaned_name)
-        if formatted_uuid:
-            return formatted_uuid
-
-        # Search for user by name
-        return await self._resolve_user_id(cleaned_name)
-
-    async def resolve_user_name(self, user_id: str) -> Optional[str]:
-        """
-        Convert a Notion user ID to its human-readable name.
-
-        Args:
-            user_id: Notion user ID to resolve
-
-        Returns:
-            User name if found, None if not found or inaccessible
-        """
-        if not user_id:
-            return None
-
-        # Validate and format UUID
-        formatted_id = format_uuid(user_id)
-        if not formatted_id:
-            return None
-
-        try:
-            user = await self.notion_user_manager.get_user_by_id(formatted_id)
-            return user.name if user else None
-        except Exception:
-            return None
-
-    async def _resolve_user_id(self, name: str) -> Optional[str]:
-        """Search for users matching the name."""
-        try:
-            users = await self.notion_user_manager.find_users_by_name(name)
-
-            if not users:
-                return None
-
-            # Use fuzzy matching to find best match
-            best_match = find_best_match(
-                query=name,
-                items=users,
-                text_extractor=lambda user: user.name or "",
-            )
-
-            return best_match.item.id if best_match else None
-        except Exception:
-            return None
-
-    async def _resolve_page_id(self, name: str) -> Optional[str]:
-        """Search for pages matching the name."""
-        search_results = await self.workspace.search_pages(
-            query=name, limit=self.search_limit
-        )
-
-        return self._find_best_fuzzy_match(query=name, candidate_objects=search_results)
-
-    async def _resolve_database_id(self, name: str) -> Optional[str]:
-        """Search for databases matching the name."""
-        search_results = await self.workspace.search_databases(
-            query=name, limit=self.search_limit
-        )
-
-        return self._find_best_fuzzy_match(query=name, candidate_objects=search_results)
-
-    def _find_best_fuzzy_match(
-        self, query: str, candidate_objects: list
-    ) -> Optional[str]:
-        """
-        Find the best fuzzy match among candidate objects using existing fuzzy matching logic.
-
-        Args:
-            query: The search query to match against
-            candidate_objects: Objects (pages or databases) with .id and .title attributes
-
-        Returns:
-            ID of best match, or None if no match meets threshold
-        """
-        if not candidate_objects:
-            return None
-
-        # Use existing fuzzy matching logic
-        best_match = find_best_match(
-            query=query,
-            items=candidate_objects,
-            text_extractor=lambda obj: obj.title,
-        )
-
-        return best_match.item.id if best_match else None

notionary/telemetry/__init__.py

@@ -1,19 +0,0 @@
-from .service import ProductTelemetry
-from .views import (
-    BaseTelemetryEvent,
-    DatabaseFactoryUsedEvent,
-    MarkdownToNotionConversionEvent,
-    NotionMarkdownSyntaxPromptEvent,
-    NotionToMarkdownConversionEvent,
-    QueryOperationEvent,
-)
-
-__all__ = [
-    "ProductTelemetry",
-    "BaseTelemetryEvent",
-    "DatabaseFactoryUsedEvent",
-    "QueryOperationEvent",
-    "NotionMarkdownSyntaxPromptEvent",
-    "MarkdownToNotionConversionEvent",
-    "NotionToMarkdownConversionEvent",
-]

notionary/telemetry/service.py

@@ -1,136 +0,0 @@
-import os
-import uuid
-from pathlib import Path
-
-from dotenv import load_dotenv
-from posthog import Posthog
-
-from notionary.telemetry.views import BaseTelemetryEvent
-from notionary.util import LoggingMixin, SingletonMetaClass
-
-load_dotenv()
-
-POSTHOG_EVENT_SETTINGS = {
-    "process_person_profile": True,
-}
-
-
-class ProductTelemetry(LoggingMixin, metaclass=SingletonMetaClass):
-    """
-    Anonymous telemetry for Notionary - enabled by default.
-    Disable via: ANONYMIZED_NOTIONARY_TELEMETRY=false
-    """
-
-    USER_ID_PATH = str(Path.home() / ".cache" / "notionary" / "telemetry_user_id")
-    PROJECT_API_KEY = "phc_gItKOx21Tc0l07C1taD0QPpqFnbWgWjVfRjF6z24kke"
-    HOST = "https://eu.i.posthog.com"
-    UNKNOWN_USER_ID = "UNKNOWN"
-
-    _logged_init_message = False
-    _curr_user_id = None
-
-    def __init__(self):
-        # Default: enabled, disable via environment variable
-        telemetry_setting = os.getenv("ANONYMIZED_NOTIONARY_TELEMETRY", "true").lower()
-        telemetry_disabled = telemetry_setting == "false"
-        self.debug_logging = os.getenv("NOTIONARY_DEBUG", "false").lower() == "true"
-
-        if telemetry_disabled:
-            self._posthog_client = None
-        else:
-            if not self._logged_init_message:
-                self.logger.info(
-                    "Anonymous telemetry enabled to improve Notionary. "
-                    "To disable: export ANONYMIZED_NOTIONARY_TELEMETRY=false"
-                )
-                self._logged_init_message = True
-
-            self._posthog_client = Posthog(
-                project_api_key=self.PROJECT_API_KEY,
-                host=self.HOST,
-                disable_geoip=True,
-                enable_exception_autocapture=True,
-            )
-
-            # Silence posthog's logging unless debug mode
-            if not self.debug_logging:
-                import logging
-
-                posthog_logger = logging.getLogger("posthog")
-                posthog_logger.disabled = True
-
-        if self._posthog_client is None:
-            self.logger.debug("Telemetry disabled")
-
-    def capture(self, event: BaseTelemetryEvent) -> None:
-        """
-        Safe event tracking that never affects library functionality
-
-        Args:
-            event: BaseTelemetryEvent instance to capture
-        """
-        if self._posthog_client is None:
-            return
-
-        self._direct_capture(event)
-
-    def _direct_capture(self, event: BaseTelemetryEvent) -> None:
-        """
-        Direct capture method - PostHog handles threading internally
-        Should not be thread blocking because posthog magically handles it
-        """
-        if self._posthog_client is None:
-            return
-
-        try:
-            self._posthog_client.capture(
-                distinct_id=self.user_id,
-                event=event.name,
-                properties={
-                    "library": "notionary",
-                    **event.properties,
-                    **POSTHOG_EVENT_SETTINGS,
-                },
-            )
-
-        except Exception as e:
-            self.logger.error(f"Failed to send telemetry event {event.name}: {e}")
-
-    def flush(self) -> None:
-        """
-        Flush pending events - simplified without threading complexity
-        """
-        if not self._posthog_client:
-            self.logger.debug("PostHog client not available, skipping flush.")
-            return
-
-        try:
-            self._posthog_client.flush()
-            self.logger.debug("PostHog client telemetry queue flushed.")
-        except Exception as e:
-            self.logger.error(f"Failed to flush PostHog client: {e}")
-
-    @property
-    def user_id(self) -> str:
-        """Anonymous, persistent user ID"""
-        if self._curr_user_id:
-            return self._curr_user_id
-
-        # File access may fail due to permissions or other reasons.
-        # We don't want to crash so we catch all exceptions.
-        try:
-            if not os.path.exists(self.USER_ID_PATH):
-                os.makedirs(os.path.dirname(self.USER_ID_PATH), exist_ok=True)
-                with open(self.USER_ID_PATH, "w") as f:
-                    new_user_id = str(uuid.uuid4())
-                    f.write(new_user_id)
-                self._curr_user_id = new_user_id
-            else:
-                with open(self.USER_ID_PATH, "r") as f:
-                    self._curr_user_id = f.read().strip()
-
-            return self._curr_user_id
-        except Exception as e:
-            self.logger.debug(f"Error getting user ID: {e}")
-            self._curr_user_id = self.UNKNOWN_USER_ID
-            return self._curr_user_id

notionary/telemetry/views.py

@@ -1,73 +0,0 @@
-from abc import ABC, abstractmethod
-from dataclasses import asdict, dataclass
-from typing import Any, Optional
-
-
-@dataclass
-class BaseTelemetryEvent(ABC):
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        pass
-
-    @property
-    def properties(self) -> dict[str, Any]:
-        return {k: v for k, v in asdict(self).items() if k != "name"}
-
-
-@dataclass
-class DatabaseFactoryUsedEvent(BaseTelemetryEvent):
-    """Event fired when a database factory method is used"""
-
-    factory_method: str
-
-    @property
-    def name(self) -> str:
-        return "database_factory_used"
-
-
-@dataclass
-class QueryOperationEvent(BaseTelemetryEvent):
-    """Event fired when a query operation is performed"""
-
-    query_type: str
-
-    @property
-    def name(self) -> str:
-        return "query_operation"
-
-
-@dataclass
-class NotionMarkdownSyntaxPromptEvent(BaseTelemetryEvent):
-    """Event fired when Notion Markdown syntax is used"""
-
-    @property
-    def name(self) -> str:
-        return "notion_markdown_syntax_used"
-
-
-# Tracks markdown conversion
-@dataclass
-class MarkdownToNotionConversionEvent(BaseTelemetryEvent):
-    """Event fired when markdown is converted to Notion blocks"""
-
-    handler_element_name: Optional[str] = (
-        None  # e.g. "HeadingElement", "ParagraphElement"
-    )
-
-    @property
-    def name(self) -> str:
-        return "markdown_to_notion_conversion"
-
-
-@dataclass
-class NotionToMarkdownConversionEvent(BaseTelemetryEvent):
-    """Event fired when Notion blocks are converted to markdown"""
-
-    handler_element_name: Optional[str] = (
-        None  # e.g. "HeadingElement", "ParagraphElement"
-    )
-
-    @property
-    def name(self) -> str:
-        return "notion_to_markdown_conversion"

notionary/user/base_notion_user.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC
-from typing import Optional
-
-from notionary.user.client import NotionUserClient
-from notionary.util import LoggingMixin
-
-
-class BaseNotionUser(LoggingMixin, ABC):
-    """
-    Base class for all Notion user types with common functionality.
-    """
-
-    def __init__(
-        self,
-        user_id: str,
-        name: Optional[str] = None,
-        avatar_url: Optional[str] = None,
-        token: Optional[str] = None,
-    ):
-        """Initialize base user properties."""
-        self._user_id = user_id
-        self._name = name
-        self._avatar_url = avatar_url
-        self.client = NotionUserClient(token=token)
-
-    @property
-    def id(self) -> str:
-        """Get the user ID."""
-        return self._user_id
-
-    @property
-    def name(self) -> Optional[str]:
-        """Get the user name."""
-        return self._name
-
-    @property
-    def avatar_url(self) -> Optional[str]:
-        """Get the avatar URL."""
-        return self._avatar_url
-
-    def get_display_name(self) -> str:
-        """Get a display name for the user."""
-        return self._name or f"User {self._user_id[:8]}"
-
-    def __str__(self) -> str:
-        """String representation of the user."""
-        return f"{self.__class__.__name__}(name='{self.get_display_name()}', id='{self._user_id[:8]}...')"
-
-    def __repr__(self) -> str:
-        """Detailed string representation."""
-        return self.__str__()

notionary/user/models.py

@@ -1,84 +0,0 @@
-from dataclasses import dataclass
-from typing import Literal, Optional
-
-from pydantic import BaseModel
-
-
-class PersonUser(BaseModel):
-    """Person user details"""
-
-    email: Optional[str] = None
-
-
-class BotOwner(BaseModel):
-    """Bot owner information - simplified structure"""
-
-    type: Literal["workspace", "user"]
-    workspace: Optional[bool] = None
-
-
-class WorkspaceLimits(BaseModel):
-    """Workspace limits for bot users"""
-
-    max_file_upload_size_in_bytes: int
-
-
-class BotUser(BaseModel):
-    """Bot user details"""
-
-    owner: Optional[BotOwner] = None
-    workspace_name: Optional[str] = None
-    workspace_limits: Optional[WorkspaceLimits] = None
-
-
-class NotionUserResponse(BaseModel):
-    """
-    Represents a Notion user object as returned by the Users API.
-    Can represent both person and bot users.
-    """
-
-    object: Literal["user"]
-    id: str
-    type: Optional[Literal["person", "bot"]] = None
-    name: Optional[str] = None
-    avatar_url: Optional[str] = None
-
-    # Person-specific fields
-    person: Optional[PersonUser] = None
-
-    # Bot-specific fields
-    bot: Optional[BotUser] = None
-
-
-class NotionBotUserResponse(NotionUserResponse):
-    """
-    Specialized response for bot user (from /users/me endpoint)
-    """
-
-    # Bot users should have these fields, but they can still be None
-    type: Literal["bot"]
-    bot: Optional[BotUser] = None
-
-
-class NotionUsersListResponse(BaseModel):
-    """
-    Response model for paginated users list from /v1/users endpoint.
-    Follows Notion's standard pagination pattern.
-    """
-
-    object: Literal["list"]
-    results: list[NotionUserResponse]
-    next_cursor: Optional[str] = None
-    has_more: bool
-    type: Literal["user"]
-    user: dict = {}
-
-
-@dataclass
-class WorkspaceInfo:
-    """Dataclass to hold workspace information for bot users."""
-
-    name: Optional[str] = None
-    limits: Optional[WorkspaceLimits] = None
-    owner_type: Optional[str] = None
-    is_workspace_owned: bool = False