PyPI - voodoo-framework - Versions diffs - 1.0.0__py3-none-any.whl - Mend

voodoo-framework 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

voodoo/__init__.py +51 -0
voodoo/agent.py +37 -0
voodoo/api.py +143 -0
voodoo/cli.py +250 -0
voodoo/components.py +107 -0
voodoo/config.py +51 -0
voodoo/core.py +236 -0
voodoo/data.py +179 -0
voodoo/i18n.py +107 -0
voodoo/mcp.py +141 -0
voodoo/queue.py +61 -0
voodoo/status.py +131 -0
voodoo/storage.py +85 -0
voodoo/telemetry.py +157 -0
voodoo/theme.py +112 -0
voodoo_framework-1.0.0.dist-info/METADATA +23 -0
voodoo_framework-1.0.0.dist-info/RECORD +20 -0
voodoo_framework-1.0.0.dist-info/WHEEL +5 -0
voodoo_framework-1.0.0.dist-info/entry_points.txt +2 -0
voodoo_framework-1.0.0.dist-info/top_level.txt +1 -0

voodoo/__init__.py ADDED Viewed

@@ -0,0 +1,51 @@
+from .core import create_app, register_event, ws_manager
+from .components import Div, Button, Input, Card, Text, Heading, ChatBox, Table
+from .data import BaseModel, on_insert, on_update, rls_policy, get_db
+from .queue import queue, enqueue
+from .agent import Agent
+from .api import api
+from .storage import storage
+from .mcp import mcp, MCPClient
+from .status import ServiceStatus
+from .telemetry import trace, TelemetryMiddleware, telemetry_store
+from .config import config
+from .theme import Theme, ThemeColors, set_theme, default_theme
+from .i18n import _, I18n, i18n_instance
+__all__ = [
+    "create_app",
+    "register_event",
+    "ws_manager",
+    "Div",
+    "Button",
+    "Input",
+    "Card",
+    "Text",
+    "Heading",
+    "ChatBox",
+    "Table",
+    "BaseModel",
+    "on_insert",
+    "on_update",
+    "rls_policy",
+    "get_db",
+    "queue",
+    "enqueue",
+    "Agent",
+    "api",
+    "storage",
+    "mcp",
+    "MCPClient",
+    "ServiceStatus",
+    "trace",
+    "TelemetryMiddleware",
+    "telemetry_store",
+    "config",
+    "Theme",
+    "ThemeColors",
+    "set_theme",
+    "default_theme",
+    "_",
+    "I18n",
+    "i18n_instance"
+]

voodoo/agent.py ADDED Viewed

@@ -0,0 +1,37 @@
+import asyncio
+from typing import AsyncGenerator, List, Dict
+class Agent:
+    def __init__(self, system_prompt: str = "You are a helpful AI assistant."):
+        self.system_prompt = system_prompt
+        self.history: List[Dict[str, str]] = [
+            {"role": "system", "content": system_prompt}
+        ]
+    async def stream(self, prompt: str) -> AsyncGenerator[str, None]:
+        from voodoo.telemetry import telemetry_store
+        self.history.append({"role": "user", "content": prompt})
+        # In a real scenario, this would connect to OpenAI/Anthropic etc.
+        # For this standalone framework, we'll simulate a streaming response
+        # or use an actual API if configured.
+        # Simulating a stream of tokens:
+        words = f"This is an AI response to: '{prompt}'. In a real app, this streams from an LLM. Here are some more tokens to simulate streaming.".split(" ")
+        telemetry_store.record_agent_tokens(len(prompt.split()) + len(words))
+        full_response = ""
+        for word in words:
+            await asyncio.sleep(0.1)  # Simulate network latency
+            token = word + " "
+            full_response += token
+            yield token
+        self.history.append({"role": "assistant", "content": full_response.strip()})
+    async def run(self, prompt: str) -> str:
+        response = ""
+        async for chunk in self.stream(prompt):
+            response += chunk
+        return response

voodoo/api.py ADDED Viewed

@@ -0,0 +1,143 @@
+import inspect
+from typing import Any, Callable, Dict, List, Type, Optional, Union, get_type_hints
+from starlette.requests import Request
+from starlette.responses import JSONResponse, HTMLResponse, Response
+from starlette.routing import Route
+from pydantic import BaseModel, create_model
+class API:
+    def __init__(self):
+        self.routes: List[Route] = []
+        self.paths: Dict[str, Dict[str, Any]] = {}
+        # Add docs routes
+        self.routes.append(Route("/openapi.json", self._openapi_schema, methods=["GET"]))
+        self.routes.append(Route("/docs", self._swagger_ui, methods=["GET"]))
+        self.routes.append(Route("/redoc", self._redoc_ui, methods=["GET"]))
+    def _openapi_schema(self, request: Request):
+        schema = {
+            "openapi": "3.0.2",
+            "info": {"title": "Voodoo API", "version": "1.0.0"},
+            "paths": self.paths,
+            "components": {"schemas": {}}
+        }
+        return JSONResponse(schema)
+    def _swagger_ui(self, request: Request):
+        html = """
+        <!DOCTYPE html>
+        <html>
+        <head>
+        <title>Swagger UI</title>
+        <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@5.0.0/swagger-ui.css" />
+        </head>
+        <body>
+        <div id="swagger-ui"></div>
+        <script src="https://unpkg.com/swagger-ui-dist@5.0.0/swagger-ui-bundle.js"></script>
+        <script>
+        window.onload = () => {
+            window.ui = SwaggerUIBundle({
+                url: '/openapi.json',
+                dom_id: '#swagger-ui',
+            });
+        };
+        </script>
+        </body>
+        </html>
+        """
+        return HTMLResponse(html)
+    def _redoc_ui(self, request: Request):
+        html = """
+        <!DOCTYPE html>
+        <html>
+        <head>
+        <title>ReDoc</title>
+        </head>
+        <body>
+        <redoc spec-url='/openapi.json'></redoc>
+        <script src="https://unpkg.com/redoc@2.0.0-rc.53/bundles/redoc.standalone.js"></script>
+        </body>
+        </html>
+        """
+        return HTMLResponse(html)
+    def _add_route(self, path: str, method: str, func: Callable):
+        # Register in OpenAPI paths
+        if path not in self.paths:
+            self.paths[path] = {}
+        self.paths[path][method.lower()] = {
+            "summary": func.__name__.replace("_", " ").title(),
+            "responses": {
+                "200": {"description": "Successful Response"}
+            }
+        }
+        async def endpoint(request: Request):
+            sig = inspect.signature(func)
+            kwargs = {}
+            for name, param in sig.parameters.items():
+                if param.annotation is Request:
+                    kwargs[name] = request
+                elif inspect.isclass(param.annotation) and issubclass(param.annotation, BaseModel):
+                    # Parse JSON body using Pydantic
+                    body = await request.json()
+                    kwargs[name] = param.annotation(**body)
+                else:
+                    # Path or Query param
+                    if name in request.path_params:
+                        val = request.path_params[name]
+                        kwargs[name] = param.annotation(val) if param.annotation != inspect._empty else val
+                    elif name in request.query_params:
+                        val = request.query_params[name]
+                        kwargs[name] = param.annotation(val) if param.annotation != inspect._empty else val
+            if inspect.iscoroutinefunction(func):
+                res = await func(**kwargs)
+            else:
+                res = func(**kwargs)
+            # Serialize response
+            if isinstance(res, Response):
+                return res
+            elif isinstance(res, BaseModel):
+                return JSONResponse(res.model_dump())
+            elif isinstance(res, list) and len(res) > 0 and isinstance(res[0], BaseModel):
+                return JSONResponse([r.model_dump() for r in res])
+            elif hasattr(res, "__dict__"): # simple object serialization fallback
+                return JSONResponse(res.__dict__)
+            return JSONResponse(res)
+        # Convert FastAPI/Starlette style path params {id} to Starlette path syntax
+        # Actually, Starlette uses {id} or {id:int}, so it's compatible.
+        self.routes.append(Route(path, endpoint, methods=[method]))
+    def get(self, path: str):
+        def decorator(func: Callable):
+            self._add_route(path, "GET", func)
+            return func
+        return decorator
+    def post(self, path: str):
+        def decorator(func: Callable):
+            self._add_route(path, "POST", func)
+            return func
+        return decorator
+    def put(self, path: str):
+        def decorator(func: Callable):
+            self._add_route(path, "PUT", func)
+            return func
+        return decorator
+    def delete(self, path: str):
+        def decorator(func: Callable):
+            self._add_route(path, "DELETE", func)
+            return func
+        return decorator
+api = API()

voodoo/cli.py ADDED Viewed

@@ -0,0 +1,250 @@
+import os
+import sys
+import time
+import asyncio
+from pathlib import Path
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.panel import Panel
+from rich.markdown import Markdown
+# We initialize the Typer app
+app = typer.Typer(
+    help="🔮 Voodoo Framework CLI - Fast, Animated, AI-Powered",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+@app.command()
+def new(
+    project_name: str,
+    template: str = typer.Option("helderperez-dev/voodoo-templates", "--template", "-t", help="GitHub repository URL or 'user/repo' to use as a template"),
+    variant: str = typer.Option("default", "--variant", "-v", help="Specific template variant inside the repository"),
+):
+    """
+    Scaffold a new Voodoo project or clone a community template.
+    """
+    console.print(Panel.fit(f"Creating new Voodoo project: [bold cyan]{project_name}[/bold cyan]", border_style="cyan"))
+    project_dir = Path(project_name)
+    if project_dir.exists():
+        console.print(f"[bold red]Error:[/bold red] Directory '{project_name}' already exists.")
+        raise typer.Exit(1)
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        if template:
+            task = progress.add_task(description=f"Cloning [cyan]{variant}[/cyan] template from [cyan]{template}[/cyan]...", total=None)
+            # Resolve URL
+            if template.startswith("http://") or template.startswith("https://") or template.startswith("git@") or template.startswith("/") or template.startswith("file://"):
+                repo_url = template
+            elif len(template.split("/")) == 2:
+                repo_url = f"https://github.com/{template}.git"
+            else:
+                console.print("\n[bold red]Error:[/bold red] Template must be a valid Git URL, local path, or 'user/repo'.")
+                raise typer.Exit(1)
+            import subprocess
+            import shutil
+            import tempfile
+            fallback_to_offline = False
+            try:
+                with tempfile.TemporaryDirectory() as tmp_dir:
+                    subprocess.run(
+                        ["git", "clone", "--depth", "1", repo_url, tmp_dir],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE
+                    )
+                    variant_path = Path(tmp_dir) / variant
+                    if not variant_path.exists() or not variant_path.is_dir():
+                        # If variant doesn't exist, check if the repo root itself is the template
+                        if variant == "default" and not (Path(tmp_dir) / "default").exists():
+                            variant_path = Path(tmp_dir)
+                        else:
+                            console.print(f"\n[bold red]Error:[/bold red] Variant '{variant}' not found in template repository.")
+                            raise typer.Exit(1)
+                    # Copy the template files over to the project directory
+                    shutil.copytree(variant_path, project_dir, dirs_exist_ok=True)
+            except subprocess.CalledProcessError as e:
+                console.print(f"\n[bold yellow]Warning:[/bold yellow] Failed to clone template from {repo_url}")
+                console.print("[yellow]Falling back to offline default scaffolding...[/yellow]")
+                fallback_to_offline = True
+            if not fallback_to_offline:
+                # Remove the .git folder so the user starts with a clean slate
+                if (project_dir / ".git").exists():
+                    shutil.rmtree(project_dir / ".git", ignore_errors=True)
+                if not (project_dir / ".data").exists():
+                    os.makedirs(project_dir / ".data", exist_ok=True)
+        if not template or fallback_to_offline:
+            task = progress.add_task(description="Scaffolding offline project structure...", total=None)
+            # Simulate quick but visible animation
+            time.sleep(0.5)
+            os.makedirs(project_dir)
+            os.makedirs(project_dir / "app")
+            os.makedirs(project_dir / ".data")
+            progress.update(task, description="Writing base configuration...")
+            time.sleep(0.5)
+            (project_dir / ".env").write_text("VOODOO_DB_PATH=.data/voodoo.db\n")
+            (project_dir / "pyproject.toml").write_text(f"""[project]
+name = "{project_name}"
+version = "0.1.0"
+dependencies = [
+    "voodoo-framework"
+]
+""")
+            progress.update(task, description="Generating entry point...")
+            time.sleep(0.5)
+            (project_dir / "app" / "page.py").write_text("""from voodoo.components import Div, Heading, Text
+def page(request):
+    \"\"\"
+    A minimal single-page application.
+    Voodoo's router will automatically map app/page.py to the root "/" route.
+    \"\"\"
+    return Div(
+        Heading("Hello, Voodoo! 🪄", level=1, className="text-5xl font-bold text-center mt-32 tracking-tight"),
+        Div(Text("Welcome to your new Voodoo app."), className="text-center text-[var(--color-text-muted)] mt-6 text-lg"),
+        className="min-h-screen bg-[var(--color-background)] text-[var(--color-text)]"
+    )
+""")
+            (project_dir / "main.py").write_text("""import uvicorn
+from voodoo.core import create_app
+from voodoo.config import config
+# Voodoo automatically looks for the "app" folder in the current working directory
+app = create_app()
+if __name__ == "__main__":
+    uvicorn.run("main:app", host=config.host, port=config.port, reload=True, ws_max_size=16777216, ws_max_queue=32)
+""")
+    console.print("[bold green]✓ Project scaffolded successfully![/bold green]")
+    console.print(f"\nNext steps:\n  [cyan]cd {project_name}[/cyan]\n  [cyan]voodoo dev[/cyan]\n")
+@app.command()
+def dev(
+    app_str: str = typer.Argument("main:app", help="App instance to run (e.g., main:app)"),
+    port: int = typer.Option(8000, help="Port to run the server on"),
+):
+    """
+    Start the Voodoo development server.
+    """
+    module_name = app_str.split(":")[0]
+    module_path = Path(module_name.replace(".", "/") + ".py")
+    module_dir = Path(module_name.replace(".", "/"))
+    if not module_path.exists() and not (module_dir.is_dir() and (module_dir / "__init__.py").exists()):
+        console.print(f"\n[bold red]Error:[/bold red] Could not find module [yellow]{module_name}[/yellow].")
+        console.print("Are you sure you are inside a Voodoo project directory?")
+        console.print("To start a new project, run: [bold cyan]voodoo new <project_name>[/bold cyan]\n")
+        raise typer.Exit(1)
+    console.print(Panel.fit(f"Starting Voodoo Server on port [bold yellow]{port}[/bold yellow]", border_style="yellow"))
+    # We use a subprocess to run uvicorn
+    import subprocess
+    try:
+        # We let uvicorn take over the terminal output
+        subprocess.run(["uvicorn", app_str, "--reload", "--port", str(port)])
+    except KeyboardInterrupt:
+        console.print("\n[bold red]Server stopped.[/bold red]")
+@app.command()
+def generate(
+    component: str = typer.Argument(..., help="Component type (e.g., agent, resource, tool)"),
+    description: str = typer.Argument(..., help="What should the AI generate?"),
+):
+    """
+    AI-powered generation of Voodoo components using LLMs.
+    """
+    from openai import AsyncOpenAI
+    # Check for API keys (support OpenRouter or OpenAI)
+    api_key = os.getenv("OPENROUTER_API_KEY") or os.getenv("OPENAI_API_KEY")
+    base_url = "https://openrouter.ai/api/v1" if os.getenv("OPENROUTER_API_KEY") else None
+    if not api_key:
+        console.print("[bold red]Error:[/bold red] Neither OPENROUTER_API_KEY nor OPENAI_API_KEY is set in the environment.")
+        raise typer.Exit(1)
+    client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+    model = "openai/gpt-4o" if base_url else "gpt-4o"
+    async def _generate():
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description=f"AI is thinking about your [bold magenta]{component}[/bold magenta]...", total=None)
+            prompt = f"""
+            You are an expert Voodoo Framework developer. Voodoo is a modern Python framework built on Starlette and Pydantic.
+            Generate a Voodoo `{component}` based on this description: "{description}".
+            Only output the raw Python code. Do not include markdown code blocks (no ```python).
+            Do not include explanations. Just the raw code.
+            """
+            try:
+                response = await client.chat.completions.create(
+                    model=model,
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=0.2
+                )
+                code = response.choices[0].message.content.strip()
+                # Clean up if the model accidentally included markdown blocks
+                if code.startswith("```python"):
+                    code = code[9:]
+                if code.startswith("```"):
+                    code = code[3:]
+                if code.endswith("```"):
+                    code = code[:-3]
+                return code.strip()
+            except Exception as e:
+                console.print(f"[bold red]Failed to generate code:[/bold red] {e}")
+                raise typer.Exit(1)
+    # Run async function
+    code = asyncio.run(_generate())
+    # Save the file
+    filename = f"{component}_{int(time.time())}.py"
+    Path(filename).write_text(code + "\n")
+    console.print(f"[bold green]✓ Generated {component} successfully![/bold green]")
+    console.print(f"Saved to: [bold cyan]{filename}[/bold cyan]")
+    # Show preview
+    console.print(Panel(code, title=f"Preview: {filename}", border_style="green"))
+if __name__ == "__main__":
+    app()

voodoo/components.py ADDED Viewed

@@ -0,0 +1,107 @@
+import uuid
+from typing import Any, List
+class Component:
+    tag = "div"
+    def __init__(self, *children, id=None, **kwargs):
+        self.id = id or f"vd-{uuid.uuid4().hex[:8]}"
+        self.children = children
+        self.attributes = kwargs
+    def render(self) -> str:
+        attrs = [f'id="{self.id}"']
+        for k, v in self.attributes.items():
+            k = k.replace("_", "-")
+            if k == "className":
+                k = "class"
+            if v is not None and v is not False:
+                if v is True:
+                    attrs.append(f'{k}')
+                else:
+                    attrs.append(f'{k}="{v}"')
+        attr_str = " " + " ".join(attrs) if attrs else ""
+        rendered_children = ""
+        for child in self.children:
+            if isinstance(child, Component):
+                rendered_children += child.render()
+            else:
+                rendered_children += str(child)
+        # Self closing tags
+        if self.tag in ["input", "img", "br", "hr"]:
+            return f"<{self.tag}{attr_str} />"
+        return f"<{self.tag}{attr_str}>{rendered_children}</{self.tag}>"
+class Div(Component):
+    tag = "div"
+class Button(Component):
+    tag = "button"
+    def __init__(self, *children, on_click=None, **kwargs):
+        if on_click:
+            kwargs["onclick"] = f"voodoo.sendEvent('{on_click}', this.id, this.value)"
+        super().__init__(*children, **kwargs)
+class Input(Component):
+    tag = "input"
+    def __init__(self, *children, on_change=None, **kwargs):
+        if on_change:
+            kwargs["onchange"] = f"voodoo.sendEvent('{on_change}', this.id, this.value)"
+        super().__init__(*children, **kwargs)
+class Card(Component):
+    tag = "div"
+    def __init__(self, *children, **kwargs):
+        classes = kwargs.get("className", "")
+        # Remove default conflicting classes if user provides background/border
+        default_bg = "bg-[var(--color-surface)]" if "bg-" not in classes else ""
+        default_border = "border border-[var(--color-border)]" if "border" not in classes else ""
+        kwargs["className"] = f"{default_bg} {default_border} rounded-xl p-6 shadow-xl {classes}".strip()
+        super().__init__(*children, **kwargs)
+class Text(Component):
+    tag = "span"
+class Heading(Component):
+    tag = "h1"
+    def __init__(self, *children, level=1, **kwargs):
+        self.tag = f"h{level}"
+        super().__init__(*children, **kwargs)
+class ChatBox(Component):
+    tag = "div"
+    def __init__(self, *children, **kwargs):
+        classes = kwargs.get("className", "")
+        kwargs["className"] = f"flex flex-col space-y-2 overflow-y-auto {classes}".strip()
+        super().__init__(*children, **kwargs)
+class Table(Component):
+    tag = "table"
+    def __init__(self, headers: List[str], rows: List[List[Any]], **kwargs):
+        super().__init__(**kwargs)
+        self.headers = headers
+        self.rows = rows
+    def render(self) -> str:
+        th_cells = "".join(f'<th class="px-6 py-4 text-left text-xs font-medium text-[var(--color-text-muted)] uppercase tracking-wider">{h}</th>' for h in self.headers)
+        thead = f"<thead class='bg-[var(--color-surface)] border-b border-[var(--color-border)]'><tr>{th_cells}</tr></thead>"
+        tbody_rows = []
+        for row in self.rows:
+            tds = "".join(f'<td class="px-6 py-4 whitespace-nowrap text-sm text-[var(--color-text)]">{cell}</td>' for cell in row)
+            tbody_rows.append(f"<tr class='border-b border-[var(--color-border)] hover:bg-[var(--color-surface)] transition-colors'>{tds}</tr>")
+        tbody = f"<tbody>{''.join(tbody_rows)}</tbody>"
+        attrs = [f'id="{self.id}"']
+        for k, v in self.attributes.items():
+            if k == "className":
+                k = "class"
+            attrs.append(f'{k}="{v}"')
+        attr_str = " " + " ".join(attrs) if attrs else ""
+        return f"<table{attr_str}>{thead}{tbody}</table>"

voodoo/config.py ADDED Viewed

@@ -0,0 +1,51 @@
+import os
+import yaml
+from typing import Any, Dict, Optional
+from pydantic import BaseModel, Field
+from dotenv import load_dotenv
+# Load .env variables first
+load_dotenv()
+class VoodooConfig(BaseModel):
+    """Core configuration for the Voodoo framework."""
+    env: str = Field(default_factory=lambda: os.getenv("VOODOO_ENV", "development"))
+    db_path: str = Field(default_factory=lambda: os.getenv("VOODOO_DB_PATH", ".data/voodoo.db"))
+    storage_dir: str = Field(default_factory=lambda: os.getenv("VOODOO_STORAGE_DIR", "storage"))
+    port: int = Field(default_factory=lambda: int(os.getenv("VOODOO_PORT", "8000")))
+    host: str = Field(default_factory=lambda: os.getenv("VOODOO_HOST", "0.0.0.0"))
+    extra: Dict[str, Any] = Field(default_factory=dict)
+def load_yaml_config(file_path: str = "voodoo.yaml") -> Dict[str, Any]:
+    """Loads configuration from a YAML file if it exists."""
+    if os.path.exists(file_path):
+        with open(file_path, "r") as f:
+            try:
+                return yaml.safe_load(f) or {}
+            except yaml.YAMLError as e:
+                print(f"Error parsing {file_path}: {e}")
+    return {}
+def get_config() -> VoodooConfig:
+    """Gets the merged configuration from env vars and YAML."""
+    yaml_data = load_yaml_config()
+    # We allow yaml to override or extend defaults
+    # but environment variables usually take precedence in production.
+    # For this simple implementation, we'll merge them.
+    config_args = {}
+    # Add mapped YAML fields if they match our known fields
+    if "env" in yaml_data: config_args["env"] = yaml_data["env"]
+    if "db_path" in yaml_data: config_args["db_path"] = yaml_data["db_path"]
+    if "storage_dir" in yaml_data: config_args["storage_dir"] = yaml_data["storage_dir"]
+    if "port" in yaml_data: config_args["port"] = yaml_data["port"]
+    if "host" in yaml_data: config_args["host"] = yaml_data["host"]
+    # Store any extra custom configuration
+    config_args["extra"] = {k: v for k, v in yaml_data.items() if k not in config_args}
+    return VoodooConfig(**config_args)
+# Global config instance
+config = get_config()