Upload 12 files

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PORT=7860
+
+WORKDIR /app
+
+# Install git first (needed for Hugging Face Spaces build process)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# System deps (optional, pillow usually fine without extra)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+COPY . .
+
+CMD ["sh", "-c", "uvicorn app:app --host 0.0.0.0 --port ${PORT:-7860} --proxy-headers --forwarded-allow-ips=*"]
+

README.md

@@ -1,10 +1,50 @@
 ---
-title: StyleExplorer
-emoji: 🏆
-colorFrom: pink
-colorTo: green
+title: Neural Style Transfer API
+emoji: 🎨
+colorFrom: purple
+colorTo: pink
 sdk: docker
+app_port: 7860
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Neural Style Transfer API
+
+FastAPI backend for neural style transfer using PyTorch and VGG19.
+
+## Features
+
+- Style transfer processing with customizable parameters
+- Gallery management for generated images
+- User authentication and permission requests
+- Image storage via Hugging Face datasets
+
+## Environment Variables
+
+Set these in the Hugging Face Space secrets:
+
+- `HF_DATASET_REPO`: Your Hugging Face dataset repository (e.g., `username/style-transfer-data`)
+- `HF_TOKEN`: Hugging Face access token with write permissions
+- `MASTER_PASSWORD`: Master password for admin access
+- `ADMIN_EMAIL`: Admin email for receiving permission request notifications
+- `ALLOWED_ORIGINS`: Comma-separated list of allowed CORS origins
+- `SMTP_HOST`: SMTP server host (optional, for email notifications)
+- `SMTP_PORT`: SMTP server port (optional)
+- `SMTP_USER`: SMTP username (optional)
+- `SMTP_PASSWORD`: SMTP password (optional)
+- `SMTP_FROM_EMAIL`: Email address to send from (optional)
+
+## API Endpoints
+
+- `GET /api/health` - Health check
+- `POST /api/transfer` - Create style transfer job (requires auth)
+- `GET /api/transfer/{job_id}` - Get job status
+- `GET /api/gallery` - List gallery items
+- `GET /api/gallery/{item_id}` - Get gallery item
+- `DELETE /api/gallery/{item_id}` - Delete gallery item (requires auth)
+- `POST /api/auth/login` - Login
+- `POST /api/auth/requests` - Submit permission request
+- `GET /api/auth/requests` - List requests (admin only)
+- `POST /api/auth/requests/{id}/approve` - Approve request (admin only)
+- `POST /api/auth/requests/{id}/reject` - Reject request (admin only)

app.py

@@ -0,0 +1,9 @@
+"""
+Entry point for Hugging Face Spaces deployment.
+This file simply imports and exposes the FastAPI app from main.py.
+"""
+from main import app
+
+# The app is already configured in main.py
+# Hugging Face Spaces will automatically detect and serve this FastAPI app
+#filler

auth.py

@@ -0,0 +1,97 @@
+import os
+from jose import jwt
+from jose.exceptions import ExpiredSignatureError, JWTError
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any
+from fastapi import HTTPException, status, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from passlib.context import CryptContext
+import logging
+
+logger = logging.getLogger(__name__)
+
+# JWT configuration
+SECRET_KEY = os.getenv("JWT_SECRET_KEY", os.getenv("MASTER_PASSWORD", "change-me-in-production"))
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_HOURS = 24 * 7  # 7 days
+
+# Password hashing
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# HTTP Bearer token scheme
+security = HTTPBearer()
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against a hash."""
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password: str) -> str:
+    """Hash a password."""
+    return pwd_context.hash(password)
+
+
+def create_access_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
+    """Create a JWT access token."""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(hours=ACCESS_TOKEN_EXPIRE_HOURS)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+
+def verify_token(token: str) -> Optional[Dict[str, Any]]:
+    """Verify and decode a JWT token."""
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        return payload
+    except ExpiredSignatureError:
+        logger.warning("Token has expired")
+        return None
+    except JWTError:
+        logger.warning("Invalid token")
+        return None
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security)
+) -> Dict[str, Any]:
+    """
+    Dependency to get the current authenticated user from JWT token.
+    """
+    token = credentials.credentials
+    payload = verify_token(token)
+    if payload is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return payload
+
+
+async def get_current_user_optional(
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(HTTPBearer(auto_error=False))
+) -> Optional[Dict[str, Any]]:
+    """
+    Dependency to get the current user if authenticated, None otherwise.
+    """
+    if credentials is None:
+        return None
+    token = credentials.credentials
+    payload = verify_token(token)
+    return payload
+
+
+def require_auth(func):
+    """
+    Decorator to require authentication for an endpoint.
+    """
+    async def wrapper(*args, **kwargs):
+        # This will be handled by the Depends(get_current_user) in the route
+        return await func(*args, **kwargs)
+    return wrapper

auth_storage.py

@@ -0,0 +1,201 @@
+import os
+import json
+import logging
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+import uuid
+
+from huggingface_hub import HfApi, CommitOperationAdd, create_commit, hf_hub_url
+
+logger = logging.getLogger(__name__)
+
+USERS_FILE_PATH = "auth/users.json"
+REQUESTS_FILE_PATH = "auth/requests.json"
+
+
+def build_dataset_resolve_url(repo_id: str, path_in_repo: str, revision: str = "main") -> str:
+    """
+    Build a CDN-resolved URL for a file stored in a Hugging Face dataset repo.
+    """
+    return hf_hub_url(repo_id=repo_id, filename=path_in_repo, repo_type="dataset", revision=revision)
+
+
+class AuthStorageClient:
+    """
+    Helper for managing user authentication data and permission requests
+    in a Hugging Face dataset repository.
+    
+    Repo format:
+      - auth/users.json
+      - auth/requests.json
+    """
+
+    def __init__(self, dataset_repo: str, hf_token: Optional[str] = None, revision: str = "main"):
+        if not dataset_repo:
+            raise ValueError("HF_DATASET_REPO is not set. Please configure the dataset repository id.")
+        self.dataset_repo = dataset_repo
+        self.revision = revision
+        self.api = HfApi(token=hf_token) if hf_token else HfApi()
+
+    def load_users(self) -> List[Dict[str, Any]]:
+        """
+        Download and parse users.json from the dataset. If missing, return [].
+        """
+        try:
+            url = build_dataset_resolve_url(self.dataset_repo, USERS_FILE_PATH, self.revision)
+            import requests
+            headers = {}
+            if self.api.token:
+                headers["Authorization"] = f"Bearer {self.api.token}"
+            resp = requests.get(url, timeout=10, headers=headers)
+            if resp.status_code == 200:
+                data = resp.json()
+                return data.get("users", [])
+            logger.info("Users file not found at %s (status %s). Initializing empty users list.", url, resp.status_code)
+            return []
+        except Exception as e:
+            logger.error("Failed to load users from HF: %s", str(e))
+            return []
+
+    def save_users(self, users: List[Dict[str, Any]]) -> None:
+        """
+        Commit a new version of users.json to the dataset repo.
+        """
+        try:
+            payload = json.dumps({"users": users}, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+            operations = [
+                CommitOperationAdd(path_in_repo=USERS_FILE_PATH, path_or_fileobj=payload)
+            ]
+            create_commit(
+                repo_id=self.dataset_repo,
+                repo_type="dataset",
+                operations=operations,
+                commit_message="Update users.json",
+                revision=self.revision,
+                token=self.api.token,
+            )
+        except Exception as e:
+            logger.error("Failed to save users to HF: %s", str(e))
+            raise
+
+    def load_requests(self) -> List[Dict[str, Any]]:
+        """
+        Download and parse requests.json from the dataset. If missing, return [].
+        """
+        try:
+            url = build_dataset_resolve_url(self.dataset_repo, REQUESTS_FILE_PATH, self.revision)
+            import requests
+            headers = {}
+            if self.api.token:
+                headers["Authorization"] = f"Bearer {self.api.token}"
+            resp = requests.get(url, timeout=10, headers=headers)
+            if resp.status_code == 200:
+                data = resp.json()
+                return data.get("requests", [])
+            logger.info("Requests file not found at %s (status %s). Initializing empty requests list.", url, resp.status_code)
+            return []
+        except Exception as e:
+            logger.error("Failed to load requests from HF: %s", str(e))
+            return []
+
+    def save_requests(self, requests: List[Dict[str, Any]]) -> None:
+        """
+        Commit a new version of requests.json to the dataset repo.
+        """
+        try:
+            payload = json.dumps({"requests": requests}, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+            operations = [
+                CommitOperationAdd(path_in_repo=REQUESTS_FILE_PATH, path_or_fileobj=payload)
+            ]
+            create_commit(
+                repo_id=self.dataset_repo,
+                repo_type="dataset",
+                operations=operations,
+                commit_message="Update requests.json",
+                revision=self.revision,
+                token=self.api.token,
+            )
+        except Exception as e:
+            logger.error("Failed to save requests to HF: %s", str(e))
+            raise
+
+    def add_user(self, email: str, password_hash: str) -> None:
+        """
+        Add a new user to the users list.
+        """
+        users = self.load_users()
+        # Check if user already exists
+        if any(user.get("email") == email for user in users):
+            raise ValueError(f"User with email {email} already exists")
+        
+        users.append({
+            "email": email,
+            "password_hash": password_hash
+        })
+        self.save_users(users)
+
+    def get_user(self, email: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a user by email.
+        """
+        users = self.load_users()
+        return next((user for user in users if user.get("email") == email), None)
+
+    def delete_user(self, email: str) -> None:
+        """
+        Delete a user by email.
+        """
+        users = self.load_users()
+        users = [user for user in users if user.get("email") != email]
+        self.save_users(users)
+
+    def add_request(self, name: str, email: str, reason: str) -> str:
+        """
+        Add a new permission request. Returns the request ID.
+        """
+        requests = self.load_requests()
+        request_id = str(uuid.uuid4())
+        
+        new_request = {
+            "id": request_id,
+            "name": name,
+            "email": email,
+            "reason": reason,
+            "timestamp": datetime.utcnow().isoformat(),
+            "status": "pending",
+            "reviewed_at": None,
+            "rejection_reason": None
+        }
+        
+        requests.append(new_request)
+        self.save_requests(requests)
+        return request_id
+
+    def get_request(self, request_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a request by ID.
+        """
+        requests = self.load_requests()
+        return next((req for req in requests if req.get("id") == request_id), None)
+
+    def update_request_status(self, request_id: str, status: str, rejection_reason: Optional[str] = None) -> None:
+        """
+        Update the status of a request.
+        """
+        requests = self.load_requests()
+        for req in requests:
+            if req.get("id") == request_id:
+                req["status"] = status
+                req["reviewed_at"] = datetime.utcnow().isoformat()
+                if rejection_reason:
+                    req["rejection_reason"] = rejection_reason
+                break
+        self.save_requests(requests)
+
+    def delete_request(self, request_id: str) -> None:
+        """
+        Delete a request by ID.
+        """
+        requests = self.load_requests()
+        requests = [req for req in requests if req.get("id") != request_id]
+        self.save_requests(requests)

email_service.py

@@ -0,0 +1,121 @@
+import os
+import smtplib
+import logging
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from typing import Optional
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class EmailService:
+    """
+    Service for sending emails via SMTP.
+    Supports Gmail and other SMTP servers.
+    """
+
+    def __init__(self):
+        self.smtp_host = os.getenv("SMTP_HOST", "smtp.gmail.com")
+        self.smtp_port = int(os.getenv("SMTP_PORT", "587"))
+        self.smtp_user = os.getenv("SMTP_USER", "")
+        self.smtp_password = os.getenv("SMTP_PASSWORD", "")
+        self.from_email = os.getenv("SMTP_FROM_EMAIL", self.smtp_user)
+        self.admin_email = os.getenv("ADMIN_EMAIL", "")
+
+    def _send_email(self, to_email: str, subject: str, body: str, is_html: bool = False) -> bool:
+        """
+        Send an email via SMTP.
+        """
+        if not self.smtp_user or not self.smtp_password:
+            logger.warning("SMTP credentials not configured. Email not sent.")
+            return False
+
+        try:
+            msg = MIMEMultipart()
+            msg['From'] = self.from_email
+            msg['To'] = to_email
+            msg['Subject'] = subject
+
+            if is_html:
+                msg.attach(MIMEText(body, 'html'))
+            else:
+                msg.attach(MIMEText(body, 'plain'))
+
+            with smtplib.SMTP(self.smtp_host, self.smtp_port) as server:
+                server.starttls()
+                server.login(self.smtp_user, self.smtp_password)
+                server.send_message(msg)
+
+            logger.info(f"Email sent successfully to {to_email}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send email to {to_email}: {str(e)}")
+            return False
+
+    def send_permission_request_notification(self, name: str, email: str, reason: str, timestamp: str) -> bool:
+        """
+        Send email notification to admin when a permission request is submitted.
+        """
+        if not self.admin_email:
+            logger.warning("ADMIN_EMAIL not configured. Notification not sent.")
+            return False
+
+        subject = f"New Permission Request: {name}"
+        body = f"""
+A new permission request has been submitted:
+
+Name: {name}
+Email: {email}
+Reason: {reason}
+Timestamp: {timestamp}
+
+Please review the request in the admin interface.
+"""
+        return self._send_email(self.admin_email, subject, body)
+
+    def send_approval_email(self, user_email: str, user_name: str, password: str) -> bool:
+        """
+        Send approval email to user with their account credentials.
+        """
+        subject = "Your Style Transfer Account Has Been Approved"
+        body = f"""
+Hello {user_name},
+
+Your permission request has been approved! Your account has been created.
+
+Login Credentials:
+Email: {user_email}
+Password: {password}
+
+You can now access the Neural Style Transfer application and create style transfers.
+
+Please keep your password secure and do not share it with anyone.
+
+Best regards,
+Style Transfer Team
+"""
+        return self._send_email(user_email, subject, body)
+
+    def send_rejection_email(self, user_email: str, user_name: str, reason: Optional[str] = None) -> bool:
+        """
+        Send rejection email to user.
+        """
+        subject = "Permission Request Status Update"
+        body = f"""
+Hello {user_name},
+
+Thank you for your interest in the Neural Style Transfer application.
+
+Unfortunately, your permission request has been declined at this time.
+"""
+        if reason:
+            body += f"\nReason: {reason}\n"
+
+        body += """
+If you have any questions, please feel free to reach out.
+
+Best regards,
+Style Transfer Team
+"""
+        return self._send_email(user_email, subject, body)

env.example

@@ -0,0 +1,30 @@
+# Copy this file to `.env` in the same directory and fill in your values.
+
+# Hugging Face Dataset repository to store uploads/results/gallery
+# Format: <username>/<dataset-name>
+HF_DATASET_REPO=your-username/style-transfer-data
+
+# Hugging Face access token with write permission to the dataset
+# Create at: https://huggingface.co/settings/tokens
+HF_TOKEN=hf_your_secret_token
+
+# Comma-separated list of allowed origins for CORS
+# Include your local dev, GitHub Pages, and deployed frontend URLs
+ALLOWED_ORIGINS=http://localhost:4200,https://your-username.github.io
+
+# Master password for admin access (required)
+MASTER_PASSWORD=your-master-password-here
+
+# Admin email for receiving permission request notifications (required)
+ADMIN_EMAIL=admin@example.com
+
+# Email service configuration (for sending notifications)
+# SMTP settings (for Gmail or other SMTP servers)
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
+SMTP_USER=your-email@gmail.com
+SMTP_PASSWORD=your-app-password
+SMTP_FROM_EMAIL=your-email@gmail.com
+
+# Optional: JWT secret key (defaults to MASTER_PASSWORD if not set)
+# JWT_SECRET_KEY=your-jwt-secret-key

main.py

@@ -0,0 +1,722 @@
+import os
+import uuid
+import json
+import secrets
+from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, Depends, HTTPException, status
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+from pydantic import BaseModel
+from typing import Dict, Optional, Any
+import asyncio
+from datetime import datetime
+import time
+import math
+import tempfile
+
+from style_transfer import transfer_style
+from storage_hf import (
+    HFStorageClient,
+    build_dataset_resolve_url
+)
+from auth import (
+    verify_password,
+    get_password_hash,
+    create_access_token,
+    verify_token,
+    get_current_user
+)
+from auth_storage import AuthStorageClient
+from email_service import EmailService
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Custom JSON encoder to handle infinity
+class CustomJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, float):
+            if math.isinf(obj):
+                return "Infinity" if obj > 0 else "-Infinity"
+            if math.isnan(obj):
+                return "NaN"
+        return super().default(obj)
+
+# Custom JSONResponse that uses our custom encoder
+class CustomJSONResponse(JSONResponse):
+    def render(self, content: Any) -> bytes:
+        return json.dumps(
+            content,
+            ensure_ascii=False,
+            allow_nan=False,
+            indent=None,
+            separators=(",", ":"),
+            cls=CustomJSONEncoder,
+        ).encode("utf-8")
+
+# Initialize FastAPI
+app = FastAPI(title="Neural Style Transfer API", default_response_class=CustomJSONResponse)
+
+# Add request logging middleware
+@app.middleware("http")
+async def log_requests(request, call_next):
+    logger.info(f"Incoming request: {request.method} {request.url.path} from {request.client.host if request.client else 'unknown'}")
+    response = await call_next(request)
+    logger.info(f"Response: {request.method} {request.url.path} -> {response.status_code}")
+    return response
+
+# HF storage configuration
+HF_DATASET_REPO = os.getenv("HF_DATASET_REPO", "")  # e.g. username/style-transfer-data
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+storage_client = HFStorageClient(dataset_repo=HF_DATASET_REPO, hf_token=HF_TOKEN)
+
+# Auth storage and email service
+auth_storage = AuthStorageClient(dataset_repo=HF_DATASET_REPO, hf_token=HF_TOKEN)
+email_service = EmailService()
+MASTER_PASSWORD = os.getenv("MASTER_PASSWORD", "")
+
+# Setup CORS
+allowed_origins = os.getenv("ALLOWED_ORIGINS", "http://localhost:4200").split(",")
+allowed_origins_clean = [origin.strip() for origin in allowed_origins if origin.strip()]
+logger.info(f"CORS allowed origins: {allowed_origins_clean}")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins_clean,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+"""
+With Hugging Face storage, images are served via absolute URLs from the
+dataset CDN, so we no longer mount local static directories.
+"""
+
+# Keep track of running jobs using asyncio.Queue for thread-safe updates
+job_queues = {}
+active_jobs = {}
+
+class StyleTransferProgress(BaseModel):
+    job_id: str
+    status: str
+    progress: Optional[int] = 0
+    style_loss: Optional[float] = None
+    content_loss: Optional[float] = None
+    result_url: Optional[str] = None
+    error: Optional[str] = None
+
+# Auth models
+class LoginRequest(BaseModel):
+    email: Optional[str] = None
+    password: Optional[str] = None
+    master_password: Optional[str] = None
+
+class PermissionRequest(BaseModel):
+    name: str
+    email: str
+    reason: str
+
+class CreateUserRequest(BaseModel):
+    email: str
+    password: str
+
+class ApproveRequestData(BaseModel):
+    password: Optional[str] = None  # Optional custom password, otherwise auto-generated
+
+class RejectRequestData(BaseModel):
+    reason: Optional[str] = None
+
+# Helper function to generate unique file paths
+def get_unique_filename(directory, extension=".jpg"):
+    return os.path.join(directory, f"{uuid.uuid4()}{extension}")
+
+def load_gallery():
+    try:
+        return storage_client.load_gallery()
+    except Exception as e:
+        logger.error(f"Error loading gallery data from HF: {str(e)}")
+        return []
+
+def save_gallery(gallery_data):
+    try:
+        storage_client.save_gallery(gallery_data)
+    except Exception as e:
+        logger.error(f"Error saving gallery data to HF: {str(e)}")
+
+# Background task for style transfer
+async def run_style_transfer_task(
+    job_id: str,
+    content_local_path: str,
+    style_local_path: str,
+    output_local_path: str,
+    style_weight: float,
+    content_weight: float,
+    num_steps: int,
+    layer_weights: Dict[str, float]
+):
+    try:
+        # Create a queue for this job if it doesn't exist
+        if job_id not in job_queues:
+            job_queues[job_id] = asyncio.Queue()
+
+        queue = job_queues[job_id]
+        start_time = time.time()
+        best_loss = float('inf')
+        style_loss = 0
+        content_loss = 0
+        
+        # Update job status
+        await queue.put({
+            "status": "processing",
+            "progress": 0,
+            "style_loss": None,
+            "content_loss": None
+        })
+        
+        # Define a callback that will update the job status
+        def on_progress(progress):
+            nonlocal style_loss, content_loss, best_loss
+            # Calculate total loss as the sum of style and content loss
+            total_loss = progress["style_loss"] + progress["content_loss"]
+            
+            # Update the best loss if this one is better
+            if total_loss < best_loss:
+                best_loss = total_loss
+                
+            progress_data = {
+                "status": "processing",
+                "progress": progress["iteration"] / num_steps * 100,
+                "style_loss": progress["style_loss"],
+                "content_loss": progress["content_loss"]
+            }
+            style_loss = progress["style_loss"]
+            content_loss = progress["content_loss"]
+            
+            # Use asyncio.run_coroutine_threadsafe to safely put data in the queue from a different thread
+            loop = asyncio.get_event_loop()
+            asyncio.run_coroutine_threadsafe(queue.put(progress_data), loop)
+        
+        # Run the style transfer
+        result_path, model_best_loss = transfer_style(
+            content_path=content_local_path,
+            style_path=style_local_path,
+            output_path=output_local_path,
+            style_weight=style_weight,
+            content_weight=content_weight,
+            num_steps=num_steps,
+            layer_weights=layer_weights,
+            progress_callback=on_progress
+        )
+        
+        processing_time = time.time() - start_time
+        
+        # If best_loss is still infinity, use the model's best loss or the sum of final losses
+        if math.isinf(best_loss):
+            best_loss = model_best_loss if not math.isinf(model_best_loss) else style_loss + content_loss
+            
+        # Upload artifacts to Hugging Face dataset and build absolute URLs
+        date_prefix = datetime.utcnow().strftime("%Y/%m/%d")
+        base_prefix = f"runs/{date_prefix}/{job_id}"
+
+        content_ds_path = storage_client.upload_file(
+            local_path=content_local_path,
+            dst_path=f"{base_prefix}/content.jpg"
+        )
+        style_ds_path = storage_client.upload_file(
+            local_path=style_local_path,
+            dst_path=f"{base_prefix}/style.jpg"
+        )
+        result_ds_path = storage_client.upload_file(
+            local_path=output_local_path,
+            dst_path=f"{base_prefix}/result.jpg"
+        )
+
+        content_url = build_dataset_resolve_url(storage_client.dataset_repo, content_ds_path)
+        style_url = build_dataset_resolve_url(storage_client.dataset_repo, style_ds_path)
+        result_url = build_dataset_resolve_url(storage_client.dataset_repo, result_ds_path)
+
+        # Save to gallery
+        gallery_item = {
+            "id": job_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "contentImageUrl": content_url,
+            "styleImageUrl": style_url,
+            "resultImageUrl": result_url,
+            "bestLoss": style_loss + content_loss,
+            "styleLoss": style_loss,
+            "contentLoss": content_loss,
+            "processingTime": processing_time,
+            "parameters": {
+                "styleWeight": style_weight,
+                "contentWeight": content_weight,
+                "numSteps": num_steps,
+                "layerWeights": layer_weights
+            }
+        }
+        
+        gallery = load_gallery()
+        gallery.append(gallery_item)
+        save_gallery(gallery)
+        
+        # Update job status with result
+        await queue.put({
+            "status": "completed",
+            "progress": 100,
+            "style_loss": style_loss,
+            "content_loss": content_loss,
+            "result_url": result_url
+        })
+        
+    except Exception as e:
+        logger.error(f"Error in style transfer: {str(e)}")
+        await queue.put({
+            "status": "failed",
+            "error": str(e)
+        })
+    finally:
+        # Keep the last status update in active_jobs
+        try:
+            last_status = queue.get_nowait()
+            active_jobs[job_id] = last_status
+        except asyncio.QueueEmpty:
+            pass
+
+@app.post("/api/transfer")
+async def create_style_transfer(
+    background_tasks: BackgroundTasks,
+    content_image: UploadFile = File(...),
+    style_image: UploadFile = File(...),
+    style_weight: float = Form(1000000.0),
+    content_weight: float = Form(1.0),
+    num_steps: int = Form(300),
+    layer_weights: str = Form("{}"),
+    current_user: Dict[str, Any] = Depends(get_current_user),
+):
+    try:
+        # Parse layer weights from JSON string
+        layer_weights_dict = json.loads(layer_weights)
+        
+        # Save uploaded files temporarily to local disk for processing
+        temp_dir = tempfile.gettempdir()
+        content_path = get_unique_filename(temp_dir)
+        style_path = get_unique_filename(temp_dir)
+        output_path = get_unique_filename(temp_dir)
+
+        with open(content_path, "wb") as content_file:
+            content_file.write(await content_image.read())
+
+        with open(style_path, "wb") as style_file:
+            style_file.write(await style_image.read())
+        
+        # Create a unique job ID
+        job_id = str(uuid.uuid4())
+        
+        # Initialize job status
+        active_jobs[job_id] = {
+            "status": "pending",
+            "progress": 0,
+            "style_loss": None,
+            "content_loss": None,
+            "result_url": None,
+            "error": None
+        }
+        
+        # Start style transfer in the background
+        background_tasks.add_task(
+            run_style_transfer_task,
+            job_id,
+            content_path,
+            style_path,
+            output_path,
+            style_weight,
+            content_weight,
+            num_steps,
+            layer_weights_dict
+        )
+        
+        return {
+            "job_id": job_id,
+            "status": "pending"
+        }
+    
+    except Exception as e:
+        logger.error(f"Error creating style transfer: {str(e)}")
+        return CustomJSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+@app.get("/api/transfer/{job_id}")
+async def get_transfer_status(job_id: str):
+    if job_id not in active_jobs and job_id not in job_queues:
+        return CustomJSONResponse(
+            status_code=404,
+            content={"error": "Job not found"}
+        )
+    
+    # Try to get the latest status from the queue
+    if job_id in job_queues:
+        try:
+            # Get the latest status without removing it from the queue
+            status = job_queues[job_id].get_nowait()
+            job_queues[job_id].put_nowait(status)  # Put it back
+            active_jobs[job_id] = status  # Update active_jobs with latest status
+        except asyncio.QueueEmpty:
+            # If queue is empty, use the last known status from active_jobs
+            pass
+    
+    job_status = active_jobs[job_id]
+    
+    # Return appropriate response based on job status
+    if job_status["status"] == "completed" and job_status.get("result_url"):
+        # Clean up the queue for completed jobs
+        if job_id in job_queues:
+            del job_queues[job_id]
+        return {
+            "job_id": job_id,
+            "status": "completed",
+            "progress": 100,
+            "style_loss": job_status.get("style_loss"),
+            "content_loss": job_status.get("content_loss"),
+            "result_url": job_status["result_url"]
+        }
+    elif job_status["status"] == "failed":
+        # Clean up the queue for failed jobs
+        if job_id in job_queues:
+            del job_queues[job_id]
+        return {
+            "job_id": job_id,
+            "status": "failed",
+            "error": job_status.get("error", "Unknown error")
+        }
+    else:
+        return {
+            "job_id": job_id,
+            "status": job_status["status"],
+            "progress": job_status.get("progress", 0),
+            "style_loss": job_status.get("style_loss"),
+            "content_loss": job_status.get("content_loss")
+        }
+
+@app.get("/api/health")
+async def health_check():
+    return {"status": "ok"}
+
+@app.get("/api/gallery")
+async def get_gallery_items():
+    try:
+        gallery = load_gallery()
+        # Replace any infinity values before sending response
+        for item in gallery:
+            if 'bestLoss' in item and isinstance(item['bestLoss'], float) and math.isinf(item['bestLoss']):
+                item['bestLoss'] = 999999999 if item['bestLoss'] > 0 else -999999999
+            if 'styleLoss' in item and isinstance(item['styleLoss'], float) and math.isinf(item['styleLoss']):
+                item['styleLoss'] = 999999999 if item['styleLoss'] > 0 else -999999999
+            if 'contentLoss' in item and isinstance(item['contentLoss'], float) and math.isinf(item['contentLoss']):
+                item['contentLoss'] = 999999999 if item['contentLoss'] > 0 else -999999999
+        return gallery
+    except Exception as e:
+        logger.error(f"Error getting gallery items: {str(e)}")
+        return CustomJSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+@app.get("/api/gallery/{item_id}")
+async def get_gallery_item(item_id: str):
+    try:
+        gallery = load_gallery()
+        item = next((item for item in gallery if item["id"] == item_id), None)
+        if item is None:
+            return CustomJSONResponse(status_code=404, content={"error": "Item not found"})
+        
+        # Replace any infinity values before sending response
+        if 'bestLoss' in item and isinstance(item['bestLoss'], float) and math.isinf(item['bestLoss']):
+            item['bestLoss'] = 999999999 if item['bestLoss'] > 0 else -999999999
+        if 'styleLoss' in item and isinstance(item['styleLoss'], float) and math.isinf(item['styleLoss']):
+            item['styleLoss'] = 999999999 if item['styleLoss'] > 0 else -999999999
+        if 'contentLoss' in item and isinstance(item['contentLoss'], float) and math.isinf(item['contentLoss']):
+            item['contentLoss'] = 999999999 if item['contentLoss'] > 0 else -999999999
+            
+        return item
+    except Exception as e:
+        logger.error(f"Error getting gallery item: {str(e)}")
+        return CustomJSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+@app.delete("/api/gallery/{item_id}")
+async def delete_gallery_item(
+    item_id: str,
+    current_user: Dict[str, Any] = Depends(get_current_user),
+):
+    try:
+        gallery = load_gallery()
+        item_to_delete = next((item for item in gallery if item["id"] == item_id), None)
+        
+        if not item_to_delete:
+            return CustomJSONResponse(
+                status_code=404, 
+                content={"error": "Item not found"}
+            )
+            
+        # Remove from gallery first
+        gallery = [item for item in gallery if item["id"] != item_id]
+        save_gallery(gallery)
+
+        # Attempt to delete artifacts from dataset
+        try:
+            storage_client.delete_run_artifacts(item_to_delete)
+        except Exception as e:
+            logger.error(f"Error deleting dataset artifacts for {item_id}: {str(e)}")
+        
+        return {"status": "success"}
+    except Exception as e:
+        logger.error(f"Error deleting gallery item: {str(e)}")
+        return CustomJSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+# Authentication endpoints
+@app.post("/api/auth/login")
+async def login(login_request: LoginRequest):
+    """
+    Login with email/password or master password.
+    """
+    logger.info(f"Login attempt - email: {login_request.email}, has_master_password: {bool(login_request.master_password)}")
+    try:
+        # Check master password first (doesn't require email or password)
+        if login_request.master_password and MASTER_PASSWORD and login_request.master_password == MASTER_PASSWORD:
+            access_token = create_access_token(data={"email": None, "is_master": True})
+            return {"access_token": access_token, "token_type": "bearer", "is_master": True}
+        
+        # Check user email/password (requires both email and password)
+        if login_request.email and login_request.password:
+            user = auth_storage.get_user(login_request.email)
+            if user and verify_password(login_request.password, user["password_hash"]):
+                access_token = create_access_token(data={"email": login_request.email, "is_master": False})
+                return {"access_token": access_token, "token_type": "bearer", "is_master": False, "email": login_request.email}
+        
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email/password or master password"
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in login: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Login failed"
+        )
+
+@app.post("/api/auth/requests")
+async def submit_permission_request(request: PermissionRequest):
+    """
+    Submit a permission request. Public endpoint.
+    """
+    try:
+        request_id = auth_storage.add_request(
+            name=request.name,
+            email=request.email,
+            reason=request.reason
+        )
+        
+        # Get the request to get timestamp
+        req = auth_storage.get_request(request_id)
+        if req:
+            # Send email notification to admin
+            email_service.send_permission_request_notification(
+                name=request.name,
+                email=request.email,
+                reason=request.reason,
+                timestamp=req.get("timestamp", "")
+            )
+        
+        return {"request_id": request_id, "status": "submitted"}
+    except Exception as e:
+        logger.error(f"Error submitting permission request: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to submit request"
+        )
+
+def verify_master_password(user: Dict[str, Any] = Depends(get_current_user)) -> Dict[str, Any]:
+    """Verify that the current user is using master password."""
+    if not user.get("is_master"):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Master password required"
+        )
+    return user
+
+@app.get("/api/auth/requests")
+async def list_permission_requests(
+    admin_user: Dict[str, Any] = Depends(verify_master_password)
+):
+    """List all permission requests. Admin only."""
+    try:
+        requests = auth_storage.load_requests()
+        return {"requests": requests}
+    except Exception as e:
+        logger.error(f"Error listing requests: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to list requests"
+        )
+
+@app.post("/api/auth/requests/{request_id}/approve")
+async def approve_request(
+    request_id: str,
+    approve_data: ApproveRequestData,
+    admin_user: Dict[str, Any] = Depends(verify_master_password)
+):
+    """Approve a permission request and create user account. Admin only."""
+    try:
+        req = auth_storage.get_request(request_id)
+        if not req:
+            raise HTTPException(status_code=404, detail="Request not found")
+        
+        if req.get("status") != "pending":
+            raise HTTPException(status_code=400, detail="Request already processed")
+        
+        # Generate password if not provided
+        password = approve_data.password or secrets.token_urlsafe(12)
+        password_hash = get_password_hash(password)
+        
+        # Create user account
+        try:
+            auth_storage.add_user(email=req["email"], password_hash=password_hash)
+        except ValueError as e:
+            # User might already exist
+            logger.warning(f"User creation warning: {str(e)}")
+        
+        # Update request status
+        auth_storage.update_request_status(request_id, "approved")
+        
+        # Send approval email
+        email_service.send_approval_email(
+            user_email=req["email"],
+            user_name=req["name"],
+            password=password
+        )
+        
+        return {"status": "approved", "email": req["email"]}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error approving request: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to approve request"
+        )
+
+@app.post("/api/auth/requests/{request_id}/reject")
+async def reject_request(
+    request_id: str,
+    reject_data: RejectRequestData,
+    admin_user: Dict[str, Any] = Depends(verify_master_password)
+):
+    """Reject a permission request. Admin only."""
+    try:
+        req = auth_storage.get_request(request_id)
+        if not req:
+            raise HTTPException(status_code=404, detail="Request not found")
+        
+        if req.get("status") != "pending":
+            raise HTTPException(status_code=400, detail="Request already processed")
+        
+        # Update request status
+        auth_storage.update_request_status(request_id, "rejected", reject_data.reason)
+        
+        # Send rejection email
+        email_service.send_rejection_email(
+            user_email=req["email"],
+            user_name=req["name"],
+            reason=reject_data.reason
+        )
+        
+        return {"status": "rejected"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error rejecting request: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to reject request"
+        )
+
+@app.delete("/api/auth/requests/{request_id}")
+async def delete_request(
+    request_id: str,
+    admin_user: Dict[str, Any] = Depends(verify_master_password)
+):
+    """Delete a permission request without sending email. Admin only."""
+    try:
+        auth_storage.delete_request(request_id)
+        return {"status": "deleted"}
+    except Exception as e:
+        logger.error(f"Error deleting request: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete request"
+        )
+
+@app.post("/api/auth/users")
+async def create_user(
+    user_request: CreateUserRequest,
+    admin_user: Dict[str, Any] = Depends(verify_master_password)
+):
+    """Create a new user. Admin only."""
+    try:
+        password_hash = get_password_hash(user_request.password)
+        auth_storage.add_user(email=user_request.email, password_hash=password_hash)
+        return {"status": "created", "email": user_request.email}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error creating user: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create user"
+        )
+
+@app.get("/api/auth/users")
+async def list_users(
+    admin_user: Dict[str, Any] = Depends(verify_master_password)
+):
+    """List all users. Admin only."""
+    try:
+        users = auth_storage.load_users()
+        # Don't return password hashes
+        user_list = [{"email": user["email"]} for user in users]
+        return {"users": user_list}
+    except Exception as e:
+        logger.error(f"Error listing users: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to list users"
+        )
+
+@app.delete("/api/auth/users/{email}")
+async def delete_user(
+    email: str,
+    admin_user: Dict[str, Any] = Depends(verify_master_password)
+):
+    """Delete a user. Admin only."""
+    try:
+        auth_storage.delete_user(email)
+        return {"status": "deleted", "email": email}
+    except Exception as e:
+        logger.error(f"Error deleting user: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete user"
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True) 

requirements.txt

@@ -0,0 +1,14 @@
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=10.0.0
+numpy>=1.25.2
+fastapi==0.103.1
+uvicorn==0.23.2
+python-multipart==0.0.6
+aiofiles==23.2.1
+matplotlib>=3.7.2
+requests==2.31.0
+python-dotenv==1.0.0 
+huggingface_hub>=0.26.0
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4

run.py

@@ -0,0 +1,10 @@
+import uvicorn
+import os
+
+# Create necessary directories
+os.makedirs("uploads", exist_ok=True)
+os.makedirs("results", exist_ok=True)
+
+if __name__ == "__main__":
+    print("Starting Neural Style Transfer API")
+    uvicorn.run("main:app", host="0.0.0.0", port=7860)

storage_hf.py

@@ -0,0 +1,146 @@
+import os
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from huggingface_hub import HfApi, CommitOperationAdd, CommitOperationDelete, create_commit, hf_hub_url
+
+logger = logging.getLogger(__name__)
+
+
+GALLERY_FILE_PATH = "gallery/gallery.json"
+
+
+def build_dataset_resolve_url(repo_id: str, path_in_repo: str, revision: str = "main") -> str:
+    """
+    Build a CDN-resolved URL for a file stored in a Hugging Face dataset repo.
+    """
+    return hf_hub_url(repo_id=repo_id, filename=path_in_repo, repo_type="dataset", revision=revision)
+
+
+class HFStorageClient:
+    """
+    Simple helper around huggingface_hub for storing run artifacts and gallery metadata
+    in a Dataset repository.
+
+    Repo format:
+      - runs/YYYY/MM/DD/<job_id>/content.jpg
+      - runs/YYYY/MM/DD/<job_id>/style.jpg
+      - runs/YYYY/MM/DD/<job_id>/result.jpg
+      - gallery/gallery.json
+    """
+
+    def __init__(self, dataset_repo: str, hf_token: Optional[str] = None, revision: str = "main"):
+        if not dataset_repo:
+            raise ValueError("HF_DATASET_REPO is not set. Please configure the dataset repository id.")
+        self.dataset_repo = dataset_repo
+        self.revision = revision
+        self.api = HfApi(token=hf_token) if hf_token else HfApi()
+
+    def load_gallery(self) -> List[Dict[str, Any]]:
+        """
+        Download and parse gallery.json from the dataset. If missing, return [].
+        """
+        try:
+            # Try to get the raw file content via the hub URL
+            url = build_dataset_resolve_url(self.dataset_repo, GALLERY_FILE_PATH, self.revision)
+            import requests  # local import to avoid hard dependency elsewhere
+            headers = {}
+            if self.api.token:
+                headers["Authorization"] = f"Bearer {self.api.token}"
+            resp = requests.get(url, timeout=10, headers=headers)
+            if resp.status_code == 200:
+                return resp.json()
+            logger.info("Gallery not found at %s (status %s). Initializing empty gallery.", url, resp.status_code)
+            return []
+        except Exception as e:
+            logger.error("Failed to load gallery from HF: %s", str(e))
+            return []
+
+    def save_gallery(self, gallery: List[Dict[str, Any]]) -> None:
+        """
+        Commit a new version of gallery.json to the dataset repo.
+        """
+        try:
+            payload = json.dumps(gallery, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+            operations = [
+                CommitOperationAdd(path_in_repo=GALLERY_FILE_PATH, path_or_fileobj=payload)
+            ]
+            create_commit(
+                repo_id=self.dataset_repo,
+                repo_type="dataset",
+                operations=operations,
+                commit_message="Update gallery.json",
+                revision=self.revision,
+                token=self.api.token,
+            )
+        except Exception as e:
+            logger.error("Failed to save gallery to HF: %s", str(e))
+            raise
+
+    def upload_file(self, local_path: str, dst_path: str) -> str:
+        """
+        Upload a local file to the dataset repo at dst_path. Returns the path_in_repo.
+        """
+        if not os.path.exists(local_path):
+            raise FileNotFoundError(local_path)
+
+        try:
+            with open(local_path, "rb") as f:
+                operations = [
+                    CommitOperationAdd(path_in_repo=dst_path, path_or_fileobj=f)
+                ]
+                create_commit(
+                    repo_id=self.dataset_repo,
+                    repo_type="dataset",
+                    operations=operations,
+                    commit_message=f"Upload {dst_path}",
+                    revision=self.revision,
+                    token=self.api.token,
+                )
+            return dst_path
+        except Exception as e:
+            logger.error("Failed to upload %s to HF at %s: %s", local_path, dst_path, str(e))
+            raise
+
+    def delete_run_artifacts(self, gallery_item: Dict[str, Any]) -> None:
+        """
+        Attempt to delete the three image artifacts associated with a run.
+        This parses resolve URLs to determine paths in repo.
+        """
+        def extract_path(url: Optional[str]) -> Optional[str]:
+            if not url:
+                return None
+            marker = "/resolve/"
+            if marker in url:
+                try:
+                    # url ends with .../resolve/<rev>/<path_in_repo>
+                    parts = url.split(marker, 1)[1].split("/", 1)
+                    if len(parts) == 2:
+                        return parts[1]
+                except Exception:
+                    return None
+            return None
+
+        paths: List[str] = []
+        for key in ("contentImageUrl", "styleImageUrl", "resultImageUrl"):
+            p = extract_path(gallery_item.get(key))
+            if p:
+                paths.append(p)
+
+        if not paths:
+            return
+
+        try:
+            operations = [CommitOperationDelete(path) for path in paths]
+            create_commit(
+                repo_id=self.dataset_repo,
+                repo_type="dataset",
+                operations=operations,
+                commit_message=f"Delete artifacts for run {gallery_item.get('id', '')}",
+                revision=self.revision,
+                token=self.api.token,
+            )
+        except Exception as e:
+            logger.error("Failed to delete artifacts %s: %s", paths, str(e))
+

style_transfer.py

@@ -0,0 +1,310 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from PIL import Image
+import torchvision.transforms as transforms
+import torchvision.models as models
+import copy
+import time
+import os
+import io
+
+# Check if GPU is available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using device: {device}")
+
+# Image loading and preprocessing
+def image_loader(image_path, imsize=512):
+    loader = transforms.Compose([
+        transforms.Resize(imsize),  # Scale imported image
+        transforms.CenterCrop(imsize),  # Ensure square size
+        transforms.ToTensor(),  # Transform into torch tensor
+        transforms.Lambda(lambda x: x.repeat(1, 1, 1) if x.size(0) == 1 else x)  # Convert grayscale to RGB if needed
+    ])
+
+    image = Image.open(image_path).convert('RGB')  # Ensure image is RGB
+    # Add batch dimension (1, 3, h, w)
+    image = loader(image).unsqueeze(0)
+    return image.to(device, torch.float)
+
+def load_image_from_bytes(image_bytes, imsize=512):
+    loader = transforms.Compose([
+        transforms.Resize(imsize),
+        transforms.CenterCrop(imsize),
+        transforms.ToTensor(),
+        transforms.Lambda(lambda x: x.repeat(1, 1, 1) if x.size(0) == 1 else x)
+    ])
+    
+    image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+    image = loader(image).unsqueeze(0)
+    return image.to(device, torch.float)
+
+# Content Loss: Measures content similarity
+class ContentLoss(nn.Module):
+    def __init__(self, target):
+        super(ContentLoss, self).__init__()
+        # Detach the target content from the tree used to dynamically compute gradients
+        self.target = target.detach()
+
+    def forward(self, input):
+        self.loss = F.mse_loss(input, self.target)
+        return input
+
+# Gram matrix calculation for style representation
+def gram_matrix(input):
+    batch_size, n_channels, height, width = input.size()
+    features = input.view(batch_size * n_channels, height * width)
+    G = torch.mm(features, features.t())
+    # Normalize by total number of elements
+    return G.div(batch_size * n_channels * height * width)
+
+# Style Loss: Measures style similarity using Gram matrices
+class StyleLoss(nn.Module):
+    def __init__(self, target_feature):
+        super(StyleLoss, self).__init__()
+        self.target = gram_matrix(target_feature).detach()
+        self.weight = 1.0  # Default weight for this layer
+
+    def forward(self, input):
+        G = gram_matrix(input)
+        self.loss = F.mse_loss(G, self.target)
+        return input
+
+# Normalization layer for VGG compatibility
+class Normalization(nn.Module):
+    def __init__(self, mean, std):
+        super(Normalization, self).__init__()
+        # View the mean and std as 1x3x1x1 tensors
+        self.mean = mean.clone().detach().view(-1, 1, 1).to(device)
+        self.std = std.clone().detach().view(-1, 1, 1).to(device)
+
+    def forward(self, img):
+        # Normalize img
+        return (img - self.mean) / self.std
+
+# Build model with content and style losses
+def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
+                               style_img, content_img,
+                               content_layers=['conv_4'],
+                               style_layers=['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5'],
+                               layer_weights=None):
+    normalization = Normalization(normalization_mean, normalization_std)
+    
+    # Set default layer weights if not provided
+    if layer_weights is None:
+        layer_weights = {layer: 1.0 for layer in style_layers}
+
+    # Lists to keep track of losses
+    content_losses = []
+    style_losses = []
+
+    # Create a "sequential" module with added content/style loss layers
+    model = nn.Sequential(normalization)
+
+    i = 0  # Increment for each conv layer
+    for layer in cnn.children():
+        if isinstance(layer, nn.Conv2d):
+            i += 1
+            name = f'conv_{i}'
+        elif isinstance(layer, nn.ReLU):
+            name = f'relu_{i}'
+            # Replace in-place version with out-of-place
+            layer = nn.ReLU(inplace=False)
+        elif isinstance(layer, nn.MaxPool2d):
+            name = f'pool_{i}'
+        elif isinstance(layer, nn.BatchNorm2d):
+            name = f'bn_{i}'
+        else:
+            raise RuntimeError(f'Unrecognized layer: {layer.__class__.__name__}')
+
+        model.add_module(name, layer)
+
+        # Add content loss
+        if name in content_layers:
+            # Add content loss:
+            target = model(content_img).detach()
+            content_loss = ContentLoss(target)
+            model.add_module(f"content_loss_{i}", content_loss)
+            content_losses.append(content_loss)
+
+        # Add style loss
+        if name in style_layers:
+            # Add style loss:
+            target_feature = model(style_img).detach()
+            style_loss = StyleLoss(target_feature)
+            
+            # Apply customized layer weight
+            style_loss.weight = layer_weights.get(name, 1.0)
+            
+            model.add_module(f"style_loss_{i}", style_loss)
+            style_losses.append(style_loss)
+
+    # Trim off the layers after the last content and style losses
+    for i in range(len(model) - 1, -1, -1):
+        if isinstance(model[i], ContentLoss) or isinstance(model[i], StyleLoss):
+            break
+
+    model = model[:(i + 1)]
+
+    return model, style_losses, content_losses
+
+# Optimization loop for style transfer
+def run_style_transfer(cnn, normalization_mean, normalization_std,
+                       content_img, style_img, input_img, num_steps=300,
+                       style_weight=1000000, content_weight=1,
+                       layer_weights=None, progress_callback=None):
+    """Run the style transfer."""
+    num_steps = min(num_steps, 400)
+    
+    print('Building the style transfer model...')
+    model, style_losses, content_losses = get_style_model_and_losses(
+        cnn, normalization_mean, normalization_std, 
+        style_img, content_img, 
+        layer_weights=layer_weights
+    )
+
+    # We want to optimize the input image only
+    input_img.requires_grad_(True)
+    model.eval()  # We don't need gradients for the model parameters
+    model.requires_grad_(False)
+
+    optimizer = optim.LBFGS([input_img])
+    best_img = None
+    best_loss = float('inf')
+    prev_loss = float('inf')
+    current_step = 0
+
+    start_time = time.time()
+
+    # Function to be used with optimizer
+    def closure():
+        nonlocal current_step
+        # Correct the values of updated input image
+        with torch.no_grad():
+            input_img.clamp_(0, 1)
+
+        optimizer.zero_grad()
+        model(input_img)
+        style_score = 0
+        content_score = 0
+
+        for sl in style_losses:
+            # Apply per-layer weight
+            style_score += sl.loss * sl.weight
+            
+        for cl in content_losses:
+            content_score += cl.loss
+
+        style_score *= style_weight
+        content_score *= content_weight
+
+        loss = style_score + content_score
+        loss.backward()
+
+        current_step += 1
+        if current_step % 50 == 0:
+            elapsed = time.time() - start_time
+            print(f"Iteration: {current_step}, Style Loss: {style_score.item():.2f}, Content Loss: {content_score.item():.2f}, Total Loss: {loss.item():.2f}, Time: {elapsed:.1f}s")
+            
+            if progress_callback:
+                progress = {
+                    'iteration': current_step,
+                    'style_loss': style_score.item(),
+                    'content_loss': content_score.item(),
+                    'elapsed_time': elapsed
+                }
+                progress_callback(progress)
+
+        # Save best result so far
+        nonlocal best_loss, best_img, prev_loss
+        current_loss = loss.item()
+        
+        if current_loss < best_loss:
+            best_loss = current_loss
+            best_img = input_img.clone()
+        
+        # Update previous loss for next iteration
+        prev_loss = current_loss
+        return loss
+
+    # Run optimization with early stopping
+    while current_step < num_steps:
+        optimizer.step(closure)
+        
+        # Check stopping conditions after minimum iterations
+        if current_step >= 50 and prev_loss > 1000:
+            print(f"Stopping early at iteration {current_step} due to high loss: {prev_loss:.2f}")
+            break
+
+    # A final correction
+    with torch.no_grad():
+        input_img.clamp_(0, 1)
+
+    print(f"Total time: {time.time() - start_time:.1f}s")
+    print(f"Best loss achieved: {best_loss:.2f}")
+
+    # Return both the final and best image (often the same)
+    return input_img, best_img, best_loss
+
+# Save tensor as image
+def save_image(tensor, path):
+    image = tensor.cpu().clone()
+    image = image.squeeze(0)  # Remove batch dimension
+    image = transforms.ToPILImage()(image)
+    image.save(path)
+    return image
+
+# Main style transfer function
+def transfer_style(content_path, style_path, output_path, style_weight=1000000, 
+                  content_weight=1, num_steps=300, layer_weights=None,
+                  progress_callback=None):
+    """
+    Perform style transfer and save the result
+    
+    Args:
+        content_path: Path to content image
+        style_path: Path to style image
+        output_path: Where to save the output image
+        style_weight: Weight for style loss
+        content_weight: Weight for content loss
+        num_steps: Number of optimization steps
+        layer_weights: Dictionary of weights for each style layer
+        progress_callback: Function to call for progress updates
+    
+    Returns:
+        Tuple of (output_path, best_loss)
+    """
+    # Load images
+    content_img = image_loader(content_path)
+    style_img = image_loader(style_path)
+    
+    # Start with content image for faster convergence
+    input_img = content_img.clone()
+
+    # Load VGG19 for feature extraction
+    cnn = models.vgg19(weights=models.VGG19_Weights.IMAGENET1K_V1).features.to(device).eval()
+    
+    # Mean and std for normalization (from ImageNet)
+    cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(device)
+    cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225]).to(device)
+    
+    # Run style transfer
+    output, best_output, best_loss = run_style_transfer(
+        cnn, 
+        cnn_normalization_mean, 
+        cnn_normalization_std,
+        content_img, 
+        style_img, 
+        input_img,
+        num_steps=num_steps,
+        style_weight=style_weight,
+        content_weight=content_weight,
+        layer_weights=layer_weights,
+        progress_callback=progress_callback
+    )
+    
+    # Save result and return path
+    save_image(best_output, output_path)
+    
+    return output_path, best_loss