app.py

# import dependencies
import gradio as gr
from openai import OpenAI
import os
import random
import string

import nltk
from nltk.corpus import wordnet, stopwords
import random
import string

# Download necessary NLTK data
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
nltk.download('wordnet')
nltk.download('stopwords')

# define the openai key
api_key = os.getenv("OPENAI_API_KEY")

# make an instance of the openai client
client = OpenAI(api_key = api_key)

# finetuned model instance
finetuned_model = "gpt-3.5-turbo"







# text processing functions
def random_capitalize(word):
    if word.isalpha() and random.random() < 0.1:
        return word.capitalize()
    return word

def random_remove_punctuation(text):
    if random.random() < 0.2:
        text = list(text)
        indices = [i for i, c in enumerate(text) if c in string.punctuation]
        if indices:
            remove_indices = random.sample(indices, min(3, len(indices)))
            for idx in sorted(remove_indices, reverse=True):
                text.pop(idx)
        return ''.join(text)
    return text

def random_double_period(text):
    if random.random() < 0.2:
        text = text.replace('.', '..', 3)
    return text

def random_double_space(text):
    if random.random() < 0.2:
        words = text.split()
        for _ in range(min(3, len(words) - 1)):
            idx = random.randint(0, len(words) - 2)
            words[idx] += '  '
        return ' '.join(words)
    return text

def random_replace_comma_space(text, period_replace_percentage=0.33):

  # Count occurrences
  comma_occurrences = text.count(", ")
  period_occurrences = text.count(". ")

  # Replacements
  replace_count_comma = max(1, comma_occurrences // 3)
  replace_count_period = max(1, period_occurrences // 3)

  # Find indices
  comma_indices = [i for i in range(len(text)) if text.startswith(", ", i)]
  period_indices = [i for i in range(len(text)) if text.startswith(". ", i)]

  # Sample indices
  replace_indices_comma = random.sample(comma_indices, min(replace_count_comma, len(comma_indices)))
  replace_indices_period = random.sample(period_indices, min(replace_count_period, len(period_indices)))

  # Apply replacements
  for idx in sorted(replace_indices_comma + replace_indices_period, reverse=True):
    if text.startswith(", ", idx):
      text = text[:idx] + " ," + text[idx + 2:]
    if text.startswith(". ", idx):
      text = text[:idx] + " ." + text[idx + 2:]

  return text

def transform_paragraph(paragraph):
    words = paragraph.split()
    if len(words) > 12:
        words = [random_capitalize(word) for word in words]

        transformed_paragraph = ' '.join(words)
        transformed_paragraph = random_remove_punctuation(transformed_paragraph)
        transformed_paragraph = random_double_period(transformed_paragraph)
        transformed_paragraph = random_double_space(transformed_paragraph)
        transformed_paragraph = random_replace_comma_space(transformed_paragraph)
    else:
        transformed_paragraph = paragraph

    transformed_paragraph = transformed_paragraph.replace("#", "*")
    transformed_paragraph = transformed_paragraph.replace("*", "")
    # transformed_paragraph = transformed_paragraph.replace(", ", " ,")

    return transformed_paragraph

def transform_text(text):
    paragraphs = text.split('\n')
    transformed_paragraphs = [transform_paragraph(paragraph) for paragraph in paragraphs]
    return '\n'.join(transformed_paragraphs)

import nltk
from nltk.corpus import wordnet, stopwords

# Download necessary NLTK data (only needed once)
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
nltk.download('wordnet')
nltk.download('stopwords')

def get_synonyms(word):
    """Retrieve simple synonyms for a given word."""
    synonyms = set()
    for syn in wordnet.synsets(word):
        for lemma in syn.lemmas():
            synonym = lemma.name().replace('_', ' ')
            if synonym.isalpha() and len(synonym.split()) == 1 and len(synonym) <= 10:  # Filter out complex synonyms
                synonyms.add(synonym)
    return synonyms

def paraphrase_text(text, replace_ratio=0.6):
    """Paraphrase the input text by replacing words with synonyms."""
    words = text.split()
    stop_words = set(stopwords.words("english"))
    paraphrased_words = []

    for word in words:
        if random.random() < replace_ratio and word.lower() not in stop_words:  # Replace 60% of words
            synonyms = get_synonyms(word)
            if synonyms:
                paraphrased_words.append(random.choice(list(synonyms)))  # Pick a random synonym
            else:
                paraphrased_words.append(word)  # Keep original if no synonyms found
        else:
            paraphrased_words.append(word)  # Keep original for stopwords

    # Introduce small "human-like" errors
    text = " ".join(paraphrased_words)
    text = text.replace("  ", " ")  # Double spaces
    if random.random() < 0.1:
        text = text.replace(".", "..", 1)  # Double periods
    return text


import re

def humanize_text(AI_text):
    """Humanizes AI-generated text using GPT + Paraphrasing."""
    response = client.chat.completions.create(
        model=finetuned_model,  # This remains the same (gpt-3.5-turbo)
        temperature=1.1,  # Increased for more variation
        max_tokens=500,
        top_p=0.95,
        frequency_penalty=0.3,
        presence_penalty=0.5,
        messages=[
            {"role": "system", "content": """
            You are an advanced AI text rewriter that makes AI-generated text sound fully human-written.
            - Use natural synonyms, contractions, and varied sentence structures.
            - Restructure sentences to be complex and nuanced.
            - Avoid robotic phrasing or overly formal structures.
            - Ensure the text feels like it was written by a real person.
            """},
            {"role": "user", "content": f"Rewrite this text to make it more human:\n\n{AI_text}"}
        ]
    )

    gpt_output = response.choices[0].message.content.strip()
    
    # Apply additional paraphrasing to GPT output
    humanized_text = paraphrase_text(gpt_output)

    return humanized_text


# Define the main function to process text
def main_function(AI_text):
    return humanize_text(AI_text)  # Calls the GPT + Paraphrasing function

# Gradio interface definition
interface = gr.Interface(
  fn=main_function,
  inputs="textbox",
  outputs="textbox",
  title="AI Text Humanizer",
  description="Enter AI-generated text and get a human-written version. This space is availabe for limited time only so contact farhan.sid1111@gmail.com to put this application in production.",
)


# Launch the Gradio app
interface.launch(debug = True)






# import gradio as gr

# # Function to handle text submission
# def contact_info(text):
#     return "Contact farhan.sid1111@gmail.com for Humanizer Application service"

# # Gradio interface definition
# interface = gr.Interface(
#     fn=contact_info,
#     inputs="textbox",
#     outputs="text",
#     title="AI TEXT HUMANIZER",
#     description="Enter AI text and get its humanizer equivalent"
# )

# # Launch the Gradio app
# if __name__ == "__main__":
#     interface.launch()