better-notion 1.4.0__tar.gz → 1.5.1__tar.gz

{better_notion-1.4.0 → better_notion-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: better-notion
-Version: 1.4.0
+Version: 1.5.1
 Summary: A high-level Python SDK for the Notion API with developer experience in mind.
 Project-URL: Homepage, https://github.com/nesalia-inc/better-notion
 Project-URL: Documentation, https://github.com/nesalia-inc/better-notion#readme

{better_notion-1.4.0 → better_notion-1.5.1}/better_notion/_api/collections/databases.py

@@ -73,3 +73,35 @@ class DatabaseCollection:
         # Ensure parent is set to the database
         page_data = {"parent": {"database_id": database_id}, **kwargs}
         return await self._api._request("POST", "/pages", json=page_data)
+
+    async def create(
+        self,
+        parent: dict[str, Any],
+        title: str,
+        properties: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Create a new database.
+
+        Args:
+            parent: Parent object (e.g., {"type": "page_id", "page_id": "..."})
+            title: Database title
+            properties: Database schema/properties configuration
+
+        Returns:
+            Raw database data dict from Notion API.
+
+        Raises:
+            ValidationError: If the database configuration is invalid.
+            NotFoundError: If the parent page does not exist.
+        """
+        # Build title array
+        title_array = [{"type": "text", "text": {"content": title}}]
+
+        # Create database request
+        database_data = {
+            "parent": parent,
+            "title": title_array,
+            "properties": properties
+        }
+
+        return await self._api._request("POST", "/databases", json=database_data)

{better_notion-1.4.0 → better_notion-1.5.1}/better_notion/_cli/commands/databases.py

@@ -5,7 +5,6 @@ This module provides commands for managing Notion databases.
 """
 from __future__ import annotations
 
-import asyncio
 import json
 from typing import Any
 
@@ -19,6 +18,49 @@ from better_notion._sdk.client import NotionClient
 app = AsyncTyper(help="Databases commands")
 
 
+# Schema templates for common use cases
+SCHEMA_TEMPLATES = {
+    "minimal": {
+        "description": "Database with only a title property (minimal schema)",
+        "schema": {}
+    },
+    "simple": {
+        "description": "Simple database with title, text, and number properties",
+        "schema": {
+            "Notes": {"type": "rich_text"},
+            "Count": {"type": "number"}
+        }
+    },
+    "task": {
+        "description": "Task tracking database with status, priority, and due date",
+        "schema": {
+            "Status": {
+                "type": "select",
+                "select": {
+                    "options": [
+                        {"name": "Not Started", "color": "gray"},
+                        {"name": "In Progress", "color": "blue"},
+                        {"name": "Completed", "color": "green"}
+                    ]
+                }
+            },
+            "Priority": {
+                "type": "select",
+                "select": {
+                    "options": [
+                        {"name": "Low", "color": "gray"},
+                        {"name": "Medium", "color": "yellow"},
+                        {"name": "High", "color": "orange"},
+                        {"name": "Critical", "color": "red"}
+                    ]
+                }
+            },
+            "Due Date": {"type": "date"}
+        }
+    }
+}
+
+
 def get_client() -> NotionClient:
     """Get authenticated Notion client."""
     config = Config.load()
@@ -48,34 +90,115 @@ def get(database_id: str) -> None:
 
 
 @app.command()
-def create(
+async def create(
     parent: str = typer.Option(..., "--parent", "-p", help="Parent page ID"),
     title: str = typer.Option(..., "--title", "-t", help="Database title"),
     schema: str = typer.Option("{}", "--schema", "-s", help="JSON schema for properties"),
+    template: str = typer.Option(None, "--template", help="Use a predefined schema template (minimal, simple, task)"),
 ) -> None:
-    """Create a new database."""
-    async def _create() -> str:
-        try:
-            client = get_client()
-            parent_page = await client.pages.get(parent)
-            schema_dict = json.loads(schema)
-
-            db = await client.databases.create(
-                parent=parent_page,
-                title=title,
-                schema=schema_dict,
+    """Create a new database.
+
+    Schema Format:
+        The schema should be a JSON object mapping property names to their types.
+        Each property should have a "type" field and type-specific configuration.
+
+    Common property types:
+        - title: {"type": "title"} (Note: Every database must have exactly one title property)
+        - rich_text: {"type": "rich_text"}
+        - number: {"type": "number", "number": {"format": "number"}}
+        - select: {"type": "select", "select": {"options": [{"name": "Option1", "color": "gray"}]}}
+        - date: {"type": "date"}
+        - checkbox: {"type": "checkbox"}
+        - email: {"type": "email"}
+        - url: {"type": "url"}
+        - phone: {"type": "phone_number"}
+
+    Examples:
+        # Minimal database (title only)
+        notion databases create --parent page123 --title "My Database" --template minimal
+
+        # Simple custom schema
+        notion databases create --parent page123 --title "Tasks" \\
+            --schema '{"Status": {"type": "select", "select": {"options": [{"name": "Todo", "color": "gray"}]}}}'
+
+        # Use a predefined template
+        notion databases create --parent page123 --title "Task Tracker" --template task
+
+        # Show available templates
+        notion database-templates
+    """
+    try:
+        client = get_client()
+        parent_page = await client.pages.get(parent)
+
+        # Use template if specified
+        if template:
+            if template not in SCHEMA_TEMPLATES:
+                result = format_error(
+                    "INVALID_TEMPLATE",
+                    f"Template '{template}' not found. Available templates: {', '.join(SCHEMA_TEMPLATES.keys())}. Use 'notion database-templates' to see all templates.",
+                    retry=False
+                )
+                typer.echo(result)
+                raise typer.Exit(code=1)
+            schema_dict = SCHEMA_TEMPLATES[template]["schema"]
+        else:
+            # Parse custom schema
+            try:
+                schema_dict = json.loads(schema)
+            except json.JSONDecodeError as e:
+                result = format_error(
+                    "INVALID_SCHEMA",
+                    f"Invalid JSON schema: {str(e)}",
+                    retry=False
+                )
+                typer.echo(result)
+                raise typer.Exit(code=1)
+
+        # Validate schema structure
+        if not isinstance(schema_dict, dict):
+            result = format_error(
+                "INVALID_SCHEMA",
+                "Schema must be a JSON object (dictionary)",
+                retry=False
             )
-
-            return format_success({
-                "id": db.id,
-                "title": db.title,
-                "url": db.url,
-            })
-        except Exception as e:
-            return format_error("UNKNOWN_ERROR", str(e), retry=False)
-
-    result = asyncio.run(_create())
-    typer.echo(result)
+            typer.echo(result)
+            raise typer.Exit(code=1)
+
+        db = await client.databases.create(
+            parent=parent_page,
+            title=title,
+            schema=schema_dict,
+        )
+
+        result = format_success({
+            "id": db.id,
+            "title": db.title,
+            "url": db.url,
+            "properties_count": len(db.schema) if db.schema else 0,
+        })
+        typer.echo(result)
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        error_msg = str(e)
+        # Add helpful context for common errors
+        if "schema" in error_msg.lower():
+            error_msg += "\n\nHint: Use 'notion database-templates' to see schema examples or --template minimal for a simple database"
+        result = format_error("CREATE_ERROR", error_msg, retry=False)
+        typer.echo(result)
+        raise typer.Exit(code=1)
+
+
+@app.command("database-templates")
+def templates_cmd() -> None:
+    """Show available database schema templates.
+
+    Examples:
+        notion database-templates
+    """
+    typer.echo(json.dumps(SCHEMA_TEMPLATES, indent=2))
 
 
 @app.command()

better_notion-1.5.1/better_notion/_cli/commands/pages.py

@@ -0,0 +1,449 @@
+"""
+Pages commands for Better Notion CLI.
+
+This module provides commands for managing Notion pages.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import typer
+from typer.testing import CliRunner
+
+from better_notion._cli.async_typer import AsyncTyper
+from better_notion._cli.config import Config
+from better_notion._cli.response import format_error, format_success
+from better_notion._cli.markdown import parse_markdown_file
+from better_notion._sdk.client import NotionClient
+
+app = AsyncTyper(help="Pages commands")
+
+
+def get_client() -> NotionClient:
+    """Get authenticated Notion client."""
+    config = Config.load()
+    return NotionClient(auth=config.token, timeout=config.timeout)
+
+
+@app.command()
+async def get(page_id: str) -> None:
+    """
+    Get a page by ID.
+
+    Retrieves detailed information about a specific Notion page.
+    """
+    try:
+        client = get_client()
+        page = await client.pages.get(page_id)
+
+        # Get parent (async method - note the parentheses)
+        parent_obj = await page.parent()
+
+        result = format_success({
+            "id": page.id,
+            "title": page.title,
+            "url": page.url,
+            "parent_id": parent_obj.id if parent_obj else None,
+            "parent_type": parent_obj.object if parent_obj else None,
+            "created_time": page._data.get("created_time"),
+            "last_edited_time": page._data.get("last_edited_time"),
+            "archived": page.archived,
+            "properties": {name: str(value) for name, value in page._data.get("properties", {}).items()},
+        })
+        typer.echo(result)
+    except Exception as e:
+        result = format_error("UNKNOWN_ERROR", str(e), retry=False)
+        typer.echo(result)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+async def create(
+    root: bool = typer.Option(False, "--root", "-r", help="Create page at workspace root"),
+    parent: str = typer.Option(None, "--parent", "-p", help="Parent database or page ID"),
+    title: str = typer.Option(..., "--title", "-t", help="Page title"),
+    properties: str = typer.Option(None, "--properties", help="JSON string of additional properties"),
+) -> None:
+    """
+    Create a new page.
+
+    Creates a new page under a parent database/page or at workspace root.
+
+    Note: Workspace parent (--root) may require specific integration permissions.
+    """
+    client = get_client()
+    props = json.loads(properties) if properties else {}
+
+    # Validate mutual exclusivity
+    if root and parent:
+        result = format_error(
+            "INVALID_ARGUMENT",
+            "Cannot specify both --root and --parent",
+            retry=False
+        )
+        typer.echo(result)
+        raise typer.Exit(code=1)
+
+    # Handle workspace parent
+    if root:
+        from better_notion._sdk.parents import WorkspaceParent
+        parent_obj = WorkspaceParent()
+    else:
+        # Existing parent resolution logic
+        # Try database first
+        try:
+            parent_obj = await client.databases.get(parent)
+        except Exception as db_err:
+            # If database fails, try as page
+            try:
+                parent_obj = await client.pages.get(parent)
+            except Exception as page_err:
+                # Both failed - return detailed error
+                result = format_error(
+                    "PARENT_NOT_FOUND",
+                    f"Could not find parent '{parent}' as database or page. "
+                    f"Database error: {str(db_err)}. Page error: {str(page_err)}",
+                    retry=False
+                )
+                typer.echo(result)
+                raise typer.Exit(code=1)
+
+    page = await client.pages.create(parent=parent_obj, title=title, **props)
+
+    # Get parent info safely
+    parent_id = None
+    parent_type = None
+    if root:
+        parent_type = "workspace"
+    elif page.parent:
+        parent_id = getattr(page.parent, 'id', None)
+        parent_type = getattr(page.parent, 'object', None)
+
+    result = format_success({
+        "id": page.id,
+        "title": page.title,
+        "url": page.url,
+        "parent_id": parent_id,
+        "parent_type": parent_type,
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def update(
+    page_id: str = typer.Argument(..., help="Page ID to update"),
+    properties: str = typer.Option(..., "--properties", "-p", help="JSON string of properties to update"),
+) -> None:
+    """
+    Update a page.
+
+    Updates the specified properties of a page.
+    """
+    client = get_client()
+    page = await client.pages.get(page_id)
+    props = json.loads(properties)
+
+    updated_page = await page.update(**props)
+
+    result = format_success({
+        "id": updated_page.id,
+        "title": updated_page.title,
+        "last_edited_time": updated_page.last_edited_time,
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def delete(page_id: str) -> None:
+    """
+    Delete a page.
+
+    Permanently deletes a page and all its children.
+    """
+    client = get_client()
+    page = await client.pages.get(page_id)
+    await page.delete()
+
+    result = format_success({
+        "id": page_id,
+        "status": "deleted",
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def list(
+    database: str = typer.Option(..., "--database", "-d", help="Database ID to list pages from"),
+    filter: str = typer.Option(None, "--filter", "-f", help="JSON filter for query"),
+) -> None:
+    """
+    List pages in a database.
+
+    Lists all pages in a database, optionally filtered.
+    """
+    client = get_client()
+    db = await client.databases.get(database)
+
+    filters = json.loads(filter) if filter else {}
+    pages = await db.query(client=client, **filters)
+
+    result = format_success({
+        "database_id": database,
+        "count": len(pages),
+        "pages": [
+            {
+                "id": page.id,
+                "title": page.title,
+                "url": page.url,
+            }
+            for page in pages
+        ],
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def search(
+    query: str = typer.Argument(..., help="Search query"),
+    filter: str = typer.Option(None, "--filter", "-f", help="JSON filter for object type"),
+) -> None:
+    """
+    Search for pages.
+
+    Searches for pages matching the query.
+    """
+    client = get_client()
+    filters = json.loads(filter) if filter else {}
+
+    results = await client.search.search(query=query, filter=filters)
+
+    pages = [r for r in results if hasattr(r, 'title')]
+    result = format_success({
+        "query": query,
+        "count": len(pages),
+        "pages": [
+            {
+                "id": page.id,
+                "title": page.title,
+                "url": page.url,
+            }
+            for page in pages
+        ],
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def blocks(page_id: str) -> None:
+    """
+    Get blocks in a page.
+
+    Retrieves all blocks contained in a page.
+    """
+    client = get_client()
+    page = await client.pages.get(page_id)
+
+    block_list = []
+    async for block in page.children():
+        block_list.append({
+            "id": block.id,
+            "type": block.type,
+        })
+
+    result = format_success({
+        "page_id": page_id,
+        "count": len(block_list),
+        "blocks": block_list,
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def copy(
+    page_id: str = typer.Argument(..., help="Page ID to copy"),
+    destination: str = typer.Option(..., "--dest", "-d", help="Destination parent ID"),
+) -> None:
+    """
+    Copy a page.
+
+    Creates a copy of a page under a new parent.
+    """
+    client = get_client()
+    page = await client.pages.get(page_id)
+
+    # Get destination parent
+    try:
+        dest_parent = await client.databases.get(destination)
+    except Exception:
+        dest_parent = await client.pages.get(destination)
+
+    # Create new page with same title
+    new_page = await client.pages.create(
+        parent=dest_parent,
+        title=page.title,
+    )
+
+    result = format_success({
+        "original_id": page_id,
+        "new_id": new_page.id,
+        "new_url": new_page.url,
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def move(
+    page_id: str = typer.Argument(..., help="Page ID to move"),
+    destination: str = typer.Argument(..., help="Destination parent ID"),
+) -> None:
+    """
+    Move a page.
+
+    Moves a page to a new parent (database or page).
+    """
+    client = get_client()
+    page = await client.pages.get(page_id)
+
+    # Get destination parent
+    try:
+        dest_parent = await client.databases.get(destination)
+    except Exception:
+        dest_parent = await client.pages.get(destination)
+
+    # Update parent
+    await page.update(parent=dest_parent._data)
+
+    result = format_success({
+        "id": page_id,
+        "new_parent_id": destination,
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def archive(page_id: str) -> None:
+    """
+    Archive a page.
+
+    Archives a page (moves to trash).
+    """
+    client = get_client()
+    page = await client.pages.get(page_id)
+
+    await page.update(archived=True)
+
+    result = format_success({
+        "id": page_id,
+        "status": "archived",
+    })
+    typer.echo(result)
+
+
+@app.command()
+async def restore(page_id: str) -> None:
+    """
+    Restore an archived page.
+
+    Restores a page from the trash/archive.
+    """
+    client = get_client()
+    page = await client.pages.get(page_id)
+
+    await page.update(archived=False)
+
+    result = format_success({
+        "id": page_id,
+        "status": "restored",
+    })
+    typer.echo(result)
+
+
+@app.command("create-from-md")
+async def create_from_md(
+    file: str = typer.Option(..., "--file", "-f", help="Path to markdown file"),
+    parent: str = typer.Option(..., "--parent", "-p", help="Parent database or page ID"),
+    title: str = typer.Option(None, "--title", "-t", help="Custom page title (default: first H1 or filename)"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be created without creating"),
+) -> None:
+    """
+    Create a page from a markdown file.
+
+    Parses the markdown file and creates a new Notion page with all blocks.
+    """
+    try:
+        # Parse markdown file
+        md_title, blocks = parse_markdown_file(file)
+
+        # Use custom title if provided
+        page_title = title or md_title
+
+        if dry_run:
+            # Show what would be created
+            result = format_success({
+                "dry_run": True,
+                "file": file,
+                "title": page_title,
+                "parent": parent,
+                "blocks_count": len(blocks),
+                "blocks_preview": [
+                    {
+                        "type": block.get("type"),
+                        "preview": str(block.get(block.get("type", {}), {}))[:100]
+                    }
+                    for block in blocks[:5]  # Show first 5 blocks
+                ]
+            })
+            typer.echo(result)
+            return
+
+        client = get_client()
+
+        # Resolve parent
+        try:
+            parent_obj = await client.databases.get(parent)
+        except Exception:
+            parent_obj = await client.pages.get(parent)
+
+        # Create page
+        page = await client.pages.create(
+            parent=parent_obj,
+            title=page_title,
+        )
+
+        # Add blocks to page
+        if blocks:
+            # Use BlockCollection to append blocks
+            from better_notion._api.collections import BlockCollection
+
+            blocks_collection = BlockCollection(client.api, parent_id=page.id)
+
+            # Add blocks one by one (Notion API limitation)
+            for block_data in blocks:
+                try:
+                    await blocks_collection.append(block_data)
+                except Exception as e:
+                    # Continue with other blocks even if one fails
+                    pass
+
+        result = format_success({
+            "id": page.id,
+            "title": page_title,
+            "url": page.url,
+            "blocks_created": len(blocks),
+            "file": file,
+        })
+        typer.echo(result)
+
+    except FileNotFoundError as e:
+        result = format_error("FILE_NOT_FOUND", str(e), retry=False)
+        typer.echo(result)
+        raise typer.Exit(code=1)
+    except ValueError as e:
+        result = format_error("INVALID_FILE", str(e), retry=False)
+        typer.echo(result)
+        raise typer.Exit(code=1)
+    except Exception as e:
+        result = format_error("UNKNOWN_ERROR", str(e), retry=False)
+        typer.echo(result)
+        raise typer.Exit(code=1)