vibetuner 2.26.6__py3-none-any.whl

vibetuner/frontend/routes/user.py

@@ -0,0 +1,94 @@
+from fastapi import APIRouter, Form, HTTPException, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from pydantic_extra_types.language_code import LanguageAlpha2
+from starlette.authentication import requires
+
+from vibetuner.context import ctx
+from vibetuner.models import UserModel
+
+from ..templates import render_template
+
+
+router = APIRouter(prefix="/user")
+
+
+@router.get("/")
+@requires("authenticated", redirect="auth_login")
+async def user_profile(request: Request) -> HTMLResponse:
+    """User profile endpoint."""
+    user = await UserModel.get(request.user.id)
+    if not user:
+        raise HTTPException(
+            status_code=404,
+            detail="User not found",
+        )
+
+    await user.fetch_link("oauth_accounts")
+    return render_template(
+        "user/profile.html.jinja",
+        request,
+        {"user": user},
+    )
+
+
+@router.get("/edit")
+@requires("authenticated", redirect="auth_login")
+async def user_edit_form(request: Request) -> HTMLResponse:
+    """User profile edit form."""
+    user = await UserModel.get(request.user.id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    # Get available languages for the dropdown
+    from babel import Locale
+
+    locale_names = dict(
+        sorted(
+            {
+                locale: (Locale.parse(locale).display_name or locale).capitalize()
+                for locale in ctx.supported_languages
+            }.items(),
+            key=lambda x: x[1],
+        ),
+    )
+
+    return render_template(
+        "user/edit.html.jinja",
+        request,
+        {
+            "user": user,
+            "locale_names": locale_names,
+            "current_language": user.user_settings.language,
+        },
+    )
+
+
+@router.post("/edit")
+@requires("authenticated", redirect="auth_login")
+async def user_edit_submit(
+    request: Request,
+    name: str = Form(...),
+    language: str = Form(None),
+) -> RedirectResponse:
+    """Handle user profile edit form submission."""
+    user = await UserModel.get(request.user.id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    # Update user fields
+    user.name = name
+
+    # Update language preference if provided
+    if language and language in ctx.supported_languages:
+        try:
+            user.user_settings.language = LanguageAlpha2(language)
+        except ValueError:
+            pass  # Invalid language code, skip update
+
+    # Save user
+    await user.save()
+
+    # Update session with new data to avoid DB query on next request
+    request.session["user"] = user.session_dict
+
+    return RedirectResponse(url="/user/", status_code=302)

vibetuner/frontend/templates.py

@@ -0,0 +1,176 @@
+from datetime import timedelta
+from typing import Any
+
+from fastapi import Request
+from fastapi.templating import Jinja2Templates
+from starlette.responses import HTMLResponse
+from starlette_babel import gettext_lazy as _, gettext_lazy as ngettext
+from starlette_babel.contrib.jinja import configure_jinja_env
+
+from vibetuner.context import Context
+from vibetuner.paths import frontend_templates
+from vibetuner.templates import render_static_template
+from vibetuner.time import age_in_timedelta
+
+from .hotreload import hotreload
+
+
+__all__ = [
+    "render_static_template",
+]
+
+data_ctx = Context()
+
+
+def timeago(dt):
+    """Converts a datetime object to a human-readable string representing the time elapsed since the given datetime.
+
+    Args:
+        dt (datetime): The datetime object to convert.
+
+    Returns:
+        str: A human-readable string representing the time elapsed since the given datetime,
+        such as "X seconds ago", "X minutes ago", "X hours ago", "yesterday", "X days ago",
+        "X months ago", or "X years ago". If the datetime is more than 4 years old,
+        it returns the date in the format "MMM DD, YYYY".
+
+    """
+    try:
+        diff = age_in_timedelta(dt)
+
+        if diff < timedelta(seconds=60):
+            seconds = diff.seconds
+            return ngettext(
+                "%(seconds)d second ago",
+                "%(seconds)d seconds ago",
+                seconds,
+            ) % {"seconds": seconds}
+        if diff < timedelta(minutes=60):
+            minutes = diff.seconds // 60
+            return ngettext(
+                "%(minutes)d minute ago",
+                "%(minutes)d minutes ago",
+                minutes,
+            ) % {"minutes": minutes}
+        if diff < timedelta(days=1):
+            hours = diff.seconds // 3600
+            return ngettext("%(hours)d hour ago", "%(hours)d hours ago", hours) % {
+                "hours": hours,
+            }
+        if diff < timedelta(days=2):
+            return _("yesterday")
+        if diff < timedelta(days=65):
+            days = diff.days
+            return ngettext("%(days)d day ago", "%(days)d days ago", days) % {
+                "days": days,
+            }
+        if diff < timedelta(days=365):
+            months = diff.days // 30
+            return ngettext("%(months)d month ago", "%(months)d months ago", months) % {
+                "months": months,
+            }
+        if diff < timedelta(days=365 * 4):
+            years = diff.days // 365
+            return ngettext("%(years)d year ago", "%(years)d years ago", years) % {
+                "years": years,
+            }
+        return dt.strftime("%b %d, %Y")
+    except Exception:
+        return ""
+
+
+def format_date(dt):
+    """Formats a datetime object to display only the date.
+
+    Args:
+        dt (datetime): The datetime object to format.
+
+    Returns:
+        str: A formatted date string in the format "Month DD, YYYY" (e.g., "January 15, 2024").
+        Returns empty string if dt is None.
+    """
+    if dt is None:
+        return ""
+    try:
+        return dt.strftime("%B %d, %Y")
+    except Exception:
+        return ""
+
+
+def format_datetime(dt):
+    """Formats a datetime object to display date and time without seconds.
+
+    Args:
+        dt (datetime): The datetime object to format.
+
+    Returns:
+        str: A formatted datetime string in the format "Month DD, YYYY at HH:MM AM/PM"
+        (e.g., "January 15, 2024 at 3:45 PM"). Returns empty string if dt is None.
+    """
+    if dt is None:
+        return ""
+    try:
+        return dt.strftime("%B %d, %Y at %I:%M %p")
+    except Exception:
+        return ""
+
+
+# Add your functions here
+def format_duration(seconds):
+    """Formats duration in seconds to user-friendly format with rounding.
+
+    Args:
+        seconds (float): Duration in seconds.
+
+    Returns:
+        str: For 0-45 seconds, shows "x sec" (e.g., "30 sec").
+        For 46 seconds to 1:45, shows "1 min".
+        For 1:46 to 2:45, shows "2 min", etc.
+        Returns empty string if seconds is None or invalid.
+    """
+    if seconds is None:
+        return ""
+    try:
+        total_seconds = int(float(seconds))
+
+        if total_seconds <= 45:
+            return f"{total_seconds} sec"
+        else:
+            # Round to nearest minute for times > 45 seconds
+            # 46-105 seconds = 1 min, 106-165 seconds = 2 min, etc.
+            minutes = round(total_seconds / 60)
+            return f"{minutes} min"
+    except (ValueError, TypeError):
+        return ""
+
+
+templates: Jinja2Templates = Jinja2Templates(directory=frontend_templates)
+jinja_env = templates.env
+
+
+def render_template(
+    template: str,
+    request: Request,
+    ctx: dict[str, Any] | None = None,
+    **kwargs: Any,
+) -> HTMLResponse:
+    ctx = ctx or {}
+    merged_ctx = {**data_ctx.model_dump(), "request": request, **ctx}
+
+    return templates.TemplateResponse(template, merged_ctx, **kwargs)
+
+
+# Global Vars
+jinja_env.globals.update({"DEBUG": data_ctx.DEBUG})
+jinja_env.globals.update({"hotreload": hotreload})
+
+# Date Filters
+jinja_env.filters["timeago"] = timeago
+jinja_env.filters["format_date"] = format_date
+jinja_env.filters["format_datetime"] = format_datetime
+
+# Duration Filters
+jinja_env.filters["format_duration"] = format_duration
+jinja_env.filters["duration"] = format_duration
+
+configure_jinja_env(jinja_env)

vibetuner/logging.py

@@ -0,0 +1,87 @@
+import logging
+import sys
+from enum import Enum
+from pathlib import Path
+
+from loguru import logger
+
+
+class LogLevel(str, Enum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class InterceptHandler(logging.Handler):
+    def emit(self, record):
+        # Get corresponding Loguru level if it exists
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+
+        # Find caller from where originated the logged message
+        frame, depth = logging.currentframe(), 2
+        while frame is not None and frame.f_code.co_filename == logging.__file__:
+            frame = frame.f_back
+            depth += 1
+
+        # Format the message with module information inline
+        logger.opt(depth=depth, exception=record.exc_info).log(
+            level,
+            f"[{record.name}] {record.getMessage()}",
+        )
+
+
+def setup_logging(
+    level: str | int | None = LogLevel.INFO,
+    log_file: str | Path | None = None,
+    rotation: str = "10 MB",
+    retention: str = "1 week",
+) -> None:
+    """Configure logging for the application.
+
+    Args:
+        level: Minimum logging level threshold
+        log_file: Optional path to log file. If None, logs only to stderr
+        rotation: When to rotate the log file
+        retention: How long to keep log files
+
+    """
+    # Remove default handler
+    logger.remove()
+
+    if level is None:
+        level = LogLevel.INFO
+
+    # Define format for the logs
+    format_string = (
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+        "<level>{level: <8}</level> | "
+        "<cyan>{name}</cyan>:<cyan>{line}</cyan> - "
+        "<level>{message}</level>"
+    )
+
+    # Add stderr handler with custom format
+    logger.add(sys.stderr, level=level, format=format_string, colorize=True)
+
+    # Add file handler if log_file is specified
+    if log_file:
+        logger.add(
+            str(log_file),
+            level=level,
+            format=format_string,
+            rotation=rotation,
+            retention=retention,
+            compression="zip",
+        )
+
+    # Intercept standard logging
+    logging.basicConfig(handlers=[InterceptHandler()], level=0, force=True)
+
+    # Optional: Capture warnings from warnings module
+    logging.captureWarnings(True)
+
+    logger.info("Logging configured successfully")

vibetuner/models/__init__.py

@@ -0,0 +1,14 @@
+from beanie import Document, View
+
+from .blob import BlobModel
+from .email_verification import EmailVerificationTokenModel
+from .oauth import OAuthAccountModel
+from .user import UserModel
+
+
+__all__: list[type[Document] | type[View]] = [
+    BlobModel,
+    EmailVerificationTokenModel,
+    OAuthAccountModel,
+    UserModel,
+]

vibetuner/models/blob.py

@@ -0,0 +1,89 @@
+"""Blob storage model for file uploads and management.
+
+WARNING: This is a scaffolding-managed file. DO NOT MODIFY directly.
+Manages file metadata for S3 or local storage backends.
+"""
+
+import hashlib
+from enum import StrEnum
+from typing import Self
+
+from beanie import Document
+from pydantic import Field
+
+from vibetuner.models.registry import register_model
+
+from .mixins import TimeStampMixin
+
+
+class BlobStatus(StrEnum):
+    PENDING = "pending"
+    UPLOADED = "uploaded"
+    DELETED = "deleted"
+    ERROR = "error"
+
+
+@register_model
+class BlobModel(Document, TimeStampMixin):
+    status: BlobStatus = Field(
+        default=BlobStatus.PENDING,
+        description="Status of the blob indicating if it is pending, uploaded, or deleted",
+    )
+    bucket: str = Field(
+        ...,
+        description="Storage bucket name where the object is stored",
+    )
+    content_type: str = Field(
+        ...,
+        description="MIME type of the object (e.g., image/png, application/pdf)",
+    )
+    original_filename: str | None = Field(
+        default=None,
+        description="Original name of the file as uploaded by the user (if applicable)",
+    )
+    namespace: str | None = Field(
+        default=None,
+        description="Namespaces (prefixes) for the object, used for organization (optional)",
+    )
+    checksum: str = Field(
+        ...,
+        description="SHA256 hash of the object for integrity verification",
+    )
+    size: int = Field(..., description="Size of the object in bytes")
+
+    @property
+    def full_path(self) -> str:
+        """Get the full path of the blob in the bucket."""
+        if self.namespace:
+            return f"{self.namespace}/{self.id}"
+        else:
+            return f"{self.id}"
+
+    @classmethod
+    def from_bytes(
+        cls,
+        body: bytes,
+        content_type: str,
+        bucket: str,
+        namespace: str | None = None,
+        original_filename: str | None = None,
+    ) -> Self:
+        """Create a BlobModel instance from raw bytes and metadata."""
+        return cls(
+            original_filename=original_filename,
+            content_type=content_type,
+            bucket=bucket,
+            namespace=namespace,
+            checksum=cls.calculate_checksum(body),
+            size=len(body),
+        )
+
+    @staticmethod
+    def calculate_checksum(body: bytes) -> str:
+        """Calculate SHA256 checksum of the given bytes."""
+
+        return hashlib.sha256(body).hexdigest()
+
+    class Settings:
+        name = "blobs"
+        keep_nulls = False

vibetuner/models/email_verification.py

@@ -0,0 +1,84 @@
+"""Email verification model for magic link authentication.
+
+WARNING: This is a scaffolding-managed file. DO NOT MODIFY directly.
+Handles passwordless authentication via email verification tokens.
+"""
+
+import secrets
+from datetime import datetime, timedelta
+from typing import Optional, Self
+
+from beanie import Document
+from beanie.operators import Eq, Set
+from pydantic import Field
+
+from vibetuner.models.registry import register_model
+from vibetuner.time import now
+
+
+# Email verification token model
+@register_model
+class EmailVerificationTokenModel(Document):
+    email: str = Field(
+        ...,
+        description="Email address requesting verification",
+    )
+    token: str = Field(
+        ...,
+        description="Secure random token for email verification",
+    )
+    expires_at: datetime = Field(
+        ...,
+        description="Token expiration timestamp",
+    )
+    used: bool = Field(
+        default=False,
+        description="Whether the token has been consumed",
+    )
+
+    class Settings:
+        name = "email_verification_tokens"
+        indexes = [
+            [("token", 1)],
+            [("email", 1)],
+            [("expires_at", 1)],
+        ]
+
+    @classmethod
+    async def create_token(cls, email: str, expires_minutes: int = 15) -> Self:
+        """Create a new verification token for email login"""
+        token = secrets.token_urlsafe(32)
+        expires_at = now() + timedelta(minutes=expires_minutes)
+
+        # Invalidate any existing tokens for this email
+        await cls.find(Eq(cls.email, email)).update_many(Set({cls.used: True}))
+
+        verification_token = cls(
+            email=email, token=token, expires_at=expires_at, used=False
+        )
+
+        return await verification_token.insert()
+
+    @classmethod
+    async def verify_token(cls, token: str) -> Optional[Self]:
+        """Verify and consume a token"""
+        verification_token: Optional[Self] = await cls.find_one(
+            Eq(cls.token, token), Eq(cls.used, False)
+        )
+
+        if not verification_token:
+            return None
+
+        # Ensure expires_at is timezone-aware for comparison
+        expires_at = verification_token.expires_at
+        if expires_at.tzinfo is None:
+            from datetime import timezone
+
+            expires_at = expires_at.replace(tzinfo=timezone.utc)
+
+        if expires_at < now():
+            return None
+
+        # Mark token as used
+        verification_token.used = True
+        return await verification_token.save()

vibetuner/models/mixins.py

@@ -0,0 +1,76 @@
+"""Reusable model mixins for common functionality.
+
+WARNING: This is a scaffolding-managed file. DO NOT MODIFY directly.
+Provides timestamp tracking and other common model behaviors.
+"""
+
+from datetime import datetime, timedelta
+from enum import StrEnum
+from typing import Self
+
+from beanie import Insert, Replace, Save, SaveChanges, Update, before_event
+from pydantic import BaseModel, Field
+
+from vibetuner.time import Unit, now
+
+
+class Since(StrEnum):
+    """Reference moment for age calculations."""
+
+    CREATION = "creation"
+    UPDATE = "update"
+
+
+# ────────────────────────────────────────────────────────────────
+#  Drop-in mixin
+# ────────────────────────────────────────────────────────────────
+class TimeStampMixin(BaseModel):
+    """
+    ✦ Automatic UTC timestamps on insert/update
+    ✦ Typed helpers for age checks
+
+        doc.age()                       → timedelta
+        doc.age_in(Unit.HOURS)          → float
+        doc.is_older_than(td, since=…)  → bool
+    """
+
+    db_insert_dt: datetime = Field(
+        default_factory=lambda: now(),
+        description="Timestamp when the document was first created and inserted into the database (UTC)",
+    )
+    db_update_dt: datetime = Field(
+        default_factory=lambda: now(),
+        description="Timestamp when the document was last modified or updated (UTC)",
+    )
+
+    # ── Beanie hooks ────────────────────────────────────────────
+    @before_event(Insert)
+    def _touch_on_insert(self) -> None:
+        _now = now()
+        self.db_insert_dt = _now
+        self.db_update_dt = _now
+
+    @before_event(Update, SaveChanges, Save, Replace)
+    def _touch_on_update(self) -> None:
+        self.db_update_dt = now()
+
+    # ── Public helpers ──────────────────────────────────────────
+    def age(self, *, since: Since = Since.CREATION) -> timedelta:
+        """Timedelta since *creation* or last *update* (default: creation)."""
+        ref = self.db_update_dt if since is Since.UPDATE else self.db_insert_dt
+        return now() - ref
+
+    def age_in(
+        self, unit: Unit = Unit.SECONDS, *, since: Since = Since.CREATION
+    ) -> float:
+        """Age expressed as a float in the requested `unit`."""
+        return self.age(since=since).total_seconds() / unit.factor
+
+    def is_older_than(self, delta: timedelta, *, since: Since = Since.CREATION) -> bool:
+        """True iff the document’s age ≥ `delta`."""
+        return self.age(since=since) >= delta
+
+    def touch(self) -> Self:
+        """Manually bump `db_update_dt` and return `self` (chain-friendly)."""
+        self.db_update_dt = now()
+        return self

vibetuner/models/oauth.py

@@ -0,0 +1,57 @@
+from typing import Self
+
+from beanie import Document
+from beanie.operators import Eq
+from pydantic import BaseModel, Field
+
+from vibetuner.models.registry import register_model
+
+from .mixins import TimeStampMixin
+
+
+class OauthProviderModel(BaseModel):
+    identifier: str
+    params: dict[str, str] = {}
+    client_kwargs: dict[str, str]
+    config: dict[str, str]
+
+
+@register_model
+class OAuthAccountModel(Document, TimeStampMixin):
+    provider: str = Field(
+        ...,
+        description="OAuth provider name (google, github, twitter, etc.)",
+    )
+    provider_user_id: str = Field(
+        ...,
+        description="Unique user identifier from the OAuth provider",
+    )
+    email: str | None = Field(
+        default=None,
+        description="Email address retrieved from OAuth provider profile",
+    )
+    name: str | None = Field(
+        default=None,
+        description="Full display name retrieved from OAuth provider profile",
+    )
+    picture: str | None = Field(
+        default=None,
+        description="Profile picture URL retrieved from OAuth provider",
+    )
+
+    class Settings:
+        name = "oauth_accounts"
+        indexes = [
+            [("provider", 1), ("provider_user_id", 1)],
+        ]
+
+    @classmethod
+    async def get_by_provider_and_id(
+        cls,
+        provider: str,
+        provider_user_id: str,
+    ) -> Self | None:
+        return await cls.find_one(
+            Eq(cls.provider, provider),
+            Eq(cls.provider_user_id, provider_user_id),
+        )

vibetuner/models/registry.py

@@ -0,0 +1,15 @@
+from beanie import Document, View
+
+
+_MODEL_REGISTRY: list[type[Document] | type[View]] = []
+
+
+def register_model(cls):
+    """Decorator to register a model"""
+    _MODEL_REGISTRY.append(cls)
+    return cls
+
+
+def get_all_models():
+    """Get all registered models (call at startup)"""
+    return _MODEL_REGISTRY