app.py

import warnings
# Suppress FutureWarnings
warnings.filterwarnings("ignore", category=FutureWarning)

# --- Monkey Patch for Gradio Schema Parsing --- 
# This patch prevents APIInfoParseError by handling boolean schema values.
try:
    import gradio_client.utils as client_utils

    # Patch the helper function to handle bool types in the schema.
    original_json_schema_to_python_type = client_utils._json_schema_to_python_type

    def patched_json_schema_to_python_type(schema, defs=None):
        if isinstance(schema, bool):
            # If the schema is a boolean, simply return a generic type.
            return "Any"
        return original_json_schema_to_python_type(schema, defs)

    client_utils._json_schema_to_python_type = patched_json_schema_to_python_type

    # Also patch get_type to be extra safe.
    original_get_type = client_utils.get_type

    def patched_get_type(schema):
        if isinstance(schema, bool):
            return "Any"
        if not isinstance(schema, dict):
            return "Any"
        return original_get_type(schema)

    client_utils.get_type = patched_get_type

except Exception as e:
    print("Warning: Failed to patch gradio_client schema utils:", e)

import random
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import nltk
import gradio as gr
from nltk.sentiment import SentimentIntensityAnalyzer
from textblob import TextBlob
import torch
from transformers import (
    AutoTokenizer,
    AutoModelForCausalLM,
    AutoModelForSequenceClassification,
)

# Download necessary NLTK data
nltk.download("vader_lexicon", quiet=True)

# --- Emotion Analyzer ---
class EmotionalAnalyzer:
    def __init__(self):
        try:
            self.model = AutoModelForSequenceClassification.from_pretrained(
                "bhadresh-savani/distilbert-base-uncased-emotion"
            )
            self.tokenizer = AutoTokenizer.from_pretrained(
                "bhadresh-savani/distilbert-base-uncased-emotion"
            )
        except Exception:
            self.model = None
            self.tokenizer = None

        self.labels = ["sadness", "joy", "love", "anger", "fear", "surprise"]
        self.sia = SentimentIntensityAnalyzer()

    def predict_emotion(self, text):
        try:
            if self.model is None or self.tokenizer is None:
                raise ValueError("Model or tokenizer not initialized properly.")
            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
            with torch.no_grad():
                outputs = self.model(**inputs)
            probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
            return self.labels[torch.argmax(probs).item()]
        except Exception:
            return "Unknown"

    def analyze(self, text):
        try:
            vader_scores = self.sia.polarity_scores(text)
            blob = TextBlob(text)
            blob_data = {
                "polarity": blob.sentiment.polarity,
                "subjectivity": blob.sentiment.subjectivity,
                "word_count": len(blob.words),
                "sentence_count": len(blob.sentences),
            }
            return {
                "emotion": self.predict_emotion(text),
                "vader": vader_scores,
                "textblob": blob_data,
            }
        except Exception:
            return {"emotion": "Unknown", "vader": {}, "textblob": {}}

    def plot_emotions(self):
        try:
            simulated_emotions = {
                "joy": random.randint(10, 30),
                "sadness": random.randint(5, 20),
                "anger": random.randint(10, 25),
                "fear": random.randint(5, 15),
                "love": random.randint(10, 30),
                "surprise": random.randint(5, 20),
            }
            df = pd.DataFrame(list(simulated_emotions.items()), columns=["Emotion", "Percentage"])
            plt.figure(figsize=(8, 4))
            sns.barplot(x="Emotion", y="Percentage", data=df)
            plt.title("Simulated Emotional State")
            plt.tight_layout()
            path = "emotions.png"
            plt.savefig(path)
            plt.close()
            return path
        except Exception:
            return None  # Ensures that if there's an issue, we return None

# --- Text Completion LLM ---
tokenizer = AutoTokenizer.from_pretrained("diabolic6045/ELN-Llama-1B-base")
model = AutoModelForCausalLM.from_pretrained("diabolic6045/ELN-Llama-1B-base")

def generate_completion(message, temperature, max_length):
    try:
        inputs = tokenizer(message, return_tensors="pt", truncation=True, max_length=512)
        input_ids = inputs["input_ids"]
        current_text = message

        for _ in range(max_length - input_ids.shape[1]):
            with torch.no_grad():
                outputs = model(input_ids)
                logits = outputs.logits[:, -1, :] / temperature
                probs = torch.softmax(logits, dim=-1)
                next_token = torch.multinomial(probs, num_samples=1)

            if next_token.item() == tokenizer.eos_token_id:
                break

            input_ids = torch.cat([input_ids, next_token], dim=-1)
            new_token_text = tokenizer.decode(next_token[0], skip_special_tokens=True)
            current_text += new_token_text
        return current_text
    except Exception:
        return "Error generating text."

# --- Emotion-Aware LLM Response ---
def emotion_aware_response(input_text):
    try:
        analyzer = EmotionalAnalyzer()
        results = analyzer.analyze(input_text)
        image_path = analyzer.plot_emotions()  # This could return None if plotting fails

        prompt = (
            f"Input: {input_text}\n"
            f"Detected Emotion: {results['emotion']}\n"
            f"VADER Scores: {results['vader']}\n"
            f"Respond thoughtfully and emotionally aware:"
        )

        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
        with torch.no_grad():
            output_ids = model.generate(
                inputs.input_ids,
                max_length=512,
                do_sample=True,
                temperature=0.7,
                top_k=50,
                top_p=0.95,
                pad_token_id=tokenizer.eos_token_id
            )
        response = tokenizer.decode(output_ids[0], skip_special_tokens=True)

        summary = (
            f"Emotion: {results['emotion']}\n"
            f"VADER: {results['vader']}\n"
            f"TextBlob: {results['textblob']}\n\n"
            f"LLM Response:\n{response}"
        )
        return summary, image_path if image_path else None
    except Exception:
        return "Error processing emotion-aware response", None

# --- Gradio Interface ---
with gr.Blocks(title="ELN LLaMA 1B Enhanced Demo") as app:
    gr.Markdown("## 🧠 ELN-LLaMA Emotion-Aware & Completion Interface")
    
    with gr.Tab("💬 Emotion-Aware Response"):
        with gr.Row():
            input_text = gr.Textbox(label="Input Text", lines=4, placeholder="Type something with emotion or meaning...")
        with gr.Row():
            text_output = gr.Textbox(label="Response", lines=8)
            img_output = gr.Image(label="Emotional Visualization")
        emotion_btn = gr.Button("Generate Emotion-Aware Response")
        emotion_btn.click(emotion_aware_response, inputs=input_text, outputs=[text_output, img_output])

    with gr.Tab("📝 Text Completion"):
        comp_text = gr.Textbox(label="Prompt", lines=4)
        comp_temp = gr.Slider(minimum=0.1, maximum=1.0, value=0.7, label="Temperature")
        comp_len = gr.Slider(minimum=50, maximum=500, value=200, step=50, label="Max Length")
        comp_output = gr.Textbox(label="Generated Completion", lines=8)
        comp_button = gr.Button("Complete Text")
        comp_button.click(generate_completion, inputs=[comp_text, comp_temp, comp_len], outputs=comp_output)

# Launch the Gradio app (remove share=True if running in an environment that doesn't support it)
app.launch(share=True)