Update app.py

app.py

@@ -8,26 +8,71 @@ GROQ_API_KEY = "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"  # Rep
 os.environ["GROQ_API_KEY"] = GROQ_API_KEY
 client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
 
+# Helper Functions
 def add_human_noise(output_text):
     """
     Add subtle imperfections to make the text appear more human-like.
     """
-    noise_phrases = ["you know,", "honestly,", "to be fair,", "well,", "I think,"]
+    noise_phrases = [
+        "you know,", "like I said,", "to be honest,", "frankly,", 
+        "truth be told,", "I mean,", "well, honestly,", "if I'm being real,"
+    ]
+    filler_words = ["uh,", "um,", "so,", "well,", "I guess,"]
     sentences = output_text.split(". ")
     noisy_sentences = [
         f"{random.choice(noise_phrases)} {sentence}" if random.random() < 0.3 else sentence
         for sentence in sentences
     ]
+    noisy_sentences = [
+        f"{sentence} {random.choice(filler_words)}" if random.random() < 0.2 else sentence
+        for sentence in noisy_sentences
+    ]
     return ". ".join(noisy_sentences)
 
+def adjust_sentence_structure(output_text):
+    """
+    Break down longer sentences and introduce contractions or slight redundancies
+    to make the text feel less polished and more conversational.
+    """
+    long_sentence_threshold = 15  # Number of words to consider a sentence "long"
+    sentences = output_text.split(". ")
+    adjusted_sentences = []
+    
+    for sentence in sentences:
+        words = sentence.split()
+        if len(words) > long_sentence_threshold:
+            # Split long sentences into smaller ones
+            midpoint = len(words) // 2
+            adjusted_sentences.append(" ".join(words[:midpoint]) + ", you know,")
+            adjusted_sentences.append(" ".join(words[midpoint:]))
+        else:
+            adjusted_sentences.append(sentence)
+    
+    return ". ".join(adjusted_sentences)
+
+def add_rhetorical_asides(output_text):
+    """
+    Insert rhetorical asides or relatable human phrases into the text.
+    """
+    asides = [
+        "Don’t you think?", "Isn't that interesting?", 
+        "You see what I mean?", "Crazy, right?", "Makes sense, doesn't it?"
+    ]
+    sentences = output_text.split(". ")
+    modified_sentences = [
+        f"{sentence} {random.choice(asides)}" if random.random() < 0.2 else sentence
+        for sentence in sentences
+    ]
+    return ". ".join(modified_sentences)
+
 def refine_humanization(output_text, tone):
     """
     Refine text further for deeper humanization and introduce natural flow with slight noise.
     """
     refinement_prompt = (
-        f"Take the following text and refine it to feel truly human-like, smooth, and engaging. "
-        f"Ensure it flows naturally, uses conversational language, and introduces slight variations or imperfections. "
-        f"The tone should be {tone}. Refine this: {output_text}"
+        f"Take the following text and make it truly human-like, smooth, and conversational. "
+        f"Ensure it uses natural language, rhetorical questions, and slight imperfections. "
+        f"The tone should be {tone}. Here's the text: {output_text}"
     )
     try:
         refinement_response = client.chat.completions.create(
@@ -36,38 +81,12 @@ def refine_humanization(output_text, tone):
             stream=False,
         )
         refined_text = refinement_response.choices[0].message.content.strip()
-        return add_human_noise(refined_text)
+        refined_text = add_human_noise(refined_text)
+        refined_text = adjust_sentence_structure(refined_text)
+        return refined_text
     except Exception:
         return output_text  # Return original output if refinement fails
 
-def enforce_word_count_and_humanization(output_text, input_word_count, original_prompt, tone):
-    """
-    Ensure output text has a word count equal to or greater than the input word count
-    and passes humanization refinements.
-    """
-    output_words = output_text.split()
-    output_word_count = len(output_words)
-
-    # If output meets word count and humanization, return as is
-    if output_word_count >= input_word_count:
-        return refine_humanization(output_text, tone)
-
-    # If output is too short, regenerate with expansion
-    expansion_prompt = (
-        f"The response was too short. Expand the following text with more meaningful, detailed, and human-like content "
-        f"that flows naturally and matches the {tone} tone: {original_prompt}"
-    )
-    try:
-        expansion_response = client.chat.completions.create(
-            messages=[{"role": "user", "content": expansion_prompt}],
-            model="llama-3.3-70b-versatile",
-            stream=False,
-        )
-        expanded_text = expansion_response.choices[0].message.content.strip()
-        return refine_humanization(expanded_text, tone)
-    except Exception:
-        return output_text  # Return original output in case of error
-
 def split_text_into_chunks(text, max_words=500):
     """
     Split text into chunks of a maximum number of words.
@@ -90,10 +109,17 @@ task_option = st.radio(
     ("Humanize Text", "Rephrase Text"),
     index=0
 )
-
-# Optional Settings
 tone = st.selectbox("Select tone (for humanizing):", ["Casual", "Professional", "Neutral", "Engaging", "Friendly"])
 
+# Depth of Humanization
+humanization_depth = st.slider(
+    "Select depth of humanization:",
+    min_value=1,
+    max_value=5,
+    value=3,
+    help="Higher values introduce more layers of human-like imperfections."
+)
+
 # Generate Output
 if st.button("Generate Output"):
     if not input_text.strip():
@@ -122,13 +148,15 @@ if st.button("Generate Output"):
                         stream=False,
                     )
 
-                    # Extract and enforce word count and humanization
+                    # Extract and refine output
                     output_text = chat_completion.choices[0].message.content.strip()
-                    output_text = enforce_word_count_and_humanization(output_text, len(chunk.split()), task_prompt, tone)
+                    for _ in range(humanization_depth):
+                        output_text = refine_humanization(output_text, tone)
                     output_chunks.append(output_text)
 
                 # Combine processed chunks
                 final_output = " ".join(output_chunks)
+                final_output = add_rhetorical_asides(final_output)
                 output_word_count = len(final_output.split())
 
                 # Display Output