Update app.py

app.py

@@ -1,187 +1,144 @@
 import gradio as gr
-from google import genai 
-from google.genai import types 
+import replicate
 import os
 from typing import Optional, List
 from huggingface_hub import whoami
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image
+import requests
 from io import BytesIO
 import tempfile
 
-# --- Google Gemini API Configuration ---
-# Use GEMINI_API_KEY if available, otherwise fall back to GOOGLE_API_KEY
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+# --- Replicate API Configuration ---
+REPLICATE_API_TOKEN = os.getenv("REPLICATE_API_TOKEN")
 
-API_KEY = GEMINI_API_KEY or GOOGLE_API_KEY
+if not REPLICATE_API_TOKEN:
+    raise ValueError("REPLICATE_API_TOKEN environment variable is not set.")
 
-if not API_KEY:
-    raise ValueError("Neither GEMINI_API_KEY nor GOOGLE_API_KEY environment variable is set.")
+# Initialize Replicate client
+os.environ["REPLICATE_API_TOKEN"] = REPLICATE_API_TOKEN
 
-client = genai.Client(
-    api_key=API_KEY,
-)
-
-# Note: Gemini models don't directly generate images - they analyze/describe them
-# For image generation, you'd need to use a different API like Imagen
-# This code is updated to work with text generation about images
-GEMINI_MODEL_NAME = 'gemini-2.0-flash-exp'  # Updated model name
-
-def verify_pro_status(token: Optional[gr.OAuthToken]) -> bool:
-    """Verifies if the user is a Hugging Face PRO user or part of an enterprise org."""
+def verify_login_status(token: Optional[gr.OAuthToken]) -> bool:
+    """Verifies if the user is logged in to Hugging Face."""
     if not token:
         return False
     try:
         user_info = whoami(token=token.token)
-        if user_info.get("isPro", False):
-            return True
-        orgs = user_info.get("orgs", [])
-        if any(org.get("isEnterprise", False) for org in orgs):
-            return True
-        return False
+        return True if user_info else False
     except Exception as e:
-        print(f"Could not verify user's PRO/Enterprise status: {e}")
+        print(f"Could not verify user's login status: {e}")
         return False
 
-def _extract_image_data_from_response(response) -> Optional[bytes]:
-    """Helper to extract image data from the model's response."""
-    # Debug: Print response structure
-    print(f"Response type: {type(response)}")
-    
-    # Note: Gemini doesn't generate images directly
-    # This would need to be replaced with actual image generation API
-    # For now, return None to indicate no image was generated
-    
-    if hasattr(response, 'text'):
-        print(f"Response text: {response.text[:200] if response.text else 'Empty'}")
-    
-    return None
-
 def run_single_image_logic(prompt: str, image_path: Optional[str] = None, progress=gr.Progress()) -> str:
-    """Handles text or image analysis using Google Gemini."""
+    """Handles text-to-image or single image-to-image using Replicate's Nano Banana."""
     try:
         progress(0.2, desc="🎨 준비 중...")
         
-        contents = []
+        # Prepare input for Replicate API
+        input_data = {
+            "prompt": prompt
+        }
+        
+        # If there's an input image, add it to the input
         if image_path:
-            # Image analysis
-            input_image = Image.open(image_path)
-            contents.append(input_image)
-            contents.append(f"Describe what you see and how it could be modified based on: {prompt}")
-        else:
-            # Text-only prompt
-            contents.append(f"Describe an image concept for: {prompt}")
-
+            # Upload the local image file and get a URL
+            # For Replicate, we need to provide URLs, not local paths
+            # We'll read the file and create a temporary URL or use file directly
+            input_data["image_input"] = [image_path]
+        
         progress(0.5, desc="✨ 생성 중...")
         
-        # Remove the generation_config parameter that's causing the error
-        # Use the simpler API call format
-        try:
-            response = client.models.generate_content( 
-                model=GEMINI_MODEL_NAME,
-                contents=contents,
-            )
-        except Exception as api_error:
-            # Fallback: try with just the contents as a simple string/list
-            print(f"First attempt failed: {api_error}")
-            if image_path:
-                # For image input, we need to handle it differently
-                # The API might expect a different format
-                raise gr.Error("이미지 입력은 현재 지원되지 않습니다. Gemini API는 이미지 생성이 아닌 분석용입니다.")
-            else:
-                # For text-only, try a simpler approach
-                response = client.models.generate_content(
-                    model=GEMINI_MODEL_NAME,
-                    contents=prompt
-                )
+        # Run the model on Replicate
+        output = replicate.run(
+            "google/nano-banana",
+            input=input_data
+        )
         
         progress(0.8, desc="🖼️ 마무리 중...")
         
-        # Since Gemini doesn't generate images, we'll need to handle this differently
-        # For demonstration, create a placeholder or use a different service
-        if hasattr(response, 'text') and response.text:
-            # Return the text response for now
-            # In production, you'd call an actual image generation API here
-            description = response.text
-            
-            # Create a placeholder image with the description
-            img = Image.new('RGB', (512, 512), color='white')
-            draw = ImageDraw.Draw(img)
-            
-            # Add text to explain the situation
-            text = "Gemini API는 이미지 생성을 지원하지 않습니다.\n\n"
-            text += "생성된 설명:\n" + description[:200] + "..."
+        # Handle the output
+        if output:
+            # If output is a FileOutput object, get the URL
+            if hasattr(output, 'url'):
+                image_url = output.url()
+            elif isinstance(output, str):
+                image_url = output
+            elif isinstance(output, list) and len(output) > 0:
+                image_url = output[0]
+            else:
+                raise ValueError("Unexpected output format from Replicate")
             
-            # Simple text wrapping
-            y_position = 50
-            for line in text.split('\n'):
-                draw.text((20, y_position), line, fill='black')
-                y_position += 30
+            # Download the image from URL
+            response = requests.get(image_url)
+            response.raise_for_status()
             
-            # Save the placeholder image
+            # Save to temporary file
+            img = Image.open(BytesIO(response.content))
             with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
                 img.save(tmpfile.name)
                 progress(1.0, desc="✅ 완료!")
                 return tmpfile.name
         else:
-            raise ValueError("API 응답을 받지 못했습니다.")
+            raise ValueError("No output received from Replicate API")
 
     except Exception as e:
         print(f"Error details: {e}")
         print(f"Error type: {type(e)}")
-        raise gr.Error(f"처리 실패: {e}")
-
+        raise gr.Error(f"이미지 생성 실패: {e}")
 
 def run_multi_image_logic(prompt: str, images: List[str], progress=gr.Progress()) -> str:
     """
-    Handles multi-image analysis.
+    Handles multi-image editing by sending a list of images and a prompt.
     """
     if not images:
         raise gr.Error("'여러 이미지' 탭에서 최소 한 개의 이미지를 업로드해주세요.")
     
     try:
         progress(0.2, desc="🎨 이미지 준비 중...")
-        contents = []
-        for image_path in images:
-            if isinstance(image_path, (list, tuple)):
-                image_path = image_path[0]
-            contents.append(Image.open(image_path))
-        contents.append(f"Analyze these images based on: {prompt}")
-
-        progress(0.5, desc="✨ 분석 중...")
         
-        # Simple API call without generation_config
-        response = client.models.generate_content( 
-            model=GEMINI_MODEL_NAME,
-            contents=contents,
+        # Prepare input for Replicate API with multiple images
+        input_data = {
+            "prompt": prompt,
+            "image_input": images  # Pass the list of image paths directly
+        }
+
+        progress(0.5, desc="✨ 생성 중...")
+        
+        # Run the model on Replicate
+        output = replicate.run(
+            "google/nano-banana",
+            input=input_data
         )
         
         progress(0.8, desc="🖼️ 마무리 중...")
         
-        # Create a result image with the analysis
-        if hasattr(response, 'text') and response.text:
-            img = Image.new('RGB', (512, 512), color='white')
-            draw = ImageDraw.Draw(img)
-            
-            text = "다중 이미지 분석 결과:\n\n"
-            text += response.text[:300] + "..."
+        # Handle the output
+        if output:
+            # If output is a FileOutput object, get the URL
+            if hasattr(output, 'url'):
+                image_url = output.url()
+            elif isinstance(output, str):
+                image_url = output
+            elif isinstance(output, list) and len(output) > 0:
+                image_url = output[0]
+            else:
+                raise ValueError("Unexpected output format from Replicate")
             
-            y_position = 50
-            for line in text.split('\n'):
-                draw.text((20, y_position), line, fill='black')
-                y_position += 30
+            # Download the image from URL
+            response = requests.get(image_url)
+            response.raise_for_status()
             
+            # Save to temporary file
+            img = Image.open(BytesIO(response.content))
             with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
                 img.save(tmpfile.name)
                 progress(1.0, desc="✅ 완료!")
                 return tmpfile.name
         else:
-            raise ValueError("API 응답을 받지 못했습니다.")
+            raise ValueError("No output received from Replicate API")
             
     except Exception as e:
         print(f"Multi-image error details: {e}")
-        raise gr.Error(f"처리 실패: {e}")
-
+        raise gr.Error(f"이미지 생성 실패: {e}")
 
 # --- Gradio App UI ---
 css = '''
@@ -320,8 +277,8 @@ button.selected {
     background: #1f2937;
 }
 
-/* Pro Message Styling */
-.pro-message {
+/* Login Message Styling */
+.login-message {
     background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
     border-radius: 1rem;
     padding: 2rem;
@@ -329,7 +286,7 @@ button.selected {
     border: 2px solid #f59e0b;
 }
 
-.dark .pro-message {
+.dark .login-message {
     background: linear-gradient(135deg, #7c2d12 0%, #92400e 100%);
     border-color: #f59e0b;
 }
@@ -365,38 +322,23 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
             🍌 Real Nano Banana
         </h1>
         <p class="header-subtitle">
-            Google Gemini API로 구동되는 AI 이미지 분석기
+            Google Nano Banana로 구동되는 AI 이미지 생성기
         </p>
     </div>
     ''')
     
-    # Important Notice
+    # Login Notice
     gr.HTML('''
-    <div style="background: #fef2f2; border-radius: 0.5rem; padding: 1rem; margin-bottom: 1.5rem; 
-                border-left: 4px solid #ef4444;">
-        <p style="margin: 0; color: #991b1b; font-weight: 600;">
-            ⚠️ 참고: Gemini API는 이미지 생성이 아닌 분석을 제공합니다. 
-            실제 이미지 생성을 원하시면 DALL-E, Midjourney, Stable Diffusion 등을 사용하세요.
-        </p>
-    </div>
-    ''')
-    
-    # Pro User Notice
-    gr.HTML('''
-    <div style="background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%); 
+    <div style="background: linear-gradient(135deg, #e0f2fe 0%, #bae6fd 100%); 
                 border-radius: 0.5rem; padding: 1rem; margin-bottom: 1.5rem; 
-                border-left: 4px solid #f59e0b;">
-        <p style="margin: 0; color: #92400e; font-weight: 600;">
-            🌟 이 스페이스는 Hugging Face PRO 사용자 전용입니다. 
-            <a href="https://huggingface.co/pro" target="_blank" 
-               style="color: #dc2626; text-decoration: underline;">
-               PRO 구독하기
-            </a>
+                border-left: 4px solid #0284c7;">
+        <p style="margin: 0; color: #075985; font-weight: 600;">
+            🔐 이 서비스를 사용하려면 Hugging Face 계정으로 로그인해주세요.
         </p>
     </div>
     ''')
 
-    pro_message = gr.Markdown(visible=False)
+    login_message = gr.Markdown(visible=False)
     main_interface = gr.Column(visible=False, elem_classes="main-container")
 
     with main_interface:
@@ -412,12 +354,12 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                     with gr.TabItem("🖼️ 단일 이미지", id="single") as single_tab:
                         image_input = gr.Image(
                             type="filepath",
-                            label="입력 이미지",
+                            label="입력 이미지 (선택사항)",
                             elem_classes="image-input"
                         )
                         gr.HTML('''
                         <p style="text-align: center; color: #6b7280; font-size: 0.9rem; margin-top: 0.5rem;">
-                            💡 텍스트 설명만 원하시면 비워두세요
+                            💡 텍스트→이미지 생성은 비워두세요
                         </p>
                         ''')
                         
@@ -437,15 +379,15 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 gr.HTML('<h3>✍️ 프롬프트</h3>')
                 prompt_input = gr.Textbox(
                     label="",
-                    info="AI에게 원하는 것을 설명하세요",
-                    placeholder="예: 이 이미지를 분석해주세요, 무엇이 보이나요?, 이미지를 어떻게 개선할 수 있을까요?",
+                    info="AI에게 원하는 이미지를 설명하세요",
+                    placeholder="예: 맛있어 보이는 피자, 우주를 배경으로 한 고양이, 미래적인 도시 풍경...",
                     lines=3,
                     elem_classes="prompt-input"
                 )
                 
                 # Generate Button
                 generate_button = gr.Button(
-                    "🚀 분석하기", 
+                    "🚀 생성하기", 
                     variant="primary",
                     elem_classes="generate-btn"
                 )
@@ -454,11 +396,13 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 with gr.Accordion("💡 예제 프롬프트", open=False):
                     gr.Examples(
                         examples=[
-                            ["이 이미지에서 무엇이 보이나요?"],
-                            ["이미지의 색상과 구성을 분석해주세요"],
-                            ["이 장면을 더 극적으로 만들려면 어떻게 해야 할까요?"],
-                            ["이미지의 분위기와 감정을 설명해주세요"],
-                            ["기술적인 관점에서 이 이미지를 평가해주세요"],
+                            ["A delicious looking pizza with melting cheese"],
+                            ["A cat in a spacesuit walking on the moon surface"],
+                            ["Cyberpunk city at night with neon lights"],
+                            ["Japanese garden with cherry blossoms in spring"],
+                            ["Fantasy wizard tower in a magical world"],
+                            ["Make the scene more dramatic and cinematic"],
+                            ["Transform this into a watercolor painting style"],
                         ],
                         inputs=prompt_input
                     )
@@ -467,7 +411,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
 
             with gr.Column(scale=1):
                 gr.HTML('<div class="card">')
-                gr.HTML('<h3 style="margin-top: 0;">🎨 분석 결과</h3>')
+                gr.HTML('<h3 style="margin-top: 0;">🎨 생성 결과</h3>')
                 
                 output_image = gr.Image(
                     label="", 
@@ -476,7 +420,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 )
                 
                 use_image_button = gr.Button(
-                    "♻️ 이 이미지를 다음 분석에 사용", 
+                    "♻️ 이 이미지를 다음 편집에 사용", 
                     elem_classes="use-btn",
                     visible=False
                 )
@@ -487,8 +431,9 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                     <h4 style="margin-top: 0; color: #0369a1;">💡 팁</h4>
                     <ul style="margin: 0; padding-left: 1.5rem; color: #0c4a6e;">
                         <li>구체적이고 상세한 프롬프트를 사용하세요</li>
-                        <li>이미지를 업로드하여 AI 분석을 받을 수 있습니다</li>
-                        <li>다중 이미지 모드로 여러 이미지를 비교 분석할 수 있습니다</li>
+                        <li>생성된 이미지를 재사용하여 반복적으로 개선할 수 있습니다</li>
+                        <li>다중 이미지 모드로 여러 참조 이미지를 결합할 수 있습니다</li>
+                        <li>영어 프롬프트가 더 좋은 결과를 생성합니다</li>
                     </ul>
                 </div>
                 ''')
@@ -500,7 +445,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
         <div style="text-align: center; margin-top: 2rem; padding: 1rem; 
                     border-top: 1px solid #e5e7eb;">
             <p style="color: #6b7280;">
-                Made with 💜 by Hugging Face PRO | Powered by Google Gemini API
+                Made with 💜 using Replicate API | Powered by Google Nano Banana
             </p>
         </div>
         ''')
@@ -515,8 +460,8 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
         active_tab: str,
         oauth_token: Optional[gr.OAuthToken] = None,
     ):
-        if not verify_pro_status(oauth_token):
-            raise gr.Error("액세스 거부: 이 서비스는 PRO 사용자 전용입니다.")
+        if not verify_login_status(oauth_token):
+            raise gr.Error("로그인이 필요합니다. 상단의 'Sign in with Hugging Face' 버튼을 클릭해주세요.")
         if not prompt:
             raise gr.Error("프롬프트를 입력해주세요.")
         if active_tab == "multiple" and multi_images:
@@ -547,36 +492,32 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
     ):
         if not profile:
             return gr.update(visible=False), gr.update(visible=False)
-        if verify_pro_status(oauth_token):
+        if verify_login_status(oauth_token):
             return gr.update(visible=True), gr.update(visible=False)
         else:
             message = '''
-            <div class="pro-message">
-                <h2>✨ PRO 사용자 전용 기능</h2>
+            <div class="login-message">
+                <h2>🔐 로그인이 필요합니다</h2>
                 <p style="font-size: 1.1rem; margin: 1rem 0;">
-                    이 강력한 AI 이미지 분석 도구는 Hugging Face <strong>PRO</strong> 멤버 전용입니다.
+                    이 AI 이미지 생성 도구를 사용하려면 Hugging Face 계정으로 로그인해주세요.
                 </p>
                 <p style="margin: 1rem 0;">
-                    PRO 구독으로 다음을 누리세요:
+                    로그인하면 다음 기능을 사용��� 수 있습니다:
                 </p>
                 <ul style="text-align: left; display: inline-block; margin: 1rem 0;">
-                    <li>🚀 Google Gemini API 무제한 액세스</li>
-                    <li>⚡ 빠른 이미지 분석</li>
-                    <li>🎨 상세한 이미지 설명</li>
-                    <li>🔧 다중 이미지 비교 분석</li>
+                    <li>🚀 Google Nano Banana를 통한 고품질 이미지 생성</li>
+                    <li>⚡ 빠른 이미지 생성 및 편집</li>
+                    <li>🎨 텍스트를 이미지로 변환</li>
+                    <li>🔧 다중 이미지 편집 및 결합</li>
                 </ul>
-                <a href="https://huggingface.co/pro" target="_blank" 
-                   style="display: inline-block; margin-top: 1rem; padding: 1rem 2rem;
-                          background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-                          color: white; text-decoration: none; border-radius: 0.5rem;
-                          font-weight: bold; font-size: 1.1rem;">
-                    🌟 지금 PRO 멤버 되기
-                </a>
+                <p style="margin-top: 1.5rem; font-weight: bold;">
+                    상단의 "Sign in with Hugging Face" 버튼을 클릭하여 시작하세요!
+                </p>
             </div>
             '''
             return gr.update(visible=False), gr.update(visible=True, value=message)
 
-    demo.load(control_access, inputs=None, outputs=[main_interface, pro_message])
+    demo.load(control_access, inputs=None, outputs=[main_interface, login_message])
 
 if __name__ == "__main__":
     demo.queue(max_size=None, default_concurrency_limit=None)