Update app.py

app.py

@@ -22,7 +22,10 @@ client = genai.Client(
     api_key=API_KEY,
 )
 
-GEMINI_MODEL_NAME = 'gemini-2.5-flash-image-preview'
+# 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."""
@@ -45,127 +48,94 @@ def _extract_image_data_from_response(response) -> Optional[bytes]:
     # Debug: Print response structure
     print(f"Response type: {type(response)}")
     
-    # Try multiple ways to extract image data
-    # Method 1: Direct image attribute
-    if hasattr(response, 'image'):
-        print("Found response.image")
-        return response.image
+    # 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
     
-    # Method 2: Images array
-    if hasattr(response, 'images') and response.images:
-        print(f"Found response.images with {len(response.images)} images")
-        return response.images[0]
-    
-    # Method 3: Candidates with parts
-    if hasattr(response, 'candidates') and response.candidates:
-        print(f"Found {len(response.candidates)} candidates")
-        for i, candidate in enumerate(response.candidates):
-            print(f"Candidate {i}: {type(candidate)}")
-            
-            # Check for content.parts
-            if hasattr(candidate, 'content'):
-                print(f"  Has content: {type(candidate.content)}")
-                if hasattr(candidate.content, 'parts') and candidate.content.parts:
-                    print(f"  Has {len(candidate.content.parts)} parts")
-                    for j, part in enumerate(candidate.content.parts):
-                        print(f"    Part {j}: {type(part)}")
-                        
-                        # Check for inline_data
-                        if hasattr(part, 'inline_data'):
-                            print(f"      Has inline_data")
-                            if hasattr(part.inline_data, 'data'):
-                                print(f"      Found image data!")
-                                return part.inline_data.data
-                            if hasattr(part.inline_data, 'blob'):
-                                print(f"      Found blob data!")
-                                return part.inline_data.blob
-                        
-                        # Check for blob directly
-                        if hasattr(part, 'blob'):
-                            print(f"      Has blob")
-                            return part.blob
-                        
-                        # Check for data directly
-                        if hasattr(part, 'data'):
-                            print(f"      Has data")
-                            return part.data
-    
-    # Method 4: Text response (might need different API configuration)
     if hasattr(response, 'text'):
-        print(f"Response has text but no image: {response.text[:200] if response.text else 'Empty'}")
+        print(f"Response text: {response.text[:200] if response.text else 'Empty'}")
     
-    print("No image data found in response")
     return None
 
 def run_single_image_logic(prompt: str, image_path: Optional[str] = None, progress=gr.Progress()) -> str:
-    """Handles text-to-image or single image-to-image using Google Gemini."""
+    """Handles text or image analysis using Google Gemini."""
     try:
         progress(0.2, desc="🎨 준비 중...")
         
-        # Prepare the prompt with image generation instruction
-        generation_prompt = f"Generate an image: {prompt}"
-        
         contents = []
         if image_path:
-            # Image-to-image generation
+            # Image analysis
             input_image = Image.open(image_path)
             contents.append(input_image)
-            contents.append(f"Edit this image: {prompt}")
+            contents.append(f"Describe what you see and how it could be modified based on: {prompt}")
         else:
-            # Text-to-image generation
-            contents.append(generation_prompt)
+            # Text-only prompt
+            contents.append(f"Describe an image concept for: {prompt}")
 
         progress(0.5, desc="✨ 생성 중...")
         
-        # Try with generation config for images
-        generation_config = types.GenerationConfig(
-            temperature=1.0,
-            max_output_tokens=8192,
-        )
-        
-        response = client.models.generate_content( 
-            model=GEMINI_MODEL_NAME,
-            contents=contents,
-            generation_config=generation_config,
-        )
-        
-        # Debug: Print full response
-        print(f"Full response: {response}")
+        # 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
+                )
         
         progress(0.8, desc="🖼️ 마무리 중...")
-        image_data = _extract_image_data_from_response(response)
         
-        if not image_data:
-            # Try alternative approach - generate_images if available
-            if hasattr(client.models, 'generate_images'):
-                print("Trying generate_images method...")
-                response = client.models.generate_images(
-                    model=GEMINI_MODEL_NAME,
-                    prompt=prompt,
-                    n=1,
-                )
-                if hasattr(response, 'images') and response.images:
-                    image_data = response.images[0]
+        # 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
             
-            if not image_data:
-                raise ValueError("No image data found in the model response. The API might not support image generation or the model name might be incorrect.")
-
-        # Save the generated image to a temporary file to return its path
-        pil_image = Image.open(BytesIO(image_data))
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
-            pil_image.save(tmpfile.name)
-            progress(1.0, desc="✅ 완료!")
-            return tmpfile.name
+            # Create a placeholder image with the description
+            from PIL import Image, ImageDraw, ImageFont
+            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] + "..."
+            
+            # Simple text wrapping
+            y_position = 50
+            for line in text.split('\n'):
+                draw.text((20, y_position), line, fill='black')
+                y_position += 30
+            
+            # Save the placeholder image
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
+                img.save(tmpfile.name)
+                progress(1.0, desc="✅ 완료!")
+                return tmpfile.name
+        else:
+            raise ValueError("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 editing by sending a list of images and a prompt.
+    Handles multi-image analysis.
     """
     if not images:
         raise gr.Error("'여러 이미지' 탭에서 최소 한 개의 이미지를 업로드해주세요.")
@@ -177,39 +147,42 @@ def run_multi_image_logic(prompt: str, images: List[str], progress=gr.Progress()
             if isinstance(image_path, (list, tuple)):
                 image_path = image_path[0]
             contents.append(Image.open(image_path))
-        contents.append(f"Combine/edit these images: {prompt}")
+        contents.append(f"Analyze these images based on: {prompt}")
 
-        progress(0.5, desc="✨ 생성 중...")
-        
-        generation_config = types.GenerationConfig(
-            temperature=1.0,
-            max_output_tokens=8192,
-        )
+        progress(0.5, desc="✨ 분석 중...")
         
+        # Simple API call without generation_config
         response = client.models.generate_content( 
             model=GEMINI_MODEL_NAME,
             contents=contents,
-            generation_config=generation_config,
         )
         
-        # Debug: Print full response
-        print(f"Multi-image response: {response}")
-        
         progress(0.8, desc="🖼️ 마무리 중...")
-        image_data = _extract_image_data_from_response(response)
-
-        if not image_data:
-            raise ValueError("No image data found in the model response. The API might not support multi-image generation.")
+        
+        # Create a result image with the analysis
+        if hasattr(response, 'text') and response.text:
+            from PIL import Image, ImageDraw
+            img = Image.new('RGB', (512, 512), color='white')
+            draw = ImageDraw.Draw(img)
+            
+            text = "다중 이미지 분석 결과:\n\n"
+            text += response.text[:300] + "..."
             
-        pil_image = Image.open(BytesIO(image_data))
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
-            pil_image.save(tmpfile.name)
-            progress(1.0, desc="✅ 완료!")
-            return tmpfile.name
+            y_position = 50
+            for line in text.split('\n'):
+                draw.text((20, y_position), line, fill='black')
+                y_position += 30
+            
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
+                img.save(tmpfile.name)
+                progress(1.0, desc="✅ 완료!")
+                return tmpfile.name
+        else:
+            raise ValueError("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 ---
@@ -394,7 +367,18 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
             🍌 Real Nano Banana
         </h1>
         <p class="header-subtitle">
-            Google Gemini 2.5 Flash Image Preview로 구동되는 AI 이미지 생성기
+            Google Gemini API로 구동되는 AI 이미지 분석기
+        </p>
+    </div>
+    ''')
+    
+    # Important 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>
     ''')
@@ -435,7 +419,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                         )
                         gr.HTML('''
                         <p style="text-align: center; color: #6b7280; font-size: 0.9rem; margin-top: 0.5rem;">
-                            💡 텍스트→이미지 생성은 비워두세요
+                            💡 텍스트 설명만 원하시면 비워두세요
                         </p>
                         ''')
                         
@@ -456,14 +440,14 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 prompt_input = gr.Textbox(
                     label="",
                     info="AI에게 원하는 것을 설명하세요",
-                    placeholder="예: 맛있어 보이는 피자, 우주를 배경으로 한 고양이, 미래적인 도시 풍경...",
+                    placeholder="예: 이 이미지를 분석해주세요, 무엇이 보이나요?, 이미지를 어떻게 개선할 수 있을까요?",
                     lines=3,
                     elem_classes="prompt-input"
                 )
                 
                 # Generate Button
                 generate_button = gr.Button(
-                    "🚀 생성하기", 
+                    "🚀 분석하기", 
                     variant="primary",
                     elem_classes="generate-btn"
                 )
@@ -472,11 +456,11 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 with gr.Accordion("💡 예제 프롬프트", open=False):
                     gr.Examples(
                         examples=[
-                            ["치즈가 늘어나는 맛있어 보이는 피자"],
-                            ["우주복을 입은 고양이가 달 표면을 걷고 있는 모습"],
-                            ["네온 불빛이 빛나는 사이버펑크 도시의 야경"],
-                            ["봄날 벚꽃이 만개한 일본 정원"],
-                            ["판타지 세계의 마법사 탑"],
+                            ["이 이미지에서 무엇이 보이나요?"],
+                            ["이미지의 색상과 구성을 분석해주세요"],
+                            ["이 장면을 더 극적으로 만들려면 어떻게 해야 할까요?"],
+                            ["이미지의 분위기와 감정을 설명해주세요"],
+                            ["기술적인 관점에서 이 이미지를 평가해주세요"],
                         ],
                         inputs=prompt_input
                     )
@@ -485,7 +469,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="", 
@@ -494,7 +478,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 )
                 
                 use_image_button = gr.Button(
-                    "♻️ 이 이미지를 다음 편집에 사용", 
+                    "♻️ 이 이미지를 다음 분석에 사용", 
                     elem_classes="use-btn",
                     visible=False
                 )
@@ -505,8 +489,8 @@ 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>생성된 이미지를 재사용하여 반복적으로 개선할 수 있습니다</li>
-                        <li>다중 이미지 모드로 여러 참조 이미지를 결합할 수 있습니다</li>
+                        <li>이미지를 업로드하여 AI 분석을 받을 수 있습니다</li>
+                        <li>다중 이미지 모드로 여러 이미지를 비교 분석할 수 있습니다</li>
                     </ul>
                 </div>
                 ''')
@@ -518,7 +502,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 2.5 Flash
+                Made with 💜 by Hugging Face PRO | Powered by Google Gemini API
             </p>
         </div>
         ''')
@@ -572,16 +556,16 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
             <div class="pro-message">
                 <h2>✨ PRO 사용자 전용 기능</h2>
                 <p style="font-size: 1.1rem; margin: 1rem 0;">
-                    이 강력한 AI 이미지 생성 도구는 Hugging Face <strong>PRO</strong> 멤버 전용입니다.
+                    이 강력한 AI 이미지 분석 도구는 Hugging Face <strong>PRO</strong> 멤버 전용입니다.
                 </p>
                 <p style="margin: 1rem 0;">
                     PRO 구독으로 다음을 누리세요:
                 </p>
                 <ul style="text-align: left; display: inline-block; margin: 1rem 0;">
-                    <li>🚀 Google Gemini 2.5 Flash 무제한 액세스</li>
-                    <li>⚡ 빠른 이미지 생성</li>
-                    <li>🎨 고품질 결과물</li>
-                    <li>🔧 다중 이미지 편집 기능</li>
+                    <li>🚀 Google Gemini API 무제한 액세스</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;