Update app-backup3.py

app-backup3.py

@@ -1,4 +1,3 @@
-# ──────────────────────────────── Imports ────────────────────────────────
 import os, json, re, logging, requests, markdown, time, io
 from datetime import datetime
 import random
@@ -19,25 +18,11 @@ BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")  # Keep this name
 BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
 BRAVE_IMAGE_ENDPOINT = "https://api.search.brave.com/res/v1/images/search"
 BRAVE_VIDEO_ENDPOINT = "https://api.search.brave.com/res/v1/videos/search"
-BRAVE_NEWS_ENDPOINT = "https://api.search.brave.com/res/v1/news/search"
+BRAVE_NEWS_ENDPOINT  = "https://api.search.brave.com/res/v1/news/search"
 IMAGE_API_URL  = "http://211.233.58.201:7896"
 MAX_TOKENS     = 7999
 
-# 안정적인 대체 이미지 URL 목록
-FALLBACK_IMAGES = [
-    "https://images.pexels.com/photos/2559941/pexels-photo-2559941.jpeg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/417074/pexels-photo-417074.jpeg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/312839/pexels-photo-312839.jpeg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/3844788/pexels-photo-3844788.jpeg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/33041/antelope-canyon-lower-canyon-arizona.jpg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/572897/pexels-photo-572897.jpeg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/773471/pexels-photo-773471.jpeg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/1366630/pexels-photo-1366630.jpeg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/1237119/pexels-photo-1237119.jpeg?auto=compress&cs=tinysrgb&w=600",
-    "https://images.pexels.com/photos/1429567/pexels-photo-1429567.jpeg?auto=compress&cs=tinysrgb&w=600",
-]
-
-# Search modes and style definitions (in English)
+# Brave Search modes and style definitions (in English)
 SEARCH_MODES = {
     "comprehensive": "Comprehensive answer with multiple sources",
     "academic": "Academic and research-focused results",
@@ -156,8 +141,8 @@ Guidelines for Using Search Results:
 - Include source links directly in your response using markdown: [Source Name](URL)
 - For each major claim or piece of information, indicate its source
 - If sources conflict, explain the different perspectives and their reliability
-- Include 3-5 relevant images by writing: ![Image description](image_url)
-- Include 1-2 relevant video links when appropriate by writing: [Video: Title](video_url)
+- Include relevant images by writing: ![Image description](image_url)
+- Include relevant video links when appropriate by writing: [Video: Title](video_url)
 - Format search information into a cohesive, well-structured response
 - Include a "References" section at the end listing all major sources with links
 """
@@ -397,11 +382,12 @@ def brave_news_search(query: str, count: int = 5):
     return []
 
 def mock_results(query: str) -> str:
-    """Fallback search results if API fails"""
+    """Fallback search results if API fails or returns empty."""
     ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     return (f"# Fallback Search Content (Generated: {ts})\n\n"
-            f"The search API request failed. Please generate a response based on any pre-existing knowledge about '{query}'.\n\n"
-            f"You may consider the following points:\n\n"
+            f"The search API request failed or returned no results for '{query}'. "
+            f"Please generate a response based on any pre-existing knowledge.\n\n"
+            f"Consider these points:\n\n"
             f"- Basic concepts and importance of {query}\n"
             f"- Commonly known related statistics or trends\n"
             f"- Typical expert opinions on this subject\n"
@@ -608,112 +594,8 @@ def process_uploaded_files(files):
     return result
 
 # ──────────────────────────────── Image & Utility ─────────────────────────
-def create_placeholder_image(text, width=600, height=400):
-    """Create a placeholder image with text."""
-    try:
-        # 이미지 생성
-        from PIL import Image, ImageDraw, ImageFont
-        import numpy as np
-        
-        # 랜덤 컬러 생성
-        r = random.randint(100, 240)
-        g = random.randint(100, 240)
-        b = random.randint(100, 240)
-        
-        # 이미지 생성 및 배경색 설정
-        img = Image.new('RGB', (width, height), color=(r, g, b))
-        draw = ImageDraw.Draw(img)
-        
-        # 텍스트 추가 (폰트가 없으면 기본 폰트 사용)
-        try:
-            font = ImageFont.truetype("arial.ttf", 20)
-        except:
-            font = ImageFont.load_default()
-        
-        # 텍스트가 너무 길면 줄바꿈
-        words = text.split()
-        lines = []
-        current_line = []
-        
-        for word in words:
-            current_line.append(word)
-            if len(' '.join(current_line)) > 30:  # 적당한 길이에서 줄바꿈
-                lines.append(' '.join(current_line[:-1]))
-                current_line = [word]
-        
-        if current_line:
-            lines.append(' '.join(current_line))
-        
-        text_to_draw = '\n'.join(lines)
-        
-        # 텍스트 위치 계산 (중앙)
-        textsize = draw.textsize(text_to_draw, font=font)
-        text_x = (width - textsize[0]) / 2
-        text_y = (height - textsize[1]) / 2
-        
-        # 텍스트 그리기
-        draw.text((text_x, text_y), text_to_draw, fill=(255, 255, 255), font=font)
-        
-        # 이미지를 base64로 인코딩
-        buffered = BytesIO()
-        img.save(buffered, format="JPEG")
-        img_str = base64.b64encode(buffered.getvalue()).decode()
-        
-        return img_str
-    except Exception as e:
-        logging.error(f"Error creating placeholder image: {e}")
-        return None
-
-def get_random_fallback_image():
-    """Get a random fallback image from the list."""
-    return random.choice(FALLBACK_IMAGES)
-
-def extract_image_urls_from_search(image_results, query):
-    """Extract valid image URLs from Brave image search results, with fallbacks."""
-    # 안정적인 대체 이미지로 시작 (최소 3개 보장)
-    valid_urls = [
-        {
-            'url': get_random_fallback_image(),
-            'title': f"Related to: {query} ({i+1})",
-            'source': "https://www.pexels.com/"
-        } for i in range(3)
-    ]
-    
-    # API 결과에서 검증된 이미지 추가
-    if image_results:
-        for img in image_results:
-            url = img.get('image_url')
-            if url and url.startswith('http'):
-                # 이미 추가된 URL 개수가 5개 미만인 경우에만 추가
-                if len(valid_urls) < 5:
-                    valid_urls.append({
-                        'url': url,
-                        'title': img.get('title', f"Related to: {query}"),
-                        'source': img.get('source_url', '')
-                    })
-    
-    return valid_urls
-
-def extract_video_data_from_search(video_results):
-    """Extract valid video data from Brave video search results."""
-    if not video_results:
-        return []
-    
-    valid_videos = []
-    for vid in video_results:
-        url = vid.get('video_url')
-        if url and url.startswith('http'):
-            valid_videos.append({
-                'url': url,
-                'title': vid.get('title', 'Video'),
-                'thumbnail': vid.get('thumbnail_url', ''),
-                'source': vid.get('source', 'Video source')
-            })
-    
-    return valid_videos
-
 def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
-    """Image generation function."""
+    """Image generation function (via Gradio endpoint)."""
     if not prompt:
         return None, "Insufficient prompt"
     try:
@@ -734,7 +616,6 @@ def extract_image_prompt(response_text: str, topic: str):
     Generate a single-line English image prompt from the response content.
     """
     client = get_openai_client()
-    
     try:
         response = client.chat.completions.create(
             model="gpt-4.1-mini",
@@ -757,7 +638,7 @@ def md_to_html(md: str, title="Perplexity-like Response"):
     return f"<!DOCTYPE html><html><head><title>{title}</title><meta charset='utf-8'></head><body>{markdown.markdown(md)}</body></html>"
 
 def keywords(text: str, top=5):
-    """Simple keyword extraction."""
+    """Simple keyword extraction for query. Returns first N words (roughly)."""
     cleaned = re.sub(r"[^가-힣a-zA-Z0-9\s]", "", text)
     return " ".join(cleaned.split()[:top])
 
@@ -921,10 +802,9 @@ def perplexity_app():
     # Display existing messages
     for m in st.session_state.messages:
         with st.chat_message(m["role"]):
-            # Process markdown to allow clickable links and properly rendered content
             st.markdown(m["content"], unsafe_allow_html=True)
             
-            # Display images if present
+            # Display images if present in the message
             if "images" in m and m["images"]:
                 st.subheader("Related Images")
                 cols = st.columns(min(3, len(m["images"])))
@@ -949,7 +829,7 @@ def perplexity_app():
                     video_url = video.get('url', '')
                     thumbnail = video.get('thumbnail', '')
                     
-                    # Display video information with thumbnail if available
+                    # Display video with thumbnail if available
                     if thumbnail:
                         col1, col2 = st.columns([1, 3])
                         with col1:
@@ -994,7 +874,7 @@ def process_input(query: str, uploaded_files):
         has_uploaded_files = bool(uploaded_files) and len(uploaded_files) > 0
         
         try:
-            # 상태 표시를 위한 상태 컴포넌트
+            # 상태 표시
             status = st.status("Preparing to answer your query...")
             status.update(label="Initializing client...")
             
@@ -1011,12 +891,12 @@ def process_input(query: str, uploaded_files):
                 with st.spinner("Searching the web..."):
                     search_content = do_web_search(keywords(query, top=5))
                 
-                # Perform specific searches for media
+                # Perform specific searches for images, videos, news
                 try:
                     status.update(label="Finding images and videos...")
                     image_results = brave_image_search(query, 5)
                     video_results = brave_video_search(query, 2)
-                    news_results = brave_news_search(query, 3)
+                    news_results  = brave_news_search(query, 3)
                 except Exception as search_err:
                     logging.error(f"Media search error: {search_err}")
             
@@ -1027,9 +907,28 @@ def process_input(query: str, uploaded_files):
                 with st.spinner("Analyzing files..."):
                     file_content = process_uploaded_files(uploaded_files)
             
-            # Extract usable image and video data with fallbacks
-            valid_images = extract_image_urls_from_search(image_results, query)
-            valid_videos = extract_video_data_from_search(video_results)
+            # 최종적으로 사용할 이미지/비디오 목록 구성
+            # (이번에는 "fallback" 없이 Brave 검색 결과만 사용)
+            valid_images = []
+            for img in image_results:
+                url = img.get('image_url')
+                if url and url.startswith('http'):
+                    valid_images.append({
+                        'url': url,
+                        'title': img.get('title', f"Related to: {query}"),
+                        'source': img.get('source_url', '')
+                    })
+
+            valid_videos = []
+            for vid in video_results:
+                url = vid.get('video_url')
+                if url and url.startswith('http'):
+                    valid_videos.append({
+                        'url': url,
+                        'title': vid.get('title', 'Video'),
+                        'thumbnail': vid.get('thumbnail_url', ''),
+                        'source': vid.get('source', 'Video source')
+                    })
             
             # Build system prompt
             status.update(label="Preparing comprehensive answer...")
@@ -1040,9 +939,6 @@ def process_input(query: str, uploaded_files):
                 include_uploaded_files=has_uploaded_files
             )
 
-            # OpenAI API 호출 준비
-            status.update(label="Generating response...")
-            
             # 메시지 구성
             api_messages = [
                 {"role": "system", "content": sys_prompt}
@@ -1050,54 +946,52 @@ def process_input(query: str, uploaded_files):
             
             user_content = query
             
-            # 검색 결과가 있으면 사용자 프롬프트에 추가
+            # 검색 결과 추가
             if search_content:
                 user_content += "\n\n" + search_content
             
-            # 파일 내용이 있으면 사용자 프롬프트에 추가
+            # 파일 내용 추가
             if file_content:
                 user_content += "\n\n" + file_content
             
-            # Include specific image information
+            # 이미지/비디오 메타정보를 user_content에 추가
             if valid_images:
                 user_content += "\n\n# Available Images\n"
-                for i, img in enumerate(valid_images[:5]):
+                for i, img in enumerate(valid_images):
                     user_content += f"\n{i+1}. ![{img['title']}]({img['url']})\n"
                     if img['source']:
                         user_content += f"   Source: {img['source']}\n"
             
-            # Include specific video information
             if valid_videos:
                 user_content += "\n\n# Available Videos\n"
-                for i, vid in enumerate(valid_videos[:2]):
+                for i, vid in enumerate(valid_videos):
                     user_content += f"\n{i+1}. **{vid['title']}** - [{vid['source']}]({vid['url']})\n"
-                    
-            # 사용자 메시지 추가
+            
+            # OpenAI API에 전달할 최종 메시지
             api_messages.append({"role": "user", "content": user_content})
             
-            # OpenAI API 스트리밍 호출 - 고정 모델 "gpt-4.1-mini" 사용
+            # OpenAI API 스트리밍 호출
             try:
-                # 스트리밍 방식으로 API 호출
                 stream = client.chat.completions.create(
-                    model="gpt-4.1-mini",  # 고정 모델 사용
+                    model="gpt-4.1-mini",
                     messages=api_messages,
                     temperature=1,
                     max_tokens=MAX_TOKENS,
                     top_p=1,
-                    stream=True  # 스트리밍 활성화
+                    stream=True
                 )
                 
-                # 스트리밍 응답 처리
+                # 스트리밍으로 partial content 수신
                 for chunk in stream:
                     if chunk.choices and len(chunk.choices) > 0 and chunk.choices[0].delta.content is not None:
                         content_delta = chunk.choices[0].delta.content
                         full_response += content_delta
                         message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
                 
-                # 최종 응답 표시 (커서 제거)
+                # 최종 응답 표시
                 message_placeholder.markdown(full_response, unsafe_allow_html=True)
                 
-                # Display related images if available
+                # 실제 검색된 이미지를 UI에 표시
                 if valid_images:
                     st.subheader("Related Images")
                     image_cols = st.columns(min(3, len(valid_images)))
@@ -1106,27 +1000,15 @@ def process_input(query: str, uploaded_files):
                         col_idx = i % len(image_cols)
                         try:
                             with image_cols[col_idx]:
-                                # 이미지 URL 체크
                                 img_url = img_data['url']
                                 caption = img_data['title']
-                                
-                                try:
-                                    # 이미지 표시 시도
-                                    st.image(img_url, caption=caption, use_column_width=True)
-                                    if img_data.get('source'):
-                                        st.markdown(f"[Source]({img_data['source']})")
-                                except Exception as img_err:
-                                    # 실패 시 대체 이미지 (Pexels 안정적인 이미지)
-                                    st.image(get_random_fallback_image(), 
-                                             caption=f"{caption} (Fallback image)", 
-                                             use_column_width=True)
-                                    st.markdown("[Source: Pexels](https://www.pexels.com/)")
-                                    logging.warning(f"Using fallback image: {img_err}")
-                        except Exception as col_err:
-                            logging.error(f"Error displaying image in column: {col_err}")
-                            continue
+                                st.image(img_url, caption=caption, use_column_width=True)
+                                if img_data.get('source'):
+                                    st.markdown(f"[Source]({img_data['source']})")
+                        except Exception as img_err:
+                            logging.warning(f"Error displaying image: {img_err}")
                 
-                # Display related videos if available
+                # 실제 검색된 비디오를 UI에 표시
                 if valid_videos:
                     st.subheader("Related Videos")
                     for video in valid_videos:
@@ -1134,7 +1016,6 @@ def process_input(query: str, uploaded_files):
                         video_url = video.get('url', '')
                         thumbnail = video.get('thumbnail', '')
                         
-                        # Display video information with thumbnail if available
                         if thumbnail:
                             try:
                                 col1, col2 = st.columns([1, 3])
@@ -1147,16 +1028,15 @@ def process_input(query: str, uploaded_files):
                                     st.markdown(f"**[{video_title}]({video_url})**")
                                     st.write(f"Source: {video.get('source', 'Unknown')}")
                             except Exception as vid_err:
-                                # 오류시 기본 형식으로 표시
                                 st.markdown(f"🎬 **[{video_title}]({video_url})**")
                                 st.write(f"Source: {video.get('source', 'Unknown')}")
                         else:
                             st.markdown(f"🎬 **[{video_title}]({video_url})**")
                             st.write(f"Source: {video.get('source', 'Unknown')}")
-                
+
                 status.update(label="Response completed!", state="complete")
                 
-                # Save the response with images and videos in the session state
+                # 세션 저장
                 st.session_state.messages.append({
                     "role": "assistant", 
                     "content": full_response,
@@ -1170,7 +1050,7 @@ def process_input(query: str, uploaded_files):
                 status.update(label=f"Error: {error_message}", state="error")
                 raise Exception(f"Response generation error: {error_message}")
             
-            # Additional image generation if enabled
+            # 추가 이미지 생성(옵션)
             if st.session_state.generate_image and full_response:
                 with st.spinner("Generating custom image..."):
                     try:
@@ -1181,9 +1061,9 @@ def process_input(query: str, uploaded_files):
                             st.image(img, caption=cap)
                     except Exception as img_error:
                         logging.error(f"Image generation error: {str(img_error)}")
-                        st.warning("Custom image generation failed. Using web images only.")
+                        st.warning("Custom image generation failed.")
 
-            # Download buttons
+            # 다운로드 버튼
             if full_response:
                 st.subheader("Download This Response")
                 c1, c2 = st.columns(2)
@@ -1216,10 +1096,9 @@ def process_input(query: str, uploaded_files):
             ans = f"An error occurred while processing your request: {error_message}"
             st.session_state.messages.append({"role": "assistant", "content": ans})
 
-
 # ──────────────────────────────── main ────────────────────────────────────
 def main():
     perplexity_app()
 
 if __name__ == "__main__":
-    main()
+    main()