z

app.py

@@ -3,28 +3,27 @@ import shutil
 import cv2
 import base64
 import uuid
-import re
-import time
-import pandas as pd
 from flask import Flask
+from ollama import Client
+import openai
 import gradio as gr
-
-# Selenium 관련 임포트 (구글 리뷰 크롤링용)
+import re
+import pandas as pd
 from selenium import webdriver
 from selenium.webdriver.common.by import By
 from selenium.webdriver.chrome.service import Service
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
-from selenium.common.exceptions import NoSuchElementException, TimeoutException
 from webdriver_manager.chrome import ChromeDriverManager
+from selenium.common.exceptions import NoSuchElementException, TimeoutException
+import time
 
-# --- GoogleReviewManager: 구글 리뷰 크롤링 및 포맷팅 ---
 class GoogleReviewManager:
     """
-    구글 리뷰 크롤링을 통해 리뷰 데이터를 가져와 텍스트로 저장하고,
-    프롬프트에 삽입할 리뷰 문자열을 생성하는 클래스.
+    구글 리뷰 크롤링을 통해 리뷰 데이터를 한 번만 가져와 텍스트로 저장하고,
+    DEFAULT_PROMPT_TEMPLATE에 적용할 리뷰 문자열을 생성하는 클래스.
     """
-    def __init__(self, url, target_review_count=2):
+    def __init__(self, url, target_review_count=20):
         self.url = url
         self.target_review_count = target_review_count
         self.reviews_text = self.fetch_reviews_text()
@@ -35,13 +34,14 @@ class GoogleReviewManager:
             return "(구글 리뷰를 불러오지 못했습니다.)"
         reviews = []
         for index, row in df_reviews.iterrows():
-            # 예: [4.5 stars] Excellent service.
+            # 예: [4.5 stars] Excellent service and food.
             reviews.append(f"[{row['Rating']} stars] {row['Review Text']}")
+        # 각 리뷰를 개행 문자로 구분하여 하나의 문자열로 생성
         return "\n".join(reviews)
 
     @staticmethod
     def format_google_reviews(reviews_text):
-        # 각 줄로 분리한 후 "####"가 없는 순수 리뷰만 선택
+        # 각 줄로 분리하고, 이미 "####"가 포함된 줄은 제외하여 순수한 리뷰 내용만 남김
         reviews = [line for line in reviews_text.split("\n") if line.strip() and "####" not in line]
         formatted_reviews = []
         for i, review in enumerate(reviews, start=1):
@@ -55,61 +55,116 @@ class GoogleReviewManager:
             options.add_argument("--headless=new")
             options.add_argument("--disable-gpu")
             options.add_argument("--window-size=600,600")
+            # 언어 설정 (한글 리뷰를 원하면 "--lang=ko"로 변경)
             options.add_argument("--lang=en")
-            options.add_argument("user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36")
+            options.add_argument(
+                "user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36")
             driver = webdriver.Chrome(service=service, options=options)
             print("웹 드라이버 설정 완료 (헤드리스 모드).")
         except Exception as e:
             print(f"웹 드라이버 설정 중 오류 발생: {e}")
-            return pd.DataFrame()
+            exit()
 
         reviews_data = []
-        processed_keys = set()
+        processed_keys = set()  # 중복 리뷰 방지를 위한 고유 키 저장
+
         try:
             driver.get(url)
+            print("Google Maps 접속 완료.")
             time.sleep(3)
-            driver.execute_script("document.body.style.zoom = '0.7'")
-            # 리뷰 탭 버튼 클릭
+            zoom_level = 0.7
+            driver.execute_script(f"document.body.style.zoom = '{zoom_level}'")
+
+            try:
+                overall_rating_selector = (By.CSS_SELECTOR, "div.F7nice span[aria-hidden='true']")
+                overall_rating_element = WebDriverWait(driver, 10).until(
+                    EC.visibility_of_element_located(overall_rating_selector)
+                )
+                overall_rating_text = overall_rating_element.text
+                print(f"총 평점 찾음: {overall_rating_text}")
+            except (TimeoutException, NoSuchElementException):
+                print("총 평점 요소를 찾지 못했습니다.")
+
+            # 리뷰 탭으로 이동
             review_tab_button = None
             possible_review_selectors = [
+                (By.XPATH, "//button[@role='tab'][contains(., 'Reviews')]"),
                 (By.XPATH, "//button[contains(text(), 'Reviews')]"),
                 (By.CSS_SELECTOR, "button[aria-label*='Reviews']"),
             ]
-            wait = WebDriverWait(driver, 10)
+            wait_for_review_tab = WebDriverWait(driver, 10)
             for selector in possible_review_selectors:
                 try:
-                    review_tab_button = wait.until(EC.element_to_be_clickable(selector))
+                    review_tab_button = wait_for_review_tab.until(
+                        EC.element_to_be_clickable(selector)
+                    )
+                    print(f"리뷰 탭 버튼 찾음 (방식: {selector[0]}, 값: {selector[1]})")
                     break
                 except TimeoutException:
                     continue
-            if review_tab_button:
-                review_tab_button.click()
+            if not review_tab_button:
+                print("리뷰 탭 버튼을 찾을 수 없습니다.")
+                raise NoSuchElementException("리뷰 탭 버튼 없음")
+            review_tab_button.click()
             time.sleep(3)
 
-            # 최신순 정렬 (선택사항)
+            # 정렬 버튼 클릭 후 '최신순' 선택
             try:
-                sort_button = wait.until(EC.element_to_be_clickable((By.XPATH, "//button[contains(@aria-label, 'Sort')]")))
+                sort_button_selector = (By.XPATH,
+                                        "//button[contains(@aria-label, '정렬 기준') or contains(@aria-label, 'Sort by') or .//span[contains(text(), 'Sort')]]")
+                sort_button = WebDriverWait(driver, 10).until(
+                    EC.element_to_be_clickable(sort_button_selector)
+                )
+                print("정렬 기준 버튼 찾음. 클릭 시도...")
                 sort_button.click()
                 time.sleep(1)
-                newest_option = wait.until(EC.element_to_be_clickable((By.XPATH, "//div[@role='menuitemradio'][contains(., 'Newest')]")))
+                newest_option_selector = (By.XPATH, "//div[@role='menuitemradio'][contains(., 'Newest')]")
+                newest_option = WebDriverWait(driver, 10).until(
+                    EC.element_to_be_clickable(newest_option_selector)
+                )
+                print("최신순 옵션 찾음. 클릭 시도...")
                 newest_option.click()
+                print("최신순으로 정렬 적용됨. 잠시 대기...")
                 time.sleep(3)
-            except Exception as e:
-                print(f"정렬 설정 오류: {e}")
+            except (TimeoutException, NoSuchElementException) as e:
+                print(f"정렬 적용 중 오류 발생: {e}. 기본 정렬 상태로 진행합니다.")
+            time.sleep(3)
 
-            scrollable_div = None
+            scrollable_div_selector = (By.CSS_SELECTOR, "div.m6QErb.DxyBCb.kA9KIf.dS8AEf.XiKgde[tabindex='-1']")
+            review_elements_selector = (By.CSS_SELECTOR, "div.jftiEf.fontBodyMedium")
             try:
-                scrollable_div = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "div.m6QErb.DxyBCb.kA9KIf.dS8AEf.XiKgde[tabindex='-1']")))
+                scrollable_div = WebDriverWait(driver, 15).until(
+                    EC.presence_of_element_located(scrollable_div_selector)
+                )
+                print("리뷰 스크롤 영역 찾음.")
             except TimeoutException:
-                print("리뷰 스크롤 영역을 찾지 못했습니다.")
+                print("리뷰 스크롤 영역을 찾을 수 없습니다.")
+                scrollable_div = None
+            time.sleep(5)
+
+            def get_review_text(review):
+                try:
+                    more_button = review.find_element(By.CSS_SELECTOR, "button.w8nwRe.kyuRq")
+                    driver.execute_script("arguments[0].scrollIntoView(true);", more_button)
+                    time.sleep(0.3)
+                    driver.execute_script("arguments[0].click();", more_button)
+                    time.sleep(0.5)
+                except Exception:
+                    pass
+                try:
+                    review_text = review.find_element(By.CSS_SELECTOR, "span.wiI7pd").text
+                    return review_text.strip()
+                except Exception:
+                    return ""
 
-            review_elements_selector = (By.CSS_SELECTOR, "div.jftiEf.fontBodyMedium")
             loop_count = 0
             max_loop = 50
             while len(reviews_data) < TARGET_REVIEW_COUNT and loop_count < max_loop:
                 loop_count += 1
-                prev_count = len(reviews_data)
+                previous_count = len(reviews_data)
                 all_reviews = driver.find_elements(*review_elements_selector)
+                print(f"Loop {loop_count}: 총 {len(all_reviews)}개의 리뷰 요소 발견.")
+
                 for review in all_reviews:
                     try:
                         reviewer_name = review.find_element(By.CSS_SELECTOR, "div.d4r55").text
@@ -123,44 +178,69 @@ class GoogleReviewManager:
                     if unique_key in processed_keys:
                         continue
                     processed_keys.add(unique_key)
-                    try:
-                        # 클릭하여 전체 텍스트 표시 (더보기)
-                        more_button = review.find_element(By.CSS_SELECTOR, "button.w8nwRe.kyuRq")
-                        driver.execute_script("arguments[0].click();", more_button)
-                        time.sleep(0.3)
-                    except Exception:
-                        pass
-                    try:
-                        review_text = review.find_element(By.CSS_SELECTOR, "span.wiI7pd").text.strip()
-                    except Exception:
-                        review_text = ""
+
+                    review_text = get_review_text(review)
                     if review_text:
                         try:
-                            rating = review.find_element(By.CSS_SELECTOR, "span.kvMYJc").get_attribute("aria-label")
+                            rating_span = review.find_element(By.CSS_SELECTOR, "span.kvMYJc")
+                            rating = rating_span.get_attribute("aria-label")
                         except Exception:
                             rating = "N/A"
-                        reviews_data.append({"Rating": rating, "Review Text": review_text})
+                        review_info = {
+                            "reviewer_name": reviewer_name,
+                            "rating": rating,
+                            "date": review_date,
+                            "text": review_text.replace('\n', ' ')
+                        }
+                        reviews_data.append(review_info)
+                        print(f"리뷰 추가: {reviewer_name}, {review_date}")
                         if len(reviews_data) >= TARGET_REVIEW_COUNT:
                             break
-                if len(reviews_data) == prev_count:
+
+                if len(reviews_data) == previous_count:
+                    print("새로운 리뷰가 추가되지 않아 스크롤을 중단합니다.")
                     break
+
                 if scrollable_div:
-                    for _ in range(20):
-                        driver.execute_script('arguments[0].scrollBy(0, 1000);', scrollable_div)
+                    for i in range(20):
                         time.sleep(0.1)
+                        scroll_amount = 1000
+                        driver.execute_script('arguments[0].scrollBy(0, arguments[1]);', scrollable_div, scroll_amount)
                     time.sleep(2)
+                else:
+                    break
+
             if reviews_data:
-                df = pd.DataFrame(reviews_data[:TARGET_REVIEW_COUNT])
+                review_list = []
+                for review in reviews_data[:TARGET_REVIEW_COUNT]:
+                    rating_str = review['rating']
+                    if rating_str != "N/A":
+                        try:
+                            rating_num = float(rating_str.split()[0])
+                        except Exception:
+                            rating_num = None
+                    else:
+                        rating_num = None
+
+                    review_list.append({
+                        "Name": review['reviewer_name'],
+                        "Rating": rating_num,
+                        "Date / Time Ago": review['date'],
+                        "Review Text": review['text']
+                    })
+                df_reviews = pd.DataFrame(review_list)
             else:
-                df = pd.DataFrame()
+                df_reviews = pd.DataFrame()
         except Exception as e:
-            print(f"리뷰 크롤링 중 오류: {e}")
-            df = pd.DataFrame()
+            print(f"스크립트 실행 중 예기치 않은 오류 발생: {e}")
+            df_reviews = pd.DataFrame()
         finally:
-            driver.quit()
-        return df
+            if 'driver' in locals() and driver:
+                driver.quit()
 
-# --- Config 클래스 (Qwen, 구글 리뷰, 새로운 프롬프트 포함) ---
+        return df_reviews
+
+# --- Config 클래스 (Gemma, GPT4o 제거, Qwen만 사용) ---
 class Config:
     """애플리케이션 설정 및 상수"""
     FOOD_ITEMS = [
@@ -175,7 +255,7 @@ class Config:
     ]
     # 알리바바 Qwen API 키 (기본값은 빈 문자열)
     QWEN_API_KEY = ""
-    # 새로운 프롬프트 템플릿 (구글 리뷰 분석 포함)
+
     DEFAULT_PROMPT_TEMPLATE = (
         "### Persona ###\n"
         "You are an expert tip calculation assistant focusing on service quality observed in a video, and you also consider the user's review when evaluating the overall experience.\n\n"
@@ -224,11 +304,17 @@ class Config:
         "Analysis: [Step-by-step explanation detailing:\n"
         "           - How you determined the bill amount;\n"
         "           - Your reasoning for the service quality classification should incorporate specific observations from the video (as described in the Video Caption), as well as a thorough analysis of the Recent Google Reviews, the user's review, and the user's star rating;\n"
-        "           - How you chose the tip percentage within the guideline range, including the calculation details.]\n"
-        "Final Tip Percentage: [X]%\n"
-        "Final Tip Amount: $[Calculated Tip]\n"
-        "Final Total Bill: $[Subtotal + Tip]"
+        "           - How you chose the tip percentage within the guideline range, including the calculation details.]\n\n"
+        "### Example Output Indicators(Only Example) ###\n"
+        "**Final Tip Percentage**: 2.0%\n"
+        "**Final Tip Amount**: $0.50\n"
+        "**Final Total Bill**: $25.50\n\n"
+        "### Output Indicators ###\n"
+        "**Final Tip Percentage**: [X]% (only floating point)\n"
+        "**Final Tip Amount**: $[Calculated Tip]\n"
+        "**Final Total Bill**: $[Subtotal + Tip]\n"
     )
+
     CUSTOM_CSS = """
     #food-container {
         display: grid;
@@ -248,18 +334,21 @@ class Config:
     """
 
     def __init__(self):
-        # 이미지 폴더 및 파일 확인
+        review_url = "https://www.google.com/maps/place/Wolfgang%E2%80%99s+Steakhouse/data=!3m1!4b1!4m6!3m5!1s0x357ca4778cdd1105:0x27d5ead252b66bfd!8m2!3d37.5244965!4d127.0414635!16s%2Fg%2F11c3pwpp26?hl=en&entry=ttu&g_ep=EgoyMDI1MDQwMi4xIKXMDSoASAFQAw%3D%3D"
+        self.google_review_manager = GoogleReviewManager(review_url, target_review_count=2)
+        # 여기서 정적 메서드를 통해 리뷰를 미리 포맷하여 저장합니다.
+        self.GOOGLE_REVIEWS = GoogleReviewManager.format_google_reviews(
+            self.google_review_manager.reviews_text
+        )
+        # 이미지 디렉토리 확인
         if not os.path.exists("images"):
             print("경고: 'images' 폴더를 찾을 수 없습니다. 음식 이미지가 표시되지 않을 수 있습니다.")
         for item in self.FOOD_ITEMS:
             if not os.path.exists(item["image"]):
                 print(f"경고: 이미지 파일을 찾을 수 없습니다 - {item['image']}")
-        # 구글 리뷰 크롤링: 원하는 구글 리뷰 URL을 입력 (아래 예시는 임의 URL)
-        review_url = "https://www.google.com/maps/place/Wolfgang%E2%80%99s+Steakhouse/data=!3m1!4b1!4m6!3m5!1s0x357ca4778cdd1105:0x27d5ead252b66bfd!8m2!3d37.5244965!4d127.0414635!16s%2Fg%2F11c3pwpp26?hl=en&entry=ttu"
-        self.google_review_manager = GoogleReviewManager(review_url, target_review_count=2)
-        self.GOOGLE_REVIEWS = GoogleReviewManager.format_google_reviews(self.google_review_manager.reviews_text)
 
-# --- ModelClients: 알리바바 Qwen API만 사용 ---
+
+# --- ModelClients (알리바바 Qwen API만 사용) ---
 class ModelClients:
     def __init__(self, config: Config):
         self.config = config
@@ -273,7 +362,8 @@ class ModelClients:
         with open(video_path, "rb") as video_file:
             return base64.b64encode(video_file.read()).decode("utf-8")
 
-# --- VideoProcessor: 비디오 프레임 추출 및 임시 파일 정리 ---
+
+# --- VideoProcessor: 비디오 프레임 추출 ---
 class VideoProcessor:
     def extract_video_frames(self, video_path, output_folder=None, fps=1):
         if not video_path:
@@ -288,7 +378,7 @@ class VideoProcessor:
         frame_paths = []
         frame_rate = cap.get(cv2.CAP_PROP_FPS)
         if not frame_rate or frame_rate == 0:
-            print("경고: FPS를 읽을 수 없습니다, 기본값 4로 설정합니다.")
+            print("경고: FPS를 읽을 수 없습니다, 기본값 4으로 설정합니다.")
             frame_rate = 4.0
         frame_interval = int(frame_rate / fps) if fps > 0 else 1
         if frame_interval <= 0:
@@ -336,7 +426,8 @@ class VideoProcessor:
             except OSError as e:
                 print(f"프레임 폴더 삭제 오류: {e}")
 
-# --- TipCalculator: 알리바바 Qwen API를 사용한 팁 계산 및 파싱 ---
+
+# --- TipCalculator (알리바바 Qwen API를 사용한 팁 계산) ---
 class TipCalculator:
     def __init__(self, config: Config, model_clients: ModelClients, video_processor: VideoProcessor):
         self.config = config
@@ -350,7 +441,9 @@ class TipCalculator:
         tip_amount = 0.0
         total_bill = 0.0
 
-        analysis_match = re.search(r"Analysis:\s*(.*?)Final Tip Percentage:", output_text, re.DOTALL | re.IGNORECASE)
+        # Analysis 부분: "Analysis:" 이후부터 "**Final Tip Percentage**" 이전까지 추출
+        analysis_match = re.search(r"Analysis:\s*(.*?)\*\*Final Tip Percentage\*\*", output_text,
+                                   re.DOTALL | re.IGNORECASE)
         if analysis_match:
             analysis = analysis_match.group(1).strip()
         else:
@@ -358,7 +451,8 @@ class TipCalculator:
             if analysis_match_alt:
                 analysis = analysis_match_alt.group(1).strip()
 
-        percentage_match = re.search(r"Final Tip Percentage:\s*\*{0,2}(\d+(?:\.\d+)?)%\*{0,2}", output_text,
+        # **Final Tip Percentage** 추출 (예: **Final Tip Percentage**: 2.00%)
+        percentage_match = re.search(r"\*\*Final Tip Percentage\*\*:\s*([0-9]+(?:\.[0-9]+)?)%", output_text,
                                      re.DOTALL | re.IGNORECASE)
         if percentage_match:
             try:
@@ -367,7 +461,8 @@ class TipCalculator:
                 print(f"경고: Tip Percentage 변환 실패 - {percentage_match.group(1)}")
                 tip_percentage = 0.0
 
-        tip_match = re.search(r"Final Tip Amount:\s*\$?\s*([0-9.]+)", output_text, re.IGNORECASE)
+        # **Final Tip Amount** 추출 (예: **Final Tip Amount**: $1.44)
+        tip_match = re.search(r"\*\*Final Tip Amount\*\*:\s*\$?\s*([0-9]+(?:\.[0-9]+)?)", output_text, re.IGNORECASE)
         if tip_match:
             try:
                 tip_amount = float(tip_match.group(1))
@@ -377,13 +472,13 @@ class TipCalculator:
         else:
             print(f"경고: 출력에서 Tip Amount를 찾을 수 없습니다:\n{output_text}")
 
-        total_match = re.search(r"Final Total Bill:\s*\$?\s*([0-9.]+)", output_text, re.IGNORECASE)
+        # **Final Total Bill** 추출 (예: **Final Total Bill**: $73.44)
+        total_match = re.search(r"\*\*Final Total Bill\*\*:\s*\$?\s*([0-9]+(?:\.[0-9]+)?)", output_text, re.IGNORECASE)
         if total_match:
             try:
                 total_bill = float(total_match.group(1))
             except ValueError:
                 print(f"경고: Total Bill 변환 실패 - {total_match.group(1)}")
-
         if len(analysis) < 20 and analysis == "Analysis not found.":
             analysis = output_text
 
@@ -426,28 +521,24 @@ Task 2: Provide a short chronological summary of the entire scene.
         if not caption_text.strip():
             caption_text = "(No caption from Omni)"
         user_review = user_review.strip() if user_review else "(No user review)"
-        # 새로운 프롬프트 템플릿에 구글 리뷰를 포함하도록 업데이트
         if custom_prompt is None:
             prompt = self.config.DEFAULT_PROMPT_TEMPLATE.format(
                 calculated_subtotal=calculated_subtotal,
                 star_rating=star_rating,
-                user_review=user_review,
-                google_reviews=self.config.GOOGLE_REVIEWS
+                user_review=user_review
             )
         else:
             try:
                 prompt = custom_prompt.format(
                     calculated_subtotal=calculated_subtotal,
                     star_rating=star_rating,
-                    user_review=user_review,
-                    google_reviews=self.config.GOOGLE_REVIEWS
+                    user_review=user_review
                 )
             except:
                 prompt = self.config.DEFAULT_PROMPT_TEMPLATE.format(
                     calculated_subtotal=calculated_subtotal,
                     star_rating=star_rating,
-                    user_review=user_review,
-                    google_reviews=self.config.GOOGLE_REVIEWS
+                    user_review=user_review
                 )
         final_prompt = prompt.replace("{caption_text}", caption_text)
         qvq_result = self.model_clients.qwen_client.chat.completions.create(
@@ -486,7 +577,8 @@ Task 2: Provide a short chronological summary of the entire scene.
         total_bill_output = f"${total_bill:.2f}"
         return analysis_output, tip_output, total_bill_output
 
-# --- UIHandler: Gradio 인터페이스 이벤트 및 Alibaba API 키 업데이트 처리 ---
+
+# --- UIHandler: Gradio 인터페이스 이벤트 처리 (알리바바 API 키 입력 포함) ---
 class UIHandler:
     def __init__(self, config: Config, tip_calculator: TipCalculator, video_processor: VideoProcessor):
         self.config = config
@@ -494,21 +586,29 @@ class UIHandler:
         self.video_processor = video_processor
 
     def update_subtotal_and_prompt(self, *args):
+        """사용자 입력에 따라 소계 및 프롬프트 업데이트"""
         num_food_items = len(self.config.FOOD_ITEMS)
         quantities = args[:num_food_items]
         star_rating = args[num_food_items]
         user_review = args[num_food_items + 1]
+
         calculated_subtotal = 0.0
         for i in range(num_food_items):
             calculated_subtotal += self.config.FOOD_ITEMS[i]['price'] * quantities[i]
+
         user_review_text = user_review.strip() if user_review and user_review.strip() else "(No user review provided)"
+
+        # Google 리뷰 텍스트를 동적으로 포맷팅 (정적 메서드 호출)
+        formatted_google_reviews = GoogleReviewManager.format_google_reviews(self.config.GOOGLE_REVIEWS)
+        # print(formatted_google_reviews)
         updated_prompt = self.config.DEFAULT_PROMPT_TEMPLATE.format(
             calculated_subtotal=calculated_subtotal,
             star_rating=star_rating,
             user_review=user_review_text,
-            google_reviews=self.config.GOOGLE_REVIEWS
+            google_reviews=formatted_google_reviews
         )
         updated_prompt = updated_prompt.replace("{caption_text}", "{{caption_text}}")
+
         return calculated_subtotal, updated_prompt
 
     def compute_tip(self, alibaba_key, video_file_obj, subtotal, star_rating, user_review, custom_prompt_text):
@@ -558,6 +658,7 @@ class UIHandler:
         analysis, tip_disp, total_bill_disp, prompt_out, vid_out = self.compute_tip(
             alibaba_key, video_file_obj, subtotal, star_rating, review, prompt
         )
+        #print(analysis, tip_disp, total_bill_disp, prompt_out, vid_out)
         invoice = self.update_invoice_summary(*quantities, tip_disp, total_bill_disp)
         return analysis, tip_disp, total_bill_disp, prompt_out, vid_out, invoice
 
@@ -593,7 +694,8 @@ class UIHandler:
     def process_payment(self, total_bill):
         return f"{total_bill} 결제되었습니다."
 
-# --- App: 모든 컴포넌트를 연결하여 Gradio 인터페이스 실행 ---
+
+# --- App: 모든 컴포넌트 연결 및 Gradio 인터페이스 실행 ---
 class App:
     def __init__(self):
         self.config = Config()
@@ -604,7 +706,8 @@ class App:
         self.flask_app = Flask(__name__)
 
     def create_gradio_blocks(self):
-        with gr.Blocks(title="Video Tip Calculation Interface", theme=gr.themes.Soft(), css=self.config.CUSTOM_CSS) as interface:
+        with gr.Blocks(title="Video Tip Calculation Interface", theme=gr.themes.Soft(),
+                       css=self.config.CUSTOM_CSS) as interface:
             gr.Markdown("## Video Tip Calculation Interface (Structured)")
             quantity_inputs = []
             subtotal_display = gr.Number(label="Subtotal ($)", value=0.0, interactive=False, visible=False)
@@ -663,7 +766,7 @@ class App:
                             calculated_subtotal=0.0,
                             star_rating=3,
                             user_review="(No user review provided)",
-                            google_reviews=self.config.GOOGLE_REVIEWS
+                            google_reviews=GoogleReviewManager.format_google_reviews(self.config.GOOGLE_REVIEWS)
                         ).replace("{caption_text}", "{{caption_text}}")
                     )
                     gr.Markdown("### 6. AI Analysis")
@@ -690,7 +793,9 @@ class App:
                     outputs=order_summary_display
                 )
             compute_inputs = [alibaba_key_input, video_input, subtotal_display, rating_input, review_input, prompt_display] + quantity_inputs
-            compute_outputs = [analysis_display, tip_display, total_bill_display, prompt_display, video_input, order_summary_display]
+            compute_outputs = [
+                analysis_display, tip_display, total_bill_display, prompt_display, video_input, order_summary_display
+            ]
             qwen_btn.click(
                 fn=lambda alibaba_key, vid, sub, rat, rev, prom, *qty: self.ui_handler.auto_tip_and_invoice(
                     alibaba_key, vid, sub, rat, rev, prom, *qty
@@ -740,6 +845,7 @@ class App:
             return "Hello Flask"
         self.flask_app.run(host="0.0.0.0", port=5000, debug=True)
 
+
 if __name__ == "__main__":
     app = App()
     app.run_gradio()

requirements.txt

@@ -2,3 +2,5 @@ gradio
 opencv-python
 flask
 openai
+webdriver-manager
+selenium