vanna 0.7.9__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

vanna/components/rich/feedback/__init__.py

@@ -0,0 +1,21 @@
+"""User feedback components."""
+
+from .notification import NotificationComponent
+from .status_card import StatusCardComponent
+from .progress import ProgressBarComponent, ProgressDisplayComponent
+from .status_indicator import StatusIndicatorComponent
+from .log_viewer import LogViewerComponent, LogEntry
+from .badge import BadgeComponent
+from .icon_text import IconTextComponent
+
+__all__ = [
+    "NotificationComponent",
+    "StatusCardComponent",
+    "ProgressBarComponent",
+    "ProgressDisplayComponent",
+    "StatusIndicatorComponent",
+    "LogViewerComponent",
+    "LogEntry",
+    "BadgeComponent",
+    "IconTextComponent",
+]

vanna/components/rich/feedback/badge.py

@@ -0,0 +1,16 @@
+"""Badge component for displaying status or labels."""
+
+from typing import Optional
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class BadgeComponent(RichComponent):
+    """Simple badge/pill component for displaying status or labels."""
+
+    type: ComponentType = ComponentType.BADGE
+    text: str
+    variant: str = (
+        "default"  # "default", "primary", "success", "warning", "error", "info"
+    )
+    size: str = "medium"  # "small", "medium", "large"
+    icon: Optional[str] = None

vanna/components/rich/feedback/icon_text.py

@@ -0,0 +1,14 @@
+"""Icon with text component."""
+
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class IconTextComponent(RichComponent):
+    """Simple component for displaying an icon with text."""
+
+    type: ComponentType = ComponentType.ICON_TEXT
+    icon: str
+    text: str
+    variant: str = "default"  # "default", "primary", "secondary", "muted"
+    size: str = "medium"  # "small", "medium", "large"
+    alignment: str = "left"  # "left", "center", "right"

vanna/components/rich/feedback/log_viewer.py

@@ -0,0 +1,41 @@
+"""Log viewer component."""
+
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class LogEntry(BaseModel):
+    """Log entry for tool execution."""
+
+    timestamp: str = Field(default_factory=lambda: datetime.utcnow().isoformat())
+    level: str = "info"  # "debug", "info", "warning", "error"
+    message: str
+    data: Optional[Dict[str, Any]] = None
+
+
+class LogViewerComponent(RichComponent):
+    """Generic log viewer for displaying timestamped entries."""
+
+    type: ComponentType = ComponentType.LOG_VIEWER
+    title: str = "Logs"
+    entries: List[LogEntry] = Field(default_factory=list)
+    max_entries: int = 100
+    searchable: bool = True
+    show_timestamps: bool = True
+    auto_scroll: bool = True
+
+    def add_entry(
+        self, message: str, level: str = "info", data: Optional[Dict[str, Any]] = None
+    ) -> "LogViewerComponent":
+        """Add a new log entry."""
+        new_entry = LogEntry(message=message, level=level, data=data)
+        new_entries = self.entries + [new_entry]
+
+        # Limit to max_entries
+        if len(new_entries) > self.max_entries:
+            new_entries = new_entries[-self.max_entries :]
+
+        return self.update(entries=new_entries)

vanna/components/rich/feedback/notification.py

@@ -0,0 +1,19 @@
+"""Notification component for alerts and messages."""
+
+from typing import Any, Dict, List, Optional
+from pydantic import Field
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class NotificationComponent(RichComponent):
+    """Notification component for alerts and messages."""
+
+    type: ComponentType = ComponentType.NOTIFICATION
+    message: str
+    title: Optional[str] = None
+    level: str = "info"  # "success", "info", "warning", "error"
+    icon: Optional[str] = None
+    dismissible: bool = True
+    auto_dismiss: bool = False
+    auto_dismiss_delay: int = 5000  # milliseconds
+    actions: List[Dict[str, Any]] = Field(default_factory=list)

vanna/components/rich/feedback/progress.py

@@ -0,0 +1,37 @@
+"""Progress components for displaying progress indicators."""
+
+from typing import Any, Dict, Optional
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class ProgressBarComponent(RichComponent):
+    """Progress bar with status and value."""
+
+    type: ComponentType = ComponentType.PROGRESS_BAR
+    value: float  # 0.0 to 1.0
+    label: Optional[str] = None
+    show_percentage: bool = True
+    status: Optional[str] = None  # "success", "warning", "error"
+    animated: bool = False
+
+
+class ProgressDisplayComponent(RichComponent):
+    """Generic progress display for any long-running process."""
+
+    type: ComponentType = ComponentType.PROGRESS_DISPLAY
+    label: str
+    value: float = 0.0  # 0.0 to 1.0
+    description: Optional[str] = None
+    status: Optional[str] = None  # "info", "success", "warning", "error"
+    show_percentage: bool = True
+    animated: bool = False
+    indeterminate: bool = False
+
+    def update_progress(
+        self, value: float, description: Optional[str] = None
+    ) -> "ProgressDisplayComponent":
+        """Update progress value and optionally description."""
+        updates: Dict[str, Any] = {"value": max(0.0, min(1.0, value))}
+        if description is not None:
+            updates["description"] = description
+        return self.update(**updates)

vanna/components/rich/feedback/status_card.py

@@ -0,0 +1,28 @@
+"""Status card component for displaying process status."""
+
+from typing import Any, Dict, List, Optional
+from pydantic import Field
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class StatusCardComponent(RichComponent):
+    """Generic status card that can display any process status."""
+
+    type: ComponentType = ComponentType.STATUS_CARD
+    title: str
+    status: str  # "pending", "running", "completed", "failed", "success", "warning", "error"
+    description: Optional[str] = None
+    icon: Optional[str] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    actions: List[Dict[str, Any]] = Field(default_factory=list)
+    collapsible: bool = False
+    collapsed: bool = False
+
+    def set_status(
+        self, status: str, description: Optional[str] = None
+    ) -> "StatusCardComponent":
+        """Update the status and optionally the description."""
+        updates = {"status": status}
+        if description is not None:
+            updates["description"] = description
+        return self.update(**updates)

vanna/components/rich/feedback/status_indicator.py

@@ -0,0 +1,14 @@
+"""Status indicator component."""
+
+from typing import Optional
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class StatusIndicatorComponent(RichComponent):
+    """Status indicator with icon and message."""
+
+    type: ComponentType = ComponentType.STATUS_INDICATOR
+    status: str  # "success", "warning", "error", "info", "loading"
+    message: str
+    icon: Optional[str] = None
+    pulse: bool = False

vanna/components/rich/interactive/__init__.py

@@ -0,0 +1,21 @@
+"""Interactive components."""
+
+from .task_list import TaskListComponent, Task
+from .ui_state import (
+    StatusBarUpdateComponent,
+    TaskTrackerUpdateComponent,
+    ChatInputUpdateComponent,
+    TaskOperation,
+)
+from .button import ButtonComponent, ButtonGroupComponent
+
+__all__ = [
+    "TaskListComponent",
+    "Task",
+    "StatusBarUpdateComponent",
+    "TaskTrackerUpdateComponent",
+    "ChatInputUpdateComponent",
+    "TaskOperation",
+    "ButtonComponent",
+    "ButtonGroupComponent",
+]

vanna/components/rich/interactive/button.py

@@ -0,0 +1,95 @@
+"""Button component for interactive actions."""
+
+from typing import Any, Dict, List, Literal, Optional
+from ....core.rich_component import ComponentType, RichComponent
+
+
+class ButtonComponent(RichComponent):
+    """Interactive button that sends a message when clicked.
+
+    The button renders in the UI and when clicked, sends its action
+    value as a message to the chat input.
+
+    Args:
+        label: Text displayed on the button
+        action: Message/command to send when clicked
+        variant: Visual style variant
+        size: Button size
+        icon: Optional emoji or icon
+        icon_position: Position of icon relative to label
+        disabled: Whether button is disabled
+
+    Example:
+        ButtonComponent(
+            label="Generate Report",
+            action="/report sales",
+            variant="primary",
+            icon="📊"
+        )
+    """
+
+    def __init__(
+        self,
+        label: str,
+        action: str,
+        variant: Literal[
+            "primary", "secondary", "success", "warning", "error", "ghost", "link"
+        ] = "primary",
+        size: Literal["small", "medium", "large"] = "medium",
+        icon: Optional[str] = None,
+        icon_position: Literal["left", "right"] = "left",
+        disabled: bool = False,
+    ):
+        super().__init__(
+            type=ComponentType.BUTTON,
+            data={
+                "label": label,
+                "action": action,
+                "variant": variant,
+                "size": size,
+                "icon": icon,
+                "icon_position": icon_position,
+                "disabled": disabled,
+            },
+        )
+
+
+class ButtonGroupComponent(RichComponent):
+    """Group of buttons with consistent styling.
+
+    Args:
+        buttons: List of button data dictionaries
+        orientation: Layout direction
+        spacing: Gap between buttons
+        alignment: Button alignment within group
+        full_width: Whether buttons should stretch to fill width
+
+    Example:
+        ButtonGroupComponent(
+            buttons=[
+                {"label": "Yes", "action": "/confirm yes", "variant": "success"},
+                {"label": "No", "action": "/confirm no", "variant": "error"},
+            ],
+            orientation="horizontal",
+            spacing="medium"
+        )
+    """
+
+    def __init__(
+        self,
+        buttons: List[Dict[str, Any]],
+        orientation: Literal["horizontal", "vertical"] = "horizontal",
+        spacing: Literal["small", "medium", "large"] = "medium",
+        alignment: Literal["start", "center", "end", "stretch"] = "start",
+        full_width: bool = False,
+    ):
+        super().__init__(
+            type=ComponentType.BUTTON_GROUP,
+            data={
+                "buttons": buttons,
+                "orientation": orientation,
+                "spacing": spacing,
+                "alignment": alignment,
+                "full_width": full_width,
+            },
+        )

vanna/components/rich/interactive/task_list.py

@@ -0,0 +1,58 @@
+"""Task list component for interactive task tracking."""
+
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class Task(BaseModel):
+    """Individual task in a task list."""
+
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    title: str
+    description: Optional[str] = None
+    status: str = "pending"  # "pending", "in_progress", "completed", "error"
+    progress: Optional[float] = None  # 0.0 to 1.0
+    created_at: str = Field(default_factory=lambda: datetime.utcnow().isoformat())
+    completed_at: Optional[str] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+class TaskListComponent(RichComponent):
+    """Interactive task list with progress tracking."""
+
+    type: ComponentType = ComponentType.TASK_LIST
+    title: str = "Tasks"
+    tasks: List[Task] = Field(default_factory=list)
+    show_progress: bool = True
+    allow_reorder: bool = False
+    show_timestamps: bool = True
+    filter_status: Optional[str] = None  # Filter by task status
+
+    def add_task(self, task: Task) -> "TaskListComponent":
+        """Add a task to the list."""
+        new_tasks = self.tasks + [task]
+        return self.update(tasks=new_tasks)
+
+    def update_task(self, task_id: str, **updates: Any) -> "TaskListComponent":
+        """Update a specific task."""
+        new_tasks = []
+        for task in self.tasks:
+            if task.id == task_id:
+                task_data = task.model_dump()
+                task_data.update(updates)
+                new_tasks.append(Task(**task_data))
+            else:
+                new_tasks.append(task)
+        return self.update(tasks=new_tasks)
+
+    def complete_task(self, task_id: str) -> "TaskListComponent":
+        """Mark a task as completed."""
+        return self.update_task(
+            task_id,
+            status="completed",
+            completed_at=datetime.utcnow().isoformat(),
+            progress=1.0,
+        )

vanna/components/rich/interactive/ui_state.py

@@ -0,0 +1,93 @@
+"""UI state update components for controlling interface elements."""
+
+from enum import Enum
+from typing import Any, Optional
+from .task_list import Task
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class StatusBarUpdateComponent(RichComponent):
+    """Component for updating the status bar above chat input."""
+
+    type: ComponentType = ComponentType.STATUS_BAR_UPDATE
+    status: str  # "idle", "working", "success", "error"
+    message: str
+    detail: Optional[str] = None
+
+    def __init__(self, **kwargs: Any) -> None:
+        # Set a fixed ID for status bar updates
+        kwargs.setdefault("id", "vanna-status-bar")
+        super().__init__(**kwargs)
+
+
+class TaskOperation(str, Enum):
+    """Operations for task tracker updates."""
+
+    ADD_TASK = "add_task"
+    UPDATE_TASK = "update_task"
+    REMOVE_TASK = "remove_task"
+    CLEAR_TASKS = "clear_tasks"
+
+
+class TaskTrackerUpdateComponent(RichComponent):
+    """Component for updating the task tracker in the sidebar."""
+
+    type: ComponentType = ComponentType.TASK_TRACKER_UPDATE
+    operation: TaskOperation
+    task: Optional[Task] = None  # Used for ADD_TASK
+    task_id: Optional[str] = None  # Used for UPDATE_TASK and REMOVE_TASK
+    status: Optional[str] = None  # Used for UPDATE_TASK
+    progress: Optional[float] = None  # Used for UPDATE_TASK
+    detail: Optional[str] = None  # Used for UPDATE_TASK
+
+    def __init__(self, **kwargs: Any) -> None:
+        # Set a fixed ID for task tracker updates
+        kwargs.setdefault("id", "vanna-task-tracker")
+        super().__init__(**kwargs)
+
+    @classmethod
+    def add_task(cls, task: Task) -> "TaskTrackerUpdateComponent":
+        """Create a component to add a new task."""
+        return cls(operation=TaskOperation.ADD_TASK, task=task)
+
+    @classmethod
+    def update_task(
+        cls,
+        task_id: str,
+        status: Optional[str] = None,
+        progress: Optional[float] = None,
+        detail: Optional[str] = None,
+    ) -> "TaskTrackerUpdateComponent":
+        """Create a component to update an existing task."""
+        return cls(
+            operation=TaskOperation.UPDATE_TASK,
+            task_id=task_id,
+            status=status,
+            progress=progress,
+            detail=detail,
+        )
+
+    @classmethod
+    def remove_task(cls, task_id: str) -> "TaskTrackerUpdateComponent":
+        """Create a component to remove a task."""
+        return cls(operation=TaskOperation.REMOVE_TASK, task_id=task_id)
+
+    @classmethod
+    def clear_tasks(cls) -> "TaskTrackerUpdateComponent":
+        """Create a component to clear all tasks."""
+        return cls(operation=TaskOperation.CLEAR_TASKS)
+
+
+class ChatInputUpdateComponent(RichComponent):
+    """Component for updating chat input state and appearance."""
+
+    type: ComponentType = ComponentType.CHAT_INPUT_UPDATE
+    placeholder: Optional[str] = None
+    disabled: Optional[bool] = None
+    value: Optional[str] = None  # Set input text value
+    focus: Optional[bool] = None  # Focus/unfocus the input
+
+    def __init__(self, **kwargs: Any) -> None:
+        # Set a fixed ID for chat input updates
+        kwargs.setdefault("id", "vanna-chat-input")
+        super().__init__(**kwargs)

vanna/components/rich/specialized/__init__.py

@@ -0,0 +1,7 @@
+"""Specialized components."""
+
+from .artifact import ArtifactComponent
+
+__all__ = [
+    "ArtifactComponent",
+]

vanna/components/rich/specialized/artifact.py

@@ -0,0 +1,20 @@
+"""Artifact component for interactive content."""
+
+import uuid
+from typing import Optional
+from pydantic import Field
+from ....core.rich_component import RichComponent, ComponentType
+
+
+class ArtifactComponent(RichComponent):
+    """Component for displaying interactive artifacts that can be rendered externally."""
+
+    type: ComponentType = ComponentType.ARTIFACT
+    artifact_id: str = Field(default_factory=lambda: f"artifact_{uuid.uuid4().hex[:8]}")
+    content: str  # HTML/SVG/JS content
+    artifact_type: str  # "html", "svg", "visualization", "interactive", "d3", "threejs"
+    title: Optional[str] = None
+    description: Optional[str] = None
+    editable: bool = True
+    fullscreen_capable: bool = True
+    external_renderable: bool = True

vanna/components/rich/text.py

@@ -0,0 +1,16 @@
+"""Rich text component."""
+
+from typing import Optional
+from ...core.rich_component import RichComponent, ComponentType
+
+
+class RichTextComponent(RichComponent):
+    """Rich text component with formatting options."""
+
+    type: ComponentType = ComponentType.TEXT
+    content: str
+    markdown: bool = False
+    code_language: Optional[str] = None  # For syntax highlighting
+    font_size: Optional[str] = None
+    font_weight: Optional[str] = None
+    text_align: Optional[str] = None

vanna/components/simple/__init__.py

@@ -0,0 +1,15 @@
+"""Simple UI components for basic rendering."""
+
+# Import from core
+from ...core.simple_component import SimpleComponent, SimpleComponentType
+from .text import SimpleTextComponent
+from .image import SimpleImageComponent
+from .link import SimpleLinkComponent
+
+__all__ = [
+    "SimpleComponent",
+    "SimpleComponentType",
+    "SimpleTextComponent",
+    "SimpleImageComponent",
+    "SimpleLinkComponent",
+]

vanna/components/simple/image.py

@@ -0,0 +1,15 @@
+"""Simple image component."""
+
+from typing import Optional
+from pydantic import Field
+from ...core.simple_component import SimpleComponent, SimpleComponentType
+
+
+class SimpleImageComponent(SimpleComponent):
+    """A simple image component."""
+
+    type: SimpleComponentType = SimpleComponentType.IMAGE
+    url: str = Field(..., description="The URL of the image to display.")
+    alt_text: Optional[str] = Field(
+        default=None, description="Alternative text for the image."
+    )

vanna/components/simple/link.py

@@ -0,0 +1,15 @@
+"""Simple link component."""
+
+from typing import Optional
+from pydantic import Field
+from ...core.simple_component import SimpleComponent, SimpleComponentType
+
+
+class SimpleLinkComponent(SimpleComponent):
+    """A simple link component."""
+
+    type: SimpleComponentType = SimpleComponentType.LINK
+    url: str = Field(..., description="The URL the link points to.")
+    text: Optional[str] = Field(
+        default=None, description="The display text for the link."
+    )

vanna/components/simple/text.py

@@ -0,0 +1,11 @@
+"""Simple text component."""
+
+from pydantic import Field
+from ...core.simple_component import SimpleComponent, SimpleComponentType
+
+
+class SimpleTextComponent(SimpleComponent):
+    """A simple text component."""
+
+    type: SimpleComponentType = SimpleComponentType.TEXT
+    text: str = Field(..., description="The text content to display.")