Update app.py

app.py

@@ -1,7 +1,10 @@
+```python
 import re
 import requests
 from bs4 import BeautifulSoup
-from duckduckgo_search import ddg
+# DuckDuckGo Search: use DDGS class
+from duckduckgo_search import DDGS
+# Google search
 from googlesearch import search as google_search
 # For Bing we use SerpAPI (requires SERPAPI_API_KEY env var)
 from serpapi import GoogleSearch as SerpBing
@@ -9,63 +12,71 @@ from rake_nltk import Rake
 import gradio as gr
 from transformers import pipeline
 
-# 1) Keyword extractor
+# 1) Keyword extractor using RAKE
 rake = Rake()
 def extract_keywords(text):
     rake.extract_keywords_from_text(text)
-    return [kw for kw, score in rake.get_ranked_phrases_with_scores()[:5]]
+    # return top 5 keywords
+    return [kw for kw in rake.get_ranked_phrases()[:5]]
 
 # 2) Search functions
+# DuckDuckGo using DDGS
+def ddg_search_links(query, num=5):
+    ddgs = DDGS()
+    results = ddgs.text(query, max_results=num)
+    # results are dicts with 'href'
+    return [r['href'] for r in results]
 
-def bing_search(query, api_key, num=5):
+def google_search_links(query, num=5):
+    return list(google_search(query, num_results=num))
+
+def bing_search_links(query, api_key, num=5):
     params = {"engine": "bing", "q": query, "api_key": api_key}
     client = SerpBing(params)
     results = client.get_dict().get('organic_results', [])
+    # filter sponsored and return links
     return [r['link'] for r in results if not r.get('sponsored')][:num]
 
-def google_search_links(query, num=5):
-    return list(google_search(query, num_results=num))
-
-def ddg_search_links(query, num=5):
-    return [r['href'] for r in ddg(query, max_results=num)]
-
-# 3) Fetch page text
-
+# 3) Fetch page text for summarization
 def fetch_text(url):
     try:
         resp = requests.get(url, timeout=3)
         soup = BeautifulSoup(resp.text, 'html.parser')
         texts = soup.find_all(['p', 'h1', 'h2', 'h3'])
-        return ' '.join([t.get_text() for t in texts])
+        return ' '.join(t.get_text() for t in texts)
     except:
         return ''
 
-# 4) Model loader
+# 4) Model loader: lightweight HF model
 generator = pipeline('text-generation', model='google/flan-t5-small', trust_remote_code=True)
 
 def model_answer(prompt):
     return generator(prompt, max_length=256, do_sample=False)[0]['generated_text']
 
-# 5) Check for forbidden search
-VERBOT = [
+# 5) Detect forbidden search phrases
+FORBID_PATTERNS = [
     "bitte nicht im internet suchen", "keine websuche", "mach das ohne web",
     "ohne online", "nur dein wissen", "nicht googeln", "such nicht"
 ]
-def search_forbidden(prompt):
+def search_forbidden(prompt: str) -> bool:
     pl = prompt.lower()
-    return any(v in pl for v in VERBOT)
+    return any(phrase in pl for phrase in FORBID_PATTERNS)
 
-# 6) Check uncertainty
-UNCERT = ["ich weiß nicht", "nicht in meinen daten", "keine information", "ich bin mir nicht sicher"]
-def is_uncertain(answer):
+# 6) Check if answer is uncertain
+UNCERTAIN_MARKERS = [
+    "ich weiß nicht", "nicht in meinen daten", "keine information", "ich bin mir nicht sicher"
+]
+def is_uncertain(answer: str) -> bool:
     al = answer.lower()
-    return any(u in al for u in UNCERT)
+    return any(marker in al for marker in UNCERTAIN_MARKERS)
 
-# 7) Combined logic
+# 7) Core processing logic
 def process(prompt, web_enabled, serpapi_key):
-    # Extract keywords
-    keys = extract_keywords(prompt)
-    # Base answer
+    # Extract keywords for search
+    keywords = extract_keywords(prompt)
+    query = ' '.join(keywords)
+
+    # If user forbids search
     if search_forbidden(prompt):
         ans = model_answer(prompt)
         if is_uncertain(ans):
@@ -75,39 +86,47 @@ def process(prompt, web_enabled, serpapi_key):
                 "aber es kann ungenau sein.\n\n" + ans
             )
         return ans
+
+    # If websearch disabled, just use model
     if not web_enabled:
         return model_answer(prompt)
-    # Web enabled, try model first
+
+    # Websearch enabled: model first
     ans = model_answer(prompt)
+    # If model confident, return
     if not is_uncertain(ans):
         return ans
-    # Uncertain: perform multi-search
-    # Google
-    g = google_search_links(' '.join(keys))
-    # DuckDuckGo
-    d = ddg_search_links(' '.join(keys))
-    # Bing
-    b = bing_search(' '.join(keys), serpapi_key)
-    urls = list(dict.fromkeys(g + d + b))
-    # Fetch and combine texts
-    texts = [fetch_text(u) for u in urls[:3]]
+
+    # Model uncertain: perform multi-search
+    links = []
+    links += google_search_links(query)
+    links += ddg_search_links(query)
+    links += bing_search_links(query, serpapi_key)
+    # Deduplicate
+    unique_links = list(dict.fromkeys(links))
+
+    # Fetch top 3 pages
+    texts = [fetch_text(u) for u in unique_links[:3]]
     combined = '\n'.join(texts)
-    # Summarize
-    summary = generator(combined, max_length=256)[0]['generated_text']
+    # Summarize combined content
+    summary = generator(combined, max_length=256, do_sample=False)[0]['generated_text']
     return summary
 
 # 8) Gradio UI
-def main(prompt, web_enabled, serpapi_key):
-    return process(prompt, web_enabled, serpapi_key)
-
 with gr.Blocks() as demo:
     gr.Markdown("# Intelligente KI mit Multi-Engine-Websuche")
     with gr.Row():
-        prompt = gr.Textbox(label="Dein Prompt", lines=3)
-        web = gr.Checkbox(label="Websuche aktivieren", value=False)
-    serp = gr.Textbox(label="SerpAPI Key (für Bing)", placeholder="Optional für Bing-Suche")
+        prompt_input = gr.Textbox(label="Dein Prompt", lines=3)
+        web_switch = gr.Checkbox(label="Websuche aktivieren", value=False)
+    serp_input = gr.Textbox(label="SerpAPI Key (für Bing)", placeholder="Optional für Bing-Suche")
     btn = gr.Button("Antwort generieren")
     output = gr.Textbox(label="Antwort", lines=10)
-    btn.click(main, inputs=[prompt, web, serp], outputs=output)
+
+    btn.click(
+        fn=process,
+        inputs=[prompt_input, web_switch, serp_input],
+        outputs=output
+    )
 
 demo.launch()
+```