Update app.py

app.py

@@ -24,11 +24,10 @@ except ImportError:
 # ============== 1) OPENAI API İstemcisi ================
 client = OpenAI(api_key="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")
 
+
 def call_openai_chat(messages, max_tokens=10000, temperature=0.8):
     """
-    Tek seferde gpt-4o-mini modeline istek atar.
-    - max_tokens=10000 => uzun çıktı
-    - temperature=0.8 => daha yaratıcı/uzun
+    GPT-4o-mini modeline istek: max_tokens=10000 => uzun metinler
     """
     response = client.chat.completions.create(
         model="gpt-4o-mini",
@@ -39,249 +38,235 @@ def call_openai_chat(messages, max_tokens=10000, temperature=0.8):
     )
     return response.choices[0].message.content
 
-# ============== 2) CHUNK #1 ve #2 => (API Çağrısı #1) ================
-def heading1_part1_api_call(input_text):
+### 2) Heading 1 (chunk #1 + chunk #2) => API Call #1
+def heading1_part1_and_part2_api(input_text):
     """
-    Chunk #1 -> Heading 1 (Part 1)
-    Chunk #2 -> Heading 1 (Part 2) => finalize
-    İki chunk'ı tek fonksiyon içinde ardışık olarak çalıştıran 1 API call. 
-    Aslında 2 istek yapar ama mantıkta tek 'block' diyebiliriz.
+    Ilk cagirida Heading1 icin 2 chunk (part1, part2) uretilir.
+    1. chunk => partial text
+    2. chunk => finalize
     """
     # Chunk #1
-    user_prompt_1 = f"""
-We have some input. We want 'Heading 1: Introductory overview of input' in 2 parts.
-Now produce PART 1 of heading 1 (~1000+ words). Return partial text, do NOT finalize.
+    prompt1 = f"""
+We want Heading 1 in two parts. 
+PART 1: ~1000+ words introduction. 
+DO NOT finalize. 
 Input:
 {input_text}
 """
-    messages_1 = [
-        {"role": "system", "content": "You are an AI assistant creating heading 1 (part 1)."},
-        {"role": "user", "content": user_prompt_1}
+    msg1 = [
+        {"role": "system", "content": "You are an AI assistant creating heading1 part1."},
+        {"role": "user", "content": prompt1}
     ]
-    h1_part1_text = call_openai_chat(messages_1)
+    part1_text = call_openai_chat(msg1)
 
     # Chunk #2
-    user_prompt_2 = f"""
-We have partial heading 1:
-{h1_part1_text}
+    prompt2 = f"""
+We have partial heading1:
+{part1_text}
 
-Now finalize heading 1 (PART 2).
-Ensure total heading1 is at least 2000 words. 
-Add expansions or clarifications. Return the final heading1 text only.
+Now finalize heading1. Make sure total ~2000+ words. 
+Return final heading1 text only.
 """
-    messages_2 = [
+    msg2 = [
         {"role": "system", "content": "You are finalizing heading #1."},
-        {"role": "user", "content": user_prompt_2}
+        {"role": "user", "content": prompt2}
     ]
-    h1_final_text = call_openai_chat(messages_2)
+    heading1_text = call_openai_chat(msg2)
 
-    return h1_final_text
+    return heading1_text
 
-# ============== 3) CHUNK #3 ve #4 => (API Çağrısı #2) ================
-def heading2_3_api_call(heading1_text):
+### 3) Heading 2 + Heading 3 => API Call #2 (chunk #3 + chunk #4)
+def heading2_and_3_api(heading1_text):
     """
-    Chunk #3 => Heading 2
-    Chunk #4 => Heading 3
-    Tek fonksiyonda ardışık 2 istek => 2 chunk
+    Tek cagirida 2 chunk: 
+    - chunk#3 => heading2
+    - chunk#4 => heading3
     """
-    # Chunk #3 => Heading2
+    # Heading2
     prompt_h2 = f"""
-We have heading1 for context. Now produce 'Heading 2: Detailed explanation of common risks.'
-Aim ~1000+ words if possible. Return final heading2 text only.
-
+We have heading1 for context. 
+Produce 'Heading 2: Detailed explanation of common risks.'
+~1000+ words. Return only heading2 text.
 Context:
-{heading1_text}
+{heading1_text[:1500]}...
 """
-    messages_h2 = [
-        {"role": "system", "content": "You are an AI assistant creating heading2."},
+    msg_h2 = [
+        {"role": "system", "content": "You are AI assistant creating heading2."},
         {"role": "user", "content": prompt_h2}
     ]
-    heading2_text = call_openai_chat(messages_h2)
+    heading2_text = call_openai_chat(msg_h2)
 
-    # Chunk #4 => Heading3
+    # Heading3
     prompt_h3 = f"""
-We have heading1 for context. Now produce 'Heading 3: Practical examples and solutions.'
-Aim ~1000+ words if possible. Return final heading3 text only.
-
+We have heading1 for context. 
+Produce 'Heading 3: Practical examples and solutions.'
+~1000+ words. Return only heading3 text.
 Context:
-{heading1_text}
+{heading1_text[:1500]}...
 """
-    messages_h3 = [
-        {"role": "system", "content": "You are an AI assistant creating heading3."},
+    msg_h3 = [
+        {"role": "system", "content": "You are AI assistant creating heading3."},
         {"role": "user", "content": prompt_h3}
     ]
-    heading3_text = call_openai_chat(messages_h3)
+    heading3_text = call_openai_chat(msg_h3)
 
     return heading2_text, heading3_text
 
-# ============== 4) CHUNK #5 ve #6 => (API Çağrısı #3) ================
-def heading4_expansion_api_call(heading1_text, heading2_text, heading3_text, input_text):
+### 4) Heading4 + expansions => API Call #3 (chunk #5 + chunk #6)
+def heading4_and_expansion_api(h1_text, h2_text, h3_text, original_input):
     """
-    Chunk #5 => Heading4
-    Chunk #6 => expansions if <4000 words or shorten if >10000 words
+    - chunk#5 => heading4
+    - chunk#6 => expansions if <4000 words or shorten if >10000
     """
     # Chunk #5 => heading4
     prompt_h4 = f"""
-We have heading1,2,3. Now produce 'Heading 4: Summary and next steps for students.'
-At least 1000 words if possible. Return heading4 text only.
+We have heading1,2,3. Now produce heading4: 'Summary and next steps'
+At least ~1000 words. Return only heading4 text.
 Context:
-Heading1 = {heading1_text[:2000]}...
-Heading2 = ...
-Heading3 = ...
+{h1_text[:1200]}...
 """
-    messages_h4 = [
-        {"role": "system", "content": "You are an AI assistant creating heading4."},
+    msg_h4 = [
+        {"role": "system", "content": "You are AI assistant creating heading4."},
         {"role": "user", "content": prompt_h4}
     ]
-    heading4_text = call_openai_chat(messages_h4)
-
-    # Chunk #6 => expansions or shorten
-    prompt_expand = f"""
-We have 4 headings:
+    heading4_text = call_openai_chat(msg_h4)
 
+    # Chunk #6 => expansions/shorten
+    prompt_final = f"""
+We have 4 headings now:
 [Heading1]
-{heading1_text}
+{h1_text}
 
 [Heading2]
-{heading2_text}
+{h2_text}
 
 [Heading3]
-{heading3_text}
+{h3_text}
 
 [Heading4]
 {heading4_text}
 
-Now combine them into ONE final text. 
+Combine them into ONE final text. 
 If total < 4000 words => expand. 
-If > 10000 words => shorten. 
-Return final text only, merged. 
-Add expansions to any heading if short, or remove details if too long.
+If > 10000 => shorten. 
+Return final text only.
 
-Original input:
-{input_text}
+Original input for references:
+{original_input}
 """
-    messages_expand = [
-        {"role": "system", "content": "You are an AI assistant ensuring total word count 4000-10000."},
-        {"role": "user", "content": prompt_expand}
+    msg_final = [
+        {"role": "system", "content": "You are ensuring final text is 4000-10000 words."},
+        {"role": "user", "content": prompt_final}
     ]
-    final_text = call_openai_chat(messages_expand)
+    final_text = call_openai_chat(msg_final)
     return final_text
 
-# ============== Dosya Okuma Fonksiyonları ================
-def read_pdf(file_path: str) -> str:
-    text = ""
-    with open(file_path, "rb") as f:
+### 5) Dosya Okuma
+def read_pdf(path:str) -> str:
+    txt = ""
+    with open(path,"rb") as f:
         pdf = PdfReader(f)
         for page in pdf.pages:
-            txt = page.extract_text()
-            if txt:
-                text += txt
-    return text
-
-def read_docx(file_path: str) -> str:
-    doc = Document(file_path)
-    paragraphs = []
+            p_txt = page.extract_text()
+            if p_txt:
+                txt += p_txt
+    return txt
+
+def read_docx(path:str) -> str:
+    doc = Document(path)
+    result = []
     for para in doc.paragraphs:
-        paragraphs.append(para.text)
-    return "\n".join(paragraphs)
+        result.append(para.text)
+    return "\n".join(result)
 
-def read_txt(file_path: str) -> str:
-    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+def read_txt(path:str) -> str:
+    with open(path,"r",encoding="utf-8",errors="ignore") as f:
         return f.read()
 
-# ============== Gradio Fonksiyon ================
-def process_input_text(file_obj, txt):
+def read_input_file_or_text(file_obj, text_str):
     """
-    Dosya yüklenmişse okur, yoksa metin kutusunu alır
+    Gradio 'File' bileşeni => dictionary, .name, .data yoksa 
+    HF versiyonuna göre .get('data') vs.
     """
     if file_obj is not None:
-        # file_obj => gradio üzerinden 
-        filename = file_obj.name
-        content = file_obj.read()
-        with open(filename, "wb") as tmp:
-            tmp.write(content)
-
-        ext = filename.lower().split('.')[-1]
-        if ext == "pdf":
-            return read_pdf(filename)
-        elif ext == "docx":
-            return read_docx(filename)
-        elif ext == "txt":
-            return read_txt(filename)
+        file_name = file_obj.name
+        file_data = file_obj.get("data",None)
+        if not file_data:
+            # Bazı Gradio versiyonlarında file_obj kendisi string olabilir
+            # or "NamedString"
+            return file_obj.name or ""
+
+        with open(file_name, "wb") as tmp:
+            tmp.write(file_data)
+
+        ext = file_name.lower().split(".")[-1]
+        if ext=="pdf":
+            return read_pdf(file_name)
+        elif ext=="docx":
+            return read_docx(file_name)
+        elif ext=="txt":
+            return read_txt(file_name)
         else:
             # fallback decode
-            return content.decode("utf-8", errors="ignore")
+            return file_data.decode("utf-8", errors="ignore")
     else:
-        return txt.strip()
+        return text_str.strip()
 
-def main_pipeline(input_text):
+### 6) pipeline
+def main_pipeline(input_content):
     """
-    3 API çağrısı, 6 chunk:
-    1) heading1_part1_api_call => chunk #1, chunk #2
-    2) heading2_3_api_call => chunk #3, chunk #4
-    3) heading4_expansion_api_call => chunk #5, chunk #6
+    3 api call => 6 chunk
     """
-    # API Call #1 => chunk#1, chunk#2
-    heading1_text = heading1_part1_api_call(input_text)
-
-    # API Call #2 => chunk#3, chunk#4
-    heading2_text, heading3_text = heading2_3_api_call(heading1_text)
-
-    # API Call #3 => chunk#5, chunk#6
-    final_text = heading4_expansion_api_call(
-        heading1_text=heading1_text,
-        heading2_text=heading2_text,
-        heading3_text=heading3_text,
-        input_text=input_text
-    )
-
-    # HTML
-    final_html = final_text.replace("\n","<br>")
-    # Word count
-    plain = re.sub(r"<.*?>","", final_text)
-    wcount = len(plain.split())
+    # API Call #1 => heading1 (part1+part2)
+    heading1_text = heading1_part1_and_part2_api(input_content)
 
-    info = f"✅ Done. Final text has ~{wcount} words."
-    return final_html, info
+    # API Call #2 => heading2, heading3
+    heading2_text, heading3_text = heading2_and_3_api(heading1_text)
 
-def run_gradio_app(user_text, file):
-    content = process_input_text(file, user_text)
+    # API Call #3 => heading4 + expansions
+    final_text = heading4_and_expansion_api(
+        heading1_text, heading2_text, heading3_text, input_content
+    )
+    # Son
+    word_count = len(re.sub(r"<.*?>","", final_text).split())
+    return final_text, word_count
+
+### 7) Gradio Fonksiyon
+def run_app(user_text, user_file):
+    # Dosya veya metin
+    content = read_input_file_or_text(user_file, user_text)
     if not content:
         return ("⚠️ Please provide text or file input!", "")
 
-    final_html, info = main_pipeline(content)
+    # pipeline
+    final_text, wcount = main_pipeline(content)
+    final_html = final_text.replace("\n", "<br>")
+    info = f"✅ Done. The final text has approx {wcount} words."
     return (final_html, info)
 
-
-# ============== Gradio Arayüz ================
-def build_app():
-    text_input = gr.Textbox(
-        lines=5,
-        label="Text Input (Optional)",
-        placeholder="Write or paste text here..."
+### 8) Gradio Arayüz
+def build_gradio_interface():
+    txt_box = gr.Textbox(
+        lines=5, label="Text Input (optional)",
+        placeholder="Write/paste text here or upload .pdf/.docx/.txt"
     )
-    file_input = gr.File(
+    file_comp = gr.File(
         label="Upload PDF/DOCX/TXT",
         file_types=[".pdf",".docx",".txt"]
     )
-    output_html = gr.HTML(label="Final Output (4 headings, 4000-10000 words)")
-    info_label = gr.Label(label="Information")
+    out_html = gr.HTML(label="Final Output")
+    out_info = gr.Label(label="Process Info")
 
     demo = gr.Interface(
-        fn=run_gradio_app,
-        inputs=[text_input, file_input],
-        outputs=[output_html, info_label],
-        title="6-Chunks in 3 API Calls (gpt-4o-mini)",
-        description=(
-            "Human-coded example with 3 separate API calls to produce 6 chunks:\n"
-            "API #1 => chunk#1-2 (Heading1 in 2 parts)\n"
-            "API #2 => chunk#3-4 (Heading2 & Heading3)\n"
-            "API #3 => chunk#5-6 (Heading4 & expansions for 4000-10000 words range)\n"
-            "(No AI used in writing this code. It's purely developer-coded!)"
-        )
+        fn=run_app,
+        inputs=[txt_box, file_comp],
+        outputs=[out_html, out_info],
+        title="GPT-4o-mini 3-API-Calls, 6-chunk approach",
+        description="Human-coded example, 3 separate API calls => 6 chunks total. Ensures 4k-10k words."
     )
     return demo
 
-if __name__ == "__main__":
-    app = build_app()
-    app.launch()
+if __name__=="__main__":
+    # App
+    app = build_gradio_interface()
+    app.launch()