Upload 7 files

app.py

@@ -0,0 +1,120 @@
+
+import streamlit as st
+from task_operations import TaskManager
+from task_visualization import TaskVisualizer
+from llm_part import get_task_advice  # Import the LLM advice function
+import pandas as pd
+from datetime import datetime
+
+def main():
+    st.title("Daily Task Tracker")
+
+    task_manager = TaskManager()
+    visualizer = TaskVisualizer()
+
+    # Ensure tasks are loaded from the database into session state
+    if 'tasks' not in st.session_state:
+        st.session_state.tasks = task_manager.load_tasks()
+
+    # Task input fields
+    task_name = st.text_input("Task Name")
+    task_time = st.time_input("Task Time")
+    task_duration_hours = st.number_input("Task Duration (Hours)", min_value=0, step=1, format="%d")
+    task_duration_minutes = st.number_input("Task Duration (Minutes)", min_value=0, max_value=59, step=1, format="%d")
+    task_category = st.selectbox("Task Category", TaskManager.CATEGORIES)
+
+    # Create a button to add the task
+    if st.button("Add Task"):
+        # Add the task to the task manager
+        task_manager.add_task(task_name, task_time, task_duration_hours, task_duration_minutes, task_category)
+        st.success(f"Task '{task_name}' added!")
+
+        # Get advice from both LLMs
+        advice_gemini, advice_llama = get_task_advice(task_name, task_category, task_duration_hours, task_duration_minutes)
+
+        # Store the responses in session state
+        st.session_state.advice_gemini = advice_gemini
+        st.session_state.advice_llama = advice_llama
+
+        # Create tabs for LLM advice display
+        tab1, tab2 = st.tabs(["Gemini LLM", "Llama LLM"])
+
+        with tab1:
+            st.header("Gemini LLM")
+            st.write("**Gemini Advice:**")
+            st.write(st.session_state.advice_gemini)
+
+        with tab2:
+            st.header("Llama LLM")
+            st.write("**Llama Advice:**")
+            st.write(st.session_state.advice_llama)
+
+    # Display tasks for today only
+    if st.session_state.tasks:
+        st.write("Today's Tasks:")
+
+        # Convert session tasks to DataFrame and filter tasks for today
+        df = pd.DataFrame(st.session_state.tasks)
+        df['Task Time'] = pd.to_datetime(df['Task Time'])
+        today_tasks = df[df['Task Time'].dt.date == datetime.today().date()]
+
+        if not today_tasks.empty:
+            st.table(today_tasks[['Task ID', 'Task Name', 'Task Time', 'Task Duration (hours)', 
+                                  'Task Duration (minutes)', 'Category']])
+        else:
+            st.write("No tasks for today.")
+
+        # Task deletion option by ID
+        task_id_to_delete = st.number_input("Enter Task ID to Delete", min_value=0, step=1)
+        if st.button("Delete Task by ID"):
+            if task_manager.delete_task_by_id(task_id_to_delete):
+                st.success(f"Task with ID '{task_id_to_delete}' deleted!")
+            else:
+                st.error(f"Task with ID '{task_id_to_delete}' not found.")
+
+    # Report options and other visualizations remain unchanged
+    if st.button("Daily Report"):
+        report = task_manager.generate_report('daily')
+        if not report.empty:
+            st.write("Daily Report:")
+            st.dataframe(report)
+            visualizer.plot_category_performance('daily', task_manager)
+        else:
+            st.warning("No tasks for today.")
+
+    if st.button("Weekly Report"):
+        report = task_manager.generate_report('weekly')
+        if not report.empty:
+            st.write("Weekly Report:")
+            st.dataframe(report)
+            visualizer.plot_category_performance('weekly', task_manager)
+        else:
+            st.warning("No tasks for this week.")
+
+    if st.button("Monthly Report"):
+        report = task_manager.generate_report('monthly')
+        if not report.empty:
+            st.write("Monthly Report:")
+            st.dataframe(report)
+            visualizer.plot_category_performance('monthly', task_manager)
+        else:
+            st.warning("No tasks for this month.")
+
+    if st.button("Yearly Report"):
+        report = task_manager.generate_report('yearly')
+        if not report.empty:
+            st.write("Yearly Report:")
+            st.dataframe(report)
+            visualizer.plot_category_performance('yearly', task_manager)
+        else:
+            st.warning("No tasks for this year.")
+
+    # Performance visualizations
+    visualizer.plot_performance()
+    visualizer.plot_overall_category_performance()
+
+    # Option to download the report
+    visualizer.download_report()
+
+if __name__ == "__main__":
+    main()

llm_part.py

@@ -0,0 +1,100 @@
+# llm_part.py
+import os
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from secret_key import gemeni_key, llama_key
+from datetime import datetime
+
+# Initialize LLM models
+llm_1 = ChatGoogleGenerativeAI(model="gemini-pro", api_key=gemeni_key)
+llm_2 = ChatGroq(model="llama3-groq-70b-8192-tool-use-preview", groq_api_key=llama_key)
+
+# Prayer times for the current day only (Fajr, Dhuhr, Asr, Maghrib, Isha)
+prayer_times = {
+    "Fajr": "04:30",
+    "Dhuhr": "11:45",
+    "Asr": "15:30",
+    "Maghrib": "17:45",
+    "Isha": "19:00"
+}
+
+# Define the next prayer function
+def get_next_prayer(current_time):
+    # Retrieve today's prayer times
+    times = list(prayer_times.values())
+    prayer_names = list(prayer_times.keys())
+
+    # Current time in comparable format
+    current_hour = current_time.hour
+    current_minute = current_time.minute
+
+    for prayer, time_str in zip(prayer_names, times):
+        prayer_hour, prayer_minute = map(int, time_str.split(':'))
+        if (prayer_hour > current_hour) or (prayer_hour == current_hour and prayer_minute > current_minute):
+            return prayer, time_str  # Return both prayer name and time
+        
+    return "Isha", times[-1]  
+
+
+templates = {
+    "Learning": "You just completed a learning task: {task_name}. You studied for {hours} hours and {minutes} minutes. "
+                "Can you suggest improvements to my learning process? What should I learn next?",
+    
+    "Gym": "You completed a gym task: {task_name}. It lasted {hours} hours and {minutes} minutes. "
+           "How can I optimize my workout? What should I focus on next time in the gym?",
+    
+    "Personal": "I just completed a personal task: {task_name}. It took me {hours} hours and {minutes} minutes. "
+                "What advice can you give for better time management or improvement?",
+    
+    "Work": "I completed a work-related task: {task_name}, which lasted {hours} hours and {minutes} minutes. "
+            "Can you suggest ways to improve my work efficiency? What should I work on next?",
+    
+    "Prayer": "You completed a prayer task: {task_name}. It took you {hours} hours and {minutes} minutes. "
+              "What practical steps can I take to deepen my spiritual connection during Salah (prayer)?"
+              "Please provide specific traditions and teachings for the next prayer, **{next_prayer}**, which is at **{next_time}**. "
+              "Format your response as bullet points for clarity."
+}
+
+# Function to select a template based on the task category
+def get_template(category):
+    return templates.get(category, "You just completed the task: {task_name}. It took {hours} hours and {minutes} minutes. "
+                                   "What advice can you give? What is the next most productive task?")
+
+# Template function to generate advice and next task recommendations for each task
+def get_task_advice(task_name, task_category, hours, minutes):
+    # Get the template based on the category
+    template_str = get_template(task_category)
+
+    # Determine the next prayer and its time
+    current_time = datetime.now()
+    next_prayer, next_time = get_next_prayer(current_time)
+
+    # Create the prompt
+    prompt_template = PromptTemplate(
+        input_variables=["task_name", "hours", "minutes", "next_prayer", "next_time"],
+        template=template_str
+    )
+    
+    prompt = prompt_template.format(task_name=task_name, hours=hours, minutes=minutes, 
+                                     next_prayer=next_prayer, next_time=next_time)
+
+    # Set up LLMChain for both models
+    chain_1 = LLMChain(llm=llm_1, prompt=prompt_template)
+    chain_2 = LLMChain(llm=llm_2, prompt=prompt_template)
+
+    try:
+        # Run the LLMChain to get the responses
+        response_llm1 = chain_1.run({"task_name": task_name, "hours": hours, "minutes": minutes, 
+                                       "next_prayer": next_prayer, "next_time": next_time})
+    except Exception as e:
+        response_llm1 = f"Error generating response from Gemini: {str(e)}"
+    
+    try:
+        response_llm2 = chain_2.run({"task_name": task_name, "hours": hours, "minutes": minutes, 
+                                       "next_prayer": next_prayer, "next_time": next_time})
+    except Exception as e:
+        response_llm2 = f"Error generating response from Llama: {str(e)}"
+    
+    return response_llm1, response_llm2

requirements.txt

@@ -0,0 +1,6 @@
+pandas
+matplotlib
+langchain
+langchain-google-genai
+langchain-groq
+langchain_community

secret_key.py

@@ -0,0 +1,2 @@
+gemeni_key="AIzaSyCLyDgZNcE_v4wLMFF8SoimKga9bbLSun0"
+llama_key="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"

task_operations.py

@@ -0,0 +1,112 @@
+# components/task_operations.py
+
+import sqlite3
+import pandas as pd
+from datetime import datetime
+import streamlit as st
+
+class TaskManager:
+    DB_FILE = "tasks.db"
+    CATEGORIES = ['Learning', 'Gym', 'Personal', 'Family', 'Work', 'Prayer']
+
+    def __init__(self):
+        self.conn = sqlite3.connect(self.DB_FILE)
+        self.create_table()
+
+    def create_table(self):
+        # Create tasks table with essential fields
+        query = """
+        CREATE TABLE IF NOT EXISTS tasks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            task_name TEXT NOT NULL,
+            task_time TEXT NOT NULL,
+            task_duration_hours INTEGER NOT NULL,
+            task_duration_minutes INTEGER NOT NULL,
+            category TEXT NOT NULL
+        );
+        """
+        self.conn.execute(query)
+        self.conn.commit()
+
+    def load_tasks(self):
+        # Load tasks from the database
+        query = "SELECT * FROM tasks;"
+        df = pd.read_sql_query(query, self.conn)
+
+        if not df.empty:
+            # Rename columns explicitly to avoid conflicts
+            column_mapping = {
+                'task_name': 'Task Name', 
+                'task_time': 'Task Time',
+                'task_duration_hours': 'Task Duration (hours)',
+                'task_duration_minutes': 'Task Duration (minutes)', 
+                'category': 'Category', 
+                'id': 'Task ID'
+            }
+
+            # Check for any conflicts before renaming
+            existing_columns = set(df.columns)
+            for original, new_name in column_mapping.items():
+                if new_name in existing_columns and original != new_name:
+                    raise ValueError(f"Conflict detected: Column '{new_name}' already exists in the DataFrame.")
+
+            # Rename columns in the DataFrame
+            df.rename(columns=column_mapping, inplace=True)
+
+            # Convert 'task_time' to datetime after renaming
+            df['Task Time'] = pd.to_datetime(df['Task Time'])
+
+            return df.to_dict(orient='records')
+        else:
+            return []
+
+    def save_task(self, task):
+        # Save task into the database
+        query = """
+        INSERT INTO tasks (task_name, task_time, task_duration_hours, task_duration_minutes, category)
+        VALUES (?, ?, ?, ?, ?);
+        """
+        self.conn.execute(query, (task['Task Name'], task['Task Time'], task['Task Duration (hours)'], 
+                                  task['Task Duration (minutes)'], task['Category']))
+        self.conn.commit()
+
+    def add_task(self, task_name, task_time, task_duration_hours, task_duration_minutes, task_category):
+        task_time_full = datetime.combine(datetime.today(), task_time)
+        task_entry = {
+            "Task Name": task_name,
+            "Task Time": task_time_full,
+            "Task Duration (hours)": int(task_duration_hours),
+            "Task Duration (minutes)": int(task_duration_minutes),
+            "Category": task_category
+        }
+        self.save_task(task_entry)
+        st.session_state.tasks.append(task_entry)
+
+    def delete_task_by_id(self, task_id):
+        # Delete task by its ID
+        query = "DELETE FROM tasks WHERE id = ?;"
+        self.conn.execute(query, (task_id,))
+        self.conn.commit()
+        return True
+
+    def generate_report(self, timeframe):
+        df = pd.DataFrame(self.load_tasks())
+        if df.empty:
+            return pd.DataFrame()
+
+        df['Task Time'] = pd.to_datetime(df['Task Time'])
+
+        if timeframe == 'daily':
+            report = df[df['Task Time'].dt.date == pd.Timestamp.today().date()]
+        elif timeframe == 'weekly':
+            week_start = pd.Timestamp.today() - pd.DateOffset(days=pd.Timestamp.today().dayofweek)
+            report = df[(df['Task Time'] >= week_start) & (df['Task Time'] < pd.Timestamp.today() + pd.DateOffset(days=1))]
+        elif timeframe == 'monthly':
+            report = df[df['Task Time'].dt.month == pd.Timestamp.today().month]
+        elif timeframe == 'yearly':
+            report = df[df['Task Time'].dt.year == pd.Timestamp.today().year]
+        else:
+            report = pd.DataFrame()
+
+        report['Total Duration'] = report['Task Duration (hours)'] + report['Task Duration (minutes)'] / 60.0
+        return report

task_visualization.py

@@ -0,0 +1,54 @@
+# components/task_visualization.py
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import streamlit as st
+
+class TaskVisualizer:
+    def plot_performance(self):
+        df = pd.DataFrame(st.session_state.tasks)
+        df['Total Duration'] = df['Task Duration (hours)'] + df['Task Duration (minutes)'] / 60.0
+
+        plt.figure(figsize=(10, 5))
+        task_times = df.groupby('Task Name')['Total Duration'].sum()
+        task_times.plot(kind='bar')
+        plt.xlabel('Task')
+        plt.ylabel('Hours Spent')
+        plt.title('Overall Task Performance')
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        st.pyplot(plt)
+
+    def plot_category_performance(self, timeframe, task_manager):
+        report = task_manager.generate_report(timeframe)
+        if not report.empty:
+            category_times = report.groupby('Category')['Total Duration'].sum()
+
+            plt.figure(figsize=(10, 5))
+            category_times.plot(kind='bar', color='skyblue')
+            plt.xlabel('Category')
+            plt.ylabel('Total Hours Spent')
+            plt.title(f'Task Performance by Category - {timeframe.capitalize()} Report')
+            plt.xticks(rotation=45)
+            plt.tight_layout()
+            st.pyplot(plt)
+
+    def plot_overall_category_performance(self):
+        df = pd.DataFrame(st.session_state.tasks)
+        df['Total Duration'] = df['Task Duration (hours)'] + df['Task Duration (minutes)'] / 60.0
+
+        category_times = df.groupby('Category')['Total Duration'].sum()
+
+        plt.figure(figsize=(10, 5))
+        category_times.plot(kind='bar', color='lightgreen')
+        plt.xlabel('Category')
+        plt.ylabel('Total Hours Spent')
+        plt.title('Overall Task Performance by Category')
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        st.pyplot(plt)
+
+    def download_report(self):
+        df = pd.DataFrame(st.session_state.tasks)
+        csv = df.to_csv(index=False)
+        st.download_button("Download CSV", data=csv, file_name="task_report.csv", mime='text/csv')