voodoo-framework 1.0.0__py3-none-any.whl

voodoo/core.py

@@ -0,0 +1,236 @@
+import asyncio
+import json
+import os
+import importlib.util
+from typing import Dict, Any, Callable
+from starlette.applications import Starlette
+from starlette.routing import Route, WebSocketRoute, Mount
+from starlette.responses import HTMLResponse, Response
+from starlette.websockets import WebSocket
+from starlette.staticfiles import StaticFiles
+import inspect
+
+class WebSocketManager:
+    def __init__(self):
+        self.active_connections: list[WebSocket] = []
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections.append(websocket)
+
+    def disconnect(self, websocket: WebSocket):
+        if websocket in self.active_connections:
+            self.active_connections.remove(websocket)
+
+    async def broadcast_patch(self, element_id: str, html: str):
+        message = json.dumps({"type": "patch", "id": element_id, "html": html})
+        for connection in self.active_connections:
+            try:
+                await connection.send_text(message)
+            except Exception:
+                pass
+
+    async def broadcast_append(self, element_id: str, html: str):
+        message = json.dumps({"type": "append", "id": element_id, "html": html})
+        for connection in self.active_connections:
+            try:
+                await connection.send_text(message)
+            except Exception:
+                pass
+
+ws_manager = WebSocketManager()
+event_handlers: Dict[str, Callable] = {}
+
+def register_event(name: str, handler: Callable):
+    event_handlers[name] = handler
+
+async def websocket_endpoint(websocket: WebSocket):
+    print(f"WS Connecting: {websocket.headers}")
+    await ws_manager.connect(websocket)
+    print("WS Connected!")
+    try:
+        while True:
+            data = await websocket.receive_text()
+            print(f"WS Received: {data}")
+            msg = json.loads(data)
+            if msg.get("type") == "event":
+                handler = event_handlers.get(msg["event"])
+                if handler:
+                    if inspect.iscoroutinefunction(handler):
+                        await handler(msg["id"], msg["value"])
+                    else:
+                        handler(msg["id"], msg["value"])
+    except Exception as e:
+        print(f"WS Disconnected/Error: {e}")
+        ws_manager.disconnect(websocket)
+
+def render_page(component) -> str:
+    from voodoo.components import Component
+    from voodoo.theme import default_theme
+    
+    html_content = component.render() if isinstance(component, Component) else str(component)
+    
+    # Read client.js
+    client_js_path = os.path.join(os.path.dirname(__file__), "client.js")
+    with open(client_js_path, "r") as f:
+        client_js = f.read()
+        
+    tailwind_config = default_theme.to_tailwind_config()
+    css_vars = default_theme.to_css_variables()
+    
+    # Check for theme cookie if available via a simple hack or rely on client side script
+    # Better: handle it strictly on client side using JS on load to prevent flash of wrong theme
+    
+    html_class = f"dark {default_theme.mode}" if default_theme.mode == "dark" else default_theme.mode
+
+    return f"""
+    <!DOCTYPE html>
+    <html lang="en" class="{html_class}">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Voodoo App</title>
+        <script src="https://cdn.tailwindcss.com"></script>
+        <script>
+            tailwind.config = {tailwind_config};
+            
+            // Prevent flash of incorrect theme
+            if (document.cookie.includes('voodoo_theme=light')) {{
+                document.documentElement.classList.remove('dark');
+                document.documentElement.classList.add('light');
+            }} else if (document.cookie.includes('voodoo_theme=dark')) {{
+                document.documentElement.classList.remove('light');
+                document.documentElement.classList.add('dark');
+            }}
+        </script>
+        <style>
+            {css_vars}
+            body {{ 
+                background-color: var(--color-background); 
+                color: var(--color-text); 
+                font-family: var(--font-sans); 
+            }}
+            ::-webkit-scrollbar {{ width: 8px; height: 8px; }}
+            ::-webkit-scrollbar-track {{ background: transparent; }}
+            ::-webkit-scrollbar-thumb {{ background: var(--color-surface); border-radius: 4px; border: 1px solid var(--color-border); }}
+            ::-webkit-scrollbar-thumb:hover {{ background: var(--color-text-muted); }}
+        </style>
+    </head>
+    <body class="bg-[var(--color-background)] text-[var(--color-text)] min-h-screen antialiased selection:bg-[var(--color-secondary)] selection:text-white">
+        <div id="root">
+            {html_content}
+        </div>
+        <script>
+            {client_js}
+        </script>
+    </body>
+    </html>
+    """
+
+def create_app(app_dir: str = "app") -> Starlette:
+    from voodoo.config import config
+    base_storage_dir = os.path.join(os.getcwd(), config.storage_dir)
+    public_storage_dir = os.path.join(base_storage_dir, "public")
+    os.makedirs(public_storage_dir, exist_ok=True)
+    
+    routes = [
+        WebSocketRoute("/_voodoo_ws", websocket_endpoint),
+        Mount("/storage/public", app=StaticFiles(directory=public_storage_dir), name="storage_public")
+    ]
+    
+    # Simple file-based router
+    pages_dir = os.path.join(app_dir, "pages")
+    if os.path.exists(pages_dir):
+        for filename in os.listdir(pages_dir):
+            if filename.endswith(".py") and not filename.startswith("_"):
+                name = filename[:-3]
+                route_path = "/" if name == "index" else f"/{name}"
+                filepath = os.path.join(pages_dir, filename)
+                spec = importlib.util.spec_from_file_location(f"page_{name}", filepath)
+                if spec and spec.loader:
+                    page_module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(page_module)
+                    if hasattr(page_module, "page"):
+                        # create a closure to capture the module
+                        def make_route(mod):
+                            async def handler(request):
+                                sig = inspect.signature(mod.page)
+                                if "request" in sig.parameters:
+                                    component = mod.page(request)
+                                else:
+                                    component = mod.page()
+                                if inspect.iscoroutine(component):
+                                    component = await component
+                                return HTMLResponse(render_page(component))
+                            return handler
+                        routes.append(Route(route_path, make_route(page_module)))
+    else:
+        page_path = os.path.join(app_dir, "page.py")
+        if os.path.exists(page_path):
+            spec = importlib.util.spec_from_file_location("page", page_path)
+            if spec and spec.loader:
+                page_module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(page_module)
+                
+                if hasattr(page_module, "page"):
+                    async def index(request):
+                        sig = inspect.signature(page_module.page)
+                        if "request" in sig.parameters:
+                            component = page_module.page(request)
+                        else:
+                            component = page_module.page()
+                        if inspect.iscoroutine(component):
+                            component = await component
+                        return HTMLResponse(render_page(component))
+                    routes.append(Route("/", index))
+
+    # Initialize components if needed
+    models_path = os.path.join(app_dir, "models.py")
+    if os.path.exists(models_path):
+        spec = importlib.util.spec_from_file_location("models", models_path)
+        if spec and spec.loader:
+            models_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(models_module)
+
+    workers_path = os.path.join(app_dir, "workers.py")
+    if os.path.exists(workers_path):
+        spec = importlib.util.spec_from_file_location("workers", workers_path)
+        if spec and spec.loader:
+            workers_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(workers_module)
+
+    api_path = os.path.join(app_dir, "api.py")
+    if os.path.exists(api_path):
+        spec = importlib.util.spec_from_file_location("api", api_path)
+        if spec and spec.loader:
+            api_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(api_module)
+            
+            from voodoo.api import api as voodoo_api
+            routes.extend(voodoo_api.routes)
+
+    from voodoo.queue import start_workers, stop_workers
+    from voodoo.data import init_db
+    from voodoo.telemetry import TelemetryMiddleware
+    from voodoo.i18n import I18nMiddleware
+    from starlette.middleware import Middleware
+    from contextlib import asynccontextmanager
+    
+    @asynccontextmanager
+    async def lifespan(app: Starlette):
+        # Startup
+        await init_db()
+        worker_task = asyncio.create_task(start_workers())
+        yield
+        # Shutdown
+        await stop_workers()
+        worker_task.cancel()
+
+    middleware = [
+        Middleware(TelemetryMiddleware),
+        Middleware(I18nMiddleware)
+    ]
+
+    app = Starlette(debug=True, routes=routes, middleware=middleware, lifespan=lifespan)
+    
+    return app

voodoo/data.py

@@ -0,0 +1,179 @@
+import asyncio
+import aiosqlite
+from typing import Any, Callable, Dict, List, Type, get_type_hints
+
+_db_connection = None
+_triggers: Dict[str, Dict[str, List[Callable]]] = {}
+_rls_policies: Dict[str, Callable] = {}
+
+import os
+
+async def init_db(db_path: str = None):
+    if db_path is None:
+        from voodoo.config import config
+        db_path = config.db_path
+        
+    db_dir = os.path.dirname(db_path)
+    if db_dir:
+        os.makedirs(db_dir, exist_ok=True)
+        
+    global _db_connection
+    _db_connection = await aiosqlite.connect(db_path)
+    _db_connection.row_factory = aiosqlite.Row
+    for model in _models:
+        await model._create_table()
+
+async def get_db():
+    if _db_connection is None:
+        await init_db()
+    return _db_connection
+
+def on_insert(model_cls: Type):
+    def decorator(func: Callable):
+        table = model_cls.__name__.lower()
+        if table not in _triggers:
+            _triggers[table] = {"insert": [], "update": []}
+        _triggers[table]["insert"].append(func)
+        return func
+    return decorator
+
+def on_update(model_cls: Type):
+    def decorator(func: Callable):
+        table = model_cls.__name__.lower()
+        if table not in _triggers:
+            _triggers[table] = {"insert": [], "update": []}
+        _triggers[table]["update"].append(func)
+        return func
+    return decorator
+
+def rls_policy(model_cls: Type):
+    def decorator(func: Callable):
+        table = model_cls.__name__.lower()
+        _rls_policies[table] = func
+        return func
+    return decorator
+
+_models: List[Type] = []
+
+class ModelMeta(type):
+    def __init__(cls, name, bases, attrs):
+        super().__init__(name, bases, attrs)
+        if name != "BaseModel":
+            _models.append(cls)
+
+class BaseModel(metaclass=ModelMeta):
+    id: int
+    
+    @classmethod
+    async def _create_table(cls):
+        db = await get_db()
+        table_name = cls.__name__.lower()
+        hints = get_type_hints(cls)
+        columns = []
+        for col_name, col_type in hints.items():
+            if col_name == "id":
+                columns.append("id INTEGER PRIMARY KEY AUTOINCREMENT")
+            elif col_type == int:
+                columns.append(f"{col_name} INTEGER")
+            elif col_type == str:
+                columns.append(f"{col_name} TEXT")
+            elif col_type == bool:
+                columns.append(f"{col_name} BOOLEAN")
+            else:
+                columns.append(f"{col_name} TEXT")
+                
+        query = f"CREATE TABLE IF NOT EXISTS {table_name} ({', '.join(columns)})"
+        await db.execute(query)
+        await db.commit()
+
+    @classmethod
+    async def find_all(cls, user_context: dict = None) -> List['BaseModel']:
+        from voodoo.telemetry import telemetry_store
+        telemetry_store.record_db_query()
+        db = await get_db()
+        table_name = cls.__name__.lower()
+        query = f"SELECT * FROM {table_name}"
+        params = []
+        
+        if table_name in _rls_policies and user_context:
+            policy = _rls_policies[table_name]
+            where_clause = policy(user_context)
+            if where_clause:
+                query += f" WHERE {where_clause}"
+                
+        async with db.execute(query, params) as cursor:
+            rows = await cursor.fetchall()
+            results = []
+            hints = get_type_hints(cls)
+            for row in rows:
+                obj = cls()
+                for k in row.keys():
+                    val = row[k]
+                    if k in hints and hints[k] == bool:
+                        val = bool(val)
+                    setattr(obj, k, val)
+                results.append(obj)
+            return results
+
+    async def insert(self):
+        from voodoo.telemetry import telemetry_store
+        telemetry_store.record_db_query()
+        db = await get_db()
+        table_name = self.__class__.__name__.lower()
+        
+        hints = get_type_hints(self.__class__)
+        cols = []
+        vals = []
+        placeholders = []
+        
+        for col_name in hints.keys():
+            if col_name == "id" and not hasattr(self, "id"):
+                continue
+            if hasattr(self, col_name):
+                cols.append(col_name)
+                vals.append(getattr(self, col_name))
+                placeholders.append("?")
+                
+        query = f"INSERT INTO {table_name} ({', '.join(cols)}) VALUES ({', '.join(placeholders)})"
+        cursor = await db.execute(query, vals)
+        await db.commit()
+        
+        self.id = cursor.lastrowid
+        
+        # Trigger hooks
+        if table_name in _triggers and _triggers[table_name]["insert"]:
+            for hook in _triggers[table_name]["insert"]:
+                if asyncio.iscoroutinefunction(hook):
+                    asyncio.create_task(hook(self))
+                else:
+                    hook(self)
+        return self
+
+    async def update(self):
+        from voodoo.telemetry import telemetry_store
+        telemetry_store.record_db_query()
+        db = await get_db()
+        table_name = self.__class__.__name__.lower()
+        
+        hints = get_type_hints(self.__class__)
+        cols = []
+        vals = []
+        
+        for col_name in hints.keys():
+            if col_name != "id" and hasattr(self, col_name):
+                cols.append(f"{col_name} = ?")
+                vals.append(getattr(self, col_name))
+                
+        vals.append(self.id)
+        query = f"UPDATE {table_name} SET {', '.join(cols)} WHERE id = ?"
+        await db.execute(query, vals)
+        await db.commit()
+        
+        # Trigger hooks
+        if table_name in _triggers and _triggers[table_name]["update"]:
+            for hook in _triggers[table_name]["update"]:
+                if asyncio.iscoroutinefunction(hook):
+                    asyncio.create_task(hook(self))
+                else:
+                    hook(self)
+        return self

voodoo/i18n.py

@@ -0,0 +1,107 @@
+import os
+import json
+from contextvars import ContextVar
+from typing import Dict, Any, Optional
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+
+# Context variables for the current request's language and translations
+current_language: ContextVar[str] = ContextVar("current_language", default="en")
+translations: ContextVar[Dict[str, Any]] = ContextVar("translations", default={})
+
+class I18n:
+    """Internationalization manager for Voodoo."""
+    def __init__(self, default_lang: str = "en", locales_dir: str = "locales"):
+        self.default_lang = default_lang
+        self.locales_dir = locales_dir
+        self.locales: Dict[str, Dict[str, Any]] = {}
+        self.load_locales()
+
+    def load_locales(self):
+        """Loads JSON locale files from the locales directory."""
+        if not os.path.exists(self.locales_dir):
+            return
+            
+        for filename in os.listdir(self.locales_dir):
+            if filename.endswith(".json"):
+                lang = filename[:-5]
+                filepath = os.path.join(self.locales_dir, filename)
+                try:
+                    with open(filepath, "r", encoding="utf-8") as f:
+                        self.locales[lang] = json.load(f)
+                except Exception as e:
+                    print(f"Error loading locale {lang}: {e}")
+
+    def get_translation(self, lang: str, key: str, **kwargs) -> str:
+        """Retrieves a translation string by key for a specific language."""
+        lang_dict = self.locales.get(lang) or self.locales.get(self.default_lang) or {}
+        
+        # Support nested keys like "home.title"
+        keys = key.split(".")
+        val = lang_dict
+        for k in keys:
+            if isinstance(val, dict):
+                val = val.get(k)
+            else:
+                val = None
+                break
+                
+        if val is None:
+            return key # fallback to key if not found
+            
+        if isinstance(val, str) and kwargs:
+            try:
+                return val.format(**kwargs)
+            except KeyError:
+                return val
+        
+        return str(val)
+
+# Global i18n instance
+i18n_instance = I18n()
+
+def _(key: str, **kwargs) -> str:
+    """
+    Translates a key using the current request's language.
+    This is the main function to be used in components and pages.
+    """
+    lang = current_language.get()
+    return i18n_instance.get_translation(lang, key, **kwargs)
+
+class I18nMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware to detect and set the language for the current request.
+    Priority: Query Param (?lang=) > Cookie (voodoo_lang) > Accept-Language Header > Default
+    """
+    def __init__(self, app, i18n: Optional[I18n] = None):
+        super().__init__(app)
+        self.i18n = i18n or i18n_instance
+
+    async def dispatch(self, request: Request, call_next):
+        # 1. Query Param
+        lang = request.query_params.get("lang")
+        
+        # 2. Cookie
+        if not lang:
+            lang = request.cookies.get("voodoo_lang")
+            
+        # 3. Accept-Language Header
+        if not lang:
+            accept_lang = request.headers.get("accept-language")
+            if accept_lang:
+                # e.g., "pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7"
+                lang = accept_lang.split(",")[0].split("-")[0]
+                
+        if not lang or lang not in self.i18n.locales:
+            lang = self.i18n.default_lang
+
+        # Set the context variable for the duration of this request
+        token = current_language.set(lang)
+        try:
+            response = await call_next(request)
+            # If lang was set via query, we might want to set a cookie for future requests
+            if request.query_params.get("lang"):
+                response.set_cookie("voodoo_lang", lang)
+            return response
+        finally:
+            current_language.reset(token)

voodoo/mcp.py

@@ -0,0 +1,141 @@
+import inspect
+import asyncio
+from typing import Any, Callable, Dict, Optional
+from voodoo.api import api
+from starlette.requests import Request
+from starlette.responses import JSONResponse, StreamingResponse
+
+class MCPServer:
+    def __init__(self, name: str = "voodoo-mcp", version: str = "1.0.0"):
+        self.name = name
+        self.version = version
+        self.tools: Dict[str, Dict[str, Any]] = {}
+        self.resources: Dict[str, Dict[str, Any]] = {}
+        
+        # Register SSE endpoints
+        api.get("/mcp/sse")(self._sse_endpoint)
+        api.post("/mcp/messages")(self._messages_endpoint)
+
+    def tool(self, name: Optional[str] = None, description: Optional[str] = None):
+        def decorator(func: Callable):
+            tool_name = name or func.__name__
+            self.tools[tool_name] = {
+                "func": func,
+                "description": description or func.__doc__ or "No description provided."
+            }
+            return func
+        return decorator
+
+    def resource(self, uri: str, name: Optional[str] = None):
+        def decorator(func: Callable):
+            res_name = name or func.__name__
+            self.resources[uri] = {
+                "func": func,
+                "name": res_name
+            }
+            return func
+        return decorator
+
+    async def _sse_endpoint(self, request: Request):
+        async def event_generator():
+            yield 'event: endpoint\ndata: /mcp/messages\n\n'
+            while True:
+                await asyncio.sleep(15)
+                yield ':\n\n'
+        return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+    async def _messages_endpoint(self, request: Request):
+        try:
+            body = await request.json()
+            method = body.get("method")
+            params = body.get("params", {})
+            msg_id = body.get("id")
+
+            if method == "tools/list":
+                tools_list = [
+                    {
+                        "name": t_name,
+                        "description": t_data["description"],
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {}
+                        }
+                    }
+                    for t_name, t_data in self.tools.items()
+                ]
+                return JSONResponse({
+                    "jsonrpc": "2.0",
+                    "id": msg_id,
+                    "result": {"tools": tools_list}
+                })
+
+            elif method == "tools/call":
+                tool_name = params.get("name")
+                args = params.get("arguments", {})
+                if tool_name in self.tools:
+                    func = self.tools[tool_name]["func"]
+                    if inspect.iscoroutinefunction(func):
+                        result = await func(**args)
+                    else:
+                        result = func(**args)
+                    return JSONResponse({
+                        "jsonrpc": "2.0",
+                        "id": msg_id,
+                        "result": {"content": [{"type": "text", "text": str(result)}]}
+                    })
+                else:
+                    return JSONResponse({"jsonrpc": "2.0", "id": msg_id, "error": {"code": -32601, "message": "Tool not found"}})
+
+            elif method == "resources/list":
+                res_list = [
+                    {
+                        "uri": uri,
+                        "name": r_data["name"]
+                    }
+                    for uri, r_data in self.resources.items()
+                ]
+                return JSONResponse({
+                    "jsonrpc": "2.0",
+                    "id": msg_id,
+                    "result": {"resources": res_list}
+                })
+
+            elif method == "resources/read":
+                uri = params.get("uri")
+                if uri in self.resources:
+                    func = self.resources[uri]["func"]
+                    if inspect.iscoroutinefunction(func):
+                        content = await func()
+                    else:
+                        content = func()
+                    return JSONResponse({
+                        "jsonrpc": "2.0",
+                        "id": msg_id,
+                        "result": {"contents": [{"uri": uri, "text": str(content)}]}
+                    })
+                return JSONResponse({"jsonrpc": "2.0", "id": msg_id, "error": {"code": -32602, "message": "Resource not found"}})
+            
+            return JSONResponse({"jsonrpc": "2.0", "id": msg_id, "error": {"code": -32601, "message": "Method not found"}})
+        except Exception as e:
+            return JSONResponse({"jsonrpc": "2.0", "error": {"code": -32603, "message": str(e)}}, status_code=500)
+
+class MCPClient:
+    def __init__(self, endpoint_url: str):
+        self.endpoint_url = endpoint_url
+
+    async def call_tool(self, name: str, arguments: Dict[str, Any]) -> Any:
+        import httpx
+        async with httpx.AsyncClient() as client:
+            payload = {
+                "jsonrpc": "2.0",
+                "method": "tools/call",
+                "params": {
+                    "name": name,
+                    "arguments": arguments
+                },
+                "id": 1
+            }
+            response = await client.post(self.endpoint_url, json=payload)
+            return response.json()
+
+mcp = MCPServer()