vibetuner 2.26.9__py3-none-any.whl → 2.44.1__py3-none-any.whl

vibetuner/frontend/routes/debug.py

@@ -3,13 +3,13 @@ from fastapi import (
     Depends,
     HTTPException,
     Request,
-    Response,
 )
 from fastapi.responses import (
     HTMLResponse,
     RedirectResponse,
 )
 
+from vibetuner.config import settings
 from vibetuner.context import ctx
 from vibetuner.models import UserModel
 from vibetuner.models.registry import get_all_models
@@ -18,32 +18,41 @@ from ..deps import MAGIC_COOKIE_NAME
 from ..templates import render_template
 
 
-def check_debug_access(request: Request, prod: str | None = None):
+def check_debug_access(request: Request):
     """Check if debug routes should be accessible."""
     # Always allow in development mode
     if ctx.DEBUG:
         return True
 
-    # In production, require prod=1 parameter
-    if prod == "1":
-        return True
+    # In production, require magic cookie
+    if MAGIC_COOKIE_NAME not in request.cookies:
+        raise HTTPException(status_code=404, detail="Not found")
+    if request.cookies[MAGIC_COOKIE_NAME] != "granted":
+        raise HTTPException(status_code=404, detail="Not found")
 
-    # Deny access
-    raise HTTPException(status_code=404, detail="Not found")
+    return True
 
 
-router = APIRouter(prefix="/debug", dependencies=[Depends(check_debug_access)])
+# Unprotected router for token-based debug access
+auth_router = APIRouter()
 
 
-@router.get("/", response_class=HTMLResponse)
-def debug_index(request: Request):
-    return render_template("debug/index.html.jinja", request)
+@auth_router.get("/_unlock-debug")
+def unlock_debug_access(token: str | None = None):
+    """Grant debug access by setting the magic cookie.
 
+    In DEBUG mode, no token is required.
+    In production, the token must match DEBUG_ACCESS_TOKEN.
+    If DEBUG_ACCESS_TOKEN is not configured, debug access is disabled in production.
+    """
+    if not ctx.DEBUG:
+        # In production, validate token
+        if settings.debug_access_token is None:
+            raise HTTPException(status_code=404, detail="Not found")
+        if token is None or token != settings.debug_access_token:
+            raise HTTPException(status_code=404, detail="Not found")
 
-@router.get("/magic")
-def set_magic_cookie(response: Response):
-    """Set the magic access cookie."""
-    response = RedirectResponse(url="/", status_code=302)
+    response = RedirectResponse(url="/debug", status_code=302)
     response.set_cookie(
         key=MAGIC_COOKIE_NAME,
         value="granted",
@@ -55,14 +64,23 @@ def set_magic_cookie(response: Response):
     return response
 
 
-@router.get("/no-magic")
-def remove_magic_cookie(response: Response):
-    """Remove the magic access cookie."""
+@auth_router.get("/_lock-debug")
+def lock_debug_access():
+    """Revoke debug access by removing the magic cookie."""
     response = RedirectResponse(url="/", status_code=302)
     response.delete_cookie(key=MAGIC_COOKIE_NAME)
     return response
 
 
+# Protected router for debug endpoints requiring cookie auth
+router = APIRouter(prefix="/debug", dependencies=[Depends(check_debug_access)])
+
+
+@router.get("/", response_class=HTMLResponse)
+def debug_index(request: Request):
+    return render_template("debug/index.html.jinja", request)
+
+
 @router.get("/version", response_class=HTMLResponse)
 def debug_version(request: Request):
     return render_template("debug/version.html.jinja", request)
@@ -136,20 +154,11 @@ def _is_beanie_link_schema(option: dict) -> bool:
 
 def _infer_link_target_from_field_name(field_name: str) -> str:
     """Infer the target model type from field name patterns."""
-    # Common patterns for field names that reference other models
+    # Core vibetuner models
     patterns = {
         "oauth_accounts": "OAuthAccountModel",
-        "accounts": "AccountModel",
         "users": "UserModel",
         "user": "UserModel",
-        "stations": "StationModel",
-        "station": "StationModel",
-        "rundowns": "RundownModel",
-        "rundown": "RundownModel",
-        "fillers": "FillerModel",
-        "filler": "FillerModel",
-        "voices": "VoiceModel",
-        "voice": "VoiceModel",
         "blobs": "BlobModel",
         "blob": "BlobModel",
     }
@@ -374,10 +383,13 @@ async def debug_users(request: Request):
     )
 
 
+# The following endpoints are restricted to DEBUG mode only (no production access).
+# These are dangerous operations that could compromise security if allowed in production.
+
+
 @router.post("/impersonate/{user_id}")
 async def debug_impersonate_user(request: Request, user_id: str):
     """Impersonate a user by setting their ID in the session."""
-    # Double check debug mode for security
     if not ctx.DEBUG:
         raise HTTPException(status_code=404, detail="Not found")
 
@@ -395,7 +407,6 @@ async def debug_impersonate_user(request: Request, user_id: str):
 @router.post("/stop-impersonation")
 async def debug_stop_impersonation(request: Request):
     """Stop impersonating and clear user session."""
-    # Double check debug mode for security
     if not ctx.DEBUG:
         raise HTTPException(status_code=404, detail="Not found")
 
@@ -406,7 +417,6 @@ async def debug_stop_impersonation(request: Request):
 @router.get("/clear-session")
 async def debug_clear_session(request: Request):
     """Clear all session data to fix corrupted sessions."""
-    # Double check debug mode for security
     if not ctx.DEBUG:
         raise HTTPException(status_code=404, detail="Not found")
 

vibetuner/frontend/templates.py

@@ -17,9 +17,40 @@ from .hotreload import hotreload
 
 __all__ = [
     "render_static_template",
+    "render_template",
+    "render_template_string",
+    "register_filter",
 ]
 
 
+_filter_registry: dict[str, Any] = {}
+
+
+def register_filter(name: str | None = None):
+    """Decorator to register a custom Jinja2 filter.
+
+    Args:
+        name: Optional custom name for the filter. If not provided,
+              uses the function name.
+
+    Usage:
+        @register_filter()
+        def my_filter(value):
+            return value.upper()
+
+        @register_filter("custom_name")
+        def another_filter(value):
+            return value.lower()
+    """
+
+    def decorator(func):
+        filter_name = name or func.__name__
+        _filter_registry[filter_name] = func
+        return func
+
+    return decorator
+
+
 def timeago(dt):
     """Converts a datetime object to a human-readable string representing the time elapsed since the given datetime.
 
@@ -158,6 +189,38 @@ def render_template(
     return templates.TemplateResponse(template, merged_ctx, **kwargs)
 
 
+def render_template_string(
+    template: str,
+    request: Request,
+    ctx: dict[str, Any] | None = None,
+) -> str:
+    """Render a template to a string instead of HTMLResponse.
+
+    Useful for Server-Sent Events (SSE), AJAX responses, or any case where you need
+    the rendered HTML as a string rather than a full HTTP response.
+
+    Args:
+        template: Path to template file (e.g., "admin/partials/episode.html.jinja")
+        request: FastAPI Request object
+        ctx: Optional context dictionary to pass to template
+
+    Returns:
+        str: Rendered template as a string
+
+    Example:
+        html = render_template_string(
+            "admin/partials/episode_article.html.jinja",
+            request,
+            {"episode": episode}
+        )
+    """
+    ctx = ctx or {}
+    merged_ctx = {**data_ctx.model_dump(), "request": request, **ctx}
+
+    template_obj = templates.get_template(template)
+    return template_obj.render(merged_ctx)
+
+
 # Global Vars
 jinja_env.globals.update({"DEBUG": data_ctx.DEBUG})
 jinja_env.globals.update({"hotreload": hotreload})
@@ -171,4 +234,22 @@ jinja_env.filters["format_datetime"] = format_datetime
 jinja_env.filters["format_duration"] = format_duration
 jinja_env.filters["duration"] = format_duration
 
+# Import user-defined filters to trigger registration
+try:
+    import app.frontend.templates as _app_templates  # type: ignore[import-not-found] # noqa: F401
+except ModuleNotFoundError:
+    # Silent pass - templates module is optional
+    pass
+except ImportError as e:
+    from vibetuner.logging import logger
+
+    logger.warning(
+        f"Failed to import app.frontend.templates: {e}. Custom filters will not be available."
+    )
+
+# Apply all registered custom filters
+for filter_name, filter_func in _filter_registry.items():
+    jinja_env.filters[filter_name] = filter_func
+
+# Configure Jinja environment after all filters are registered
 configure_jinja_env(jinja_env)

vibetuner/mongo.py

@@ -1,6 +1,8 @@
 from importlib import import_module
+from typing import Optional
 
 from beanie import init_beanie
+from deprecated import deprecated
 from pymongo import AsyncMongoClient
 
 from vibetuner.config import settings
@@ -8,26 +10,64 @@ from vibetuner.logging import logger
 from vibetuner.models.registry import get_all_models
 
 
-async def init_models() -> None:
-    """Initialize MongoDB connection and register all Beanie models."""
+# Global singleton, created lazily
+mongo_client: Optional[AsyncMongoClient] = None
+
+
+def _ensure_client() -> None:
+    """
+    Lazily create the global MongoDB client if mongodb_url is configured.
+    Safe to call many times.
+    """
+    global mongo_client
+
+    if settings.mongodb_url is None:
+        logger.warning("MongoDB URL is not configured. Mongo engine disabled.")
+        return
+
+    if mongo_client is None:
+        mongo_client = AsyncMongoClient(
+            host=str(settings.mongodb_url),
+            compressors=["zstd"],
+        )
+        logger.debug("MongoDB client created.")
+
+
+async def init_mongodb() -> None:
+    """Initialize MongoDB and register Beanie models."""
+    _ensure_client()
+
+    if mongo_client is None:
+        # Nothing to do; URL missing
+        return
 
-    # Try to import user models to trigger their registration
+    # Import user models so they register themselves
     try:
         import_module("app.models")
     except ModuleNotFoundError:
-        # Silent pass for missing app.models module (expected in some projects)
-        pass
+        logger.debug("app.models not found; skipping user model import.")
     except ImportError as e:
-        # Log warning for any import error (including syntax errors, missing dependencies, etc.)
-        logger.warning(
-            f"Failed to import app.models: {e}. User models will not be registered."
-        )
-
-    client: AsyncMongoClient = AsyncMongoClient(
-        host=str(settings.mongodb_url),
-        compressors=["zstd"],
-    )
+        logger.warning(f"Failed to import app.models: {e}. User models may be missing.")
 
     await init_beanie(
-        database=client[settings.mongo_dbname], document_models=get_all_models()
+        database=mongo_client[settings.mongo_dbname],
+        document_models=get_all_models(),
     )
+    logger.info("MongoDB + Beanie initialized successfully.")
+
+
+async def teardown_mongodb() -> None:
+    """Dispose the MongoDB client."""
+    global mongo_client
+
+    if mongo_client is not None:
+        await mongo_client.close()
+        mongo_client = None
+        logger.info("MongoDB client closed.")
+    else:
+        logger.debug("MongoDB client was never initialized; nothing to tear down.")
+
+
+@deprecated(reason="Use init_mongodb() instead")
+async def init_models() -> None:
+    await init_mongodb()

vibetuner/paths.py

@@ -33,24 +33,27 @@ def create_core_templates_symlink(target: Path) -> None:
         logger.error(f"Cannot create symlink: {e}")
         return
 
-    # Case 1: target does not exist → create symlink
+    # Case 1: target is already a symlink → check if it needs updating
+    if target.is_symlink():
+        if target.resolve() != source:
+            target.unlink()
+            target.symlink_to(source, target_is_directory=True)
+            logger.info(f"Updated symlink '{target}' → '{source}'")
+        else:
+            logger.debug(f"Symlink '{target}' already points to '{source}'")
+        return
+
+    # Case 2: target does not exist → create symlink
     if not target.exists():
         target.symlink_to(source, target_is_directory=True)
         logger.info(f"Created symlink '{target}' → '{source}'")
         return
 
-    # Case 2: exists but is not a symlink → error
-    if not target.is_symlink():
-        logger.error(f"Cannot create symlink: '{target}' exists and is not a symlink.")
-        raise FileExistsError(
-            f"Cannot create symlink: '{target}' exists and is not a symlink."
-        )
-
-    # Case 3: is a symlink but points somewhere else → update it
-    if target.resolve() != source:
-        target.unlink()
-        target.symlink_to(source, target_is_directory=True)
-        logger.info(f"Updated symlink '{target}' → '{source}'")
+    # Case 3: exists but is not a symlink → error
+    logger.error(f"Cannot create symlink: '{target}' exists and is not a symlink.")
+    raise FileExistsError(
+        f"Cannot create symlink: '{target}' exists and is not a symlink."
+    )
 
 
 # Package templates always available

vibetuner/services/blob.py

@@ -6,18 +6,13 @@ To extend blob functionality, create wrapper services in the parent services dir
 
 import mimetypes
 from pathlib import Path
-from typing import Literal
 
 import aioboto3
-from aiobotocore.config import AioConfig
 
 from vibetuner.config import settings
 from vibetuner.models import BlobModel
 from vibetuner.models.blob import BlobStatus
-
-
-S3_SERVICE_NAME: Literal["s3"] = "s3"
-DEFAULT_CONTENT_TYPE: str = "application/octet-stream"
+from vibetuner.services.s3_storage import DEFAULT_CONTENT_TYPE, S3StorageService
 
 
 class BlobService:
@@ -34,25 +29,22 @@ class BlobService:
             raise ValueError(
                 "R2 bucket endpoint URL, access key, and secret key must be set in settings."
             )
-        self.session = session or aioboto3.Session(
-            aws_access_key_id=settings.r2_access_key.get_secret_value(),
-            aws_secret_access_key=settings.r2_secret_key.get_secret_value(),
-            region_name=settings.r2_default_region,
-        )
-        self.endpoint_url = str(settings.r2_bucket_endpoint_url)
-        self.config = AioConfig(
-            request_checksum_calculation="when_required",
-            response_checksum_validation="when_required",
-        )
 
-        if not default_bucket:
-            if settings.r2_default_bucket_name is None:
-                raise ValueError(
-                    "Default bucket name must be provided either in settings or as an argument."
-                )
-            self.default_bucket = settings.r2_default_bucket_name
-        else:
-            self.default_bucket = default_bucket
+        bucket = default_bucket or settings.r2_default_bucket_name
+        if bucket is None:
+            raise ValueError(
+                "Default bucket name must be provided either in settings or as an argument."
+            )
+
+        self.storage = S3StorageService(
+            endpoint_url=str(settings.r2_bucket_endpoint_url),
+            access_key=settings.r2_access_key.get_secret_value(),
+            secret_key=settings.r2_secret_key.get_secret_value(),
+            region=settings.r2_default_region,
+            default_bucket=bucket,
+            session=session,
+        )
+        self.default_bucket = bucket
 
     async def put_object(
         self,
@@ -80,17 +72,12 @@ class BlobService:
             raise ValueError("Blob ID must be set before uploading to R2.")
 
         try:
-            async with self.session.client(
-                service_name=S3_SERVICE_NAME,
-                endpoint_url=self.endpoint_url,
-                config=self.config,
-            ) as s3_client:
-                await s3_client.put_object(
-                    Bucket=bucket,
-                    Key=blob.full_path,
-                    Body=body,
-                    ContentType=content_type,
-                )
+            await self.storage.put_object(
+                key=blob.full_path,
+                body=body,
+                content_type=content_type,
+                bucket=bucket,
+            )
             blob.status = BlobStatus.UPLOADED
         except Exception:
             blob.status = BlobStatus.ERROR
@@ -144,16 +131,10 @@ class BlobService:
         if not blob:
             raise ValueError(f"Blob not found: {key}")
 
-        async with self.session.client(
-            service_name=S3_SERVICE_NAME,
-            endpoint_url=self.endpoint_url,
-            config=self.config,
-        ) as s3_client:
-            response = await s3_client.get_object(
-                Bucket=blob.bucket,
-                Key=blob.full_path,
-            )
-            return await response["Body"].read()
+        return await self.storage.get_object(
+            key=blob.full_path,
+            bucket=blob.bucket,
+        )
 
     async def delete_object(self, key: str) -> None:
         """Delete an object from the R2 bucket"""
@@ -172,4 +153,9 @@ class BlobService:
         if not blob:
             return False
 
+        if check_bucket:
+            return await self.storage.object_exists(
+                key=blob.full_path, bucket=blob.bucket
+            )
+
         return True

vibetuner/services/email.py

@@ -6,7 +6,7 @@ To extend email functionality, create wrapper services in the parent services di
 
 from typing import Literal
 
-import boto3
+import aioboto3
 
 from vibetuner.config import settings
 
@@ -17,11 +17,9 @@ SES_SERVICE_NAME: Literal["ses"] = "ses"
 class SESEmailService:
     def __init__(
         self,
-        ses_client=None,
         from_email: str | None = None,
     ) -> None:
-        self.ses_client = ses_client or boto3.client(
-            service_name=SES_SERVICE_NAME,
+        self.session = aioboto3.Session(
             region_name=settings.project.aws_default_region,
             aws_access_key_id=settings.aws_access_key_id.get_secret_value()
             if settings.aws_access_key_id
@@ -36,15 +34,16 @@ class SESEmailService:
         self, to_address: str, subject: str, html_body: str, text_body: str
     ):
         """Send email using Amazon SES"""
-        response = self.ses_client.send_email(
-            Source=self.from_email,
-            Destination={"ToAddresses": [to_address]},
-            Message={
-                "Subject": {"Data": subject, "Charset": "UTF-8"},
-                "Body": {
-                    "Html": {"Data": html_body, "Charset": "UTF-8"},
-                    "Text": {"Data": text_body, "Charset": "UTF-8"},
+        async with self.session.client(SES_SERVICE_NAME) as ses_client:
+            response = await ses_client.send_email(
+                Source=self.from_email,
+                Destination={"ToAddresses": [to_address]},
+                Message={
+                    "Subject": {"Data": subject, "Charset": "UTF-8"},
+                    "Body": {
+                        "Html": {"Data": html_body, "Charset": "UTF-8"},
+                        "Text": {"Data": text_body, "Charset": "UTF-8"},
+                    },
                 },
-            },
-        )
-        return response
+            )
+            return response