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

vibetuner/services/s3_storage.py

@@ -0,0 +1,454 @@
+"""ABOUTME: S3-compatible storage service for managing buckets and objects.
+ABOUTME: Provides async operations for R2, MinIO, and other S3-compatible storage providers.
+"""
+
+from typing import Any, Literal
+
+import aioboto3
+from aiobotocore.config import AioConfig
+from botocore.exceptions import ClientError
+
+
+S3_SERVICE_NAME: Literal["s3"] = "s3"
+DEFAULT_CONTENT_TYPE: str = "application/octet-stream"
+
+
+class S3StorageService:
+    """Async S3-compatible storage service for bucket and object operations.
+
+    This service provides a clean interface to S3-compatible storage providers
+    (AWS S3, Cloudflare R2, MinIO, etc.) without any database dependencies.
+
+    All operations are async and use aioboto3 for efficient I/O.
+    """
+
+    def __init__(
+        self,
+        endpoint_url: str,
+        access_key: str,
+        secret_key: str,
+        region: str = "auto",
+        default_bucket: str | None = None,
+        session: aioboto3.Session | None = None,
+    ) -> None:
+        """Initialize S3 storage service with explicit configuration.
+
+        Args:
+            endpoint_url: S3-compatible endpoint URL (e.g., "https://xxx.r2.cloudflarestorage.com")
+            access_key: Access key ID for authentication
+            secret_key: Secret access key for authentication
+            region: AWS region (default "auto" for R2/MinIO)
+            default_bucket: Optional default bucket for operations
+            session: Optional custom aioboto3 session
+        """
+        self.endpoint_url = endpoint_url
+        self.default_bucket = default_bucket
+        self.session = session or aioboto3.Session(
+            aws_access_key_id=access_key,
+            aws_secret_access_key=secret_key,
+            region_name=region,
+        )
+        self.config = AioConfig(
+            request_checksum_calculation="when_required",
+            response_checksum_validation="when_required",
+        )
+
+    def _get_bucket(self, bucket: str | None) -> str:
+        """Get bucket name, using default if not specified.
+
+        Args:
+            bucket: Optional bucket name
+
+        Returns:
+            Bucket name to use
+
+        Raises:
+            ValueError: If no bucket specified and no default bucket set
+        """
+        if bucket is None:
+            if self.default_bucket is None:
+                raise ValueError(
+                    "No bucket specified and no default bucket configured. "
+                    "Provide bucket parameter or set default_bucket during initialization."
+                )
+            return self.default_bucket
+        return bucket
+
+    # =========================================================================
+    # Object Operations
+    # =========================================================================
+
+    async def put_object(
+        self,
+        key: str,
+        body: bytes,
+        content_type: str = DEFAULT_CONTENT_TYPE,
+        bucket: str | None = None,
+        metadata: dict[str, str] | None = None,
+    ) -> None:
+        """Upload an object to S3-compatible storage.
+
+        Args:
+            key: Object key (path) in the bucket
+            body: Raw bytes to upload
+            content_type: MIME type of the object
+            bucket: Bucket name (uses default_bucket if None)
+            metadata: Optional custom metadata dict
+        """
+        bucket_name = self._get_bucket(bucket)
+
+        async with self.session.client(
+            service_name=S3_SERVICE_NAME,
+            endpoint_url=self.endpoint_url,
+            config=self.config,
+        ) as s3_client:
+            put_params: dict[str, Any] = {
+                "Bucket": bucket_name,
+                "Key": key,
+                "Body": body,
+                "ContentType": content_type,
+            }
+            if metadata:
+                put_params["Metadata"] = metadata
+
+            await s3_client.put_object(**put_params)
+
+    async def get_object(self, key: str, bucket: str | None = None) -> bytes:
+        """Retrieve an object from S3-compatible storage.
+
+        Args:
+            key: Object key (path) in the bucket
+            bucket: Bucket name (uses default_bucket if None)
+
+        Returns:
+            Raw bytes of the object
+
+        Raises:
+            ClientError: If object doesn't exist or other S3 error
+        """
+        bucket_name = self._get_bucket(bucket)
+
+        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=bucket_name,
+                Key=key,
+            )
+            return await response["Body"].read()
+
+    async def delete_object(self, key: str, bucket: str | None = None) -> None:
+        """Delete an object from S3-compatible storage.
+
+        Args:
+            key: Object key (path) in the bucket
+            bucket: Bucket name (uses default_bucket if None)
+        """
+        bucket_name = self._get_bucket(bucket)
+
+        async with self.session.client(
+            service_name=S3_SERVICE_NAME,
+            endpoint_url=self.endpoint_url,
+            config=self.config,
+        ) as s3_client:
+            await s3_client.delete_object(
+                Bucket=bucket_name,
+                Key=key,
+            )
+
+    async def object_exists(self, key: str, bucket: str | None = None) -> bool:
+        """Check if an object exists in S3-compatible storage.
+
+        Args:
+            key: Object key (path) in the bucket
+            bucket: Bucket name (uses default_bucket if None)
+
+        Returns:
+            True if object exists, False otherwise
+        """
+        bucket_name = self._get_bucket(bucket)
+
+        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.head_object(
+                    Bucket=bucket_name,
+                    Key=key,
+                )
+                return True
+        except ClientError as e:
+            error_code = e.response.get("Error", {}).get("Code", "")
+            if error_code == "404":
+                return False
+            raise
+
+    async def list_objects(
+        self,
+        prefix: str | None = None,
+        bucket: str | None = None,
+        max_keys: int = 1000,
+    ) -> list[dict[str, Any]]:
+        """List objects in a bucket with optional prefix filter.
+
+        Args:
+            prefix: Optional prefix to filter objects
+            bucket: Bucket name (uses default_bucket if None)
+            max_keys: Maximum number of keys to return (default 1000)
+
+        Returns:
+            List of object metadata dicts with keys: key, size, last_modified, etag
+        """
+        bucket_name = self._get_bucket(bucket)
+
+        async with self.session.client(
+            service_name=S3_SERVICE_NAME,
+            endpoint_url=self.endpoint_url,
+            config=self.config,
+        ) as s3_client:
+            list_params: dict[str, Any] = {
+                "Bucket": bucket_name,
+                "MaxKeys": max_keys,
+            }
+            if prefix:
+                list_params["Prefix"] = prefix
+
+            response = await s3_client.list_objects_v2(**list_params)
+
+            if "Contents" not in response:
+                return []
+
+            return [
+                {
+                    "key": obj.get("Key", ""),
+                    "size": obj.get("Size", 0),
+                    "last_modified": obj.get("LastModified"),
+                    "etag": obj.get("ETag", "").strip('"'),
+                }
+                for obj in response["Contents"]
+            ]
+
+    async def get_object_metadata(
+        self, key: str, bucket: str | None = None
+    ) -> dict[str, Any]:
+        """Get metadata for an object without downloading it.
+
+        Args:
+            key: Object key (path) in the bucket
+            bucket: Bucket name (uses default_bucket if None)
+
+        Returns:
+            Metadata dict with keys: content_type, size, last_modified, etag, metadata
+        """
+        bucket_name = self._get_bucket(bucket)
+
+        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.head_object(
+                Bucket=bucket_name,
+                Key=key,
+            )
+
+            return {
+                "content_type": response.get("ContentType"),
+                "size": response.get("ContentLength"),
+                "last_modified": response.get("LastModified"),
+                "etag": response.get("ETag", "").strip('"'),
+                "metadata": response.get("Metadata", {}),
+            }
+
+    # =========================================================================
+    # Bucket Operations
+    # =========================================================================
+
+    async def list_buckets(self) -> list[dict[str, Any]]:
+        """List all buckets accessible with current credentials.
+
+        Returns:
+            List of bucket metadata dicts with keys: name, creation_date
+        """
+        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.list_buckets()
+
+            return [
+                {
+                    "name": bucket.get("Name", ""),
+                    "creation_date": bucket.get("CreationDate"),
+                }
+                for bucket in response.get("Buckets", [])
+            ]
+
+    async def create_bucket(self, bucket: str, region: str | None = None) -> None:
+        """Create a new bucket.
+
+        Args:
+            bucket: Name of the bucket to create
+            region: Optional region (uses session default if None)
+        """
+        async with self.session.client(
+            service_name=S3_SERVICE_NAME,
+            endpoint_url=self.endpoint_url,
+            config=self.config,
+        ) as s3_client:
+            create_params: dict[str, Any] = {"Bucket": bucket}
+
+            # Only set CreateBucketConfiguration for non-us-east-1 regions
+            if region and region not in ("us-east-1", "auto"):
+                create_params["CreateBucketConfiguration"] = {
+                    "LocationConstraint": region
+                }
+
+            await s3_client.create_bucket(**create_params)
+
+    async def delete_bucket(self, bucket: str, force: bool = False) -> None:
+        """Delete a bucket.
+
+        Args:
+            bucket: Name of the bucket to delete
+            force: If True, delete all objects in bucket first
+
+        Note:
+            S3 buckets must be empty before deletion unless force=True
+        """
+        if force:
+            # Delete all objects in the bucket first
+            objects = await self.list_objects(bucket=bucket)
+            async with self.session.client(
+                service_name=S3_SERVICE_NAME,
+                endpoint_url=self.endpoint_url,
+                config=self.config,
+            ) as s3_client:
+                for obj in objects:
+                    await s3_client.delete_object(
+                        Bucket=bucket,
+                        Key=obj["key"],
+                    )
+
+        async with self.session.client(
+            service_name=S3_SERVICE_NAME,
+            endpoint_url=self.endpoint_url,
+            config=self.config,
+        ) as s3_client:
+            await s3_client.delete_bucket(Bucket=bucket)
+
+    async def bucket_exists(self, bucket: str) -> bool:
+        """Check if a bucket exists and is accessible.
+
+        Args:
+            bucket: Name of the bucket to check
+
+        Returns:
+            True if bucket exists and is accessible, False otherwise
+        """
+        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.head_bucket(Bucket=bucket)
+                return True
+        except ClientError as e:
+            error_code = e.response.get("Error", {}).get("Code", "")
+            if error_code in ("404", "NoSuchBucket"):
+                return False
+            raise
+
+    async def get_bucket_location(self, bucket: str) -> str:
+        """Get the region/location of a bucket.
+
+        Args:
+            bucket: Name of the bucket
+
+        Returns:
+            Region string (e.g., "us-east-1", "auto")
+        """
+        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_bucket_location(Bucket=bucket)
+            location = response.get("LocationConstraint")
+            # S3 returns None for us-east-1
+            return location if location else "us-east-1"
+
+    # =========================================================================
+    # Advanced Operations
+    # =========================================================================
+
+    async def copy_object(
+        self,
+        src_key: str,
+        dest_key: str,
+        src_bucket: str | None = None,
+        dest_bucket: str | None = None,
+    ) -> None:
+        """Copy an object from one location to another.
+
+        Args:
+            src_key: Source object key
+            dest_key: Destination object key
+            src_bucket: Source bucket (uses default_bucket if None)
+            dest_bucket: Destination bucket (uses default_bucket if None)
+        """
+        src_bucket_name = self._get_bucket(src_bucket)
+        dest_bucket_name = self._get_bucket(dest_bucket)
+
+        async with self.session.client(
+            service_name=S3_SERVICE_NAME,
+            endpoint_url=self.endpoint_url,
+            config=self.config,
+        ) as s3_client:
+            copy_source = f"{src_bucket_name}/{src_key}"
+            await s3_client.copy_object(
+                CopySource=copy_source,
+                Bucket=dest_bucket_name,
+                Key=dest_key,
+            )
+
+    async def generate_presigned_url(
+        self,
+        key: str,
+        bucket: str | None = None,
+        expiration: int = 3600,
+        method: str = "get_object",
+    ) -> str:
+        """Generate a presigned URL for temporary access to an object.
+
+        Args:
+            key: Object key
+            bucket: Bucket name (uses default_bucket if None)
+            expiration: URL expiration time in seconds (default 3600 = 1 hour)
+            method: S3 method name ("get_object" or "put_object")
+
+        Returns:
+            Presigned URL string
+        """
+        bucket_name = self._get_bucket(bucket)
+
+        async with self.session.client(
+            service_name=S3_SERVICE_NAME,
+            endpoint_url=self.endpoint_url,
+            config=self.config,
+        ) as s3_client:
+            url = await s3_client.generate_presigned_url(
+                ClientMethod=method,
+                Params={
+                    "Bucket": bucket_name,
+                    "Key": key,
+                },
+                ExpiresIn=expiration,
+            )
+            return url

vibetuner/sqlmodel.py

@@ -0,0 +1,109 @@
+# ABOUTME: SQLModel/SQLAlchemy async engine setup and session management.
+# ABOUTME: Provides database initialization, teardown, and FastAPI dependency injection.
+
+from typing import AsyncGenerator, Optional
+
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlmodel import SQLModel
+
+from vibetuner.config import settings
+from vibetuner.logging import logger
+
+
+# These will be filled lazily if/when database_url is set
+engine: Optional[AsyncEngine] = None
+async_session: Optional[async_sessionmaker[AsyncSession]] = None
+
+
+def _ensure_engine() -> None:
+    """
+    Lazily configure the engine + sessionmaker if database_url is set.
+
+    Safe to call multiple times.
+    """
+    global engine, async_session
+
+    if settings.database_url is None:
+        logger.warning("database_url is not configured. SQLModel engine is disabled.")
+        return
+
+    if engine is None:
+        engine = create_async_engine(
+            str(settings.database_url),
+            echo=settings.debug,
+        )
+        async_session = async_sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+
+
+async def init_sqlmodel() -> None:
+    """
+    Called from lifespan/startup.
+    Initializes the database engine if DB is configured.
+
+    Note: This does NOT create tables. Use `vibetuner db create-schema` CLI command
+    for schema creation, or call `create_schema()` directly.
+    """
+    _ensure_engine()
+
+    if engine is None:
+        # Nothing to do, DB not configured
+        return
+
+    logger.info("SQLModel engine initialized successfully.")
+
+
+async def create_schema() -> None:
+    """
+    Create all tables defined in SQLModel metadata.
+
+    Call this from the CLI command `vibetuner db create-schema` or manually
+    during initial setup. This is idempotent - existing tables are not modified.
+    """
+    _ensure_engine()
+
+    if engine is None:
+        raise RuntimeError("database_url is not configured. Cannot create schema.")
+
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+        logger.info("SQLModel schema created successfully.")
+
+
+async def teardown_sqlmodel() -> None:
+    """
+    Called from lifespan/shutdown.
+    """
+    global engine
+
+    if engine is None:
+        return
+
+    await engine.dispose()
+    engine = None
+    logger.info("SQLModel engine disposed.")
+
+
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    """
+    FastAPI dependency.
+
+    If the DB is not configured, you can:
+    - raise a RuntimeError (fail fast), OR
+    - raise HTTPException(500), OR
+    - return a dummy object in tests.
+    """
+    if async_session is None:
+        # Fail fast – you can customize this to HTTPException if used only in web context
+        raise RuntimeError("database_url is not configured. No DB session available.")
+
+    async with async_session() as session:
+        yield session

vibetuner/tasks/lifespan.py

@@ -3,17 +3,22 @@ from typing import AsyncGenerator
 
 from vibetuner.context import Context, ctx
 from vibetuner.logging import logger
-from vibetuner.mongo import init_models
+from vibetuner.mongo import init_mongodb, teardown_mongodb
+from vibetuner.sqlmodel import init_sqlmodel, teardown_sqlmodel
 
 
 @asynccontextmanager
 async def base_lifespan() -> AsyncGenerator[Context, None]:
     logger.info("Vibetuner task worker starting")
 
-    await init_models()
+    await init_mongodb()
+    await init_sqlmodel()
 
     yield ctx
 
+    await teardown_sqlmodel()
+    await teardown_mongodb()
+
     logger.info("Vibetuner task worker stopping")
 
 

vibetuner/tasks/worker.py

@@ -4,12 +4,13 @@ from vibetuner.config import settings
 from vibetuner.tasks.lifespan import lifespan
 
 
-worker = Worker(
-    redis_url=str(settings.redis_url),
-    queue_name=(
-        settings.project.project_slug
-        if not settings.debug
-        else f"debug-{settings.project.project_slug}"
-    ),
-    lifespan=lifespan,
+worker: Worker | None = (
+    Worker(
+        redis_url=str(settings.redis_url),
+        queue_name=settings.redis_key_prefix.rstrip(":"),
+        lifespan=lifespan,
+        concurrency=settings.worker_concurrency,
+    )
+    if settings.workers_available
+    else None
 )

vibetuner/templates/frontend/email_sent.html.jinja

@@ -4,7 +4,7 @@
     {{ _("Check Your Email") }}
 {% endblock title %}
 {% block body %}
-    <div class="min-h-screen bg-gradient-to-br from-primary to-secondary flex items-center justify-center p-4">
+    <div class="min-h-screen bg-linear-to-br from-primary to-secondary flex items-center justify-center p-4">
         <div class="card w-full max-w-md bg-base-100 shadow-2xl backdrop-blur-sm bg-opacity-95">
             <div class="card-body text-center">
                 <!-- Success Icon -->

vibetuner/templates/frontend/index.html.jinja

@@ -1,4 +1,4 @@
-{% set BODY_CLASS = "min-h-screen bg-gradient-to-br from-slate-50 via-blue-50 to-indigo-100 flex flex-col justify-between" %}
+{% set BODY_CLASS = "min-h-screen bg-linear-to-br from-slate-50 via-blue-50 to-indigo-100 flex flex-col justify-between" %}
 {% extends "base/skeleton.html.jinja" %}
 
 {% block body %}
@@ -13,7 +13,7 @@
             </p>
             <!-- Decorative element -->
             <div class="mt-12 flex justify-center">
-                <div class="w-24 h-1 bg-gradient-to-r from-blue-400 to-indigo-500 rounded-full"></div>
+                <div class="w-24 h-1 bg-linear-to-r from-blue-400 to-indigo-500 rounded-full"></div>
             </div>
         </div>
     </div>

vibetuner/templates/frontend/login.html.jinja

@@ -4,7 +4,7 @@
     {{ _("Sign In") }}
 {% endblock title %}
 {% block body %}
-    <div class="min-h-screen bg-gradient-to-br from-primary to-secondary flex items-center justify-center p-4">
+    <div class="min-h-screen bg-linear-to-br from-primary to-secondary flex items-center justify-center p-4">
         <div class="card w-full max-w-md bg-base-100 shadow-2xl backdrop-blur-sm bg-opacity-95">
             <div class="card-body">
                 <!-- Header -->

vibetuner/templates/frontend/user/edit.html.jinja

@@ -64,7 +64,7 @@
                 <!-- Additional Info Card -->
                 <div class="mt-6 bg-blue-50 border border-blue-200 rounded-lg p-4">
                     <div class="flex items-start">
-                        <div class="flex-shrink-0">
+                        <div class="shrink-0">
                             <svg class="h-5 w-5 text-blue-600"
                                  xmlns="http://www.w3.org/2000/svg"
                                  viewBox="0 0 20 20"

vibetuner/templates/frontend/user/profile.html.jinja

@@ -15,7 +15,7 @@
                 <!-- Profile Card -->
                 <div class="bg-white shadow-lg rounded-lg overflow-hidden">
                     <!-- Profile Header -->
-                    <div class="bg-gradient-to-r from-blue-500 to-indigo-600 px-6 py-8">
+                    <div class="bg-linear-to-r from-blue-500 to-indigo-600 px-6 py-8">
                         <div class="flex items-center space-x-4">
                             <!-- Avatar -->
                             {% if user.picture or (user.oauth_accounts and user.oauth_accounts[0].picture) %}