fix3

app.py

@@ -1,178 +1,253 @@
 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
-from dotenv import load_dotenv
 
-load_dotenv()
+# Your private space details
+PRIVATE_SPACE_REPO = "prgarg007/ai-style-transfer-dreamsofa"  # Replace with your actual private space name
+HF_TOKEN = os.getenv("HF_TOKEN")
 
-style_transfer_function = gr.load(
-    "prgarg007/ai-style-transfer-dreamsofa",
-    src="spaces",
-    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 process_with_private_space(swatch_image, product_image, room_image, room_style):
-    """
-    Call the private space as a function and return the results
-    """
-    if style_transfer_function is None:
-        return None, None, "Error: Could not connect to the AI processing service. Please try again later."
-    
-    if not swatch_image or not product_image or not room_image:
-        return None, None, "Please upload all three images (swatch, product, and room)."
-    
+def download_private_assets(cache_dir):
+    """Download necessary files from private space"""
     try:
-        # Call the private space as a function using the API name we defined
-        styled_product, final_result, status_message = style_transfer_function(
-            swatch_image, 
-            product_image, 
-            room_image, 
-            room_style,
-            api_name="process_style_transfer"
+        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
         )
         
-        return styled_product, final_result, status_message
+        print("Successfully downloaded private space assets!")
+        return True
         
     except Exception as e:
-        return None, None, f"Error processing images: {str(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 the public interface that uses the private space as a function"""
+    """Create public interface that uses private app functionality"""
+    
+    # Load the private app
+    private_app = load_private_app()
     
-    with gr.Blocks(
-        title="AI Style Transfer & Room Integration - Public Access",
-        theme=gr.themes.Soft()
-    ) as app:
-        
-        gr.Markdown("""
-        # 🚀 AI Powered Style Transfer & Room Integration
-        ## Public Access 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! ✨
-        """)
-        
-        # Check if the private space is loaded
-        if style_transfer_function is None:
+    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 Currently Unavailable**
+            # ⚠️ Service Temporarily Unavailable
             
-            The AI processing service is currently unavailable. This might be due to:
-            - Network connectivity issues
+            We're experiencing technical difficulties loading the AI processing service.
+            
+            **Possible causes:**
+            - Network connectivity issues  
             - Authentication problems
             - Service maintenance
             
-            Please try again later or contact support.
+            **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 app
+        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()
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                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
-                )
+        # 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
                 
-                room_input = gr.Image(
-                    label="🏠 Room/Background Image",
-                    type="pil", 
-                    height=200,
-                )
+                Transform your furniture with AI-powered style transfer and room integration!
                 
-                room_style = gr.Dropdown(
-                    choices=["modern", "vintage", "industrial", "scandinavian", "bohemian", "rustic"],
-                    value="modern",
-                    label="🎭 Room Style Theme",
-                )
+                **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! ✨
                 
-                process_btn = gr.Button(
-                    "🤖 Transform with AI", 
-                    variant="primary", 
-                    size="lg",
-                    scale=1
-                )
-                
-                gr.Markdown("""
-                ### 💡 Tips for Best Results:
-                - Use high-quality, clear images
-                - Ensure good lighting in your photos
-                - Choose images with similar perspectives
-                - Swatch images work best when the pattern/texture is clearly visible
+                *Your code and processing logic are securely protected*
                 """)
-            
-            with gr.Column(scale=1):
-                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
-                )
+                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
+                        )
                 
-                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("""
-                ### 🚀 Processing Steps:
-                1. **AI Analysis**: Examines your swatch and product images
-                2. **Style Transfer**: Applies the swatch style to your furniture  
-                3. **Room Integration**: Places the styled furniture in your room
-                4. **Final Rendering**: Creates photorealistic results
+                ### 🎨 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
                 
-                *Processing typically takes 30-60 seconds*
+                ### 🔒 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
         
-        # Connect the button to our function that calls the private space
-        process_btn.click(
-            fn=process_with_private_space,
-            inputs=[swatch_input, product_input, room_input, room_style],
-            outputs=[styled_product_output, final_output, status_output],
-            show_progress=True
-        )
+        else:
+            raise Exception("Private app doesn't have expected functions")
+            
+    except Exception as e:
+        print(f"Error creating interface with private app: {str(e)}")
         
-        # Add some example information
-        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
-        - Gradio for seamless user experience
-        
-        ### 🔒 Privacy & Security:
-        - Your images are processed securely
-        - No images are permanently stored
-        - Processing happens in real-time
-        """)
-    
-    return app
+        # 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()
 
-if __name__ == "__main__":
-    demo = create_public_interface()
-    demo.launch()
+# Launch the app
+print("Launching public interface...")
+app.launch()