Spaces:
Running
Running
| 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" # 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() |