Update app.py

app.py

@@ -1,129 +1,76 @@
-import torch
-from transformers import pipeline
 import spacy
-import textwrap
-import streamlit as st
-import subprocess
-import networkx as nx
-import matplotlib.pyplot as plt
-import concurrent.futures
 import json
-import fitz  # PyMuPDF
+import pdfplumber
 import docx
 from bs4 import BeautifulSoup
+from io import StringIO
+import streamlit as st
 
-# Ensure spaCy model is downloaded
-def ensure_spacy_model():
-    try:
-        nlp = spacy.load("en_core_web_sm")
-    except OSError:
-        subprocess.run(["python", "-m", "spacy", "download", "en_core_web_sm"])
-        nlp = spacy.load("en_core_web_sm")
-    return nlp
-
-# Load sentiment analysis model
-sentiment_pipeline = pipeline("sentiment-analysis")
-
-# Load spaCy model for Named Entity Recognition (NER)
-nlp = ensure_spacy_model()
+nlp = spacy.load("en_core_web_sm")
+nlp.max_length = 50_000_000  # Increase max length to handle large texts
 
 def extract_text_from_file(uploaded_file):
-    """Extracts text from various file types."""
+    """Extract text from various file formats."""
     file_type = uploaded_file.name.split(".")[-1].lower()
-    text = ""
     
     if file_type == "txt":
-        text = uploaded_file.read().decode("utf-8").strip()
+        text = uploaded_file.getvalue().decode("utf-8")
+    
     elif file_type == "html":
-        soup = BeautifulSoup(uploaded_file.read(), "html.parser")
+        soup = BeautifulSoup(uploaded_file.getvalue(), "html.parser")
         text = soup.get_text()
+    
     elif file_type == "json":
         data = json.load(uploaded_file)
-        text = "\n".join(map(str, data.values())) if isinstance(data, dict) else "\n".join(map(str, data))
+        text = "\n".join(str(value) for value in data.values()) if isinstance(data, dict) else json.dumps(data)
+    
     elif file_type == "pdf":
-        doc = fitz.open(stream=uploaded_file.read(), filetype="pdf")
-        text = "\n".join([page.get_text("text") for page in doc])
+        text = ""
+        with pdfplumber.open(uploaded_file) as pdf:
+            for page in pdf.pages:
+                text += page.extract_text() + "\n"
+    
     elif file_type == "docx":
         doc = docx.Document(uploaded_file)
         text = "\n".join([para.text for para in doc.paragraphs])
-    else:
-        st.error("Unsupported file format. Please upload a TXT, HTML, JSON, PDF, or DOCX file.")
-        return None
     
-    return text.strip()
+    else:
+        raise ValueError("Unsupported file format")
 
-def parse_chat_log(chat_text):
-    """Parses chat logs to extract speaker names and messages."""
-    chat_lines = chat_text.split("\n")
-    chat_data = []
-    for line in chat_lines:
-        if ":" in line:
-            speaker, message = line.split(":", 1)
-            chat_data.append((speaker.strip(), message.strip()))
-    return chat_data
+    return text
 
-def analyze_sentiment(messages):
-    """Analyzes sentiment of messages."""
-    results = sentiment_pipeline(messages)
-    return [res['label'] for res in results]
+def infer_relationships(chat_data):
+    """Process large text inputs in chunks to avoid memory issues."""
+    relationship_scores = []
+    max_chars = 1_000_000  # Keep within spaCy's safe limits
 
-def detect_humor(messages):
-    """Detects humor based on laughter-related keywords."""
-    humor_keywords = {"lol", "haha", "lmao", "rofl", "😂", "🤣"}
-    humor_count = {}
-    for speaker, message in messages:
-        count = sum(1 for word in humor_keywords if word in message.lower())
-        humor_count[speaker] = humor_count.get(speaker, 0) + count
-    return humor_count
+    for i in range(0, len(chat_data), max_chars):
+        chunk = chat_data[i : i + max_chars]
+        doc = nlp(chunk)  # Process each chunk separately
+        relationship_scores.append(analyze_relationships(doc))
 
-def infer_relationships(messages):
-    """Infers relationships based on interactions."""
-    relationship_scores = {}
-    for speaker, message in messages:
-        doc = nlp(message)
-        for ent in doc.ents:
-            if ent.label_ == "PERSON":
-                key = tuple(sorted([speaker, ent.text]))
-                relationship_scores[key] = relationship_scores.get(key, 0) + 1
     return relationship_scores
 
-def generate_graph(relationships):
-    """Generates a graph of relationships."""
-    G = nx.Graph()
-    for (p1, p2), weight in relationships.items():
-        G.add_edge(p1, p2, weight=weight)
-    plt.figure(figsize=(8, 6))
-    pos = nx.spring_layout(G)
-    nx.draw(G, pos, with_labels=True, node_size=3000, node_color="lightblue", edge_color="gray")
-    st.pyplot(plt)
+def analyze_relationships(doc):
+    """Placeholder function for analyzing relationships in text."""
+    return {"entities": [(ent.text, ent.label_) for ent in doc.ents]}
 
 def main():
-    st.title("Chat Affinity Analyzer")
-    st.write("Upload a chat log to analyze affinity between participants.")
-    uploaded_file = st.file_uploader("Choose a chat log (TXT, HTML, JSON, PDF, DOCX)", type=["txt", "html", "json", "pdf", "docx"])
+    st.title("Chat Relationship Analyzer")
+
+    uploaded_file = st.file_uploader("Upload a file", type=["txt", "html", "json", "pdf", "docx"])
     
     if uploaded_file is not None:
-        chat_text = extract_text_from_file(uploaded_file)
-        if not chat_text:
-            st.error("Error: No valid chat messages found.")
-            return
-        
-        chat_data = parse_chat_log(chat_text)
-        humor_scores = detect_humor(chat_data)
-        relationship_scores = infer_relationships(chat_data)
-        
-        st.subheader("Funniest Person")
-        if humor_scores:
-            funniest = max(humor_scores, key=humor_scores.get)
-            st.write(f"😂 {funniest} is the funniest with {humor_scores[funniest]} laugh reactions!")
-        else:
-            st.write("No humor detected.")
-        
-        st.subheader("Relationship Graph")
-        if relationship_scores:
-            generate_graph(relationship_scores)
-        else:
-            st.write("No relationships detected.")
+        try:
+            chat_text = extract_text_from_file(uploaded_file)
+            if len(chat_text) > nlp.max_length:
+                st.warning("Text is too long. Processing in chunks.")
+
+            relationship_scores = infer_relationships(chat_text)
+            st.json(relationship_scores)
+
+        except Exception as e:
+            st.error(f"Error: {e}")
 
 if __name__ == "__main__":
     main()