vibetuner 2.6.1__py3-none-any.whl → 2.7.0__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.models import UserModel
+
+from ..context import ctx
+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/AGENTS.md

@@ -0,0 +1,165 @@
+# Core Models Module
+
+**IMMUTABLE SCAFFOLDING CODE** - These are the framework's core models that provide essential functionality.
+
+## What's Here
+
+This module contains the scaffolding's core models:
+
+- **UserModel** - Base user model with authentication support
+- **OAuthAccountModel** - OAuth provider account linking
+- **EmailVerificationTokenModel** - Magic link authentication tokens
+- **BlobModel** - File storage and blob management
+- **Mixins** - Reusable model behaviors (TimeStampMixin, etc.)
+- **Types** - Common field types and validators
+
+## Important Rules
+
+⚠️  **DO NOT MODIFY** these core models directly.
+
+**For changes to core models:**
+
+- File an issue at `https://github.com/alltuner/scaffolding`
+- Core changes benefit all projects using the scaffolding
+
+**For your application models:**
+
+- Create them in `src/app/models/` instead
+- Import core models when needed: `from vibetuner.models import UserModel`
+- Use mixins from here: `from vibetuner.models.mixins import TimeStampMixin`
+
+## User Model Pattern (for reference)
+
+Your application models in `src/app/models/` should follow this pattern:
+
+```python
+from beanie import Document
+from pydantic import Field
+from vibetuner.models.mixins import TimeStampMixin
+
+class Product(Document, TimeStampMixin):
+    name: str
+    price: float = Field(gt=0)
+    stock: int = Field(ge=0)
+
+    class Settings:
+        name = "products"
+        indexes = ["name"]
+```
+
+## Available Mixins
+
+### TimeStampMixin
+
+Automatic timestamps for all models:
+
+- `db_insert_dt` - Created at (UTC)
+- `db_update_dt` - Updated at (UTC)
+- Methods: `age()`, `age_in()`, `is_older_than()`
+
+Import in your app models:
+
+```python
+from vibetuner.models.mixins import TimeStampMixin
+```
+
+## Queries
+
+### Finding Documents
+
+```python
+from beanie.operators import Eq, In, Gt, Lt
+
+# By ID (preferred method)
+product = await Product.get(product_id)
+
+# By field (use Beanie operators)
+product = await Product.find_one(Eq(Product.name, "Widget"))
+products = await Product.find(Lt(Product.price, 100)).to_list()
+
+# Multiple conditions
+results = await Product.find(
+    Eq(Product.category, "electronics"),
+    Gt(Product.price, 50)
+).to_list()
+
+# With In operator
+products = await Product.find(
+    In(Product.category, ["electronics", "gadgets"])
+).to_list()
+```
+
+### Save/Delete
+
+```python
+# Create
+product = Product(name="Widget", price=9.99, stock=100)
+await product.insert()
+
+# Update
+product.price = 19.99
+await product.save()
+
+# Delete
+await product.delete()
+```
+
+### Aggregation
+
+```python
+results = await Product.aggregate([
+    {"$match": {"price": {"$gt": 50}}},
+    {"$group": {"_id": "$category", "total": {"$sum": 1}}}
+]).to_list()
+```
+
+## Indexes
+
+```python
+from pymongo import IndexModel, TEXT
+
+class Settings:
+    indexes = [
+        "field_name",  # Simple index
+        [("field1", 1), ("field2", -1)],  # Compound index
+        IndexModel([("text_field", TEXT)])  # Text search
+    ]
+```
+
+## Relationships
+
+```python
+from beanie import Link
+
+class Order(Document):
+    user: Link[User]
+    products: list[Link[Product]]
+
+# Fetch with relations
+order = await Order.get(order_id, fetch_links=True)
+print(order.user.email)  # Automatically loaded
+```
+
+## Extending Core Models
+
+If you need to add fields to User or other core models:
+
+1. **Option A**: File an issue at `https://github.com/alltuner/scaffolding` for widely useful fields
+2. **Option B**: Create a related model in `src/app/models/` that links to the core model:
+
+```python
+from beanie import Document, Link
+from vibetuner.models import UserModel
+
+class UserProfile(Document):
+    user: Link[UserModel]
+    bio: str
+    avatar_url: str
+
+    class Settings:
+        name = "user_profiles"
+```
+
+## MongoDB MCP
+
+Claude Code has MongoDB MCP access for database operations, queries, and debugging.

vibetuner/models/CLAUDE.md

@@ -0,0 +1,165 @@
+# Core Models Module
+
+**IMMUTABLE SCAFFOLDING CODE** - These are the framework's core models that provide essential functionality.
+
+## What's Here
+
+This module contains the scaffolding's core models:
+
+- **UserModel** - Base user model with authentication support
+- **OAuthAccountModel** - OAuth provider account linking
+- **EmailVerificationTokenModel** - Magic link authentication tokens
+- **BlobModel** - File storage and blob management
+- **Mixins** - Reusable model behaviors (TimeStampMixin, etc.)
+- **Types** - Common field types and validators
+
+## Important Rules
+
+⚠️  **DO NOT MODIFY** these core models directly.
+
+**For changes to core models:**
+
+- File an issue at `https://github.com/alltuner/scaffolding`
+- Core changes benefit all projects using the scaffolding
+
+**For your application models:**
+
+- Create them in `src/app/models/` instead
+- Import core models when needed: `from vibetuner.models import UserModel`
+- Use mixins from here: `from vibetuner.models.mixins import TimeStampMixin`
+
+## User Model Pattern (for reference)
+
+Your application models in `src/app/models/` should follow this pattern:
+
+```python
+from beanie import Document
+from pydantic import Field
+from vibetuner.models.mixins import TimeStampMixin
+
+class Product(Document, TimeStampMixin):
+    name: str
+    price: float = Field(gt=0)
+    stock: int = Field(ge=0)
+
+    class Settings:
+        name = "products"
+        indexes = ["name"]
+```
+
+## Available Mixins
+
+### TimeStampMixin
+
+Automatic timestamps for all models:
+
+- `db_insert_dt` - Created at (UTC)
+- `db_update_dt` - Updated at (UTC)
+- Methods: `age()`, `age_in()`, `is_older_than()`
+
+Import in your app models:
+
+```python
+from vibetuner.models.mixins import TimeStampMixin
+```
+
+## Queries
+
+### Finding Documents
+
+```python
+from beanie.operators import Eq, In, Gt, Lt
+
+# By ID (preferred method)
+product = await Product.get(product_id)
+
+# By field (use Beanie operators)
+product = await Product.find_one(Eq(Product.name, "Widget"))
+products = await Product.find(Lt(Product.price, 100)).to_list()
+
+# Multiple conditions
+results = await Product.find(
+    Eq(Product.category, "electronics"),
+    Gt(Product.price, 50)
+).to_list()
+
+# With In operator
+products = await Product.find(
+    In(Product.category, ["electronics", "gadgets"])
+).to_list()
+```
+
+### Save/Delete
+
+```python
+# Create
+product = Product(name="Widget", price=9.99, stock=100)
+await product.insert()
+
+# Update
+product.price = 19.99
+await product.save()
+
+# Delete
+await product.delete()
+```
+
+### Aggregation
+
+```python
+results = await Product.aggregate([
+    {"$match": {"price": {"$gt": 50}}},
+    {"$group": {"_id": "$category", "total": {"$sum": 1}}}
+]).to_list()
+```
+
+## Indexes
+
+```python
+from pymongo import IndexModel, TEXT
+
+class Settings:
+    indexes = [
+        "field_name",  # Simple index
+        [("field1", 1), ("field2", -1)],  # Compound index
+        IndexModel([("text_field", TEXT)])  # Text search
+    ]
+```
+
+## Relationships
+
+```python
+from beanie import Link
+
+class Order(Document):
+    user: Link[User]
+    products: list[Link[Product]]
+
+# Fetch with relations
+order = await Order.get(order_id, fetch_links=True)
+print(order.user.email)  # Automatically loaded
+```
+
+## Extending Core Models
+
+If you need to add fields to User or other core models:
+
+1. **Option A**: File an issue at `https://github.com/alltuner/scaffolding` for widely useful fields
+2. **Option B**: Create a related model in `src/app/models/` that links to the core model:
+
+```python
+from beanie import Document, Link
+from vibetuner.models import UserModel
+
+class UserProfile(Document):
+    user: Link[UserModel]
+    bio: str
+    avatar_url: str
+
+    class Settings:
+        name = "user_profiles"
+```
+
+## MongoDB MCP
+
+Claude Code has MongoDB MCP access for database operations, queries, and debugging.

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,
+]