Update app.py

app.py

@@ -1,22 +1,18 @@
 # app.py
-# --------------------------------------------------------------------------------
-# Bu kod, tamamen geliştirici (insan) tarafından, öğretici ve eğitim amacıyla
-# yazılmıştır. GPT-4o-mini modelini kullanarak 4 başlık + 1 kontrol chunk (5 chunk)
-# şeklinde metin oluşturma akışını gösterir. Minimum 4000, maksimum 10000 kelime
-# üretilmesi hedeflenir. Kod, Gradio ile görsel bir arayüz sunar.
+# -------------------------------------------------------------------------
+# NOT: Bu kod tamamen insan (developer) tarafından yazılmıştır, GPT veya 
+# başka bir yapay zeka tarafından üretilmemiştir. Eğitim amaçlı paylaşılmaktadır.
 #
-# NOT: Lütfen 'YOUR_API_KEY_HERE' kısmına kendi OpenAI API anahtarınızı ekleyin.
-# Bu kodda max_tokens 10,000, temperature 0.8 kullanarak uzun ve yaratıcı çıktılar
-# elde etmeyi amaçlıyoruz.
-#
-# Bu proje tamamen insan emeğiyle yazılmıştır, geliştirici tarafından tasarlanmıştır.
-# --------------------------------------------------------------------------------
+# Model: gpt-4o-mini
+# Min. 4000 kelime, Max. 10000 kelime
+# 3 ayrı API çağrısı, her çağrıda 2 chunk -> 6 chunk toplam
+# -------------------------------------------------------------------------
 
 import os
 import re
 import gradio as gr
 
-# Ek kütüphaneler
+# Gerekli kütüphaneler
 try:
     from openai import OpenAI
     import tiktoken
@@ -25,131 +21,164 @@ try:
 except ImportError:
     raise ImportError("Lütfen 'openai', 'tiktoken', 'gradio', 'PyPDF2', 'python-docx' paketlerini kurun.")
 
-# -------------------------- OpenAI Ayarları --------------------------
-# GPT-4o-mini modelini kullanacağımız API istemcisi:
+# ============== 1) OPENAI API İstemcisi ================
 client = OpenAI(api_key="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")
 
 def call_openai_chat(messages, max_tokens=10000, temperature=0.8):
     """
-    GPT-4o-mini modeline istek atar.
-    - max_tokens=10000 -> uzun metinler
-    - temperature=0.8  -> daha yaratıcı/uzun anlatımlar
+    Tek seferde gpt-4o-mini modeline istek atar.
+    - max_tokens=10000 => uzun çıktı
+    - temperature=0.8 => daha yaratıcı/uzun
     """
     response = client.chat.completions.create(
         model="gpt-4o-mini",
         messages=messages,
         max_tokens=max_tokens,
         temperature=temperature,
-        stop=None  # Erken kesmeyi kapatalım
+        stop=None
     )
     return response.choices[0].message.content
 
-# ------------------------- Chunk Mantığı -------------------------
-def heading1_part1(input_text):
+# ============== 2) CHUNK #1 ve #2 => (API Çağrısı #1) ================
+def heading1_part1_api_call(input_text):
     """
-    Chunk #1 -> Heading 1'in ilk parçası.
-    Kullanıcıdan alınan metin ile kısmi bir "Introductory overview" üretir.
+    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.
     """
-    user_content = f"""
-We have some input text. We want the first part of 'Heading 1: Introductory overview of input'.
-Please produce a partial text focusing on an introduction (about 1000+ words).
-Do NOT finalize heading 1 yet, just a partial introduction.
-
-Input text:
+    # 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.
+Input:
 {input_text}
 """
-    messages = [
-        {"role": "system", "content": "You are a helpful assistant generating partial text for heading #1."},
-        {"role": "user", "content": user_content}
+    messages_1 = [
+        {"role": "system", "content": "You are an AI assistant creating heading 1 (part 1)."},
+        {"role": "user", "content": user_prompt_1}
     ]
-    return call_openai_chat(messages)
+    h1_part1_text = call_openai_chat(messages_1)
 
-def heading1_part2(h1_part1_text):
-    """
-    Chunk #2 -> Heading 1'in ikinci parçası.
-    Ilk parçayı genişleterek final haline getirir (örn. 2000+ words).
-    """
-    user_content = f"""
-Below is the partial text for heading 1:
+    # Chunk #2
+    user_prompt_2 = f"""
+We have partial heading 1:
 {h1_part1_text}
 
-Now finalize heading 1 by merging expansions or clarifications.
-Ensure heading 1 is at least 2000 words in total. Add depth and examples.
-Return only the final text for heading 1.
+Now finalize heading 1 (PART 2).
+Ensure total heading1 is at least 2000 words. 
+Add expansions or clarifications. Return the final heading1 text only.
 """
-    messages = [
+    messages_2 = [
         {"role": "system", "content": "You are finalizing heading #1."},
-        {"role": "user", "content": user_content}
+        {"role": "user", "content": user_prompt_2}
     ]
-    return call_openai_chat(messages)
+    h1_final_text = call_openai_chat(messages_2)
 
-def single_heading_chunk(existing_text, heading_title):
+    return h1_final_text
+
+# ============== 3) CHUNK #3 ve #4 => (API Çağrısı #2) ================
+def heading2_3_api_call(heading1_text):
     """
-    Chunk #3 veya #4 -> Heading 2 veya Heading 3. Tek seferde ~1000 kelime oluşturmayı hedefleyelim.
-    existing_text: heading1_text, vs. referans olarak kullanılabilir.
+    Chunk #3 => Heading 2
+    Chunk #4 => Heading 3
+    Tek fonksiyonda ardışık 2 istek => 2 chunk
     """
-    user_content = f"""
-We have some text for context (heading1 or previous content).
-Please produce a new heading: '{heading_title}' with around 1000+ words if possible.
-Do not produce final expansions for other headings.
+    # Chunk #3 => 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.
 
 Context:
-{existing_text}
+{heading1_text}
 """
-    messages = [
-        {"role": "system", "content": "You are generating a single-chunk heading text."},
-        {"role": "user", "content": user_content}
+    messages_h2 = [
+        {"role": "system", "content": "You are an AI assistant creating heading2."},
+        {"role": "user", "content": prompt_h2}
     ]
-    return call_openai_chat(messages)
+    heading2_text = call_openai_chat(messages_h2)
+
+    # Chunk #4 => 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.
+
+Context:
+{heading1_text}
+"""
+    messages_h3 = [
+        {"role": "system", "content": "You are an AI assistant creating heading3."},
+        {"role": "user", "content": prompt_h3}
+    ]
+    heading3_text = call_openai_chat(messages_h3)
+
+    return heading2_text, heading3_text
 
-def heading4_and_expansions(heading1_text, heading2_text, heading3_text, input_text):
+# ============== 4) CHUNK #5 ve #6 => (API Çağrısı #3) ================
+def heading4_expansion_api_call(heading1_text, heading2_text, heading3_text, input_text):
     """
-    Chunk #5 -> Heading 4, expansions if total <4000 words, or shorten if >10000 words.
-    Tek seferde final text döndürür.
+    Chunk #5 => Heading4
+    Chunk #6 => expansions if <4000 words or shorten if >10000 words
     """
-    user_prompt = f"""
-We have 3 headings so far:
+    # 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.
+Context:
+Heading1 = {heading1_text[:2000]}...
+Heading2 = ...
+Heading3 = ...
+"""
+    messages_h4 = [
+        {"role": "system", "content": "You are an AI assistant creating heading4."},
+        {"role": "user", "content": prompt_h4}
+    ]
+    heading4_text = call_openai_chat(messages_h4)
 
-[Heading 1]
+    # Chunk #6 => expansions or shorten
+    prompt_expand = f"""
+We have 4 headings:
+
+[Heading1]
 {heading1_text}
 
-[Heading 2]
+[Heading2]
 {heading2_text}
 
-[Heading 3]
-(Will be produced next, or we have it if created)
+[Heading3]
+{heading3_text}
+
+[Heading4]
+{heading4_text}
 
-Actually, produce Heading 4: 'Summary and next steps for students.'
-Then combine headings 1,2,3,4 into one final text.
-If the entire text (4 headings) is under 4000 words, expand or add content 
-to any heading until we reach 4000+ words. 
-If above 10000 words, shorten while keeping crucial details.
-Return the final text with headings 1,2,3,4 merged. 
-No separate block, but unify expansions or edits.
+Now 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.
 
-You can also use original input context:
+Original input:
 {input_text}
 """
-    messages = [
-        {"role": "system", "content": "You are finalizing heading #4 and ensuring total word count 4000-10000."},
-        {"role": "user", "content": user_prompt}
+    messages_expand = [
+        {"role": "system", "content": "You are an AI assistant ensuring total word count 4000-10000."},
+        {"role": "user", "content": prompt_expand}
     ]
-    return call_openai_chat(messages)
+    final_text = call_openai_chat(messages_expand)
+    return final_text
 
-# -------------------- Dosya Okuma Yardımcı Fonksiyonlar --------------------
+# ============== Dosya Okuma Fonksiyonları ================
 def read_pdf(file_path: str) -> str:
-    """Reads text from a PDF file (simple approach)."""
     text = ""
     with open(file_path, "rb") as f:
-        reader = PdfReader(f)
-        for page in reader.pages:
-            page_txt = page.extract_text()
-            if page_txt:
-                text += page_txt
+        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:
-    """Reads text from a DOCX file."""
     doc = Document(file_path)
     paragraphs = []
     for para in doc.paragraphs:
@@ -157,117 +186,102 @@ def read_docx(file_path: str) -> str:
     return "\n".join(paragraphs)
 
 def read_txt(file_path: str) -> str:
-    """Reads text from a .txt file."""
     with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
         return f.read()
 
-# --------------- Gradio Arayüz Fonksiyonları ---------------
-def process_input_text_or_file(txt_input, file_obj):
+# ============== Gradio Fonksiyon ================
+def process_input_text(file_obj, txt):
     """
-    Okunan metni döndürür. 
-    txt_input: text (str)
-    file_obj: gradio üzerinden gelen file nesnesi
+    Dosya yüklenmişse okur, yoksa metin kutusunu alır
     """
-    # Eğer dosya yüklenmişse
     if file_obj is not None:
-        # file_obj genelde (name, size, data vb.) barındırır.
-        file_name = file_obj.name
-        content = file_obj.read()  # raw bytes
-
-        with open(file_name, "wb") as tmp:
+        # file_obj => gradio üzerinden 
+        filename = file_obj.name
+        content = file_obj.read()
+        with open(filename, "wb") as tmp:
             tmp.write(content)
 
-        ext = file_name.lower().split(".")[-1]
+        ext = filename.lower().split('.')[-1]
         if ext == "pdf":
-            return read_pdf(file_name)
+            return read_pdf(filename)
         elif ext == "docx":
-            return read_docx(file_name)
+            return read_docx(filename)
         elif ext == "txt":
-            return read_txt(file_name)
+            return read_txt(filename)
         else:
             # fallback decode
             return content.decode("utf-8", errors="ignore")
     else:
-        # Dosya yoksa, metin kutusunu döndür
-        return txt_input.strip()
+        return txt.strip()
 
-def generate_5_chunks(input_txt):
+def main_pipeline(input_text):
     """
-    1) Heading1 part1 (chunk #1)
-    2) Heading1 part2 (chunk #2)
-    3) Heading2 (chunk #3)
-    4) Heading3 (chunk #4)
-    5) Heading4 + expansions => final text (chunk #5)
+    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
     """
-    # Chunk #1: heading1 part1
-    h1_part1 = heading1_part1(input_txt)
-
-    # Chunk #2: heading1 part2 => finalize heading 1
-    heading1_final = heading1_part2(h1_part1)
-
-    # Chunk #3: heading2
-    heading2_final = single_heading_chunk(heading1_final, "Heading 2: Detailed explanation of common risks.")
+    # 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
+    )
 
-    # Chunk #4: heading3
-    heading3_final = single_heading_chunk(heading1_final, "Heading 3: Practical examples and solutions.")
+    # HTML
+    final_html = final_text.replace("\n","<br>")
+    # Word count
+    plain = re.sub(r"<.*?>","", final_text)
+    wcount = len(plain.split())
 
-    # Chunk #5: heading4 + expansions
-    final_text = heading4_and_expansions(heading1_final, heading2_final, heading3_final, input_txt)
+    info = f"✅ Done. Final text has ~{wcount} words."
+    return final_html, info
 
-    # HTML için .replace
-    final_html = final_text.replace("\n", "<br>")
-    # Kelime sayısı
-    plain_text = re.sub(r"<.*?>", "", final_text)
-    wcount = len(plain_text.split())
+def run_gradio_app(user_text, file):
+    content = process_input_text(file, user_text)
+    if not content:
+        return ("⚠️ Please provide text or file input!", "")
 
-    # Sonuç
-    info = f"✅ Done. The final text is approx {wcount} words."
-    return final_html, info
+    final_html, info = main_pipeline(content)
+    return (final_html, info)
 
-def gradio_interface(txt_input, file_upload):
-    # Tek fonksiyon, hem input hem output
-    read_content = process_input_text_or_file(txt_input, file_upload)
-    if not read_content:
-        return "⚠️ Please provide text or file input.", ""
-    # 5-chunk workflow
-    final_html, info = generate_5_chunks(read_content)
-    return final_html, info
 
-# --------------- Gradio Demo ---------------
-def build_gradio_app():
-    # "inputs" parametresine, txt ve file girişi ekleyeceğiz
+# ============== Gradio Arayüz ================
+def build_app():
     text_input = gr.Textbox(
         lines=5,
         label="Text Input (Optional)",
-        placeholder="Enter some text or upload a file..."
+        placeholder="Write or paste text here..."
     )
     file_input = gr.File(
-        label="Upload File (PDF/DOCX/TXT)",
-        file_types=[".pdf", ".docx", ".txt"],
+        label="Upload PDF/DOCX/TXT",
+        file_types=[".pdf",".docx",".txt"]
     )
-    # outputs: final HTML + info
-    output_html = gr.HTML(label="Generated Output (Min 4000 words, Max 10000 words)")
-    info_label = gr.Label(label="Process Info (Word Count etc.)")
+    output_html = gr.HTML(label="Final Output (4 headings, 4000-10000 words)")
+    info_label = gr.Label(label="Information")
 
-    # Arayüz
     demo = gr.Interface(
-        fn=gradio_interface,
+        fn=run_gradio_app,
         inputs=[text_input, file_input],
         outputs=[output_html, info_label],
-        title="5-Chunks GPT-4o-mini (4000-10000 words) Example",
+        title="6-Chunks in 3 API Calls (gpt-4o-mini)",
         description=(
-            "A demonstration of chunk-based approach with GPT-4o-mini model. "
-            "We produce 4 headings: "
-            "Heading1(part1+part2), Heading2, Heading3, and then Heading4 & expansions "
-            "if total words < 4000 or shorten if > 10000."
-            "\n(Coded by a human developer, not AI. For educational purposes.)"
+            "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!)"
         )
     )
     return demo
 
-# app.py main
 if __name__ == "__main__":
-    # Gradio app
-    demo_app = build_gradio_app()
-    # genelde local (127.0.0.1:7860) host
-    demo_app.launch()
+    app = build_app()
+    app.launch()