Update app.py

app.py

@@ -1,21 +1,54 @@
 import gradio as gr
-from transformers import pipeline
-import openai
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 import random
-import os
 from datetime import datetime
 
 # Initialize sentiment analysis pipeline
 sentiment_analyzer = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
 
-# Retrieve OpenAI API key from Hugging Face secret
-openai.api_key = os.getenv("open_AI_API_key")
-
+# Initialize text generation model
+model_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name)
+text_generator = pipeline(
+    "text-generation",
+    model=model,
+    tokenizer=tokenizer,
+    max_new_tokens=50,
+    temperature=0.7,
+    top_p=0.9,
+    pad_token_id=tokenizer.eos_token_id
+)
 
 class JournalCompanion:
     def __init__(self):
         self.entries = []
     
+    def generate_prompts(self, sentiment):
+        prompt_template = f"""Generate three reflective journal prompts for someone feeling {sentiment.lower()}. 
+        Make them thoughtful and encouraging. Format them as a bullet point list."""
+        
+        try:
+            response = text_generator(prompt_template)[0]['generated_text']
+            # Extract the generated prompts after the input prompt
+            prompts = response[len(prompt_template):]
+            return "\n\nReflective Prompts:" + prompts
+        except Exception as e:
+            print("Error generating prompts:", e)
+            return "\n\nReflective Prompts:\n- What thoughts and feelings are you experiencing right now?\n- How has this experience affected you?\n- What would be helpful for you at this moment?"
+
+    def generate_affirmation(self, sentiment):
+        affirmation_template = f"Generate a short, encouraging affirmation for someone feeling {sentiment.lower()}."
+        
+        try:
+            response = text_generator(affirmation_template)[0]['generated_text']
+            # Extract the generated affirmation after the input prompt
+            affirmation = response[len(affirmation_template):].strip()
+            return affirmation
+        except Exception as e:
+            print("Error generating affirmation:", e)
+            return "I acknowledge my feelings and trust in my ability to handle this moment."
+
     def analyze_entry(self, entry_text):
         if not entry_text.strip():
             return ("Please write something in your journal entry.", "", "", "")
@@ -30,7 +63,7 @@ class JournalCompanion:
             return (
                 "An error occurred during analysis. Please try again.",
                 "Error",
-                "Could not generate prompts due to an error.",
+                "Could not analyze sentiment due to an error.",
                 "Could not generate affirmation due to an error."
             )
 
@@ -42,50 +75,14 @@ class JournalCompanion:
         }
         self.entries.append(entry_data)
 
-        # Generate dynamic responses using a language model
-        prompts = self.generate_dynamic_prompts(sentiment)
-        affirmation = self.generate_dynamic_affirmation(sentiment)
+        # Generate responses using TinyLlama
+        prompts = self.generate_prompts(sentiment)
+        affirmation = self.generate_affirmation(sentiment)
         sentiment_percentage = f"{sentiment_score * 100:.1f}%"
         message = f"Entry analyzed! Sentiment: {sentiment} ({sentiment_percentage} confidence)"
         
         return message, sentiment, prompts, affirmation
 
-    def generate_dynamic_prompts(self, sentiment):
-        prompt_request = f"Generate three reflective journal prompts for a person feeling {sentiment.lower()}."
-        try:
-            response = openai.ChatCompletion.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant."},
-                    {"role": "user", "content": prompt_request}
-                ],
-                max_tokens=60,
-                n=1
-            )
-            prompts = response.choices[0].message["content"].strip()
-        except Exception as e:
-            print("Error generating prompts:", e)
-            prompts = "Could not generate prompts at this time."
-        return prompts
-
-    def generate_dynamic_affirmation(self, sentiment):
-        affirmation_request = f"Generate an affirmation for someone who is feeling {sentiment.lower()}."
-        try:
-            response = openai.ChatCompletion.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant."},
-                    {"role": "user", "content": affirmation_request}
-                ],
-                max_tokens=20,
-                n=1
-            )
-            affirmation = response.choices[0].message["content"].strip()
-        except Exception as e:
-            print("Error generating affirmation:", e)
-            affirmation = "Could not generate an affirmation at this time."
-        return affirmation
-
     def get_monthly_insights(self):
         if not self.entries:
             return "No entries yet to analyze."
@@ -93,12 +90,32 @@ class JournalCompanion:
         total_entries = len(self.entries)
         positive_entries = sum(1 for entry in self.entries if entry["sentiment"] == "POSITIVE")
         
-        insights = f"""Monthly Insights:
+        # Generate insights using TinyLlama
+        insight_template = f"""Based on journal entries:
         Total Entries: {total_entries}
         Positive Entries: {positive_entries} ({(positive_entries / total_entries * 100):.1f}%)
         Negative Entries: {total_entries - positive_entries} ({((total_entries - positive_entries) / total_entries * 100):.1f}%)
-        """
-        return insights
+        
+        Generate a brief insight about this pattern."""
+        
+        try:
+            response = text_generator(insight_template)[0]['generated_text']
+            insights = response[len(insight_template):].strip()
+            return f"""Monthly Insights:
+            {insights}
+            
+            Statistics:
+            Total Entries: {total_entries}
+            Positive Entries: {positive_entries} ({(positive_entries / total_entries * 100):.1f}%)
+            Negative Entries: {total_entries - positive_entries} ({((total_entries - positive_entries) / total_entries * 100):.1f}%)
+            """
+        except Exception as e:
+            print("Error generating insights:", e)
+            return f"""Monthly Insights:
+            Total Entries: {total_entries}
+            Positive Entries: {positive_entries} ({(positive_entries / total_entries * 100):.1f}%)
+            Negative Entries: {total_entries - positive_entries} ({((total_entries - positive_entries) / total_entries * 100):.1f}%)
+            """
 
 def create_journal_interface():
     journal = JournalCompanion()
@@ -147,4 +164,4 @@ def create_journal_interface():
 
 if __name__ == "__main__":
     interface = create_journal_interface()
-    interface.launch()
+    interface.launch()