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

notionary/util/fuzzy.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-import difflib
-from dataclasses import dataclass
-from typing import Any, Callable, List, Optional, TypeVar
-
-T = TypeVar("T")
-
-
-@dataclass
-class MatchResult:
-    """Result of a fuzzy match operation."""
-
-    item: Any
-    similarity: float
-    matched_text: str
-
-
-def calculate_similarity(query: str, target: str) -> float:
-    """Calculate similarity between two strings using difflib."""
-    return difflib.SequenceMatcher(
-        None, query.lower().strip(), target.lower().strip()
-    ).ratio()
-
-
-def find_best_matches(
-    query: str,
-    items: List[T],
-    text_extractor: Callable[[T], str],
-    min_similarity: float = 0.0,
-    limit: Optional[int] = None,
-) -> List[MatchResult[T]]:
-    """
-    Find best fuzzy matches from a list of items.
-
-    Args:
-        query: The search query
-        items: List of items to search through
-        text_extractor: Function to extract text from each item
-        min_similarity: Minimum similarity threshold (0.0 to 1.0)
-        limit: Maximum number of results to return
-
-    Returns:
-        List of MatchResult objects sorted by similarity (highest first)
-    """
-    results = []
-
-    for item in items:
-        text = text_extractor(item)
-        similarity = calculate_similarity(query, text)
-
-        if similarity >= min_similarity:
-            results.append(
-                MatchResult(item=item, similarity=similarity, matched_text=text)
-            )
-
-    # Sort by similarity (highest first)
-    results.sort(key=lambda x: x.similarity, reverse=True)
-
-    # Apply limit if specified
-    if limit:
-        results = results[:limit]
-
-    return results
-
-
-def find_best_match(
-    query: str,
-    items: List[T],
-    text_extractor: Callable[[T], str],
-    min_similarity: float = 0.0,
-) -> Optional[MatchResult[T]]:
-    """Find the single best fuzzy match."""
-    matches = find_best_matches(query, items, text_extractor, min_similarity, limit=1)
-    return matches[0] if matches else None

notionary/util/logging_mixin.py

@@ -1,59 +0,0 @@
-import logging
-import os
-from typing import ClassVar, Optional
-
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-def setup_logging():
-    """
-    Sets up logging configuration for the application.
-    """
-    log_level = os.getenv("LOG_LEVEL", "WARNING").upper()
-    logging.basicConfig(
-        level=getattr(logging, log_level),
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    )
-
-    logging.getLogger("httpx").setLevel(logging.WARNING)
-
-
-setup_logging()
-
-
-class LoggingMixin:
-    # Class attribute with proper typing
-    logger: ClassVar[logging.Logger] = None
-
-    def __init_subclass__(cls, **kwargs):
-        """
-        This method is called when a class inherits from LoggingMixin.
-        It automatically sets up the logger as a class attribute.
-        """
-        super().__init_subclass__(**kwargs)
-        cls.logger = logging.getLogger(cls.__name__)
-
-    @property
-    def instance_logger(self) -> logging.Logger:
-        """Instance logger - for instance methods"""
-        if not hasattr(self, "_logger"):
-            self._logger = logging.getLogger(self.__class__.__name__)
-        return self._logger
-
-    @staticmethod
-    def _get_class_name_from_frame(frame) -> Optional[str]:
-        local_vars = frame.f_locals
-        if "self" in local_vars:
-            return local_vars["self"].__class__.__name__
-
-        if "cls" in local_vars:
-            return local_vars["cls"].__name__
-
-        if "__qualname__" in frame.f_code.co_names:
-            qualname = frame.f_code.co_qualname
-            if "." in qualname:
-                return qualname.split(".")[0]
-
-        return None

notionary/util/page_id_utils.py

@@ -1,27 +0,0 @@
-import re
-from typing import Optional
-
-UUID_PATTERN = r"^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$"
-UUID_RAW_PATTERN = r"([a-f0-9]{32})"
-
-
-def extract_uuid(source: str) -> Optional[str]:
-    if is_valid_uuid(source):
-        return source
-
-    match = re.search(UUID_RAW_PATTERN, source.lower())
-    if not match:
-        return None
-
-    uuid_raw = match.group(1)
-    return f"{uuid_raw[0:8]}-{uuid_raw[8:12]}-{uuid_raw[12:16]}-{uuid_raw[16:20]}-{uuid_raw[20:32]}"
-
-
-def is_valid_uuid(uuid: str) -> bool:
-    return bool(re.match(UUID_PATTERN, uuid.lower()))
-
-
-def format_uuid(value: str) -> Optional[str]:
-    if is_valid_uuid(value):
-        return value
-    return extract_uuid(value)

notionary/util/singleton.py

@@ -1,18 +0,0 @@
-def singleton(cls):
-    """
-    Simple singleton decorator that ensures only one instance of a class exists.
-
-    Usage:
-        @singleton
-        class MyClass:
-            pass
-    """
-    instances = {}
-
-    def __new__(cls, *args, **kwargs):
-        if cls not in instances:
-            instances[cls] = super(cls, cls).__new__(cls)
-        return instances[cls]
-
-    cls.__new__ = __new__
-    return cls

notionary/util/singleton_metaclass.py

@@ -1,22 +0,0 @@
-from typing import Any, Dict, Type, TypeVar, cast
-
-T = TypeVar("T")
-
-
-class SingletonMetaClass(type):
-    """
-    A metaclass that ensures a class has only a single instance.
-    Provides a get_instance() method with proper type hinting.
-    """
-
-    _instances: Dict[Type, Any] = {}
-
-    def __call__(cls: Type[T], *args: Any, **kwargs: Any) -> T:
-        """Called when the class is instantiated (e.g., MyClass())."""
-        if cls not in cls._instances:
-            cls._instances[cls] = super().__call__(*args, **kwargs)
-        return cast(T, cls._instances[cls])
-
-    def get_instance(cls: Type[T], *args: Any, **kwargs: Any) -> T:
-        """Explicit method to retrieve the singleton instance with correct return type."""
-        return cls(*args, **kwargs)  # Triggers __call__

notionary/workspace.py

@@ -1,105 +0,0 @@
-import asyncio
-from typing import Optional
-
-from notionary import NotionDatabase, NotionPage
-from notionary.database.client import NotionDatabaseClient
-from notionary.page.client import NotionPageClient
-from notionary.user import NotionUser, NotionUserManager
-from notionary.util import LoggingMixin
-
-
-class NotionWorkspace(LoggingMixin):
-    """
-    Represents a Notion workspace, providing methods to interact with databases, pages, and limited user operations.
-
-    Note: Due to Notion API limitations, bulk user operations (listing all users) are not supported.
-    Only individual user queries and bot user information are available.
-    """
-
-    def __init__(self, token: Optional[str] = None):
-        """
-        Initialize the workspace with Notion clients.
-        """
-        self.database_client = NotionDatabaseClient(token=token)
-        self.page_client = NotionPageClient(token=token)
-        self.user_manager = NotionUserManager(token=token)
-
-    async def search_pages(self, query: str, limit=100) -> list[NotionPage]:
-        """
-        Search for pages globally across Notion workspace.
-        """
-        response = await self.page_client.search_pages(query, limit=limit)
-        return await asyncio.gather(
-            *(NotionPage.from_page_id(page.id) for page in response.results)
-        )
-
-    async def search_databases(
-        self, query: str, limit: int = 100
-    ) -> list[NotionDatabase]:
-        """
-        Search for databases globally across the Notion workspace.
-        """
-        response = await self.database_client.search_databases(query=query, limit=limit)
-        return await asyncio.gather(
-            *(
-                NotionDatabase.from_database_id(database.id)
-                for database in response.results
-            )
-        )
-
-    async def get_database_by_name(
-        self, database_name: str
-    ) -> Optional[NotionDatabase]:
-        """
-        Get a Notion database by its name.
-        Uses Notion's search API and returns the first matching database.
-        """
-        databases = await self.search_databases(query=database_name, limit=1)
-
-        return databases[0] if databases else None
-
-    async def list_all_databases(self, limit: int = 100) -> list[NotionDatabase]:
-        """
-        List all databases in the workspace.
-        Returns a list of NotionDatabase instances.
-        """
-        database_results = await self.database_client.search_databases(
-            query="", limit=limit
-        )
-        return [
-            await NotionDatabase.from_database_id(database.id)
-            for database in database_results.results
-        ]
-
-    # User-related methods (limited due to API constraints)
-    async def get_current_bot_user(self) -> Optional[NotionUser]:
-        """
-        Get the current bot user from the API token.
-
-        Returns:
-            Optional[NotionUser]: Current bot user or None if failed
-        """
-        return await self.user_manager.get_current_bot_user()
-
-    async def get_user_by_id(self, user_id: str) -> Optional[NotionUser]:
-        """
-        Get a specific user by their ID.
-
-        Args:
-            user_id: The ID of the user to retrieve
-
-        Returns:
-            Optional[NotionUser]: The user or None if not found/failed
-        """
-        return await self.user_manager.get_user_by_id(user_id)
-
-    async def get_workspace_info(self) -> Optional[dict]:
-        """
-        Get available workspace information including bot details.
-
-        Returns:
-            Optional[dict]: Workspace information or None if failed to get bot user
-        """
-        return await self.user_manager.get_workspace_info()
-
-    # TODO: Create database would be nice here

notionary-0.2.27.dist-info/METADATA

@@ -1,270 +0,0 @@
-Metadata-Version: 2.3
-Name: notionary
-Version: 0.2.27
-Summary: Python library for programmatic Notion workspace management - databases, pages, and content with advanced Markdown support
-License: MIT
-Author: Mathis Arends
-Author-email: mathisarends27@gmail.com
-Requires-Python: >=3.9
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
-Requires-Dist: httpx (>=0.28.0)
-Requires-Dist: posthog (>=6.3.1,<7.0.0)
-Requires-Dist: pydantic (>=2.11.4)
-Requires-Dist: python-dotenv (>=1.1.0)
-Project-URL: Homepage, https://github.com/mathisarends/notionary
-Description-Content-Type: text/markdown
-
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="./static/notionary-dark.png">
-  <source media="(prefers-color-scheme: light)" srcset="./static/notionary-light.png">
-  <img alt="Notionary logo: dark mode shows a white logo, light mode shows a black logo." src="./static/browser-use.png"  width="full">
-</picture>
-
-<h1 align="center">The Modern Notion API for Python & AI Agents</h1>
-
-<div align="center">
-
-[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
-[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Documentation](https://img.shields.io/badge/docs-mathisarends.github.io-blue.svg)](https://mathisarends.github.io/notionary/)
-
-**Transform complex Notion API interactions into simple, Pythonic code.**  
-Perfect for developers building AI agents, automation workflows, and dynamic content systems.
-
-</div>
-
----
-
-## Why Notionary?
-
-- **AI-Native Design** - Built specifically for AI agents with schema-driven markdown syntax
-- **Smart Discovery** - Find pages and databases by name with fuzzy matching—no more hunting for IDs
-- **Extended Markdown** - Rich syntax for toggles, columns, callouts, and media uploads
-- **Async-First** - Modern Python with full async/await support and high performance
-- **Round-Trip** - Read existing content, modify it, and write it back while preserving formatting
-- **Complete Coverage** - Every Notion block type supported with type safety
-
----
-
-## Installation
-
-```bash
-pip install notionary
-```
-
-Set up your [Notion integration](https://www.notion.so/profile/integrations) and configure your token:
-
-```bash
-export NOTION_SECRET=your_integration_key
-```
-
----
-
-## See It in Action
-
-### Creating Rich Database Entries
-
-https://github.com/user-attachments/assets/da8b4691-bee4-4b0f-801e-dccacb630398
-
-*Create styled project pages with properties, content, and rich formatting*
-
-### Local File Uploads (Videos & Images)
-
-https://github.com/user-attachments/assets/a079ec01-bb56-4c65-8260-7b1fca42ac68
-
-*Upload videos and images using simple markdown syntax - files are automatically uploaded to Notion*
-
----
-
-## Quick Start
-
-### Find → Create → Update Flow
-
-```python
-import asyncio
-from notionary import NotionPage, NotionDatabase
-
-async def main():
-    # Find pages by name - fuzzy matching included!
-    page = await NotionPage.from_page_name("Meeting Notes")
-    
-    # Option 1: Direct Extended Markdown
-    await page.append_markdown("""
-    ## Action Items
-    - [x] Review project proposal
-    - [ ] Schedule team meeting  
-    - [ ] Update documentation
-
-    [callout](Meeting decisions require follow-up "💡")
-    
-    +++ Details
-    Additional context and next steps...
-    +++
-    """)
-    
-    # Option 2: Type-Safe Builder (maps to same markdown internally)
-    await page.append_markdown(lambda builder: (
-        builder
-        .h2("Project Status") 
-        .callout("Milestone reached!", "🎉")
-        .columns(
-            lambda col: col.h3("Completed").bulleted_list([
-                "API design", "Database setup", "Authentication"
-            ]),
-            lambda col: col.h3("In Progress").bulleted_list([
-                "Frontend UI", "Testing", "Documentation"  
-            ]),
-            width_ratios=[0.6, 0.4]
-        )
-        .toggle("Budget Details", lambda t: t
-            .table(["Item", "Cost", "Status"], [
-                ["Development", "$15,000", "Paid"],
-                ["Design", "$8,000", "Pending"]
-            ])
-        )
-    ))
-
-asyncio.run(main())
-```
-
-### Complete Block Support
-
-Every Notion block type with extended syntax:
-
-| Block Type | Markdown Syntax | Use Case |
-|------------|-----------------|----------|
-| **Callouts** | `[callout](Text "🔥")` | Highlighting key information |
-| **Toggles** | `+++ Title\nContent\n+++` | Collapsible sections |
-| **Columns** | `::: columns\n::: column\nContent\n:::\n:::` | Side-by-side layouts |
-| **Tables** | Standard markdown tables | Structured data |
-| **Media** | `[video](./file.mp4)(caption:Description)` | Auto-uploading files |
-| **Code** | Standard code fences with captions | Code snippets |
-| **Equations** | `$LaTeX$` | Mathematical expressions |
-| **TOC** | `[toc](blue_background)` | Auto-generated navigation |
-
----
-
-## What You Can Build 💡
-
-### **AI Content Systems**
-- **Report Generation**: AI agents that create structured reports, documentation, and analysis
-- **Content Pipelines**: Automated workflows that process data and generate Notion pages
-- **Knowledge Management**: AI-powered documentation systems with smart categorization
-
-### **Workflow Automation**  
-- **Project Management**: Sync project status, update timelines, generate progress reports
-- **Data Integration**: Connect external APIs and databases to Notion workspaces
-- **Template Systems**: Dynamic page generation from templates and data sources
-
-### **Content Management**
-- **Bulk Operations**: Mass page updates, content migration, and database management  
-- **Media Handling**: Automated image/video uploads with proper organization
-- **Cross-Platform**: Sync content between Notion and other platforms
-
----
-
-## Key Features
-
-<table>
-<tr>
-<td width="50%">
-
-### Smart Discovery
-- Find pages/databases by name
-- Fuzzy matching for approximate searches  
-- No more hunting for IDs or URLs
-
-### Extended Markdown
-- Rich syntax beyond standard markdown
-- Callouts, toggles, columns, media uploads
-- Schema provided for AI agent integration
-
-### Modern Python 
-- Full async/await support
-- Type hints throughout  
-- High-performance batch operations
-
-</td>
-<td width="50%">
-
-### Round-Trip Editing
-- Read existing content as markdown
-- Edit and modify preserving formatting
-- Write back to Notion seamlessly
-
-### AI-Ready Architecture
-- Schema-driven syntax for LLM prompts
-- Perfect for AI content generation
-- Handles complex nested structures
-
-### Complete Coverage
-- Every Notion block type supported
-- File uploads with automatic handling
-- Database operations and properties
-
-</td>
-</tr>
-</table>
-
----
-
-## Examples & Documentation
-
-### Full Documentation
-[**mathisarends.github.io/notionary**](https://mathisarends.github.io/notionary/) - Complete API reference, guides, and tutorials
-
-### Quick Links
-- [**Getting Started**](https://mathisarends.github.io/notionary/get-started/) - Setup and first steps
-- [**Page Management**](https://mathisarends.github.io/notionary/page/) - Content and properties  
-- [**Database Operations**](https://mathisarends.github.io/notionary/database/) - Queries and management
-- [**Block Types Reference**](https://mathisarends.github.io/notionary/blocks/) - Complete syntax guide
-
-### Hands-On Examples
-
-**Core Functionality:**
-- [Page Management](examples/page_example.py) - Create, update, and manage pages
-- [Database Operations](examples/database.py) - Connect and query databases  
-- [Workspace Discovery](examples/workspace_discovery.py) - Explore your workspace
-
-**Extended Markdown:**
-- [Basic Formatting](examples/markdown/basic.py) - Text, lists, and links
-- [Callouts & Highlights](examples/markdown/callout.py) - Information boxes  
-- [Toggle Sections](examples/markdown/toggle.py) - Collapsible content
-- [Multi-Column Layouts](examples/markdown/columns.py) - Side-by-side design
-- [Tables & Data](examples/markdown/table.py) - Structured presentations
-
----
-
-## Contributing
-
-We welcome contributions from the community! Whether you're:
-- **Fixing bugs** - Help improve stability and reliability
-- **Adding features** - Extend functionality for new use cases  
-- **Improving docs** - Make the library more accessible
-- **Sharing examples** - Show creative applications and patterns
-
-Check our [**Contributing Guide**](https://mathisarends.github.io/notionary/contributing/) to get started.
-
----
-
-<div align="center">
-
-**Ready to revolutionize your Notion workflows?**
-
-[📖 **Read the Docs**](https://mathisarends.github.io/notionary/) • [🚀 **Getting Started**](https://mathisarends.github.io/notionary/get-started/) • [💻 **Browse Examples**](examples/)
-
-*Built with ❤️ for Python developers and AI agents*
-
----
-
-**Transform complex Notion API interactions into simple, powerful code.**
-
-</div>
-