notionary 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

notionary/cli/main.py

@@ -6,18 +6,45 @@ Notionary CLI - Integration Key Setup
 import click
 import os
 import platform
+import asyncio
+import logging
 from pathlib import Path
 from dotenv import load_dotenv
 from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Prompt, Confirm
+from rich.table import Table
+from rich import box
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from notionary.workspace import NotionWorkspace
+
+
+# Disable logging for CLI usage
+def disable_notionary_logging():
+    """Disable logging for notionary modules when used in CLI"""
+    # Option 1: Set to WARNING level (recommended for CLI)
+    logging.getLogger("notionary").setLevel(logging.WARNING)
+    logging.getLogger("DatabaseDiscovery").setLevel(logging.WARNING)
+    logging.getLogger("NotionClient").setLevel(logging.WARNING)
+
+
+def enable_verbose_logging():
+    """Enable verbose logging for debugging (use with --verbose flag)"""
+    logging.getLogger("notionary").setLevel(logging.DEBUG)
+    logging.getLogger("DatabaseDiscovery").setLevel(logging.DEBUG)
+    logging.getLogger("NotionClient").setLevel(logging.DEBUG)
+
+
+# Initialize logging configuration for CLI
+disable_notionary_logging()
 
 console = Console()
 
+
 def get_paste_tips():
     """Get platform-specific paste tips"""
     system = platform.system().lower()
-    
+
     if system == "darwin":  # macOS
         return [
             "• Terminal: [cyan]Cmd+V[/cyan]",
@@ -34,6 +61,7 @@ def get_paste_tips():
             "• Some terminals: [cyan]Shift+Insert[/cyan]",
         ]
 
+
 def show_paste_tips():
     """Show platform-specific paste tips"""
     console.print("\n[bold yellow]💡 Paste Tips:[/bold yellow]")
@@ -41,19 +69,142 @@ def show_paste_tips():
         console.print(tip)
     console.print()
 
+
 def get_notion_secret() -> str:
     """Get NOTION_SECRET using the same logic as NotionClient"""
     load_dotenv()
     return os.getenv("NOTION_SECRET", "")
 
+
+async def fetch_notion_databases_with_progress():
+    """Fetch databases using DatabaseDiscovery with progress animation"""
+    try:
+        workspace = NotionWorkspace()
+
+        # Create progress display with custom spinner
+        with Progress(
+            SpinnerColumn(spinner_name="dots12", style="cyan"),
+            TextColumn("[bold blue]Discovering databases..."),
+            TimeElapsedColumn(),
+            console=console,
+            transient=True,
+        ) as progress:
+            # Add progress task
+            task = progress.add_task("Fetching...", total=None)
+
+            # Fetch databases
+            databases = await workspace.list_all_databases(limit=50)
+
+            # Update progress to show completion
+            progress.update(
+                task, description=f"[bold green]Found {len(databases)} databases!"
+            )
+
+            # Brief pause to show completion
+            await asyncio.sleep(0.5)
+
+        return {"databases": databases, "success": True}
+
+    except Exception as e:
+        return {"error": str(e), "success": False}
+
+
+def show_databases_overview(api_key: str):
+    """Show available databases with nice formatting"""
+    console.print("\n[bold blue]🔍 Connecting to Notion...[/bold blue]")
+
+    # Run async function in sync context
+    try:
+        result = asyncio.run(fetch_notion_databases_with_progress())
+    except Exception as e:
+        console.print(
+            Panel.fit(
+                f"[bold red]❌ Unexpected error[/bold red]\n\n"
+                f"[red]{str(e)}[/red]\n\n"
+                "[yellow]Please check:[/yellow]\n"
+                "• Your internet connection\n"
+                "• Your integration key validity\n"
+                "• Try running the command again",
+                title="Connection Error",
+            )
+        )
+        return
+
+    if not result["success"]:
+        console.print(
+            Panel.fit(
+                f"[bold red]❌ Could not fetch databases[/bold red]\n\n"
+                f"[red]{result['error']}[/red]\n\n"
+                "[yellow]Common issues:[/yellow]\n"
+                "• Check your integration key\n"
+                "• Make sure your integration has access to databases\n"
+                "• Visit your integration settings to grant access",
+                title="Connection Error",
+            )
+        )
+        return
+
+    databases = result["databases"]
+
+    if not databases:
+        console.print(
+            Panel.fit(
+                "[bold yellow]⚠️  No databases found[/bold yellow]\n\n"
+                "Your integration key is valid, but no databases are accessible.\n\n"
+                "[bold blue]To grant access:[/bold blue]\n"
+                "1. Go to any Notion database\n"
+                "2. Click the '...' menu (top right)\n"
+                "3. Go to 'Add connections'\n"
+                "4. Find and select your integration\n\n"
+                "[cyan]https://www.notion.so/help/add-and-manage-connections-with-the-api[/cyan]",
+                title="No Databases Available",
+            )
+        )
+        return
+
+    # Create beautiful table
+    table = Table(
+        title=f"📊 Available Databases ({len(databases)} found)",
+        box=box.ROUNDED,
+        title_style="bold green",
+        header_style="bold cyan",
+    )
+
+    table.add_column("#", style="dim", justify="right", width=3)
+    table.add_column("Database Name", style="bold white", min_width=25)
+    table.add_column("ID", style="dim cyan", min_width=36)
+
+    for i, (title, db_id) in enumerate(databases, 1):
+        table.add_row(str(i), title or "Untitled Database", db_id)
+
+    console.print("\n")
+    console.print(table)
+
+    # Success message with next steps
+    console.print(
+        Panel.fit(
+            "[bold green]🎉 Setup Complete![/bold green]\n\n"
+            f"Found [bold cyan]{len(databases)}[/bold cyan] accessible database(s).\n"
+            "You can now use notionary in your Python code!\n\n"
+            "[bold yellow]💡 Tip:[/bold yellow] Run [cyan]notionary db[/cyan] anytime to see this overview again.",
+            title="Ready to Go!",
+        )
+    )
+
+
 @click.group()
 @click.version_option()  # Automatische Version aus setup.py
-def main():
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
+def main(verbose):
     """
     Notionary CLI - Notion API Integration
     """
+    if verbose:
+        enable_verbose_logging()
+        console.print("[dim]Verbose logging enabled[/dim]")
     pass
 
+
 @main.command()
 def init():
     """
@@ -61,31 +212,64 @@ def init():
     """
     # Check if key already exists
     existing_key = get_notion_secret()
-    
+
     if existing_key:
-        console.print(Panel.fit(
-            "[bold green]✅ You're all set![/bold green]\n"
-            f"Your Notion Integration Key is already configured.\n"
-            f"Key: [dim]{existing_key[:8]}...[/dim]",
-            title="Already Configured"
-        ))
-        
-        # Option to reconfigure
-        if Confirm.ask("\n[yellow]Would you like to update your key?[/yellow]"):
+        console.print(
+            Panel.fit(
+                "[bold green]✅ You're all set![/bold green]\n"
+                f"Your Notion Integration Key is already configured.\n"
+                f"Key: [dim]{existing_key[:8]}...[/dim]",
+                title="Already Configured",
+            )
+        )
+
+        # Option to reconfigure or show databases
+        choice = Prompt.ask(
+            "\n[yellow]What would you like to do?[/yellow]",
+            choices=["show", "update", "exit"],
+            default="show",
+        )
+
+        if choice == "show":
+            show_databases_overview(existing_key)
+        elif choice == "update":
             setup_new_key()
         else:
-            console.print("\n[blue]No changes made. Happy coding! 🚀[/blue]")
+            console.print("\n[blue]Happy coding! 🚀[/blue]")
     else:
         # No key found, start setup
-        console.print(Panel.fit(
-            "[bold green]🚀 Notionary Setup[/bold green]\n"
-            "Enter your Notion Integration Key to get started...\n\n"
-            "[bold blue]🔗 Create an Integration Key or get an existing one:[/bold blue]\n"
-            "[cyan]https://www.notion.so/profile/integrations[/cyan]",
-            title="Initialization"
-        ))
+        console.print(
+            Panel.fit(
+                "[bold green]🚀 Notionary Setup[/bold green]\n"
+                "Enter your Notion Integration Key to get started...\n\n"
+                "[bold blue]🔗 Create an Integration Key or get an existing one:[/bold blue]\n"
+                "[cyan]https://www.notion.so/profile/integrations[/cyan]",
+                title="Initialization",
+            )
+        )
         setup_new_key()
 
+
+@main.command()
+def db() -> None:
+    """
+    Show available Notion databases
+    """
+    existing_key = get_notion_secret()
+
+    if not existing_key:
+        console.print(
+            Panel.fit(
+                "[bold red]❌ No Integration Key found![/bold red]\n\n"
+                "Please run [cyan]notionary init[/cyan] first to set up your key.",
+                title="Not Configured",
+            )
+        )
+        return
+
+    show_databases_overview(existing_key)
+
+
 def setup_new_key():
     """Handle the key setup process"""
     try:
@@ -93,92 +277,100 @@ def setup_new_key():
         console.print("\n[bold blue]🔗 Create an Integration Key:[/bold blue]")
         console.print("[cyan]https://www.notion.so/profile/integrations[/cyan]")
         console.print()
-        
+
         # Get integration key
-        integration_key = Prompt.ask(
-            "[bold cyan]Notion Integration Key[/bold cyan]"
-        )
-        
+        integration_key = Prompt.ask("[bold cyan]Notion Integration Key[/bold cyan]")
+
         # Input validation
         if not integration_key or not integration_key.strip():
             console.print("[bold red]❌ Integration Key cannot be empty![/bold red]")
             return
-            
+
         # Trim whitespace
         integration_key = integration_key.strip()
-        
+
         # Check for common paste issues
         if integration_key in ["^V", "^v", "^C", "^c"]:
             console.print("[bold red]❌ Paste didn't work! Try:[/bold red]")
             show_paste_tips()
             return
-        
+
         # Show masked feedback that paste worked
         masked_key = "•" * len(integration_key)
-        console.print(f"[dim]Received: {masked_key} ({len(integration_key)} characters)[/dim]")
-        
+        console.print(
+            f"[dim]Received: {masked_key} ({len(integration_key)} characters)[/dim]"
+        )
+
         # Basic validation for Notion keys
-        if not integration_key.startswith('ntn_') or len(integration_key) < 30:
-            console.print("[bold yellow]⚠️  Warning: This doesn't look like a valid Notion Integration Key[/bold yellow]")
-            console.print("[dim]Notion keys usually start with 'ntn_' and are about 50+ characters long[/dim]")
+        if not integration_key.startswith("ntn_") or len(integration_key) < 30:
+            console.print(
+                "[bold yellow]⚠️  Warning: This doesn't look like a valid Notion Integration Key[/bold yellow]"
+            )
+            console.print(
+                "[dim]Notion keys usually start with 'ntn_' and are about 50+ characters long[/dim]"
+            )
             if not Confirm.ask("Continue anyway?"):
                 return
-        
+
         # Save the key
         if save_integration_key(integration_key):
-            return  # Success!
-        
+            # Show databases overview after successful setup
+            show_databases_overview(integration_key)
+
     except KeyboardInterrupt:
         console.print("\n[yellow]Setup cancelled.[/yellow]")
     except Exception as e:
         console.print(f"\n[bold red]❌ Error during setup: {e}[/bold red]")
         raise click.Abort()
 
+
 def save_integration_key(integration_key: str) -> bool:
     """Save the integration key to .env file"""
     try:
         # .env Datei im aktuellen Verzeichnis erstellen/aktualisieren
         env_file = Path.cwd() / ".env"
-        
+
         # Bestehende .env lesen falls vorhanden
         existing_lines = []
         if env_file.exists():
-            with open(env_file, 'r', encoding='utf-8') as f:
+            with open(env_file, "r", encoding="utf-8") as f:
                 existing_lines = [line.rstrip() for line in f.readlines()]
-        
+
         # NOTION_SECRET Zeile hinzufügen/ersetzen
         updated_lines = []
         notion_secret_found = False
-        
+
         for line in existing_lines:
-            if line.startswith('NOTION_SECRET='):
-                updated_lines.append(f'NOTION_SECRET={integration_key}')
+            if line.startswith("NOTION_SECRET="):
+                updated_lines.append(f"NOTION_SECRET={integration_key}")
                 notion_secret_found = True
             else:
                 updated_lines.append(line)
-        
+
         # Falls NOTION_SECRET noch nicht existiert, hinzufügen
         if not notion_secret_found:
-            updated_lines.append(f'NOTION_SECRET={integration_key}')
-        
+            updated_lines.append(f"NOTION_SECRET={integration_key}")
+
         # .env Datei schreiben
-        with open(env_file, 'w', encoding='utf-8') as f:
-            f.write('\n'.join(updated_lines) + '\n')
-        
+        with open(env_file, "w", encoding="utf-8") as f:
+            f.write("\n".join(updated_lines) + "\n")
+
         # Verification
         written_key = get_notion_secret()
         if written_key == integration_key:
-            console.print("\n[bold green]✅ Integration Key saved and verified![/bold green]")
+            console.print(
+                "\n[bold green]✅ Integration Key saved and verified![/bold green]"
+            )
             console.print(f"[dim]Configuration: {env_file}[/dim]")
-            console.print("\n[blue]Ready to use notionary in your Python code! 🚀[/blue]")
             return True
         else:
             console.print("\n[bold red]❌ Error: Key verification failed![/bold red]")
             return False
-            
+
     except Exception as e:
         console.print(f"\n[bold red]❌ Error saving key: {e}[/bold red]")
         return False
 
-if __name__ == '__main__':
-    main()
+
+if __name__ == "__main__":
+    main()

notionary/cli/onboarding.py

@@ -0,0 +1,117 @@
+import asyncio
+from dataclasses import dataclass
+from notionary import NotionDatabase
+
+
+@dataclass
+class OnboardingPageResult:
+    url: str
+    tile: str
+    emoji: str
+
+
+async def generate_doc_for_database(
+    datbase_name: str,
+) -> OnboardingPageResult:
+    database = await NotionDatabase.from_database_name(datbase_name)
+    page = await database.create_blank_page()
+
+    page_title = "Welcome to Notionary!"
+    page_icon = "📚"
+
+    markdown_content = """!> [🚀] This page was created fully automatically and serves as a showcase of what is possible with Notionary.
+
+    ---
+
+    ## 🗃️ Working with Databases
+
+    Discover and manage your Notion databases programmatically:
+
+    ```python
+    import asyncio
+    from notionary import NotionDatabase, DatabaseDiscovery
+
+    async def main():
+    # Discover available databases
+    discovery = DatabaseDiscovery()
+    await discovery()
+
+    # Connect to a database by name
+    db = await NotionDatabase.from_database_name("Projects")
+
+    # Create a new page in the database
+    page = await db.create_blank_page()
+
+    # Query pages from database
+    async for page in db.iter_pages():
+        title = await page.get_title()
+        print(f"Page: {title}")
+
+    if __name__ == "__main__":
+    asyncio.run(main())
+    ```
+
+    ## 📄 Creating and Managing Pages
+    Create and update Notion pages with rich content:
+    ```python
+    import asyncio
+    from notionary import NotionPage
+
+    async def main():
+        # Create a page from URL
+        page = NotionPage.from_url("https://www.notion.so/your-page-url")
+
+        # Or find by name
+        page = await NotionPage.from_page_name("My Project Page")
+
+        # Update page metadata
+        await page.set_title("Updated Title")
+        await page.set_emoji_icon("🚀")
+        await page.set_random_gradient_cover()
+
+        # Add markdown content
+        markdown = '''
+        # Project Overview
+
+        !> [💡] This page was created programmatically using Notionary.
+
+        ## Features
+        - **Rich** Markdown support
+        - Async functionality
+        - Custom syntax extensions
+        '''
+
+        await page.replace_content(markdown)
+
+    if __name__ == "__main__":
+        asyncio.run(main())
+    ```
+
+    ## 📊 Tables and Structured Data
+    Create tables for organizing information:
+    FeatureStatusPriorityAPI IntegrationCompleteHighDocumentationIn ProgressMediumDatabase QueriesCompleteHighFile UploadsCompleteMedium
+
+    🎥 Media Embedding
+    Embed videos directly in your pages:
+    @[Caption](https://www.youtube.com/watch?v=dQw4w9WgXcQ) - Never gonna give you up!
+
+    Happy building with Notionary! 🎉"""
+
+    await page.set_title(page_title)
+    await page.set_emoji_icon(page_icon)
+    await page.set_random_gradient_cover()
+    await page.append_markdown(markdown_content)
+
+    url = await page.get_url()
+
+    return OnboardingPageResult(
+        url=url,
+        tile=page_title,
+        emoji=page_icon,
+    )
+
+
+if __name__ == "__main__":
+    print("🚀 Starting Notionary onboarding page generation...")
+    result = asyncio.run(generate_doc_for_database("Wissen & Notizen"))
+    print(f"✅ Onboarding page created: {result.tile} {result.emoji} - {result.url}")

notionary/database/client.py

@@ -0,0 +1,132 @@
+from typing import Dict, Any, Optional
+from dotenv import load_dotenv
+from notionary.base_notion_client import BaseNotionClient
+
+from notionary.models.notion_database_response import (
+    NotionDatabaseResponse,
+    NotionDatabaseSearchResponse,
+    NotionPageResponse,
+    NotionQueryDatabaseResponse,
+)
+from notionary.util import singleton
+
+load_dotenv()
+
+
+@singleton
+class NotionDatabaseClient(BaseNotionClient):
+    """
+    Specialized Notion client for database operations.
+    Inherits connection management and HTTP methods from BaseNotionClient.
+    """
+
+    def __init__(self, token: Optional[str] = None, timeout: int = 30):
+        super().__init__(token, timeout)
+
+    async def get_database(self, database_id: str) -> NotionDatabaseResponse:
+        """
+        Gets metadata for a Notion database by its ID.
+        """
+        response = await self.get(f"databases/{database_id}")
+        return NotionDatabaseResponse.model_validate(response)
+
+    async def patch_database(
+        self, database_id: str, data: Dict[str, Any]
+    ) -> NotionDatabaseResponse:
+        """
+        Updates a Notion database with the provided data.
+        """
+        response = await self.patch(f"databases/{database_id}", data=data)
+        return NotionDatabaseResponse.model_validate(response)
+
+    async def query_database(
+        self, database_id: str, query_data: Dict[str, Any] = None
+    ) -> NotionQueryDatabaseResponse:
+        """
+        Queries a Notion database with the provided filter and sorts.
+        """
+        response = await self.post(f"databases/{database_id}/query", data=query_data)
+        return NotionQueryDatabaseResponse.model_validate(response)
+
+    async def query_database_by_title(
+        self, database_id: str, page_title: str
+    ) -> NotionQueryDatabaseResponse:
+        """
+        Queries a Notion database by title.
+        """
+        query_data = {
+            "filter": {"property": "title", "title": {"contains": page_title}}
+        }
+
+        return await self.query_database(database_id=database_id, query_data=query_data)
+
+    async def search_databases(
+        self, query: str = "", sort_ascending: bool = True, limit: int = 100
+    ) -> NotionDatabaseSearchResponse:
+        """
+        Searches for databases in Notion using the search endpoint.
+
+        Args:
+            query: Search query string
+            sort_ascending: Whether to sort in ascending order
+            limit: Maximum number of results to return
+        """
+        search_data = {
+            "query": query,
+            "filter": {"value": "database", "property": "object"},
+            "sort": {
+                "direction": "ascending" if sort_ascending else "descending",
+                "timestamp": "last_edited_time",
+            },
+            "page_size": limit,
+        }
+
+        response = await self.post("search", search_data)
+        return NotionDatabaseSearchResponse.model_validate(response)
+
+    async def create_page(self, parent_database_id: str) -> NotionPageResponse:
+        """
+        Creates a new blank page in the given database with minimal properties.
+        """
+        page_data = {
+            "parent": {"database_id": parent_database_id},
+            "properties": {},
+        }
+        response = await self.post("pages", page_data)
+        return NotionPageResponse.model_validate(response)
+
+    async def update_database_title(
+        self, database_id: str, title: str
+    ) -> NotionDatabaseResponse:
+        """
+        Updates the title of a database.
+        """
+        data = {"title": [{"text": {"content": title}}]}
+        return await self.patch_database(database_id, data)
+
+    async def update_database_emoji(
+        self, database_id: str, emoji: str
+    ) -> NotionDatabaseResponse:
+        """
+        Updates the emoji/icon of a database.
+        """
+        data = {"icon": {"type": "emoji", "emoji": emoji}}
+        return await self.patch_database(database_id, data)
+
+    async def update_database_cover_image(
+        self, database_id: str, image_url: str
+    ) -> NotionDatabaseResponse:
+        """
+        Updates the cover image of a database.
+        """
+        data = {"cover": {"type": "external", "external": {"url": image_url}}}
+        return await self.patch_database(database_id, data)
+
+    async def update_database_external_icon(
+        self, database_id: str, icon_url: str
+    ) -> NotionDatabaseResponse:
+        """
+        Updates the database icon with an external image URL.
+        """
+        data = {"icon": {"type": "external", "external": {"url": icon_url}}}
+        return await self.patch_database(database_id, data)

notionary/database/database_exceptions.py

@@ -0,0 +1,13 @@
+class NotionDatabaseException(Exception):
+    """Base exception for all Notion database operations."""
+
+    pass
+
+
+class DatabaseNotFoundException(NotionDatabaseException):
+    """Exception raised when a database is not found."""
+
+    def __init__(self, identifier: str, message: str = None):
+        self.identifier = identifier
+        self.message = message or f"Database not found: {identifier}"
+        super().__init__(self.message)