app.py

import os
import sys
import importlib.util
from pathlib import Path
from huggingface_hub import hf_hub_download, snapshot_download, HfFileSystem
import gradio as gr

# Your private space details
PRIVATE_SPACE_REPO = "prgarg007/ai-style-transfer-dreamsofa-moodboard"  # Replace with your actual private space name
HF_TOKEN = os.getenv("HF_TOKEN")

def setup_cache_directory():
    """Setup and return cache directory for private space files"""
    cache_dir = Path("private_space_cache")
    cache_dir.mkdir(exist_ok=True)
    return cache_dir

def download_private_assets(cache_dir):
    """Download necessary files from private space"""
    try:
        print("Downloading private space assets...")
        
        # Download entire repository snapshot for directory structure
        snapshot_download(
            repo_id=PRIVATE_SPACE_REPO,
            repo_type="space",
            local_dir=cache_dir,
            token=HF_TOKEN
        )
        
        print("Successfully downloaded private space assets!")
        return True
        
    except Exception as e:
        print(f"Error downloading private assets: {str(e)}")
        return False

def load_private_app():
    """Download and import the private space app"""
    try:
        print("Setting up cache directory...")
        cache_dir = setup_cache_directory()
        
        print("Downloading private space files...")
        if not download_private_assets(cache_dir):
            return None
        
        print("Loading private app code...")
        
        # Download the main app.py file from private space
        app_path = hf_hub_download(
            repo_id=PRIVATE_SPACE_REPO,
            filename="app.py",
            repo_type="space",
            token=HF_TOKEN
        )
        
        print(f"App file downloaded to: {app_path}")
        
        # Add the cache directory to Python path so imports work
        sys.path.insert(0, str(cache_dir))
        
        # Import and execute the private app
        spec_app = importlib.util.spec_from_file_location("private_app", app_path)
        private_app_module = importlib.util.module_from_spec(spec_app)
        
        # Set environment variables that might be needed
        # Copy any environment variables from current space to the imported module
        env_vars_to_copy = ["OPENAI_API_KEY", "HF_TOKEN"]
        for var in env_vars_to_copy:
            if os.getenv(var):
                os.environ[var] = os.getenv(var)
        
        # Execute the module
        spec_app.loader.exec_module(private_app_module)
        
        print("Successfully loaded private app module!")
        return private_app_module
        
    except Exception as e:
        print(f"Error loading private app: {str(e)}")
        return None

def create_public_interface():
    """Create public interface that uses private app functionality"""
    
    # Load the private app
    private_app = load_private_app()
    
    if private_app is None:
        # Fallback interface if loading fails
        with gr.Blocks(title="AI Style Transfer - Loading Error") as error_app:
            gr.Markdown("""
            # ⚠️ Service Temporarily Unavailable
            
            We're experiencing technical difficulties loading the AI processing service.
            
            **Possible causes:**
            - Network connectivity issues  
            - Authentication problems
            - Service maintenance
            
            **Solutions:**
            1. Check that HF_TOKEN environment variable is set correctly
            2. Verify the private space name is correct  
            3. Ensure you have access to the private space
            4. Try refreshing the page in a few minutes
            
            If the problem persists, please contact support.
            """)
        return error_app
    
    # If we successfully loaded the private app, create the interface using its functions
    try:
        # The private app should have a create_interface function
        if hasattr(private_app, 'create_interface'):
            print("Using create_interface from private app...")
            return private_app.create_interface()
        
        # Alternative: if it has the main components, build interface manually
        elif hasattr(private_app, 'process_images'):
            print("Building interface using private app functions...")
            
            with gr.Blocks(title="AI Style Transfer & Room Integration", theme=gr.themes.Soft()) as app:
                gr.Markdown("""
                # 🚀 AI Powered Style Transfer & Room Integration
                ## Secure Processing Portal
                
                Transform your furniture with AI-powered style transfer and room integration!
                
                **How it works:**
                1. Upload a **swatch image** (fabric/pattern you want to apply)
                2. Upload a **product image** (furniture piece to style)  
                3. Upload a **room image** (where you want to place the furniture)
                4. Select your preferred **room style**
                5. Let AI work its magic! ✨
                
                *Your code and processing logic are securely protected*
                """)
                
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("### 📤 Upload Your Images")
                        
                        swatch_input = gr.Image(
                            label="🎨 Swatch/Pattern Image",
                            type="pil",
                            height=200
                        )
                        
                        product_input = gr.Image(
                            label="📦 Furniture/Product Image",
                            type="pil", 
                            height=200
                        )
                        
                        room_input = gr.Image(
                            label="🏠 Room/Background Image",
                            type="pil",
                            height=200
                        )
                        
                        room_style = gr.Dropdown(
                            choices=["modern", "vintage", "industrial", "scandinavian", "bohemian", "rustic"],
                            value="modern",
                            label="🎭 Room Style Theme"
                        )
                        
                        process_btn = gr.Button("🤖 Transform with AI", variant="primary", size="lg")
                    
                    with gr.Column():
                        gr.Markdown("### 🎯 AI Generated Results")
                        
                        styled_product_output = gr.Image(
                            label="🎨 Step 1: Styled Product",
                            height=300
                        )
                        
                        final_output = gr.Image(
                            label="🏆 Step 2: Room Integration",
                            height=300
                        )
                        
                        status_output = gr.Textbox(
                            label="🔄 Processing Status",
                            value="Ready to transform your furniture with AI...",
                            interactive=False
                        )
                
                # Connect to the private app's processing function
                process_btn.click(
                    fn=private_app.process_images,  # Use the function from private space
                    inputs=[swatch_input, product_input, room_input, room_style],
                    outputs=[styled_product_output, final_output, status_output],
                    show_progress=True
                )
                
                gr.Markdown("""
                ### 🎨 Example Use Cases:
                - **Interior Design**: Preview how different fabrics look on your furniture
                - **E-commerce**: Show products in various styles and room settings
                - **Home Renovation**: Experiment with different design aesthetics  
                - **Furniture Customization**: Visualize custom upholstery options
                
                ### ⚡ Powered by:
                - OpenAI DALL-E for image generation
                - Advanced AI for style analysis and transfer
                - Secure code execution from private repository
                
                ### 🔒 Privacy & Security:
                - Your processing code is kept private and secure
                - Images are processed securely without permanent storage
                - Code execution happens in isolated environment
                """)
            
            return app
        
        else:
            raise Exception("Private app doesn't have expected functions")
            
    except Exception as e:
        print(f"Error creating interface with private app: {str(e)}")
        
        # Final fallback
        with gr.Blocks(title="AI Style Transfer - Configuration Error") as fallback_app:
            gr.Markdown(f"""
            # ⚠️ Configuration Error
            
            Successfully connected to private space but encountered a configuration error:
            
            `{str(e)}`
            
            Please check:
            1. Private space code structure
            2. Required functions are properly defined
            3. Environment variables are set correctly
            
            Contact support if this issue persists.
            """)
        return fallback_app


"""Main function to create and launch the public interface"""
print("Starting public interface...")
print(f"Private space: {PRIVATE_SPACE_REPO}")
print(f"HF Token available: {'Yes' if HF_TOKEN else 'No'}")

# Create the public interface
app = create_public_interface()

# Launch the app
print("Launching public interface...")
app.launch()