Update app.py

app.py

@@ -27,7 +27,9 @@ client = OpenAI(api_key="sk-proj-ALzSolLWgz2iSnP3jwT0kZSfRmLXn1cywJrCNwAq7Ys0cRr
 
 def call_openai_chat(messages, max_tokens=10000, temperature=0.8):
     """
-    GPT-4o-mini modeline istek: max_tokens=10000 => uzun metinler
+    gpt-4o-mini modeline istek atar.
+    - max_tokens=10000 => uzun metin
+    - temperature=0.8 => daha yaratıcı
     """
     response = client.chat.completions.create(
         model="gpt-4o-mini",
@@ -38,102 +40,103 @@ def call_openai_chat(messages, max_tokens=10000, temperature=0.8):
     )
     return response.choices[0].message.content
 
-### 2) Heading 1 (chunk #1 + chunk #2) => API Call #1
-def heading1_part1_and_part2_api(input_text):
+
+# ============== 2) Chunk Fonksiyonları ===============
+
+def heading1_part1_and_part2(input_text):
     """
-    Ilk cagirida Heading1 icin 2 chunk (part1, part2) uretilir.
-    1. chunk => partial text
-    2. chunk => finalize
+    API Çağrısı #1 => 2 chunk (Heading 1 Part1 + Part2)
+    Part1 ~1000 kelime, Part2 => final ~2000 kelime
     """
-    # Chunk #1
+    # chunk #1 => part1
     prompt1 = f"""
-We want Heading 1 in two parts. 
-PART 1: ~1000+ words introduction. 
-DO NOT finalize. 
+We want Heading 1 (introductory overview) in two parts.
+PART 1 => around 1000+ words. NOT final.
 Input:
 {input_text}
 """
-    msg1 = [
+    msgs1 = [
         {"role": "system", "content": "You are an AI assistant creating heading1 part1."},
         {"role": "user", "content": prompt1}
     ]
-    part1_text = call_openai_chat(msg1)
+    h1_part1 = call_openai_chat(msgs1)
 
-    # Chunk #2
+    # chunk #2 => part2 => finalize
     prompt2 = f"""
-We have partial heading1:
-{part1_text}
+Partial heading1:
+{h1_part1}
 
-Now finalize heading1. Make sure total ~2000+ words. 
-Return final heading1 text only.
+Now finalize heading1 with part2.
+Ensure total ~2000+ words. Return final heading1 only.
 """
-    msg2 = [
+    msgs2 = [
         {"role": "system", "content": "You are finalizing heading #1."},
         {"role": "user", "content": prompt2}
     ]
-    heading1_text = call_openai_chat(msg2)
+    heading1_final = call_openai_chat(msgs2)
+    return heading1_final
 
-    return heading1_text
 
-### 3) Heading 2 + Heading 3 => API Call #2 (chunk #3 + chunk #4)
 def heading2_and_3_api(heading1_text):
     """
-    Tek cagirida 2 chunk: 
-    - chunk#3 => heading2
-    - chunk#4 => heading3
+    API Çağrısı #2 => 2 chunk (Heading2, Heading3)
+    chunk #3 => heading2
+    chunk #4 => heading3
     """
-    # Heading2
+    # heading2
     prompt_h2 = f"""
 We have heading1 for context. 
-Produce 'Heading 2: Detailed explanation of common risks.'
-~1000+ words. Return only heading2 text.
-Context:
-{heading1_text[:1500]}...
+Produce 'Heading 2: Detailed explanation of common risks.' ~1000+ words.
+Return heading2 text only.
+Context sample:
+{heading1_text[:1500]}
 """
-    msg_h2 = [
-        {"role": "system", "content": "You are AI assistant creating heading2."},
+    msgs_h2 = [
+        {"role": "system", "content": "You are creating heading2."},
         {"role": "user", "content": prompt_h2}
     ]
-    heading2_text = call_openai_chat(msg_h2)
+    heading2_text = call_openai_chat(msgs_h2)
 
-    # Heading3
+    # heading3
     prompt_h3 = f"""
 We have heading1 for context. 
-Produce 'Heading 3: Practical examples and solutions.'
-~1000+ words. Return only heading3 text.
-Context:
-{heading1_text[:1500]}...
+Produce 'Heading 3: Practical examples and solutions.' ~1000+ words.
+Return heading3 text only.
+Context sample:
+{heading1_text[:1500]}
 """
-    msg_h3 = [
-        {"role": "system", "content": "You are AI assistant creating heading3."},
+    msgs_h3 = [
+        {"role": "system", "content": "You are creating heading3."},
         {"role": "user", "content": prompt_h3}
     ]
-    heading3_text = call_openai_chat(msg_h3)
+    heading3_text = call_openai_chat(msgs_h3)
 
     return heading2_text, heading3_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
+    API Çağrısı #3 => 2 chunk (Heading4, expansions/shorten)
+    chunk #5 => heading4
+    chunk #6 => expansions if <4000 words, or shorten if >10000
     """
-    # Chunk #5 => heading4
+    # chunk #5 => heading4
     prompt_h4 = f"""
-We have heading1,2,3. Now produce heading4: 'Summary and next steps'
-At least ~1000 words. Return only heading4 text.
-Context:
-{h1_text[:1200]}...
+We have heading1,2,3. 
+Produce 'Heading 4: Summary and next steps for students.' ~1000 words at least.
+Return heading4 only.
+Context sample:
+{h1_text[:1200]}
 """
-    msg_h4 = [
-        {"role": "system", "content": "You are AI assistant creating heading4."},
+    msgs_h4 = [
+        {"role": "system", "content": "You are creating heading4."},
         {"role": "user", "content": prompt_h4}
     ]
-    heading4_text = call_openai_chat(msg_h4)
+    heading4_text = call_openai_chat(msgs_h4)
 
-    # Chunk #6 => expansions/shorten
-    prompt_final = f"""
+    # chunk #6 => expansions or shorten
+    prompt_expand = f"""
 We have 4 headings now:
+
 [Heading1]
 {h1_text}
 
@@ -146,123 +149,87 @@ We have 4 headings now:
 [Heading4]
 {heading4_text}
 
-Combine them into ONE final text. 
+Combine them into one final text. 
 If total < 4000 words => expand. 
 If > 10000 => shorten. 
-Return final text only.
-
-Original input for references:
+Return final text only, merged. 
+Original input:
 {original_input}
 """
-    msg_final = [
-        {"role": "system", "content": "You are ensuring final text is 4000-10000 words."},
-        {"role": "user", "content": prompt_final}
+    msgs_expand = [
+        {"role": "system", "content": "You ensure final word count 4000-10000."},
+        {"role": "user", "content": prompt_expand}
     ]
-    final_text = call_openai_chat(msg_final)
+    final_text = call_openai_chat(msgs_expand)
     return final_text
 
-### 5) Dosya Okuma
-def read_pdf(path:str) -> str:
-    txt = ""
-    with open(path,"rb") as f:
-        pdf = PdfReader(f)
-        for page in pdf.pages:
-            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:
-        result.append(para.text)
-    return "\n".join(result)
-
-def read_txt(path:str) -> str:
-    with open(path,"r",encoding="utf-8",errors="ignore") as f:
-        return f.read()
-
-def read_input_file_or_text(file_obj, text_str):
-    """
-    Gradio 'File' bileşeni => dictionary, .name, .data yoksa 
-    HF versiyonuna göre .get('data') vs.
-    """
-    if file_obj is not None:
-        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 file_data.decode("utf-8", errors="ignore")
-    else:
-        return text_str.strip()
-
-### 6) pipeline
-def main_pipeline(input_content):
+# ============== 3) Pipeline (6 chunk, 3 API çağrısı) ==============
+
+def main_pipeline(input_txt):
     """
-    3 api call => 6 chunk
+    3 API Çağrısı:
+    1) heading1_part1_and_part2 => chunk #1 + #2
+    2) heading2_and_3_api => chunk #3 + #4
+    3) heading4_and_expansion_api => chunk #5 + #6
     """
-    # API Call #1 => heading1 (part1+part2)
-    heading1_text = heading1_part1_and_part2_api(input_content)
+    # API #1 => Heading1
+    heading1_text = heading1_part1_and_part2(input_txt)
 
-    # API Call #2 => heading2, heading3
+    # API #2 => Heading2, Heading3
     heading2_text, heading3_text = heading2_and_3_api(heading1_text)
 
-    # API Call #3 => heading4 + expansions
+    # API #3 => Heading4 + expansions
     final_text = heading4_and_expansion_api(
-        heading1_text, heading2_text, heading3_text, input_content
+        h1_text=heading1_text,
+        h2_text=heading2_text,
+        h3_text=heading3_text,
+        original_input=input_txt
     )
-    # Son
-    word_count = len(re.sub(r"<.*?>","", final_text).split())
-    return final_text, word_count
+    return final_text
+
+# ============== 4) Gradio Arayüz Fonksiyonları ==============
 
-### 7) Gradio Fonksiyon
-def run_app(user_text):
-    # Dosya veya metin
-    content = read_input_file_or_text(user_text)
-    if not content:
-        return ("⚠️ Please provide text", "")
+def run_pipeline(user_input_text):
+    """
+    Tek girdi: user_input_text (string).
+    Dönüş: final_html, info_label
+    """
+    if not user_input_text.strip():
+        return ("⚠️ Please provide some text!", "")
 
     # pipeline
-    final_text, wcount = main_pipeline(content)
-    final_html = final_text.replace("\n", "<br>")
-    info = f"✅ Done. The final text has approx {wcount} words."
+    final_text = main_pipeline(user_input_text)
+    # HTML
+    final_html = final_text.replace("\n","<br>")
+    # Word count
+    plain_text = re.sub(r"<.*?>","", final_text)
+    wcount = len(plain_text.split())
+
+    info = f"✅ Done. Final text ~{wcount} words (target 4000-10000)."
     return (final_html, info)
 
-### 8) Gradio Arayüz
-def build_gradio_interface():
-    txt_box = gr.Textbox(
-        lines=5, label="Transcript Input",
-    )
+def build_app():
+    text_input = gr.Textbox(
+        lines=5,
+        label="Input Text (Minimum 4000 words, maximum 10000 words in final result)",
+        placeholder="Paste or type your input text here..."
     )
-    out_html = gr.HTML(label="Final Output")
-    out_info = gr.Label(label="Process Info")
+    output_html = gr.HTML(label="Final Output")
+    output_info = gr.Label(label="Information (Word Count)")
 
     demo = gr.Interface(
-        fn=run_app,
-        inputs=[txt_box, file_comp],
-        outputs=[out_html, out_info],
-        title="GPT-4o-mini 3-API-Calls, 6-chunk approach",
-        description="3 separate API calls => 6 chunks total. Ensures 4k-10k words."
+        fn=run_pipeline,
+        inputs=text_input,
+        outputs=[output_html, output_info],
+        title="6 Chunks with 3 API Calls (gpt-4o-mini)",
+        description=(
+            "Human-coded example. 3 API calls, each producing 2 chunks => 6 total.\n"
+            "Heading1 in 2 parts, then heading2+3, then heading4+expansions.\n"
+            "Ensures at least 4000 words, max 10000 words.\n"
+        )
     )
     return demo
 
-if __name__=="__main__":
-    # App
-    app = build_gradio_interface()
+if __name__ == "__main__":
+    app = build_app()
     app.launch()