Deploy AI Virtual Try-On

Solved the conflict in README file

README.md

@@ -1,3 +1,39 @@
+# 🤖 AI-Powered Virtual Try-On
+
+A portfolio-ready, full-stack AI fashion assistant and virtual try-on system. Combines computer vision, conversational AI, and web automation to deliver style advice, outfit analysis, and shopping recommendations—all in one interactive web app.
+
+## 🚀 Features
+- **Virtual Try-On:** Upload clothing and avatar images to generate realistic try-on results.
+- **AI Fashion Analysis:** Get style advice and outfit analysis using BLIP and CLIP models.
+- **Conversational Assistant:** Chat with a TinyLlama-powered AI for personalized fashion tips.
+- **Automated Shopping:** Find similar items and compare prices across e-commerce sites using Playwright automation.
+- **Modern UI:** Gradio-powered web interface for easy interaction.
+
+## 🏗️ Architecture
+- **Frontend:** Gradio (for Hugging Face Spaces)
+- **Backend:** Flask API server (runs in background)
+- **AI Models:** BLIP, CLIP, TinyLlama (all open-source, loaded on demand)
+- **Automation:** Playwright for web scraping and product search
+
+## 🛠️ Setup & Deployment
+1. All dependencies are listed in `requirements.txt`.
+2. The backend Flask server is started automatically by `app.py`.
+3. The Gradio interface is the entry point for Hugging Face Spaces.
+
+## 💡 Usage
+- Upload a fashion image to get instant AI-powered analysis and advice.
+- Chat with the AI assistant for style tips and outfit suggestions.
+- Use the shopping automation to discover and compare similar products online.
+
+## 🌐 Public Demo
+Deploy this project on [Hugging Face Spaces](https://huggingface.co/spaces) for a live, shareable demo. Free CPU and GPU options available.
+
+## 📄 License
+Open-source, for educational and portfolio use. See project root for details.
+
+---
+
+**For more details, see the full documentation and quick start guides in the main project repository.**
 ---
 title: Ai Virtual Tryon
 emoji: 🌍

app.py

@@ -0,0 +1,49 @@
+import gradio as gr
+import subprocess
+import threading
+import time
+import requests
+import base64
+from PIL import Image
+import io
+
+# Start Flask backend
+def start_backend():
+    subprocess.Popen(["python", "src/main.py"])
+
+backend_thread = threading.Thread(target=start_backend)
+backend_thread.daemon = True
+backend_thread.start()
+time.sleep(15)  # Wait for models to load
+
+def analyze_fashion(image):
+    if image is None:
+        return "Please upload an image first!"
+    
+    # Convert PIL to base64
+    buffered = io.BytesIO()
+    image.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode()
+    
+    try:
+        response = requests.post(
+            "http://localhost:5000/ai_api/analyze-image",
+            json={"image": f"data:image/png;base64,{img_str}"},
+            timeout=30
+        )
+        result = response.json()
+        return result.get('advice', 'Analysis complete!')
+    except:
+        return "AI analysis service starting up... Please try again in a moment."
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=analyze_fashion,
+    inputs=gr.Image(type="pil", label="Upload Fashion Image"),
+    outputs=gr.Textbox(label="AI Fashion Analysis"),
+    title="🤖 AI-Powered Fashion Advisor",
+    description="Upload any fashion image to get AI-powered style advice and recommendations!"
+)
+
+if __name__ == "__main__":
+    iface.launch()

huggingface.yaml

@@ -0,0 +1,14 @@
+# Hugging Face Space configuration file
+# See https://huggingface.co/docs/hub/spaces-config-reference for all options
+
+title: AI-Powered Virtual Try-On
+sdk: gradio
+python_version: 3.10
+app_file: app.py
+description: |
+  A full-stack AI fashion assistant and virtual try-on system. Upload images, get style advice, chat with an AI stylist, and discover similar products—all in one interactive web app. Powered by BLIP, CLIP, TinyLlama, and Playwright automation.
+
+# Optional: hardware
+# hardware: cpu-basic
+# Uncomment for GPU support if needed:
+# hardware: gpu

requirements.txt

@@ -0,0 +1,48 @@
+annotated-types==0.7.0
+anyio==4.10.0
+blinker==1.9.0
+certifi==2025.8.3
+charset-normalizer==3.4.3
+click==8.2.1
+distro==1.9.0
+filelock==3.19.1
+Flask==3.1.1
+flask-cors==6.0.0
+Flask-SQLAlchemy==3.1.1
+fsspec==2025.7.0
+greenlet==3.2.4
+h11==0.16.0
+hf-xet==1.1.8
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.4
+idna==3.10
+itsdangerous==2.2.0
+Jinja2==3.1.6
+jiter==0.10.0
+MarkupSafe==3.0.2
+mpmath==1.3.0
+numpy==2.2.6
+openai==1.100.2
+packaging==25.0
+pillow==11.3.0
+playwright==1.54.0
+pydantic==2.11.7
+pydantic_core==2.33.2
+pyee==13.0.0
+PyYAML==6.0.2
+regex==2025.7.34
+requests==2.32.5
+safetensors==0.6.2
+sniffio==1.3.1
+SQLAlchemy==2.0.41
+sympy==1.14.0
+tokenizers==0.21.4
+torch==2.8.0
+torchvision==0.23.0
+tqdm==4.67.1
+transformers==4.55.2
+typing-inspection==0.4.1
+typing_extensions==4.14.0
+urllib3==2.5.0
+Werkzeug==3.1.3

src/main.py

@@ -0,0 +1,46 @@
+import os
+import sys
+# DON'T CHANGE THIS !!!
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from flask import Flask, send_from_directory
+from src.models.user import db
+from src.routes.user import user_bp
+from src.routes.ai_agent import ai_agent_bp # Import the new AI agent blueprint
+from src.routes.shopping_automation import shopping_bp # Import shopping automation blueprint
+
+app = Flask(__name__, static_folder=os.path.join(os.path.dirname(__file__), 'static'))
+app.config['SECRET_KEY'] = 'asdf#FGSgvasgf$5$WGT'
+
+app.register_blueprint(user_bp, url_prefix='/api')
+app.register_blueprint(ai_agent_bp, url_prefix='/ai_api') # Register the AI agent blueprint
+app.register_blueprint(shopping_bp, url_prefix='/shopping_api') # Register shopping automation blueprint
+
+# uncomment if you need to use database
+app.config['SQLALCHEMY_DATABASE_URI'] = f"sqlite:///{os.path.join(os.path.dirname(__file__), 'database', 'app.db')}"
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+db.init_app(app)
+with app.app_context():
+    db.create_all()
+
+@app.route('/', defaults={'path': ''})
+@app.route('/<path:path>')
+def serve(path):
+    static_folder_path = app.static_folder
+    if static_folder_path is None:
+            return "Static folder not configured", 404
+
+    if path != "" and os.path.exists(os.path.join(static_folder_path, path)):
+        return send_from_directory(static_folder_path, path)
+    else:
+        index_path = os.path.join(static_folder_path, 'index.html')
+        if os.path.exists(index_path):
+            return send_from_directory(static_folder_path, 'index.html')
+        else:
+            return "index.html not found", 404
+
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000, debug=True)
+
+

src/models/user.py

@@ -0,0 +1,18 @@
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+
+class User(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(80), unique=True, nullable=False)
+    email = db.Column(db.String(120), unique=True, nullable=False)
+
+    def __repr__(self):
+        return f'<User {self.username}>'
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'username': self.username,
+            'email': self.email
+        }

src/routes/ai_agent.py

@@ -0,0 +1,215 @@
+from flask import Blueprint, request, jsonify
+from flask_cors import cross_origin
+import base64
+import io
+from PIL import Image
+import torch
+from transformers import (
+    BlipProcessor,
+    BlipForConditionalGeneration,
+    CLIPProcessor,
+    CLIPModel,
+    AutoTokenizer,
+    AutoModelForCausalLM,
+)
+import os
+import json
+
+ai_agent_bp = Blueprint('ai_agent', __name__)
+
+# Global state
+blip_model = None
+blip_processor = None
+clip_model = None
+clip_processor = None
+llm_tokenizer = None
+llm_model = None
+
+def device():
+    return 'cuda' if torch.cuda.is_available() else 'cpu'
+
+def load_models():
+    global blip_model, blip_processor, clip_model, clip_processor, llm_model, llm_tokenizer
+
+    if blip_model is None:
+        print('Loading BLIP image captioning model...')
+        blip_processor = BlipProcessor.from_pretrained('Salesforce/blip-image-captioning-base')
+        blip_model = BlipForConditionalGeneration.from_pretrained('Salesforce/blip-image-captioning-base').to(device())
+        blip_model.eval()
+
+    if clip_model is None:
+        print('Loading CLIP model...')
+        clip_processor = CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32')
+        clip_model = CLIPModel.from_pretrained('openai/clip-vit-base-patch32').to(device())
+        clip_model.eval()
+
+    # Optional lightweight local LLM for chat (no paid APIs)
+    if os.environ.get('USE_TINY_LLAMA', '1') == '1' and llm_model is None:
+        try:
+            print('Loading TinyLlama chat model (CPU)...')
+            llm_tokenizer = AutoTokenizer.from_pretrained('TinyLlama/TinyLlama-1.1B-Chat-v1.0')
+            llm_model = AutoModelForCausalLM.from_pretrained('TinyLlama/TinyLlama-1.1B-Chat-v1.0').to('cpu')
+            llm_model.eval()
+        except Exception as e:
+            print(f'Failed to load TinyLlama: {e}')
+
+
+def analyze_fashion_image(pil_image: Image.Image):
+    load_models()
+
+    # BLIP caption
+    inputs = blip_processor(pil_image, return_tensors='pt').to(device())
+    with torch.no_grad():
+        out = blip_model.generate(**inputs, max_length=64)
+    caption = blip_processor.decode(out[0], skip_special_tokens=True)
+
+    # Lightweight fashion prompts via BLIP conditional generation
+    fashion_prompts = [
+        'Describe the clothing type and key attributes.',
+        'List the dominant colors.',
+        'What style or vibe does this outfit convey?',
+        'Suggest an occasion where this outfit fits well.'
+    ]
+    analysis = {}
+    for prompt in fashion_prompts:
+        try:
+            cond_inputs = blip_processor(pil_image, prompt, return_tensors='pt').to(device())
+            with torch.no_grad():
+                out2 = blip_model.generate(**cond_inputs, max_length=48)
+            resp = blip_processor.decode(out2[0], skip_special_tokens=True)
+            analysis[prompt] = resp
+        except Exception:
+            analysis[prompt] = ''
+
+    return {
+        'caption': caption,
+        'fashion_analysis': analysis,
+    }
+
+
+def simple_rule_based_advice(text: str) -> str:
+    t = (text or '').lower()
+    advice = []
+    if 'black' in t:
+        advice.append('Black is versatile; add a contrasting accessory (silver, gold, or a bold color) to elevate the look.')
+    if 'white' in t:
+        advice.append('White gives a clean aesthetic; consider layering with textured fabrics or a light jacket for depth.')
+    if 'blue' in t:
+        advice.append('Blue pairs well with neutrals (tan, white, grey). Try denim-on-denim or navy with beige for a classic combo.')
+    if 'dress' in t:
+        advice.append('Consider heel height and bag size to match the dress formality. A belt can define the silhouette if needed.')
+    if 'shirt' in t or 'top' in t:
+        advice.append('Balance the silhouette: pair fitted tops with relaxed bottoms or vice versa. Tuck/half-tuck for shape.')
+    if not advice:
+        advice.append('Consider color harmony, silhouette balance, and occasion. Add one statement accessory to complete the look.')
+    return ' '.join(advice)
+
+
+def llm_advise(system_prompt: str, user_prompt: str) -> str:
+    # Try TinyLlama, else fallback to rule-based
+    if llm_model is None or llm_tokenizer is None:
+        return simple_rule_based_advice(user_prompt)
+    prompt = (
+        f"<|system|>\n{system_prompt}\n<|user|>\n{user_prompt}\n<|assistant|>"
+    )
+    inputs = llm_tokenizer(prompt, return_tensors='pt')
+    with torch.no_grad():
+        out = llm_model.generate(
+            **inputs,
+            max_new_tokens=220,
+            do_sample=True,
+            temperature=0.7,
+            top_p=0.9,
+            eos_token_id=llm_tokenizer.eos_token_id,
+        )
+    text = llm_tokenizer.decode(out[0], skip_special_tokens=True)
+    # Extract assistant part
+    if '<|assistant|>' in text:
+        text = text.split('<|assistant|>')[-1].strip()
+    return text
+
+
+@ai_agent_bp.route('/analyze-image', methods=['POST'])
+@cross_origin()
+def analyze_image():
+    try:
+        data = request.get_json(force=True)
+        if not data or 'image' not in data:
+            return jsonify({'error': 'No image provided'}), 400
+        b64 = data['image']
+        if ',' in b64:
+            b64 = b64.split(',')[1]
+        image_bytes = base64.b64decode(b64)
+        pil = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+
+        analysis = analyze_fashion_image(pil)
+        sys_prompt = (
+            'You are a professional fashion stylist. Provide constructive, specific, and friendly advice about fit, colors, style, and accessories.'
+        )
+        user_msg = data.get('message') or f"Analyze and advise based on: {json.dumps(analysis)}"
+        advice = llm_advise(sys_prompt, user_msg)
+        return jsonify({'success': True, 'analysis': analysis, 'advice': advice})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@ai_agent_bp.route('/chat', methods=['POST'])
+@cross_origin()
+def chat():
+    try:
+        data = request.get_json(force=True)
+        message = (data or {}).get('message', '').strip()
+        if not message:
+            return jsonify({'error': 'No message provided'}), 400
+        sys_prompt = 'You are a helpful, up-to-date fashion stylist assistant.'
+        reply = llm_advise(sys_prompt, message)
+        return jsonify({'success': True, 'reply': reply})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@ai_agent_bp.route('/recommend-similar', methods=['POST'])
+@cross_origin()
+def recommend_similar():
+    try:
+        data = request.get_json(force=True)
+        if 'image' not in data:
+            return jsonify({'error': 'No image provided'}), 400
+        b64 = data['image']
+        if ',' in b64:
+            b64 = b64.split(',')[1]
+        image_bytes = base64.b64decode(b64)
+        pil = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+
+        load_models()
+        inputs = clip_processor(images=pil, return_tensors='pt').to(device())
+        with torch.no_grad():
+            _ = clip_model.get_image_features(**inputs)
+        # Placeholder recommendations (no external API)
+        recs = [
+            {
+                'title': 'Similar silhouette',
+                'description': 'Find items with a matching cut and color palette.',
+                'stores': ['Zara', 'H&M', 'ASOS']
+            },
+            {
+                'title': 'Complementary accessories',
+                'description': 'Belts, bags, and shoes that elevate this outfit.',
+                'stores': ['Uniqlo', 'Mango', 'Amazon']
+            },
+            {
+                'title': 'Alternative colors',
+                'description': 'Same style in seasonal colorways to suit your palette.',
+                'stores': ['Nordstrom', "Macy's", 'Urban Outfitters']
+            }
+        ]
+        return jsonify({'success': True, 'recommendations': recs})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@ai_agent_bp.route('/health', methods=['GET'])
+@cross_origin()
+def health():
+    return jsonify({'status': 'ok'})
+

src/routes/shopping_automation.py

@@ -0,0 +1,353 @@
+from flask import Blueprint, request, jsonify
+from flask_cors import cross_origin
+import asyncio
+from playwright.async_api import async_playwright
+import json
+import re
+from urllib.parse import quote_plus
+import time
+
+shopping_bp = Blueprint('shopping', __name__)
+
+# Popular fashion e-commerce sites for product search
+FASHION_SITES = {
+    'zara': {
+        'url': 'https://www.zara.com/us/en/search',
+        'search_param': 'searchTerm',
+        'selectors': {
+            'products': '.product-item',
+            'title': '.product-link',
+            'price': '.price',
+            'image': '.media-image img',
+            'link': '.product-link'
+        }
+    },
+    'hm': {
+        'url': 'https://www2.hm.com/en_us/search-results.html',
+        'search_param': 'q',
+        'selectors': {
+            'products': '.item-link',
+            'title': '.item-heading',
+            'price': '.item-price',
+            'image': '.item-image img',
+            'link': '.item-link'
+        }
+    },
+    'asos': {
+        'url': 'https://www.asos.com/us/search/',
+        'search_param': 'q',
+        'selectors': {
+            'products': '[data-testid="product-tile"]',
+            'title': '[data-testid="product-title"]',
+            'price': '[data-testid="current-price"]',
+            'image': 'img',
+            'link': 'a'
+        }
+    }
+}
+
+async def search_fashion_items(query, max_results=5):
+    """Search for fashion items across multiple e-commerce sites"""
+    results = []
+    
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+        context = await browser.new_context(
+            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        )
+        
+        for site_name, site_config in FASHION_SITES.items():
+            try:
+                page = await context.new_page()
+                
+                # Construct search URL
+                search_url = f"{site_config['url']}?{site_config['search_param']}={quote_plus(query)}"
+                
+                # Navigate to search page
+                await page.goto(search_url, wait_until='networkidle', timeout=10000)
+                await page.wait_for_timeout(2000)  # Wait for dynamic content
+                
+                # Extract product information
+                products = await page.query_selector_all(site_config['selectors']['products'])
+                
+                site_results = []
+                for product in products[:max_results]:
+                    try:
+                        # Extract product details
+                        title_elem = await product.query_selector(site_config['selectors']['title'])
+                        price_elem = await product.query_selector(site_config['selectors']['price'])
+                        image_elem = await product.query_selector(site_config['selectors']['image'])
+                        link_elem = await product.query_selector(site_config['selectors']['link'])
+                        
+                        title = await title_elem.inner_text() if title_elem else 'N/A'
+                        price = await price_elem.inner_text() if price_elem else 'N/A'
+                        image_src = await image_elem.get_attribute('src') if image_elem else ''
+                        link_href = await link_elem.get_attribute('href') if link_elem else ''
+                        
+                        # Clean up the data
+                        title = title.strip()[:100]  # Limit title length
+                        price = re.sub(r'[^\d.,\$€£]', '', price) if price != 'N/A' else 'N/A'
+                        
+                        # Make sure link is absolute
+                        if link_href and not link_href.startswith('http'):
+                            base_url = f"https://{site_name}.com" if site_name != 'hm' else 'https://www2.hm.com'
+                            link_href = base_url + link_href
+                        
+                        site_results.append({
+                            'title': title,
+                            'price': price,
+                            'image': image_src,
+                            'link': link_href,
+                            'store': site_name.upper(),
+                            'query': query
+                        })
+                        
+                    except Exception as e:
+                        print(f"Error extracting product from {site_name}: {e}")
+                        continue
+                
+                results.extend(site_results)
+                await page.close()
+                
+            except Exception as e:
+                print(f"Error searching {site_name}: {e}")
+                continue
+        
+        await browser.close()
+    
+    return results
+
+def generate_search_queries(description):
+    """Generate relevant search queries from fashion description"""
+    # Extract key fashion terms
+    fashion_keywords = [
+        'dress', 'shirt', 'blouse', 'top', 'pants', 'jeans', 'skirt', 
+        'jacket', 'coat', 'sweater', 'cardigan', 'blazer', 'suit',
+        'black', 'white', 'blue', 'red', 'green', 'navy', 'gray',
+        'casual', 'formal', 'business', 'party', 'summer', 'winter'
+    ]
+    
+    description_lower = description.lower()
+    found_keywords = [kw for kw in fashion_keywords if kw in description_lower]
+    
+    # Generate search queries
+    queries = []
+    if found_keywords:
+        # Primary query with main keywords
+        queries.append(' '.join(found_keywords[:3]))
+        
+        # Secondary queries with individual keywords
+        for keyword in found_keywords[:2]:
+            queries.append(keyword)
+    else:
+        # Fallback generic queries
+        queries = ['women dress', 'fashion top', 'casual wear']
+    
+    return queries[:3]  # Limit to 3 queries
+
+@shopping_bp.route('/search-products', methods=['POST'])
+@cross_origin()
+def search_products():
+    """Search for fashion products based on description"""
+    try:
+        data = request.get_json()
+        description = data.get('description', '').strip()
+        
+        if not description:
+            return jsonify({'error': 'No description provided'}), 400
+        
+        # Generate search queries from description
+        queries = generate_search_queries(description)
+        
+        # Run async search
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        all_results = []
+        for query in queries:
+            try:
+                results = loop.run_until_complete(search_fashion_items(query, max_results=3))
+                all_results.extend(results)
+            except Exception as e:
+                print(f"Error searching for '{query}': {e}")
+                continue
+        
+        loop.close()
+        
+        # Remove duplicates and limit results
+        seen_titles = set()
+        unique_results = []
+        for result in all_results:
+            if result['title'] not in seen_titles and len(unique_results) < 10:
+                seen_titles.add(result['title'])
+                unique_results.append(result)
+        
+        return jsonify({
+            'success': True,
+            'results': unique_results,
+            'queries_used': queries,
+            'total_found': len(unique_results)
+        })
+        
+    except Exception as e:
+        print(f"Error in search_products: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@shopping_bp.route('/get-product-details', methods=['POST'])
+@cross_origin()
+def get_product_details():
+    """Get detailed information about a specific product"""
+    try:
+        data = request.get_json()
+        product_url = data.get('url', '').strip()
+        
+        if not product_url:
+            return jsonify({'error': 'No product URL provided'}), 400
+        
+        # Run async product detail extraction
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        async def extract_product_details(url):
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(headless=True)
+                context = await browser.new_context()
+                page = await context.new_page()
+                
+                try:
+                    await page.goto(url, wait_until='networkidle', timeout=15000)
+                    await page.wait_for_timeout(2000)
+                    
+                    # Extract basic product information
+                    title = await page.title()
+                    
+                    # Try to find price (common selectors)
+                    price_selectors = [
+                        '.price', '.current-price', '.product-price', 
+                        '[data-testid="current-price"]', '.price-current',
+                        '.sale-price', '.regular-price'
+                    ]
+                    
+                    price = 'N/A'
+                    for selector in price_selectors:
+                        try:
+                            price_elem = await page.query_selector(selector)
+                            if price_elem:
+                                price = await price_elem.inner_text()
+                                break
+                        except:
+                            continue
+                    
+                    # Try to find description
+                    desc_selectors = [
+                        '.product-description', '.description', '.product-details',
+                        '[data-testid="product-description"]', '.product-info'
+                    ]
+                    
+                    description = 'N/A'
+                    for selector in desc_selectors:
+                        try:
+                            desc_elem = await page.query_selector(selector)
+                            if desc_elem:
+                                description = await desc_elem.inner_text()
+                                description = description[:500]  # Limit length
+                                break
+                        except:
+                            continue
+                    
+                    return {
+                        'title': title,
+                        'price': price,
+                        'description': description,
+                        'url': url,
+                        'available': True
+                    }
+                    
+                except Exception as e:
+                    print(f"Error extracting product details: {e}")
+                    return {
+                        'title': 'Product Details Unavailable',
+                        'price': 'N/A',
+                        'description': 'Could not extract product details',
+                        'url': url,
+                        'available': False
+                    }
+                finally:
+                    await browser.close()
+        
+        result = loop.run_until_complete(extract_product_details(product_url))
+        loop.close()
+        
+        return jsonify({
+            'success': True,
+            'product': result
+        })
+        
+    except Exception as e:
+        print(f"Error in get_product_details: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@shopping_bp.route('/compare-prices', methods=['POST'])
+@cross_origin()
+def compare_prices():
+    """Compare prices for similar items across different stores"""
+    try:
+        data = request.get_json()
+        item_name = data.get('item_name', '').strip()
+        
+        if not item_name:
+            return jsonify({'error': 'No item name provided'}), 400
+        
+        # Search across multiple sites for price comparison
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        results = loop.run_until_complete(search_fashion_items(item_name, max_results=3))
+        loop.close()
+        
+        # Group by store and extract price information
+        price_comparison = {}
+        for result in results:
+            store = result['store']
+            if store not in price_comparison:
+                price_comparison[store] = []
+            
+            # Extract numeric price for comparison
+            price_text = result['price']
+            price_numeric = None
+            if price_text != 'N/A':
+                price_match = re.search(r'[\d.,]+', price_text)
+                if price_match:
+                    try:
+                        price_numeric = float(price_match.group().replace(',', ''))
+                    except:
+                        pass
+            
+            price_comparison[store].append({
+                'title': result['title'],
+                'price_text': price_text,
+                'price_numeric': price_numeric,
+                'link': result['link'],
+                'image': result['image']
+            })
+        
+        return jsonify({
+            'success': True,
+            'comparison': price_comparison,
+            'item_searched': item_name
+        })
+        
+    except Exception as e:
+        print(f"Error in compare_prices: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@shopping_bp.route('/health', methods=['GET'])
+@cross_origin()
+def health_check():
+    """Health check for shopping automation service"""
+    return jsonify({
+        'status': 'ok',
+        'service': 'shopping_automation',
+        'playwright_available': True
+    })
+

src/routes/user.py

@@ -0,0 +1,39 @@
+from flask import Blueprint, jsonify, request
+from src.models.user import User, db
+
+user_bp = Blueprint('user', __name__)
+
+@user_bp.route('/users', methods=['GET'])
+def get_users():
+    users = User.query.all()
+    return jsonify([user.to_dict() for user in users])
+
+@user_bp.route('/users', methods=['POST'])
+def create_user():
+    
+    data = request.json
+    user = User(username=data['username'], email=data['email'])
+    db.session.add(user)
+    db.session.commit()
+    return jsonify(user.to_dict()), 201
+
+@user_bp.route('/users/<int:user_id>', methods=['GET'])
+def get_user(user_id):
+    user = User.query.get_or_404(user_id)
+    return jsonify(user.to_dict())
+
+@user_bp.route('/users/<int:user_id>', methods=['PUT'])
+def update_user(user_id):
+    user = User.query.get_or_404(user_id)
+    data = request.json
+    user.username = data.get('username', user.username)
+    user.email = data.get('email', user.email)
+    db.session.commit()
+    return jsonify(user.to_dict())
+
+@user_bp.route('/users/<int:user_id>', methods=['DELETE'])
+def delete_user(user_id):
+    user = User.query.get_or_404(user_id)
+    db.session.delete(user)
+    db.session.commit()
+    return '', 204

src/static/index.html

@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <link rel="icon" type="image/x-icon" href="/favicon.ico" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>virtual-tryon-ai</title>
+    <style>
+        body { font-family: sans-serif; margin: 20px; }
+        .section { margin-bottom: 20px; padding: 15px; border: 1px solid #ccc; border-radius: 5px; }
+        h2 { margin-top: 0; }
+        label { display: inline-block; width: 80px; margin-bottom: 5px; }
+        input[type="text"], input[type="email"], input[type="number"] { margin-bottom: 10px; padding: 5px; width: 200px; }
+        button { padding: 8px 15px; margin-right: 10px; cursor: pointer; }
+        pre { background-color: #f4f4f4; padding: 10px; border: 1px solid #ddd; border-radius: 4px; white-space: pre-wrap; word-wrap: break-word; }
+    </style>
+</head>
+<body>
+    <h1>User API Test</h1>
+
+    <!-- Get All Users -->
+    <div class="section">
+        <h2>Get All Users (GET /users)</h2>
+        <button onclick="getUsers()">Get Users</button>
+        <pre id="get-users-result"></pre>
+    </div>
+
+    <!-- Create User -->
+    <div class="section">
+        <h2>Create User (POST /users)</h2>
+        <label for="create-username">Username:</label>
+        <input type="text" id="create-username" name="username"><br>
+        <label for="create-email">Email:</label>
+        <input type="email" id="create-email" name="email"><br>
+        <button onclick="createUser()">Create User</button>
+        <pre id="create-user-result"></pre>
+    </div>
+
+    <!-- Get Single User -->
+    <div class="section">
+        <h2>Get Single User (GET /users/&lt;id&gt;)</h2>
+        <label for="get-user-id">User ID:</label>
+        <input type="number" id="get-user-id" name="user_id"><br>
+        <button onclick="getUser()">Get User</button>
+        <pre id="get-user-result"></pre>
+    </div>
+
+    <!-- Update User -->
+    <div class="section">
+        <h2>Update User (PUT /users/&lt;id&gt;)</h2>
+        <label for="update-user-id">User ID:</label>
+        <input type="number" id="update-user-id" name="user_id"><br>
+        <label for="update-username">New Username:</label>
+        <input type="text" id="update-username" name="username"><br>
+        <label for="update-email">New Email:</label>
+        <input type="email" id="update-email" name="email"><br>
+        <button onclick="updateUser()">Update User</button>
+        <pre id="update-user-result"></pre>
+    </div>
+
+    <!-- Delete User -->
+    <div class="section">
+        <h2>Delete User (DELETE /users/&lt;id&gt;)</h2>
+        <label for="delete-user-id">User ID:</label>
+        <input type="number" id="delete-user-id" name="user_id"><br>
+        <button onclick="deleteUser()">Delete User</button>
+        <pre id="delete-user-result"></pre>
+    </div>
+
+    <script>
+        const API_BASE_URL = '/api/users';
+
+        // Helper function to display results
+        function displayResult(elementId, data) {
+            document.getElementById(elementId).textContent = JSON.stringify(data, null, 2);
+        }
+
+        // Helper function to display errors
+        function displayError(elementId, error) {
+            document.getElementById(elementId).textContent = `Error: ${error.message || error}`;
+        }
+
+        // GET /users
+        async function getUsers() {
+            const resultElementId = 'get-users-result';
+            try {
+                const response = await fetch(API_BASE_URL);
+                if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+                const data = await response.json();
+                displayResult(resultElementId, data);
+            } catch (error) {
+                displayError(resultElementId, error);
+            }
+        }
+
+        // POST /users
+        async function createUser() {
+            const resultElementId = 'create-user-result';
+            const username = document.getElementById('create-username').value;
+            const email = document.getElementById('create-email').value;
+            if (!username || !email) {
+                displayError(resultElementId, 'Username and email cannot be empty');
+                return;
+            }
+            try {
+                const response = await fetch(API_BASE_URL, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ username, email })
+                });
+                const data = await response.json();
+                if (!response.ok) throw new Error(data.message || `HTTP error! status: ${response.status}`);
+                displayResult(resultElementId, data);
+                // 清空输入框
+                document.getElementById('create-username').value = '';
+                document.getElementById('create-email').value = '';
+            } catch (error) {
+                displayError(resultElementId, error);
+            }
+        }
+
+        // GET /users/<id>
+        async function getUser() {
+            const resultElementId = 'get-user-result';
+            const userId = document.getElementById('get-user-id').value;
+            if (!userId) {
+                displayError(resultElementId, 'User ID cannot be empty');
+                return;
+            }
+            try {
+                const response = await fetch(`${API_BASE_URL}/${userId}`);
+                 if (response.status === 404) throw new Error('User not found');
+                if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+                const data = await response.json();
+                displayResult(resultElementId, data);
+            } catch (error) {
+                displayError(resultElementId, error);
+            }
+        }
+
+        // PUT /users/<id>
+        async function updateUser() {
+            const resultElementId = 'update-user-result';
+            const userId = document.getElementById('update-user-id').value;
+            const username = document.getElementById('update-username').value;
+            const email = document.getElementById('update-email').value;
+            if (!userId) {
+                displayError(resultElementId, 'User ID cannot be empty');
+                return;
+            }
+            const updateData = {};
+            if (username) updateData.username = username;
+            if (email) updateData.email = email;
+            if (Object.keys(updateData).length === 0) {
+                 displayError(resultElementId, 'Please enter a username or email to update');
+                 return;
+            }
+
+            try {
+                const response = await fetch(`${API_BASE_URL}/${userId}`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(updateData)
+                });
+                if (response.status === 404) throw new Error('User not found');
+                const data = await response.json();
+                 if (!response.ok) throw new Error(data.message || `HTTP error! status: ${response.status}`);
+                displayResult(resultElementId, data);
+                 // Clear input fields
+                document.getElementById('update-username').value = '';
+                document.getElementById('update-email').value = '';
+            } catch (error) {
+                displayError(resultElementId, error);
+            }
+        }
+
+        // DELETE /users/<id>
+        async function deleteUser() {
+            const resultElementId = 'delete-user-result';
+            const userId = document.getElementById('delete-user-id').value;
+            if (!userId) {
+                displayError(resultElementId, 'User ID cannot be empty');
+                return;
+            }
+            try {
+                const response = await fetch(`${API_BASE_URL}/${userId}`, {
+                    method: 'DELETE'
+                });
+                if (response.status === 404) throw new Error('User not found');
+                if (!response.ok && response.status !== 204) throw new Error(`HTTP error! status: ${response.status}`); // Allow 204
+                // 204 No Content indicates success
+                if (response.status === 204) {
+                     displayResult(resultElementId, { message: `User ID ${userId} has been successfully deleted` });
+                } else {
+                     // Try to read potential error message even on success-like status if not 204
+                     const data = await response.text();
+                     displayResult(resultElementId, data || { message: `Deletion successful, status code: ${response.status}` });
+                }
+                 // Clear input field
+                document.getElementById('delete-user-id').value = '';
+            } catch (error) {
+                displayError(resultElementId, error);
+            }
+        }
+    </script>
+</body>
+</html>