voodoo-framework 1.0.0__py3-none-any.whl

voodoo/queue.py

@@ -0,0 +1,61 @@
+import asyncio
+import inspect
+import logging
+from typing import Callable, Dict, Any
+
+_queues: Dict[str, asyncio.Queue] = {}
+_workers: Dict[str, Callable] = {}
+_worker_tasks: list[asyncio.Task] = []
+
+logger = logging.getLogger("voodoo.queue")
+
+def queue(name: str):
+    def decorator(func: Callable):
+        if name not in _queues:
+            _queues[name] = asyncio.Queue()
+        _workers[name] = func
+        return func
+    return decorator
+
+async def enqueue(name: str, payload: Any):
+    if name not in _queues:
+        _queues[name] = asyncio.Queue()
+    from voodoo.telemetry import trace_id_var
+    trace_id = trace_id_var.get()
+    await _queues[name].put({"payload": payload, "trace_id": trace_id})
+
+async def _run_worker(name: str):
+    q = _queues[name]
+    func = _workers[name]
+    from voodoo.telemetry import trace_id_var
+    import uuid
+    while True:
+        try:
+            item = await q.get()
+            payload = item.get("payload")
+            trace_id = item.get("trace_id") or str(uuid.uuid4())
+            token = trace_id_var.set(trace_id)
+            try:
+                if inspect.iscoroutinefunction(func):
+                    await func(payload)
+                else:
+                    func(payload)
+            except Exception as e:
+                logger.error(f"Error in worker {name}: {e}")
+            finally:
+                trace_id_var.reset(token)
+                q.task_done()
+        except asyncio.CancelledError:
+            break
+
+async def start_workers():
+    for name in _workers.keys():
+        task = asyncio.create_task(_run_worker(name))
+        _worker_tasks.append(task)
+
+async def stop_workers():
+    for task in _worker_tasks:
+        task.cancel()
+    if _worker_tasks:
+        await asyncio.gather(*_worker_tasks, return_exceptions=True)
+    _worker_tasks.clear()

voodoo/status.py

@@ -0,0 +1,131 @@
+import asyncio
+from typing import Dict, Any
+from voodoo.api import api
+from voodoo.data import get_db
+from voodoo.queue import _worker_tasks, _queues
+from voodoo.storage import storage
+from voodoo.components import Div, Card, Heading
+
+from voodoo.i18n import _
+
+async def check_database() -> Dict[str, Any]:
+    try:
+        db = await get_db()
+        await db.execute("SELECT 1")
+        return {"status": "Operational", "latency": "ok"}
+    except Exception as e:
+        return {"status": "Down", "error": str(e)}
+
+async def check_queue() -> Dict[str, Any]:
+    try:
+        total_workers = len(_worker_tasks)
+        active_queues = len(_queues)
+        return {
+            "status": "Operational" if total_workers > 0 else "Degraded",
+            "workers": total_workers,
+            "queues": active_queues
+        }
+    except Exception as e:
+        return {"status": "Down", "error": str(e)}
+
+async def check_storage() -> Dict[str, Any]:
+    try:
+        if storage.use_s3 and storage.s3_client:
+            return {"status": "Operational", "type": "S3"}
+        else:
+            import os
+            if os.path.exists(storage.base_dir):
+                return {"status": "Operational", "type": "Local"}
+            return {"status": "Degraded", "type": "Local", "error": "Dir missing"}
+    except Exception as e:
+        return {"status": "Down", "error": str(e)}
+
+async def check_agent() -> Dict[str, Any]:
+    # Placeholder for Agent connectivity
+    return {"status": "Operational", "provider": "Simulated"}
+
+@api.get("/status")
+async def get_status():
+    db_health = await check_database()
+    queue_health = await check_queue()
+    storage_health = await check_storage()
+    agent_health = await check_agent()
+
+    status_code = 200
+    if any(s["status"] == "Down" for s in [db_health, queue_health, storage_health, agent_health]):
+        status_code = 503
+
+    return {
+        "services": {
+            "database": db_health,
+            "queue": queue_health,
+            "storage": storage_health,
+            "agent": agent_health
+        },
+        "overall": "Operational" if status_code == 200 else "Down"
+    }
+
+@api.get("/status/locales")
+async def get_status_locales():
+    return {
+        "database": _("status.database"),
+        "queue": _("status.queue"),
+        "storage": _("status.storage"),
+        "agent": _("status.agent"),
+        "Operational": _("status.operational"),
+        "Degraded": _("status.degraded"),
+        "Down": _("status.down")
+    }
+
+class ServiceStatus(Div):
+    def __init__(self, **kwargs):
+        # Provide default glass aesthetics for the card
+        classes = kwargs.pop("className", "")
+        card_classes = f"bg-[var(--color-surface)] border-[var(--color-border)] backdrop-blur-xl {classes}".strip()
+        super().__init__(
+            Card(
+                Heading(_("status.title"), level=2, className="text-xl font-semibold mb-6 text-[var(--color-text)] tracking-tight"),
+                Div(id="service-status-container", className="space-y-3"),
+                Div(
+                    """
+                    <script>
+                        async function fetchStatus() {
+                            try {
+                                const [resStatus, resLocales] = await Promise.all([
+                                    fetch('/status'),
+                                    fetch('/status/locales')
+                                ]);
+                                const data = await resStatus.json();
+                                const locales = await resLocales.json();
+                                
+                                const container = document.getElementById('service-status-container');
+                                let html = '';
+                                for (const [service, info] of Object.entries(data.services)) {
+                                    let color = info.status === 'Operational' ? 'text-green-400' : (info.status === 'Degraded' ? 'text-yellow-400' : 'text-red-400');
+                                    let dot = info.status === 'Operational' ? 'bg-green-400' : (info.status === 'Degraded' ? 'bg-yellow-400' : 'bg-red-400');
+                                    let serviceName = locales[service] || service;
+                                    let statusName = locales[info.status] || info.status;
+                                    html += `
+                                        <div class="flex items-center justify-between p-3 bg-[var(--color-surface)] rounded-lg border border-[var(--color-border)] backdrop-blur-sm">
+                                            <div class="flex items-center space-x-3">
+                                                <div class="w-2.5 h-2.5 rounded-full ${dot} shadow-[0_0_8px_rgba(0,0,0,0.5)] shadow-${dot.replace('bg-', '')}"></div>
+                                                <span class="capitalize text-[var(--color-text)] font-medium tracking-wide">${serviceName}</span>
+                                            </div>
+                                            <span class="${color} font-semibold text-sm tracking-wide">${statusName}</span>
+                                        </div>
+                                    `;
+                                }
+                                container.innerHTML = html;
+                            } catch (e) {
+                                console.error('Failed to fetch status', e);
+                            }
+                        }
+                        fetchStatus();
+                        setInterval(fetchStatus, 10000);
+                    </script>
+                    """
+                ),
+                className=card_classes,
+                **kwargs
+            )
+        )

voodoo/storage.py

@@ -0,0 +1,85 @@
+import os
+import aiofiles
+import asyncio
+from typing import Union
+
+try:
+    import boto3
+    import botocore.config
+except ImportError:
+    boto3 = None
+
+class StorageManager:
+    def __init__(self):
+        self.s3_bucket = os.getenv("VOODOO_S3_BUCKET")
+        self.key = os.getenv("VOODOO_S3_KEY")
+        self.secret = os.getenv("VOODOO_S3_SECRET")
+        self.endpoint = os.getenv("VOODOO_S3_ENDPOINT")
+        
+        self.use_s3 = all([self.s3_bucket, self.key, self.secret, self.endpoint])
+        self.base_dir = os.path.join(os.getcwd(), os.getenv("VOODOO_STORAGE_DIR", "storage"))
+        
+        if self.use_s3 and boto3:
+            self.s3_client = boto3.client(
+                's3',
+                aws_access_key_id=self.key,
+                aws_secret_access_key=self.secret,
+                endpoint_url=self.endpoint,
+                config=botocore.config.Config(signature_version='s3v4')
+            )
+        else:
+            self.s3_client = None
+
+    def _get_local_path(self, bucket: str, path: str) -> str:
+        """Helper to resolve the local file path for a specific bucket."""
+        return os.path.join(self.base_dir, bucket, path)
+
+    async def upload(self, file_content: Union[bytes, str], path: str, bucket: str = "public") -> str:
+        """Uploads a file to a specific bucket and returns its path/url"""
+        if isinstance(file_content, str):
+            file_content = file_content.encode('utf-8')
+            
+        if self.use_s3 and self.s3_client:
+            s3_key = f"{bucket}/{path}"
+            await asyncio.to_thread(
+                self.s3_client.put_object,
+                Bucket=self.s3_bucket,
+                Key=s3_key,
+                Body=file_content
+            )
+            return self.url(path, bucket)
+        else:
+            local_path = self._get_local_path(bucket, path)
+            os.makedirs(os.path.dirname(local_path), exist_ok=True)
+            async with aiofiles.open(local_path, 'wb') as f:
+                await f.write(file_content)
+            return self.url(path, bucket)
+
+    async def delete(self, path: str, bucket: str = "public") -> bool:
+        """Deletes a file from a specific bucket"""
+        if self.use_s3 and self.s3_client:
+            s3_key = f"{bucket}/{path}"
+            await asyncio.to_thread(
+                self.s3_client.delete_object,
+                Bucket=self.s3_bucket,
+                Key=s3_key
+            )
+            return True
+        else:
+            local_path = self._get_local_path(bucket, path)
+            if os.path.exists(local_path):
+                os.remove(local_path)
+                return True
+            return False
+
+    def url(self, path: str, bucket: str = "public") -> str:
+        """Returns the URL for a file in a specific bucket"""
+        if self.use_s3 and self.s3_client:
+            s3_key = f"{bucket}/{path}"
+            if "amazonaws.com" in self.endpoint:
+                return f"https://{self.s3_bucket}.s3.amazonaws.com/{s3_key}"
+            return f"{self.endpoint}/{self.s3_bucket}/{s3_key}"
+        else:
+            return f"/storage/{bucket}/{path}"
+
+storage = StorageManager()

voodoo/telemetry.py

@@ -0,0 +1,157 @@
+import time
+import uuid
+import logging
+import contextvars
+import functools
+import traceback
+import inspect
+from typing import Any, Callable, Dict, List
+from starlette.types import ASGIApp, Receive, Scope, Send
+from starlette.responses import JSONResponse
+from voodoo.api import api
+
+# Context variable for tracing
+trace_id_var = contextvars.ContextVar("trace_id", default=None)
+
+class TelemetryStore:
+    def __init__(self):
+        self.metrics: Dict[str, Any] = {
+            "requests_total": 0,
+            "errors_total": 0,
+            "latencies_ms": [],
+            "custom_traces": [],
+            "db_queries": 0,
+            "agent_tokens": 0
+        }
+
+    def record_request(self, latency_ms: float, error: bool = False):
+        self.metrics["requests_total"] += 1
+        if error:
+            self.metrics["errors_total"] += 1
+        self.metrics["latencies_ms"].append(latency_ms)
+        if len(self.metrics["latencies_ms"]) > 1000:
+            self.metrics["latencies_ms"].pop(0)
+
+    def record_trace(self, name: str, latency_ms: float, error: bool = False):
+        self.metrics["custom_traces"].append({
+            "name": name,
+            "latency_ms": latency_ms,
+            "error": error,
+            "timestamp": time.time(),
+            "trace_id": trace_id_var.get()
+        })
+        if len(self.metrics["custom_traces"]) > 1000:
+            self.metrics["custom_traces"].pop(0)
+
+    def record_db_query(self):
+        self.metrics["db_queries"] += 1
+
+    def record_agent_tokens(self, count: int):
+        self.metrics["agent_tokens"] += count
+
+    def get_summary(self) -> Dict[str, Any]:
+        latencies = self.metrics["latencies_ms"]
+        avg_latency = sum(latencies) / len(latencies) if latencies else 0.0
+        return {
+            "requests_total": self.metrics["requests_total"],
+            "errors_total": self.metrics["errors_total"],
+            "average_latency_ms": round(avg_latency, 2),
+            "db_queries": self.metrics["db_queries"],
+            "agent_tokens": self.metrics["agent_tokens"],
+            "recent_traces": self.metrics["custom_traces"][-10:]
+        }
+
+telemetry_store = TelemetryStore()
+
+logger = logging.getLogger("voodoo.telemetry")
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(asctime)s - %(name)s - [%(trace_id)s] - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+class TraceFilter(logging.Filter):
+    def filter(self, record):
+        record.trace_id = trace_id_var.get() or "no-trace"
+        return True
+
+logger.addFilter(TraceFilter())
+
+class TelemetryMiddleware:
+    def __init__(self, app: ASGIApp):
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send):
+        if scope["type"] not in ("http", "websocket"):
+            await self.app(scope, receive, send)
+            return
+
+        trace_id = str(uuid.uuid4())
+        token = trace_id_var.set(trace_id)
+        
+        start_time = time.perf_counter()
+        error = False
+        
+        try:
+            await self.app(scope, receive, send)
+        except Exception as e:
+            error = True
+            logger.error(f"Unhandled exception in {scope['type']}: {e}\n{traceback.format_exc()}")
+            raise
+        finally:
+            latency_ms = (time.perf_counter() - start_time) * 1000
+            telemetry_store.record_request(latency_ms, error)
+            
+            if scope["type"] == "http":
+                method = scope.get("method", "")
+                path = scope.get("path", "")
+                logger.info(f"{method} {path} completed in {latency_ms:.2f}ms")
+            elif scope["type"] == "websocket":
+                logger.info(f"WebSocket session completed in {latency_ms:.2f}ms")
+                
+            trace_id_var.reset(token)
+
+def trace(name: str = None):
+    """Decorator to trace a specific function block."""
+    def decorator(func: Callable):
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            t_name = name or func.__name__
+            start = time.perf_counter()
+            error = False
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                error = True
+                logger.error(f"Error in traced block '{t_name}': {e}\n{traceback.format_exc()}")
+                raise
+            finally:
+                latency = (time.perf_counter() - start) * 1000
+                telemetry_store.record_trace(t_name, latency, error)
+                logger.info(f"Trace '{t_name}' completed in {latency:.2f}ms")
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            t_name = name or func.__name__
+            start = time.perf_counter()
+            error = False
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                error = True
+                logger.error(f"Error in traced block '{t_name}': {e}\n{traceback.format_exc()}")
+                raise
+            finally:
+                latency = (time.perf_counter() - start) * 1000
+                telemetry_store.record_trace(t_name, latency, error)
+                logger.info(f"Trace '{t_name}' completed in {latency:.2f}ms")
+
+        if inspect.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+    return decorator
+
+@api.get("/voodoo/metrics")
+async def get_metrics():
+    return telemetry_store.get_summary()

voodoo/theme.py

@@ -0,0 +1,112 @@
+import json
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, Field
+
+class ThemeColors(BaseModel):
+    """Modern color palette for the theme."""
+    primary: str = "#007AFF" # Apple blue
+    secondary: str = "#5856D6" # Violet
+    
+    # Dark mode
+    background: str = "#0A0A0A" # Charcoal
+    surface: str = "rgba(255, 255, 255, 0.05)" # Glass surface
+    text: str = "#F3F4F6"
+    text_muted: str = "#9CA3AF"
+    border: str = "rgba(255, 255, 255, 0.1)"
+    
+    # Light mode
+    light_background: str = "#F9FAFB"
+    light_surface: str = "rgba(0, 0, 0, 0.05)"
+    light_text: str = "#111827"
+    light_text_muted: str = "#4B5563"
+    light_border: str = "rgba(0, 0, 0, 0.1)"
+    
+    # Allow extra colors
+    extra: Dict[str, str] = Field(default_factory=dict)
+
+class ThemeFonts(BaseModel):
+    """Typography settings."""
+    sans: str = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif'
+    mono: str = 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace'
+
+class Theme(BaseModel):
+    """
+    Core Theme configuration for Voodoo.
+    Designed for modern macOS 'glass' aesthetic.
+    """
+    mode: str = "dark" # dark, light, system
+    colors: ThemeColors = Field(default_factory=ThemeColors)
+    fonts: ThemeFonts = Field(default_factory=ThemeFonts)
+    
+    def to_tailwind_config(self) -> str:
+        """Generates the Tailwind configuration script."""
+        
+        # Build the colors dictionary for Tailwind
+        tw_colors = {
+            "primary": self.colors.primary,
+            "secondary": self.colors.secondary,
+            "background": self.colors.background,
+            "surface": self.colors.surface,
+            "text": self.colors.text,
+            "text-muted": self.colors.text_muted,
+            "border": self.colors.border,
+        }
+        tw_colors.update(self.colors.extra)
+
+        config = {
+            "darkMode": 'class',
+            "theme": {
+                "extend": {
+                    "colors": {
+                        "voodoo": tw_colors
+                    },
+                    "fontFamily": {
+                        "sans": [self.fonts.sans],
+                        "mono": [self.fonts.mono]
+                    }
+                }
+            }
+        }
+        return json.dumps(config)
+
+    def to_css_variables(self) -> str:
+        """Generates global CSS variables for the theme."""
+        dark_vars = [
+            f"--color-primary: {self.colors.primary};",
+            f"--color-secondary: {self.colors.secondary};",
+            f"--color-background: {self.colors.background};",
+            f"--color-surface: {self.colors.surface};",
+            f"--color-text: {self.colors.text};",
+            f"--color-text-muted: {self.colors.text_muted};",
+            f"--color-border: {self.colors.border};",
+            f"--font-sans: {self.fonts.sans};",
+            f"--font-mono: {self.fonts.mono};",
+        ]
+        light_vars = [
+            f"--color-primary: {self.colors.primary};",
+            f"--color-secondary: {self.colors.secondary};",
+            f"--color-background: {self.colors.light_background};",
+            f"--color-surface: {self.colors.light_surface};",
+            f"--color-text: {self.colors.light_text};",
+            f"--color-text-muted: {self.colors.light_text_muted};",
+            f"--color-border: {self.colors.light_border};",
+            f"--font-sans: {self.fonts.sans};",
+            f"--font-mono: {self.fonts.mono};",
+        ]
+        
+        for k, v in self.colors.extra.items():
+            dark_vars.append(f"--color-{k}: {v};")
+            light_vars.append(f"--color-{k}: {v};")
+            
+        return (
+            ":root {\n    " + "\n    ".join(light_vars) + "\n}\n" +
+            ".dark {\n    " + "\n    ".join(dark_vars) + "\n}"
+        )
+
+# Global default theme
+default_theme = Theme()
+
+def set_theme(theme: Theme):
+    """Sets the global default theme."""
+    global default_theme
+    default_theme = theme

voodoo_framework-1.0.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: voodoo-framework
+Version: 1.0.0
+Summary: Voodoo Framework
+Requires-Python: >=3.12
+Requires-Dist: starlette
+Requires-Dist: uvicorn
+Requires-Dist: pydantic
+Requires-Dist: aiosqlite
+Requires-Dist: websockets
+Requires-Dist: httpx
+Requires-Dist: python-dotenv
+Requires-Dist: pyyaml
+Requires-Dist: typer
+Requires-Dist: rich
+Requires-Dist: openai
+Requires-Dist: aiofiles
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"

voodoo_framework-1.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+voodoo/__init__.py,sha256=3dz4ShWkS7Wg8g7QgmEeL3xmW7R88MCU053SPBFhZdE,1146
+voodoo/agent.py,sha256=wqqyjHLVb8z9ngG0f59rfozrW7zNH4nMvz1M_GrmeBA,1497
+voodoo/api.py,sha256=LVfpNt9hfB4r0U8mzasoLniOarr-JD6qFmN5Iu7AY_o,5154
+voodoo/cli.py,sha256=BJszwEv5MS8X8bc4NYTSIQUR-cpoCosvbbW1Hv4clec,10465
+voodoo/components.py,sha256=hNkUjk5RBHMs_V33fGsrsqTuVjEltSgVit7Hxv8YDgg,4037
+voodoo/config.py,sha256=ACb3Vvhghm2ZJyHVXArkdGMU-isRWb0yduDr-C71HAw,2144
+voodoo/core.py,sha256=gNi-Rddip3wByZ_ExvaT5io7Vib_mdlvweSfS_YsNcQ,9686
+voodoo/data.py,sha256=9Up4cEF2pX5SeQoxDIDa8LDsJPQoCSViEkWk0suCpqc,5932
+voodoo/i18n.py,sha256=fWjaDYHEKLnd82fujse_m3C_5nAlV0s4Yf-kVaZkyng,3937
+voodoo/mcp.py,sha256=CbfSLYHGMhSYy9EB0QQzWWhmWtY0LQXui0ca5-F7LMc,5415
+voodoo/queue.py,sha256=dZHw9WKIsThu8qDIbeBqKevDk060XH2DDZS3UGj8GVg,1833
+voodoo/status.py,sha256=Esj6pd54-MocvVfq7Jwr9MIdKfGtuM7irfSvvxw2avo,5759
+voodoo/storage.py,sha256=jJPPBoxMRgHPJETHe_SYWHMyoqiPSXmDS4yeRF3cnlQ,3157
+voodoo/telemetry.py,sha256=k3YZRpw5tSIo0xOAoBfxczHf6EHpEI4BEXgJr4o_0DM,5582
+voodoo/theme.py,sha256=40uDhCAX9pw9AfUps8SgFu7AjQ9LTobNxY23aawqMM8,4043
+voodoo_framework-1.0.0.dist-info/METADATA,sha256=yIcnnMd7WrQw1eYsUN1TDbnJDJX2kNH4essiurK4BKI,610
+voodoo_framework-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+voodoo_framework-1.0.0.dist-info/entry_points.txt,sha256=t57b2RrYkby0eg4utUoYjRYKOrHJ1Bzp7t5k_sNq_UQ,42
+voodoo_framework-1.0.0.dist-info/top_level.txt,sha256=TUn9HhnGYiYJyWa6NkouunOjTGCZAGPasucG_BjBT1E,7
+voodoo_framework-1.0.0.dist-info/RECORD,,

voodoo_framework-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

voodoo_framework-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+voodoo = voodoo.cli:app

voodoo_framework-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+voodoo