Update app.py

app.py

@@ -1,46 +1,476 @@
 import gradio as gr
-import requests
 import os
-from openai import OpenAI
+import json
+import requests
+import xml.etree.ElementTree as ET
+import schedule
+import time
+import threading
+from huggingface_hub import HfApi, create_repo
+import warnings
+import pandas as pd
+from docx import Document
+import spaces
+from google.oauth2.service_account import Credentials
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseDownload
+import io
+import base64
+from gtts import gTTS  # Google Text-to-Speech
+
+# Suppress Gradio warnings
+warnings.filterwarnings("ignore", category=UserWarning, module="gradio.components.chatbot")
+
+# Log file name and path
+LOG_FILE = '/data/chat_logs.txt' if os.path.exists('/data') else 'chat_logs.txt'
+print(f"File path: {os.path.abspath(LOG_FILE)}")
+
+# API settings
+API_URL = "https://api.openai.com/v1/chat/completions"
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    print("Error: OPENAI_API_KEY environment variable not set!")
+
+# Fetch Trek bicycle products
+url = 'https://www.trekbisiklet.com.tr/output/8582384479'
+response = requests.get(url)
+root = ET.fromstring(response.content)
+
+products = []
+for item in root.findall('item'):
+    # Get all products, then check for stock availability
+    name_words = item.find('rootlabel').text.lower().split()
+    name = name_words[0]
+    full_name = ' '.join(name_words)
+    
+    stock_amount = "stokta" if item.find('stockAmount').text > '0' else "stokta değil"
+    
+    # Don't add price/link info for out-of-stock products
+    if stock_amount == "stokta":
+        # Get normal price info
+        price_str = item.find('priceTaxWithCur').text if item.find('priceTaxWithCur') is not None else "Fiyat bilgisi yok"
+        
+        # Get EFT price (money transfer discounted original price)
+        price_eft_str = item.find('priceEft').text if item.find('priceEft') is not None else ""
+        
+        # Get discounted price (promotional price)
+        price_rebate_str = item.find('priceRebateWithTax').text if item.find('priceRebateWithTax') is not None else ""
+        
+        # Get money transfer discounted promotional price
+        price_rebate_money_order_str = item.find('priceRebateWithMoneyOrderWithTax').text if item.find('priceRebateWithMoneyOrderWithTax') is not None else ""
+        
+        # Round normal price
+        try:
+            price_float = float(price_str)
+            # Round to nearest 5000 if price is above 200000
+            if price_float > 200000:
+                price = str(round(price_float / 5000) * 5000)
+            # Round to nearest 1000 if price is above 30000
+            elif price_float > 30000:
+                price = str(round(price_float / 1000) * 1000)
+            # Round to nearest 100 if price is above 10000
+            elif price_float > 10000:
+                price = str(round(price_float / 100) * 100)
+            # Otherwise round to nearest 10
+            else:
+                price = str(round(price_float / 10) * 10)
+        except (ValueError, TypeError):
+            price = price_str  # Keep as is if can't convert to number
+        
+        # Round money transfer discounted original price (if any)
+        if price_eft_str:
+            try:
+                price_eft_float = float(price_eft_str)
+                # Round to nearest 5000 if price is above 200000
+                if price_eft_float > 200000:
+                    price_eft = str(round(price_eft_float / 5000) * 5000)
+                # Round to nearest 1000 if price is above 30000
+                elif price_eft_float > 30000:
+                    price_eft = str(round(price_eft_float / 1000) * 1000)
+                # Round to nearest 100 if price is above 10000
+                elif price_eft_float > 10000:
+                    price_eft = str(round(price_eft_float / 100) * 100)
+                # Otherwise round to nearest 10
+                else:
+                    price_eft = str(round(price_eft_float / 10) * 10)
+            except (ValueError, TypeError):
+                price_eft = price_eft_str
+        else:
+            # If no money transfer discounted price is given, calculate 2.5% discount from original price
+            try:
+                price_eft_float = price_float * 0.975  # 2.5% discount
+                # Round to nearest 5000 if price is above 200000
+                if price_eft_float > 200000:
+                    price_eft = str(round(price_eft_float / 5000) * 5000)
+                # Round to nearest 1000 if price is above 30000
+                elif price_eft_float > 30000:
+                    price_eft = str(round(price_eft_float / 1000) * 1000)
+                # Round to nearest 100 if price is above 10000
+                elif price_eft_float > 10000:
+                    price_eft = str(round(price_eft_float / 100) * 100)
+                # Otherwise round to nearest 10
+                else:
+                    price_eft = str(round(price_eft_float / 10) * 10)
+            except (ValueError, TypeError):
+                price_eft = ""
+        
+        # Round discounted price
+        try:
+            if price_rebate_str:
+                price_rebate_float = float(price_rebate_str)
+                # Round to nearest 5000 if price is above 200000
+                if price_rebate_float > 200000:
+                    price_rebate = str(round(price_rebate_float / 5000) * 5000)
+                # Round to nearest 1000 if price is above 30000
+                elif price_rebate_float > 30000:
+                    price_rebate = str(round(price_rebate_float / 1000) * 1000)
+                # Round to nearest 100 if price is above 10000
+                elif price_rebate_float > 10000:
+                    price_rebate = str(round(price_rebate_float / 100) * 100)
+                # Otherwise round to nearest 10
+                else:
+                    price_rebate = str(round(price_rebate_float / 10) * 10)
+            else:
+                price_rebate = ""
+        except (ValueError, TypeError):
+            price_rebate = price_rebate_str
+        
+        # Round money transfer discounted promotional price
+        try:
+            if price_rebate_money_order_str:
+                price_rebate_money_order_float = float(price_rebate_money_order_str)
+                # Round to nearest 5000 if price is above 200000
+                if price_rebate_money_order_float > 200000:
+                    price_rebate_money_order = str(round(price_rebate_money_order_float / 5000) * 5000)
+                # Round to nearest 1000 if price is above 30000
+                elif price_rebate_money_order_float > 30000:
+                    price_rebate_money_order = str(round(price_rebate_money_order_float / 1000) * 1000)
+                # Round to nearest 100 if price is above 10000
+                elif price_rebate_money_order_float > 10000:
+                    price_rebate_money_order = str(round(price_rebate_money_order_float / 100) * 100)
+                # Otherwise round to nearest 10
+                else:
+                    price_rebate_money_order = str(round(price_rebate_money_order_float / 10) * 10)
+            else:
+                price_rebate_money_order = ""
+        except (ValueError, TypeError):
+            price_rebate_money_order = price_rebate_money_order_str
+        
+        # Get only product link, not image link
+        product_link = item.find('productLink').text if item.find('productLink') is not None else ""
+        
+        # Combine all price information
+        item_info = (stock_amount, price, product_link, price_eft, price_rebate, price_rebate_money_order)
+    else:
+        # For out-of-stock products, only indicate stock status, don't provide price and link info
+        item_info = (stock_amount, "", "", "", "", "")
+    
+    products.append((name, item_info, full_name))
+
+# Hugging Face token
+hfapi = os.getenv("hfapi")
+if not hfapi:
+    raise ValueError("hfapi environment variable not set!")
+
+create_repo("BF", token=hfapi, repo_type="space", space_sdk="gradio", exist_ok=True)
+
+global_chat_history = []  # All chat history
+history_lock = threading.Lock()  # Lock for global history
+file_lock = threading.Lock()  # Lock for file writing
+last_logged_index = 0  # Last logged message index
+
+# Google Drive authentication (Service Account from Secrets)
+SCOPES = ['https://www.googleapis.com/auth/drive.readonly']
+
+def authenticate_google_drive():
+    service_account_json = os.getenv("SERVICE_ACCOUNT_JSON")
+    if not service_account_json:
+        raise ValueError("SERVICE_ACCOUNT_JSON environment variable not found!")
+    
+    try:
+        json_data = json.loads(service_account_json)
+        print("JSON parsed successfully:", json_data.keys())
+        print("Private key content:", json_data.get("private_key"))
+        creds = Credentials.from_service_account_info(json_data, scopes=SCOPES)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"JSON from Secrets is invalid: {e}")
+    except Exception as e:
+        raise ValueError(f"Authentication error: {e}")
+    
+    return build('drive', 'v3', credentials=creds)
+
+def download_file_from_drive(service, file_id, file_name):
+    request = service.files().get_media(fileId=file_id)
+    fh = io.BytesIO()
+    downloader = MediaIoBaseDownload(fh, request)
+    done = False
+    while done is False:
+        status, done = downloader.next_chunk()
+    fh.seek(0)
+    with open(file_name, 'wb') as f:
+        f.write(fh.read())
+    return file_name
+
+# Fetch and process documents from Google Drive
+document_content = ""
+service = authenticate_google_drive()
 
-# OpenAI API istemcisi
-client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+try:
+    # Excel file from Google Drive
+    excel_file_id = "test10rgiGp5y5ZYU0dpRvps2t0t1dEzjW8LK"  # Example Excel file ID, add your own ID
+    excel_file = download_file_from_drive(service, excel_file_id, "data.xlsx")
+    df = pd.read_excel(excel_file)
+    excel_text = df.to_string()
+    document_content += excel_text + "\n"
+except Exception as e:
+    print(f"Google Drive Excel reading error: {e}")
 
-# Chatbot fonksiyonunuzu ses üretimi ile birlikte güncelleyin
-def chatbot_fn_tts(user_message, history):
-    text_response = ""
+try:
+    # Word file from Google Drive
+    word_file_id = "9I8H7G6F5E4D3C2B1A"  # Example Word file ID, add your own ID
+    word_file = download_file_from_drive(service, word_file_id, "descriptions.docx")
+    doc = Document(word_file)
+    word_text = "\n".join([para.text for para in doc.paragraphs])
+    document_content += word_text
+except Exception as e:
+    print(f"Google Drive Word reading error: {e}")
+
+# Function to generate TTS audio from text
+def text_to_speech(text, lang='tr'):
+    try:
+        tts = gTTS(text=text, lang=lang, slow=False)
+        audio_file = io.BytesIO()
+        tts.write_to_fp(audio_file)
+        audio_file.seek(0)
+        audio_base64 = base64.b64encode(audio_file.read()).decode('utf-8')
+        audio_html = f'<audio autoplay><source src="data:audio/mp3;base64,{audio_base64}" type="audio/mp3"></audio>'
+        return audio_html
+    except Exception as e:
+        print(f"TTS error: {e}")
+        return None
+
+def run_scheduler(chat_history_ref):
+    def scheduled_save_and_upload():
+        global last_logged_index
+        if chat_history_ref:
+            print(f"Scheduler triggered: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+            try:
+                with file_lock:  # File writing lock
+                    with open(LOG_FILE, 'a', encoding='utf-8') as f:
+                        f.write("\n--- Scheduled Save: {} ---\n".format(time.strftime("%Y-%m-%d %H:%M:%S")))
+                        with history_lock:  # History lock
+                            new_messages = chat_history_ref[last_logged_index:]
+                            for msg in new_messages:
+                                if msg["role"] in ["user", "assistant"]:
+                                    f.write(f"{msg['role'].capitalize()}: {msg['content']}\n")
+                            last_logged_index = len(chat_history_ref)  # Update last index
+                    print(f"Chat saved to file: {os.path.abspath(LOG_FILE)}")
+            except Exception as e:
+                print(f"Save error: {e}")
+                time.sleep(5)  # Wait before retrying
+                return  # Early exit for retry
+
+            HF_REPO_ID = "SamiKoen/BF"
+            api = HfApi(token=hfapi)
+            for attempt in range(3):  # Try 3 times
+                try:
+                    with file_lock:
+                        api.upload_file(
+                            path_or_fileobj=LOG_FILE,
+                            path_in_repo="chat_logs.txt",
+                            repo_id=HF_REPO_ID,
+                            repo_type="space",
+                            commit_message="Automatic log update - {}".format(time.strftime("%Y-%m-%d %H:%M:%S"))
+                        )
+                    print(f"Log file uploaded to HF: {LOG_FILE}")
+                    break
+                except Exception as e:
+                    print(f"HF upload error (attempt {attempt+1}/3): {e}")
+                    time.sleep(5)
+            else:
+                print("HF upload failed, all attempts completed.")
+            print(f"Scheduled job completed: {time.strftime('%H:%M:%S')}")
+
+    schedule.every().day.at("11:32").do(scheduled_save_and_upload)
+    schedule.every().day.at("15:15").do(scheduled_save_and_upload)
+    schedule.every().day.at("15:30").do(scheduled_save_and_upload)
+    schedule.every().day.at("17:32").do(scheduled_save_and_upload)
+    schedule.every().day.at("19:15").do(scheduled_save_and_upload)
+    schedule.every().day.at("21:30").do(scheduled_save_and_upload)
+    print("Scheduler started")
+    while True:
+        schedule.run_pending()
+        time.sleep(60)
+
+@spaces.GPU(duration=1200)
+def chatbot_fn(user_message, history):
+    if history is None:
+        history = []
+
+    # Log: Add user message
+    try:
+        with file_lock:
+            with open(LOG_FILE, 'a', encoding='utf-8') as f:
+                f.write(f"User: {user_message}\n")
+    except Exception as e:
+        print(f"File writing error (User): {e}")
+
+    # System messages (prompt) - just keeping the structure without showing actual prompts
+    system_messages = [
+        {"role": "system", "content": "You are an AI assistant for Trek bicycles."}
+    ]
+
+    # Add document data to system messages
+    if document_content:
+        system_messages.append({"role": "system", "content": f"Document information: {document_content}"})
+
+    # Check if product name is mentioned in user message
+    input_words = user_message.lower().split()
+    for product_info in products:
+        if product_info[0] in input_words:
+            if product_info[1][0] == "stokta":
+                # Check for campaign price
+                has_campaign = product_info[1][4] and product_info[1][4] != ""
+                
+                # Original price is always shown
+                normal_price = f"Original price: {product_info[1][1]} TL"
+                
+                # Campaign price info
+                rebate_price = ""
+                discount_info = ""
+                eft_price = ""
+                rebate_money_order_price = ""
+                
+                if has_campaign:
+                    # If product has campaign, show campaign price
+                    rebate_price = f"\nCampaign price: {product_info[1][4]} TL"
+                    
+                    # Calculate discount amount
+                    try:
+                        original_price = float(product_info[1][1].replace(',', '.'))
+                        campaign_price = float(product_info[1][4].replace(',', '.'))
+                        discount_amount = original_price - campaign_price
+                        
+                        # Show discount amount if greater than 0
+                        if discount_amount > 0:
+                            # Apply rounding rules for discount amount
+                            if discount_amount > 200000:
+                                discount_amount_rounded = round(discount_amount / 5000) * 5000
+                            elif discount_amount > 30000:
+                                discount_amount_rounded = round(discount_amount / 1000) * 1000
+                            elif discount_amount > 10000:
+                                discount_amount_rounded = round(discount_amount / 100) * 100
+                            else:
+                                discount_amount_rounded = round(discount_amount / 10) * 10
+                                
+                            # Discount info
+                            discount_info = f"\nDiscount amount: {discount_amount_rounded:.0f} TL"
+                    except (ValueError, TypeError):
+                        discount_info = ""
+                    
+                    # Don't show money transfer discounted campaign price
+                    rebate_money_order_price = ""
+                else:
+                    # If not campaign, show money transfer discounted normal price
+                    if product_info[1][3] and product_info[1][3] != "":
+                        eft_price = f"\nMoney transfer discounted price: {product_info[1][3]} TL"
+                
+                # Product link
+                product_link = f"\nProduct link: {product_info[1][2]}"
+                
+                # Combine all information
+                new_msg = f"{product_info[2]} {product_info[1][0]}\n{normal_price}{rebate_price}{discount_info}{eft_price}{rebate_money_order_price}{product_link}"
+            else:
+                # If product is out of stock, just show stock status
+                new_msg = f"{product_info[2]} {product_info[1][0]}"
+            system_messages.append({"role": "system", "content": new_msg})
+
+    messages = system_messages + history + [{"role": "user", "content": user_message}]
 
     payload = {
-        "model": "gpt-4o",
-        "messages": history + [{"role": "user", "content": user_message}],
+        "model": "gpt-4.5-preview",
+        "messages": messages,
         "temperature": 0.2,
-        "stream": False
+        "top_p": 1,
+        "n": 1,
+        "stream": True,
+        "presence_penalty": 0,
+        "frequency_penalty": 0,
     }
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {OPENAI_API_KEY}"
+    }
+    
+    response = requests.post(API_URL, headers=headers, json=payload, stream=True)
+    if response.status_code != 200:
+        yield "An error occurred."
+        return
+
+    partial_response = ""
+    
+    for chunk in response.iter_lines():
+        if not chunk:
+            continue
+        chunk_str = chunk.decode('utf-8')
+        if chunk_str.startswith("data: ") and chunk_str != "data: [DONE]":
+            try:
+                chunk_data = json.loads(chunk_str[6:])
+                delta = chunk_data['choices'][0]['delta']
+                if 'content' in delta:
+                    partial_response += delta['content']
+                    yield partial_response
+            except json.JSONDecodeError as e:
+                print(f"JSON parse error: {e} - Chunk: {chunk_str}")
+        elif chunk_str == "data: [DONE]":
+            break
+
+    # Generate TTS audio
+    audio_html = text_to_speech(partial_response)
+    
+    # Add audio to response if available
+    final_response = partial_response
+    if audio_html:
+        final_response += f'\n\n{audio_html}'
 
-    chat_response = client.chat.completions.create(**payload)
+    # Log: Add assistant response
+    try:
+        with file_lock:
+            with open(LOG_FILE, 'a', encoding='utf-8') as f:
+                f.write(f"Bot: {partial_response}\n")
+    except Exception as e:
+        print(f"File writing error (Bot): {e}")
 
-    text_response = chat_response.choices[0].message.content
+    # Update global history
+    with history_lock:
+        global_chat_history.append({"role": "user", "content": user_message})
+        global_chat_history.append({"role": "assistant", "content": partial_response})
+    
+    yield final_response
 
-    # TTS ses üretimi
-    response = client.audio.speech.create(
-        model="tts-1",
-        voice="nova",
-        input=text_response
-    )
+# Slow echo (for testing)
+def slow_echo(message, history):
+    for i in range(len(message)):
+        time.sleep(0.05)
+        yield "You typed: " + message[: i + 1]
 
-    audio_file_path = "tts_output.mp3"
-    response.stream_to_file(audio_file_path)
+# Usage mode
+USE_SLOW_ECHO = False
+chat_fn = slow_echo if USE_SLOW_ECHO else chatbot_fn
 
-    return text_response, audio_file_path
+if not USE_SLOW_ECHO:
+    scheduler_thread = threading.Thread(target=run_scheduler, args=(global_chat_history,), daemon=True)
+    scheduler_thread.start()
 
-# Gradio arayüzünü oluştur
-iface = gr.Interface(
-    fn=chatbot_fn_tts,
-    inputs=["text", "state"],
-    outputs=["text", gr.Audio(type="filepath")],
-    title="Trek GPT-4o Mini TTS Chatbot",
-    description="Yazdığınız mesaja hem metin hem sesli yanıt alırsınız."
+demo = gr.ChatInterface(
+    fn=chat_fn,
+    title="Trek Assistant with Text-to-Speech",
+    theme="default",
+    type="messages",
+    flagging_mode="manual",
+    flagging_options=["Correct", "Incorrect", "Not sure", "Other"],
+    save_history=True
 )
 
 if __name__ == "__main__":
-    iface.launch(debug=True)
+    demo.launch(debug=True)