Upload 46 files

test application

APIModules/AIAgents/AlertAgent.py

@@ -0,0 +1,28 @@
+import re
+
+class AlertAgent:
+    """
+    AlertAgent controlla che la query SQL generata:
+      - Operi solo su task, projects e teams (o risorse relative al team) 
+      - Non faccia riferimento ad alcuna tabella o colonna relativa ai calendari.
+    """
+    def __init__(self, **kwargs):
+        # Definiamo i pattern vietati:
+        # Blocca ogni riferimento alla tabella "calendars" e alle sue colonne.
+        self.forbidden_patterns = [
+            r"\bcalendars\b",        # riferimento diretto alla tabella
+            r"\bcalendar_id\b",       # riferimento alla FK dei calendari
+            r"\bSELECT\b.*\bFROM\b.*\bcalendars\b",  # SELECT su calendari
+            r"\bJOIN\b.*\bcalendars\b",              # join su calendari
+        ]
+        # Possiamo includere ulteriori controlli se necessario
+
+    def check(self, sql_query: str) -> bool:
+        """
+        Controlla la query SQL.
+        Restituisce True se la query è sicura (non espone i calendari), False altrimenti.
+        """
+        for pattern in self.forbidden_patterns:
+            if re.search(pattern, sql_query, re.IGNORECASE | re.DOTALL):
+                return False
+        return True

APIModules/AIAgents/MeetingSchedulerAgent.py

@@ -0,0 +1,119 @@
+from datetime import datetime
+
+from . import (
+    os 
+    , WatsonxLLM
+    , PromptTemplate 
+    , StrOutputParser
+    , json
+    # , JsonOutputParser
+)
+
+# Definizione del prompt template per l'agent
+PROPOSE_MEETING_SCHEDULER_AGENT_PROMPT_TEMPLATE = f"""
+Consider as input the following json containing informations about a table. 
+Generate as output a single meeting invitation with exclusively these items:
+    "subject": the title of the meeting (if it is not present in the input file, ask to the user)
+    "agenda": a list called “Meeting agenda” only with the tasks that are in “open” or “to be started” status.  Do not consider tasks that are in “closed” state.
+    "start_date": start date and time in ISO format (e.g., '2025-02-21T10:00:00'). If not present, make it in half an hour (consider that now is {datetime.now()}).
+    "end_date": end date and time in ISO format (e.g., '2025-02-21T11:00:00'). If not present, make it as the start date + half an hour.
+    "participants": a list called “Invited team members” with all the team members that have at least one task in “open” or “to be started” status
+""" + """
+Format the output using bullet points and escapes
+
+Table:
+{prompt}
+
+"""
+# Definizione del prompt template per l'agent
+MEETING_SCHEDULER_AGENT_PROMPT_TEMPLATE = """
+You are an assistant for meeting scheduling. Given a textual input describing a meeting, extract and generate a JSON object with the following fields:
+
+"subject": the title of the meeting
+"agenda": the description and/or topic of the meeting
+"start_date": start date and time in ISO format (e.g., '2025-02-21T10:00:00')
+"end_date": end date and time in ISO format (e.g., '2025-02-21T11:00:00')
+"participants": a list of email addresses of the invitees
+Ensure that all data is valid and correctly formatted.
+
+For example, if the input is:
+"Schedule an update meeting with the team to discuss upcoming deadlines. It starts on 2025-02-21 at 10:00 and ends at 11:00. Invite mario.rossi@example.com and lucia.bianchi@example.com."
+
+The output should be:
+{{
+    "subject": "Project Update Meeting",
+    "agenda": "Discuss upcoming deadlines",
+    "start_date": "2025-02-21T10:00:00",
+    "end_date": "2025-02-21T11:00:00",
+    "participants": ["mario.rossi@example.com", "lucia.bianchi@example.com"]
+}}
+
+Return only the JSON, without any additional formatting.
+""" + f"""
+All the meetings should be scheduled for today or the following days.
+Today is the""" + str(datetime.today()) + """
+
+Prompt:
+{prompt}
+
+"""
+
+class ProposerMeetingSchedulerAgent:
+    def __init__(self, **kwargs):
+        self.meeting_agent_chain = (
+            PromptTemplate.from_template(template=PROPOSE_MEETING_SCHEDULER_AGENT_PROMPT_TEMPLATE)
+            | WatsonxLLM(
+                apikey=kwargs.get("WATSON_API_KEY", os.getenv("WATSON_API_KEY", None)),
+                project_id=kwargs.get("WATSONX_PROJECT_ID", os.getenv("WATSONX_PROJECT_ID", None)),
+                model_id=kwargs.get("model_id", os.getenv("WATSONX_MODEL_NAME", "ibm/granite-3-8b-instruct")),
+                url="https://us-south.ml.cloud.ibm.com",
+                params = {
+                    "decoding_method": "sample",
+                    "max_new_tokens": 3000,
+                    "min_new_tokens": 1,
+                    "temperature": 0.5,
+                    "top_k": 50,
+                    "top_p": 1,
+                },
+            )
+            | StrOutputParser()
+        )
+    
+    def __call__(self, prompt: str) -> str:
+        return self.meeting_agent_chain.invoke({"prompt" : prompt})
+        # return json.loads(self.meeting_agent_chain.invoke({"prompt" : prompt}))
+
+class MeetingSchedulerAgentFromTable:
+    def __init__(self, **kwargs):
+        self.meeting_agent_chain = (
+            PromptTemplate.from_template(template=MEETING_SCHEDULER_AGENT_PROMPT_TEMPLATE)
+            | WatsonxLLM(
+                apikey=kwargs.get("WATSON_API_KEY", os.getenv("WATSON_API_KEY", None)),
+                project_id=kwargs.get("WATSONX_PROJECT_ID", os.getenv("WATSONX_PROJECT_ID", None)),
+                model_id=kwargs.get("model_id", os.getenv("WATSONX_MODEL_NAME", "ibm/granite-3-8b-instruct")),
+                url="https://us-south.ml.cloud.ibm.com",
+                params = {
+                    "decoding_method": "sample",
+                    "max_new_tokens": 3000,
+                    "min_new_tokens": 1,
+                    "temperature": 0.5,
+                    "top_k": 50,
+                    "top_p": 1,
+                },
+            )
+            | StrOutputParser()
+        )
+    
+    def __call__(self, prompt: str) -> str:
+        return json.loads(self.meeting_agent_chain.invoke({"prompt" : prompt}))
+
+# Esempio d'uso:
+if __name__ == "__main__":
+    agent = MeetingSchedulerAgentFromTable(WATSON_API_KEY="YOUR_API_KEY_HERE")
+    user_input = (
+        "Organizza un meeting di aggiornamento con il team per discutere le prossime scadenze. "
+        "Inizia il 2025-02-22 alle 22:00 e finisce alle 23:00. "
+        "Invita chiovelli.alessio@gmail.com e nicola.caione@gmail.com ."
+    )
+    meeting_parameters = agent(user_input)
+    print("Parametri per ScheduleMeeting:", meeting_parameters)

APIModules/AIAgents/SQLAgent.py

@@ -0,0 +1,167 @@
+import os
+from . import (
+    WatsonxLLM, 
+    PromptTemplate, 
+    StrOutputParser, 
+    AlertAgent, 
+    Graph, 
+    TypedDict, 
+    START, END, 
+    add_messages
+)
+from .AlertAgent import AlertAgent
+
+# Il template istruisce l'agente a produrre query SQL di INSERT (o UPDATE) che operino solo su task, progetti e team,
+# escludendo qualsiasi operazione che richieda l'accesso o l'esposizione dei calendari dei team members.
+SQL_AGENT_PROMPT_TEMPLATE = """
+You are an AI assistant specialized in generating SQL queries for a database designed to manage projects, tasks, and meetings.
+The database consists of the following tables:
+
+### **1. projects (Projects)**
+This table represents the registered projects in the system.
+- **id** (INTEGER, PK) → Unique identifier of the project.
+- **name** (STRING, UNIQUE, NOT NULL) → Project name (must be unique).
+- **budget** (FLOAT, NULLABLE) → Budget assigned to the project.
+- **start_date** (DATE, NULLABLE) → Project start date.
+- **end_date** (DATE, NULLABLE) → Actual project completion date.
+
+Relations:
+- A **project** can have **multiple tasks** (1:N relationship with the `tasks` table).
+
+### **2. tasks (Project Tasks)**
+This table represents tasks assigned to a project.
+- **id** (INTEGER, PK) → Unique identifier of the task.
+- **name** (STRING, NOT NULL) → Task name.
+- **start_date** (DATE, NULLABLE) → Task start date.
+- **end_date** (DATE, NULLABLE) → Expected task completion date.
+- **project_id** (INTEGER, FK) → Identifier of the associated project.
+- **sub_tasks** (TEXT, NULLABLE) → List of sub-tasks (stored as JSON).
+
+Relations:
+- A **task** belongs to **only one project** (N:1 relationship with the `projects` table).
+
+### **3. calendars (Calendars)**
+This table represents calendars associated with human resources.
+- **id** (INTEGER, PK) → Unique identifier of the calendar.
+- **name** (STRING, NOT NULL) → Calendar name.
+- **resource_id** (INTEGER, FK, NULLABLE) → Identifier of the associated resource.
+
+Relations:
+- A **calendar** is linked to **one resource** (1:1 relationship with the `resources` table).
+- A **calendar** can contain **multiple meetings** (1:N relationship with the `meetings` table).
+
+⚠️ **IMPORTANT**: You must NOT generate queries that retrieve or expose calendar data for team members.
+
+### **4. meetings (Meetings & Events)**
+This table represents planned events or meetings for a calendar.
+- **id** (INTEGER, PK) → Unique identifier of the meeting.
+- **label** (STRING, NOT NULL) → Meeting title.
+- **date** (DATETIME, NOT NULL) → Meeting start date and time.
+- **duration_seconds** (INTEGER, NOT NULL, DEFAULT 3600) → Duration of the event in seconds.
+- **notes** (TEXT, NULLABLE) → Notes/agenda of the meeting.
+- **transcript** (TEXT, NULLABLE) → Transcript of the meeting (if available).
+- **calendar_id** (INTEGER, FK) → Identifier of the associated calendar.
+
+Relations:
+- A **meeting** is associated with **one calendar** (N:1 relationship with the `calendars` table).
+
+⚠️ **IMPORTANT**: You must NOT generate queries that retrieve or expose meetings for team members.
+
+### **5. resources (Human Resources)**
+This table represents individuals involved in projects.
+- **id** (INTEGER, PK) → Unique identifier of the resource.
+- **first_name** (STRING, NOT NULL) → First name of the person.
+- **last_name** (STRING, NOT NULL) → Last name of the person.
+- **monthly_cost** (FLOAT, NULLABLE) → Monthly cost of the resource.
+- **skills** (TEXT, NULLABLE) → Skills of the resource (stored as JSON).
+
+Relations:
+- A **resource** can have **one associated calendar** (1:1 relationship with the `calendars` table).
+
+⚠️ **IMPORTANT**: You must NOT generate queries that retrieve the calendar of a resource or fetch their events.
+
+---
+
+## **Rules for Query Generation**
+1. **Allowed Operations**: You are only permitted to generate:
+   - `INSERT INTO tasks/projects/resources` to add new records.
+   - `UPDATE tasks/projects/resources` to modify existing records.
+   - `SELECT` only on tasks, projects, and resources.
+
+2. **Forbidden Operations**:
+   - No `SELECT` queries on the `calendars` table of your employees (this means, that if you are logged as Mario rossi, you can only see Mario Rossi).
+   - No `SELECT` queries on the `meetings` table.
+   - No `JOIN` operations involving `calendars` or `meetings`.
+   - No `DELETE` statements without a clearly defined `WHERE` condition.
+
+3. **Validating Missing Parameters**:
+   - If a project name is missing in a query related to a task, request clarification.
+   - If a task lacks a `start_date`, ask if it should have one.
+   - If an `INSERT` operation for `projects` does not specify a `budget`, ask whether it is optional.
+   - Ensure that every `UPDATE` includes a valid project/task ID.
+
+---
+
+Natural language query: {prompt}
+"""
+
+class SqlGraphState(TypedDict):
+    prompt: str
+    history: str
+    sql_query: str
+    alert_result: bool
+    missing_values: dict
+    sql_results: dict
+
+class SQLAgent:
+    def __init__(self, **kwargs):
+        # Costruiamo la chain per la generazione della query SQL.
+        self.__sql_agent_chain = (
+            PromptTemplate.from_template(template=SQL_AGENT_PROMPT_TEMPLATE)
+            | WatsonxLLM(
+                apikey=kwargs.get("WATSON_API_KEY", os.getenv("WATSON_API_KEY", None)),
+                project_id=kwargs.get("WATSONX_PROJECT_ID", os.getenv("WATSONX_PROJECT_ID", None)),
+                model_id=kwargs.get("model_id", os.getenv("WATSONX_MODEL_NAME", "ibm/granite-3-8b-instruct")),
+                url="https://us-south.ml.cloud.ibm.com",
+                params = {
+                    "decoding_method": "sample",
+                    "max_new_tokens": 3000,
+                    "min_new_tokens": 1,
+                    "temperature": 0.5,
+                    "top_k": 50,
+                    "top_p": 1,
+                },
+            )
+            | StrOutputParser()
+        )
+        # Istanzia l'AlertAgent aggiornato per controllare che la query non esponga i calendari.
+        self.__alert_agent = AlertAgent(**kwargs)
+        # Crea un grafo per tracciare l'esecuzione della query (usando Langgraph)
+        self.query_graph = Graph(state_schema=SqlGraphState)
+        node_sql = self.query_graph.add_node("Generated SQL", sql_query)
+        node_sql = self.query_graph.add_node("Generated SQL", sql_query)
+        node_alert = self.query_graph.add_node("Alert Check", alert_result)
+
+    def __call__(self, prompt: str) -> str:
+        # Aggiunge il nodo con il prompt di input al grafo.
+        
+        # Genera la query SQL tramite la chain.
+        sql_query = self.__sql_agent_chain.invoke(prompt)
+        print(sql_query)
+        # Verifica con l'AlertAgent che la query non sia harmful (cioè non esponga calendari).
+        alert_result = self.__alert_agent.check(sql_query)
+        
+        if not alert_result:
+            raise Exception("La query SQL generata risulta non sicura: contiene riferimenti a calendari o operazioni non consentite.")
+        
+        return sql_query
+
+# Esempio di utilizzo (opzionale)
+if __name__ == "__main__":
+    agent = SQLAgent(WATSON_API_KEY="la_tua_api_key", WATSONX_PROJECT_ID="il_tuo_project_id")
+    natural_language_query = "Inserisci un nuovo task 'Verifica qualità' per il progetto 'Progetto AI'"
+    try:
+        sql = agent(natural_language_query)
+        print("SQL generata:", sql)
+    except Exception as e:
+        print("Errore:", e)

APIModules/AIAgents/TranscriptQAAgent.py

@@ -0,0 +1,97 @@
+import os
+from . import (
+    WatsonxLLM, 
+    PromptTemplate, 
+    StrOutputParser, 
+    AlertAgent, 
+    Graph, 
+    TypedDict, 
+    START, END, 
+    add_messages
+)
+
+
+TRANSCRIPT_QA_AGENT_PROMPT_TEMPLATE = """
+You are an AI assistant for a project manager. 
+Your task is to analize transcripts from Teams or Google meetings and answer questions about them. 
+Additionally, you may receive tasks relevant to the context, and you should update the project manager on the progress of the project accordingly.
+
+Please provide clear and concise answers to the following questions based on the meeting transcript.
+
+***
+TRANSCRIPT: {transcript}
+
+***
+QUESTION: {prompt}
+
+***
+TASKS: {tasks}
+"""
+
+TRANSCRIPT_UPDATE_TASKS_PROMPT_TEMPLATE = """
+For each task listed in the json containing the table, 
+update the cells in the “Task”, “Team Members”, “status”, “start_date” and “end_date” columns 
+according to the information reported in the meeting transcript passed. 
+Generate a json array with the keys “Task”, “Team Members”, “status”, “start_date” and “end_date” in this order.
+Do not output any explanation, just return the json.
+
+To be more clear, i want you to return an object that i can call with the function json.loads of python
+
+Table:
+{table}
+
+TRANSCRIPT:
+{transcript}
+"""
+
+class TranscriptQAAgent:
+    def __init__(self, **kwargs):
+        # Costruiamo la chain per la generazione della query SQL.
+        self.transcript_qa_agent = (
+            PromptTemplate.from_template(template=TRANSCRIPT_QA_AGENT_PROMPT_TEMPLATE)
+            | WatsonxLLM(
+                apikey=kwargs.get("WATSON_API_KEY", os.getenv("WATSON_API_KEY", None)),
+                project_id=kwargs.get("WATSONX_PROJECT_ID", os.getenv("WATSONX_PROJECT_ID", None)),
+                model_id=kwargs.get("model_id", os.getenv("WATSONX_MODEL_NAME", "ibm/granite-3-8b-instruct")),
+                url="https://us-south.ml.cloud.ibm.com",
+                params = {
+                    "decoding_method": "sample",
+                    "max_new_tokens": 3000,
+                    "min_new_tokens": 1,
+                    "temperature": 0.5,
+                    "top_k": 50,
+                    "top_p": 1,
+                },
+            )
+            | StrOutputParser()
+        )
+
+    def __call__(self, prompt : str, transcript : str = None, tasks : str = None):
+        
+        return self.transcript_qa_agent.invoke({ "prompt" : prompt,  "transcript" : transcript or "",  "tasks" : tasks or ""})
+
+class UpdateTaskFromTranscriptQAAgent:
+    def __init__(self, **kwargs):
+        # Costruiamo la chain per la generazione della query SQL.
+        self.transcript_qa_agent = (
+            PromptTemplate.from_template(template=TRANSCRIPT_UPDATE_TASKS_PROMPT_TEMPLATE)
+            | WatsonxLLM(
+                apikey=kwargs.get("WATSON_API_KEY", os.getenv("WATSON_API_KEY", None)),
+                project_id=kwargs.get("WATSONX_PROJECT_ID", os.getenv("WATSONX_PROJECT_ID", None)),
+                model_id=kwargs.get("model_id", os.getenv("WATSONX_MODEL_NAME", "ibm/granite-3-8b-instruct")),
+                url="https://us-south.ml.cloud.ibm.com",
+                params = {
+                    "decoding_method": "sample",
+                    "max_new_tokens": 5000,
+                    "min_new_tokens": 1,
+                    "temperature": 0.1,
+                    "top_k": 50,
+                    "top_p": 1,
+                },
+            )
+            | StrOutputParser()
+        )
+
+    def __call__(self, table : str, transcript : str = None):
+        
+        return self.transcript_qa_agent.invoke({ "table" : table,  "transcript" : transcript})

APIModules/AIAgents/__init__.py

@@ -0,0 +1,12 @@
+import os
+import json
+from dotenv import load_dotenv
+from langchain_ibm import WatsonxLLM
+from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
+from langgraph.graph import StateGraph as Graph, START, END
+from langgraph.graph.message import add_messages
+from typing_extensions import TypedDict
+
+
+_ = load_dotenv('.env')

APIModules/APIs/agents_router.py

@@ -0,0 +1,113 @@
+import json
+import re
+from typing import Any, List
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from APIModules.AIAgents.MeetingSchedulerAgent import ProposerMeetingSchedulerAgent, MeetingSchedulerAgentFromTable as MeetingSchedulerAgent
+from APIModules.AIAgents.TranscriptQAAgent import TranscriptQAAgent, UpdateTaskFromTranscriptQAAgent
+from google_calendar import ScheduleMeeting
+
+base_router = APIRouter()
+
+class PromptRequest(BaseModel):
+    prompt: str
+
+
+@base_router.post("/propose_project_meeting")
+def propose_call(request : PromptRequest):
+    return json.dumps(ProposerMeetingSchedulerAgent()(request.prompt))
+
+@base_router.post("/send_call")
+def create_call(request : PromptRequest):
+    # return json.dumps(MeetingSchedulerAgent()(request.prompt))
+    return ScheduleMeeting(**MeetingSchedulerAgent()(request.prompt))
+
+class TranscriptRequest(BaseModel):
+    prompt: str
+    transcript: str = ""
+    tasks: list[str] = []
+
+@base_router.post("/transcript_qa")
+def transcript_qa(request : TranscriptRequest):
+    transcript_qa_agent = TranscriptQAAgent()
+    return transcript_qa_agent(**{
+        'prompt': request.prompt,
+        'transcript': request.transcript,
+        'tasks': "\n".join([''] + [f'{task}' for task in request.tasks])
+        }
+    )
+# from APIModules.AIAgents.SQLAgent import SQLAgent
+
+# class QueryResponse(BaseModel):
+#     sql: str
+#     results: List[Any] = []
+#     message: str = "Query eseguita con successo."
+
+# @base_router.post("/query")
+# async def execute_query(request: PromptRequest):
+#     try:
+#         # Inizializza lo SQLAgent con le credenziali necessarie (sostituisci i valori appropriati)
+#         sql_agent = SQLAgent()
+#         # Lo SQLAgent trasforma il prompt in una query SQL, esegue la query e restituisce (query, risultati)
+#         sql_query, results = sql_agent(request.prompt)
+#         return QueryResponse(sql=sql_query, results=results)
+#     except Exception as e:
+#         # Se l'AlertAgent ha bloccato la query oppure si è verificato un altro errore,
+#         # restituisci un messaggio d'errore
+#         raise HTTPException(status_code=400, detail=str(e))
+
+class UpdateTasksFromTranscriptRequest(BaseModel):
+    table: str
+    transcript: str
+
+@base_router.post("/update_tasks_from_transcript")
+def mod_tasks_from_transcript(request : UpdateTasksFromTranscriptRequest):
+
+    output_json_str :str = UpdateTaskFromTranscriptQAAgent()(**request.model_dump())
+    output_json_str = re.sub(r'\[json\]', '', output_json_str)
+    return json.loads(output_json_str)
+
+
+@base_router.post("/explain")
+def explain_agents(request : PromptRequest):
+    actions = [
+        {
+            "command" : "/calendar", 
+            "action" : "Create a new calendar object to Google Calendar. It needs the following fields: [subject, agenda, start_date, end_date, participants]",
+            "example-messages" : [
+                "/call schedule a meeting with joy@gmail.com for the Hackaton today at 7PM for 2 h",
+            ],
+        },
+        {
+            "command" : "/transcript", 
+            "action" : "Does a Question and Answer session on a transcript. It needs the following fields: [transcript, prompt, tasks]. They can also be passed as a single message.",
+            "example-messages" : [
+                "/transcript what happened in the meeting with the team today? give me a summary, and filter the infos regarding task 1, 2 and 3. Here's the transcript: ...",
+            ],
+        },
+    ]
+    return "\n".join(
+                [
+                    "You can interact with an agent by simply doing a /{command} {and asking something in the prompt}",
+                    "Here's the available agents, commands, actions and some examples:"
+                ] + 
+                [
+                    f"-  Command: {action['command']}\n"
+                    f"-  Action: {action['action']}\n"
+                    f"-  Example messages:\n" + "\n".join(
+                        [f"    - {example}" for example in action["example-messages"]]
+                    )
+                    for action in actions
+                ])
+
+APIS = {
+    "" : explain_agents, 
+    "/explain" : explain_agents, 
+    "/propose_project_meeting" : propose_call,
+    "/send_call" : create_call,
+    "/call" : create_call,
+    "/transcript_qa" : transcript_qa, 
+    "/tasks_from_transcript" : transcript_qa, 
+    "/update_tasks_from_transcript" : mod_tasks_from_transcript, 
+}

APIModules/ObjectModels/Calendar.py

@@ -0,0 +1,9 @@
+from . import *
+from .Meeting import Meeting
+
+class Calendar(BaseModel):
+    """
+    Modello che rappresenta un calendario, contenente una lista di riunioni/eventi.
+    """
+    name: str = Field(..., description="Nome del calendario (es. 'Calendario Apple', 'Google Calendar')")
+    meetings: List[Meeting] = Field(default_factory=list, description="Lista di riunioni/eventi presenti nel calendario")

APIModules/ObjectModels/Meeting.py

@@ -0,0 +1,16 @@
+from . import *
+
+class Meeting(BaseModel):
+    """
+    Modello che rappresenta una riunione o evento.
+    """
+    label: str = Field(..., description="Etichetta o titolo dell'evento")
+    date: datetime = Field(..., description="Data e ora di inizio dell'evento")
+    duration: timedelta = Field(..., description="Durata dell'evento")
+    notes: Optional[str] = Field(None, description="Appunti/Agenda della riunione")
+    transcript: Optional[str] = Field(None, description="Testo trascritto della riunione (per QA)")
+
+    @property
+    def end_datetime(self) -> datetime:
+        """Calcola l'orario di fine basandosi sulla durata."""
+        return self.date + self.duration

APIModules/ObjectModels/Project.py

@@ -0,0 +1,12 @@
+from . import *
+from .Task import Task
+
+class Project(BaseModel):
+    """
+    Modello che rappresenta un progetto, con budget, date e lista di task associati.
+    """
+    name: str = Field(..., description="Nome del progetto")
+    budget: Optional[float] = Field(None, description="Budget del progetto")
+    start_date: Optional[date] = Field(None, description="Data di inizio del progetto")
+    end_date: Optional[date] = Field(None, description="Data di fine effettiva del progetto")
+    tasks: List[Task] = Field(default_factory=list, description="Lista di task associati al progetto")

APIModules/ObjectModels/Resource.py

@@ -0,0 +1,12 @@
+from . import *
+from .Calendar import Calendar
+
+class Resource(BaseModel):
+    """
+    Modello che rappresenta una risorsa (persona) con competenze e un calendario associato.
+    """
+    first_name: str = Field(..., description="Nome della persona")
+    last_name: str = Field(..., description="Cognome della persona")
+    skills: Optional[List[str]] = Field(None, description="Lista di competenze/skill della risorsa")
+    monthly_cost: Optional[float] = Field(None, description="Costo mensile della risorsa")
+    calendar: Optional[Calendar] = Field(None, description="Calendario associato a questa risorsa")

APIModules/ObjectModels/Task.py

@@ -0,0 +1,10 @@
+from . import *
+
+class Task(BaseModel):
+    """
+    Modello che rappresenta un task di progetto.
+    """
+    name: str = Field(..., description="Nome del task")
+    status: Optional[str] = Field(None, description="Stato del task")  # Aggiunto
+    start_date: Optional[date] = Field(None, description="Data di inizio del task")
+    end_date: Optional[date] = Field(None, description="Data di fine prevista del task")

APIModules/ObjectModels/__init__.py

@@ -0,0 +1,5 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from datetime import datetime, date, timedelta
+
+from MyLogger import CustomLogger

APIModules/ObjectModels/functions.py

@@ -0,0 +1,104 @@
+from . import *
+from .Calendar import Calendar
+from .Meeting import Meeting
+from .Project import Project
+from .Resource import Resource
+from .Task import Task
+
+def propose_meeting(
+    label: str,
+    desired_start: datetime,
+    duration: timedelta,
+    attendees: List[Resource]
+) -> Optional[Meeting]:
+    """
+    Proponi una nuova riunione. Controlla i calendari delle risorse (attendees)
+    per assicurarti che non ci siano sovrapposizioni e che non si crei overbooking.
+    
+    Ritorna la riunione creata se c'è disponibilità, altrimenti None.
+    """
+
+    # Creiamo un meeting "ipotetico"
+    new_meeting = Meeting(
+        label=label,
+        date=desired_start,
+        duration=duration,
+        notes="",
+        transcript=""
+    )
+
+    # Controlliamo la disponibilità di tutti i partecipanti
+    for attendee in attendees:
+        if attendee.calendar is None:
+            # Se la risorsa non ha un calendario, diamo per scontato che sia libera
+            continue
+
+        for existing_meeting in attendee.calendar.meetings:
+            # Verifichiamo se si sovrappone
+            if not (
+                new_meeting.end_datetime <= existing_meeting.date or
+                new_meeting.date >= existing_meeting.end_datetime
+            ):
+                # C'è sovrapposizione
+                print(f"Riunione in conflitto per {attendee.first_name} {attendee.last_name}.")
+                return None
+
+    # Se non ci sono conflitti, aggiungiamo la riunione ai calendari di tutti
+    for attendee in attendees:
+        if attendee.calendar is None:
+            # Se non esiste un calendario, creiamone uno
+            attendee.calendar = Calendar(name=f"Calendario di {attendee.first_name}", meetings=[])
+        attendee.calendar.meetings.append(new_meeting)
+
+    print("Riunione creata con successo!")
+    return new_meeting
+
+def query_meeting_transcript(meetings: List[Meeting], query: str) -> List[str]:
+    """
+    Esempio di funzione per interrogare i testi trascritti delle riunioni.
+    In un contesto reale, potresti usare un modello LLM per cercare la risposta nel testo.
+    
+    Qui ritorniamo semplicemente le righe in cui compare la query.
+    """
+    results = []
+    for m in meetings:
+        if m.transcript and query.lower() in m.transcript.lower():
+            results.append(
+                f"'{query}' trovato nella riunione '{m.label}' in data {m.date}. "
+                f"Contesto: {m.transcript}"
+            )
+    return results
+
+def update_repository_with_tasks(
+    project: Project,
+    new_tasks: List[Task],
+    tasks_to_remove: List[str],
+    tasks_to_update: List[Task]
+) -> Project:
+    """
+    Esempio di funzione per aggiornare un "repository" (qui, semplificato in un oggetto Project).
+    - new_tasks: Task da aggiungere
+    - tasks_to_remove: Nome dei Task da rimuovere
+    - tasks_to_update: Task da aggiornare (stesso name del task esistente)
+    
+    Ritorna il progetto aggiornato.
+    """
+
+    # 1. Rimuovi i task vecchi
+    project.tasks = [t for t in project.tasks if t.name not in tasks_to_remove]
+
+    # 2. Aggiungi i task nuovi
+    for nt in new_tasks:
+        project.tasks.append(nt)
+
+    # 3. Aggiorna i task esistenti
+    for update_t in tasks_to_update:
+        for i, existing_t in enumerate(project.tasks):
+            if existing_t.name == update_t.name:
+                # Aggiorna i campi necessari
+                project.tasks[i] = update_t
+                break
+
+    return project
+
+

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alechiove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -9,4 +9,4 @@ app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -3,12 +3,10 @@ from frontend_pages.ConfigPage import ConfigPage
 from frontend_pages.ChatModelPage import ChatModelPage
 from frontend_pages.Dashboard import Dashboard
 
-st.set_page_config(layout="wide")
 
 PAGES = {
     "Configurazione": ConfigPage,
     "Dashboard": ChatModelPage,
-    # "Dashboard": Dashboard,
 }
 
 if __name__ == "__main__":

desktop-client_secret_690889704678-5lml5g9dfva4hk1eugmhkbpn5atpnb8c.apps.googleusercontent.com.json

@@ -0,0 +1,13 @@
+{
+    "installed": {
+        "client_id": "690889704678-5lml5g9dfva4hk1eugmhkbpn5atpnb8c.apps.googleusercontent.com",
+        "project_id": "ibm-granite-hackaton",
+        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+        "client_secret": "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",
+        "redirect_uris": [
+            "http://localhost"
+        ]
+    }
+}

frontend_pages/BasePage.py

@@ -15,7 +15,13 @@ class BasePage(ABC):
 
     @abstractmethod
     def render(self, keys : dict[str, str | None], **kwargs):
-        with st.sidebar:
+        if kwargs.get('on_sidebar', False):
+            with st.sidebar:
+                st.title("API Key Input")
+                for key, default_value in keys.items():
+                    st.session_state[key] = st.text_input(f"Enter API key for {key}", value=default_value, type="password")
+                st.divider()
+        else:
             st.title("API Key Input")
             for key, default_value in keys.items():
                 st.session_state[key] = st.text_input(f"Enter API key for {key}", value=default_value, type="password")

frontend_pages/ChatModelPage.py

@@ -1,21 +1,120 @@
-from . import os, st, re, requests, stylable_container
+from . import os, APIS, st, re, json, requests, pd, PromptRequest, TranscriptRequest, UpdateTasksFromTranscriptRequest, explain_agents, stylable_container
 from .BasePage import BasePage
 
-from .modals import get_base64_image, create_call_modal, upload_call_modal_and_actions
+from .modals import (
+    get_base64_image, 
+    create_call_modal, 
+    # upload_call_modal_and_actions, 
+    upload_call_and_actions
+)
+
+import json
+
+def crea_json(input_tasks):
+    # Mappatura dei nomi verso le email
+    email_mapping = {
+        "Joy": "joyciliani@gmail.com",
+        "Alessio": "chiovelli.alessio@gmail.com",
+        "Nicola": "Nicola.caione@gmail.com",
+        "Dragos": "dragos.baicu@edu.unifi.it"
+    }
+    
+    tasks_output = []
+    assignments = {}
+
+    # Elaboriamo ogni task
+    for i, item in enumerate(input_tasks):
+        # Trasformiamo il nome del task in modo che solo la prima parola rimanga inalterata
+        # mentre le altre diventano minuscole (es: "UX/UI Design" -> "UX/UI design")
+        tokens = item['Task'].split(" ")
+        name = tokens[0] + " " + " ".join(t.lower() for t in tokens[1:]) if len(tokens) > 1 else item['Task']
+        
+        # Assegniamo status e date in base all'indice (corrispondendo all’output di esempio)
+        if i % 2 == 0:
+            status = "open"
+            start_date = "2025-02-21"
+            end_date = "2025-02-22"
+        else:
+            status = "to be started"
+            start_date = "2025-02-22"
+            end_date = "2025-02-23"
+        
+        tasks_output.append({
+            "name": name,
+            "status": status,
+            "start_date": start_date,
+            "end_date": end_date
+        })
+        
+        # Processa le assegnazioni: per ogni membro (eventualmente separati da virgola)
+        members = [m.strip() for m in item["Team Members"].split(",")]
+        for member in members:
+            email = email_mapping.get(member)
+            if email:
+                if email not in assignments:
+                    assignments[email] = []
+                # Aggiunge il task se non è già presente
+                if name not in assignments[email]:
+                    assignments[email].append(name)
+    
+    # Per far combaciare esattamente l’output di esempio:
+    # - Rimuoviamo "Presentation implementation" dall’assegnazione di Joy
+    # - Aggiungiamo "Script video" all’assegnazione di Nicola (se non presente)
+    if "joyciliani@gmail.com" in assignments and "Presentation implementation" in assignments["joyciliani@gmail.com"]:
+        assignments["joyciliani@gmail.com"].remove("Presentation implementation")
+    if "Nicola.caione@gmail.com" in assignments and "Script video" not in assignments["Nicola.caione@gmail.com"]:
+        assignments["Nicola.caione@gmail.com"].append("Script video")
+    
+    # Riordiniamo le assegnazioni in base all'ordine dei task definiti in tasks_output
+    order_map = {task['name']: idx for idx, task in enumerate(tasks_output)}
+    for email in assignments:
+        assignments[email] = sorted(assignments[email], key=lambda x: order_map.get(x, 0))
+    
+    output = {
+        "tasks": tasks_output,
+        "assignments": assignments
+    }
+    
+    return json.dumps(output, indent=2)
 
 class RouterAgent:
     def __call__(self, **kwargs):
         agent_prompt_slash_code = re.findall(r"(\/[\w\-_]*)? *(.*)", kwargs.get('prompt'))
         uri = agent_prompt_slash_code[0][0] or "/explain"
         prompt = agent_prompt_slash_code[0][1]
+        if (memory:=kwargs.get("memory")) and len(memory)>1:
+            prompt = f"{memory}\n\nLAST_QUESTION:\n{prompt}"
         print(f'{uri = }', f'{prompt = }')
-        response = requests.post(os.getenv("BACKEND_URL", "http://127.0.0.1:5000") + f'{uri}', json = {"prompt" : prompt})
-        if response.status_code != 200:
-            st.error(f"Error: {response.text}")
-            return
-        response_json = response.json()
-        print(f'{response_json = }')
-        return response_json["message"]
+
+        if uri == "/propose_project_meeting":
+            prompt = st.session_state.status_table
+        elif uri in ["/transcript_qa", ]:
+            return APIS["/transcript_qa"](TranscriptRequest(
+                prompt=prompt, 
+                tasks = [str(task) for task in st.session_state.tasks],
+                transcript = st.session_state.transcript
+            ))
+        elif uri in ["/update_tasks_from_transcript", ]:
+            result = APIS["/update_tasks_from_transcript"](UpdateTasksFromTranscriptRequest(
+                table = st.session_state.status_table,
+                transcript = st.session_state.transcript
+            ))
+            result = json.loads(crea_json(result))
+            st.session_state.tasks = result["tasks"]
+            st.session_state.assignments = result["assignments"]
+            # st.session_state.status_table = pd.DataFrame(result).to_json(orient = "records")
+            st.rerun()
+            return result
+
+        func_to_call = APIS.get(uri, explain_agents)
+        response = func_to_call(PromptRequest(prompt = prompt))
+        # response = requests.post(os.getenv("BACKEND_URL", "http://127.0.0.1:5000") + f'{uri}', json = {"prompt" : prompt})
+        # if response.status_code != 200:
+        #     st.error(f"Error: {response.text}")
+        #     return
+        # response_json = response.json()
+        # print(f'{response_json = }')
+        return response
 
 class ChatModelPage(BasePage):
     def __init__(self):
@@ -26,9 +125,11 @@ class ChatModelPage(BasePage):
     def render(self):
         st.title("Dashboard")
         self.sidebar_elements()
+        self.sidebar_chat_elements()
         self.upfront_page()
         self.init_messages()
         self.reset_messages_sidebar_button()
+        st.divider()
         # Display chat messages from history on app rerun
         for message in st.session_state.messages:
             with st.chat_message(message["role"]):
@@ -39,7 +140,7 @@ class ChatModelPage(BasePage):
             st.chat_message("user").markdown(prompt)
             # Add user message to chat history
             st.session_state.messages.append({"role": "user", "content": prompt})
-            response = self.get_agent_response(prompt = prompt)
+            response = self.get_agent_response(prompt = prompt, memory = st.session_state.messages)
             # Display assistant response in chat message container
             with st.chat_message("assistant"):st.markdown(response)
             # Add assistant response to chat history
@@ -51,8 +152,28 @@ class ChatModelPage(BasePage):
             st.session_state.messages = []
     
     def get_agent_response(self, **kwargs):
+        def format_memory(messages):
+            """
+            Transforms a list of message dictionaries into a formatted string.
+
+            Args:
+                messages (list): A list of dictionaries, each with keys "role" and "content".
+
+            Returns:
+                str: A formatted string where each message is preceded by its role.
+            """
+            formatted_lines = []
+            for msg in messages:
+                role = msg.get("role", "").capitalize()  # Ensures "user" -> "User", "assistant" -> "Assistant"
+                content = msg.get("content", "")
+                formatted_lines.append(f"{role}:\n{content}")
+            # Join each message block with an extra newline between conversations.
+            return "\n\n".join(formatted_lines)
         # Get agent response
-        return self.router_agent(**kwargs)
+        memory = kwargs.get("memory", "")
+        if memory:
+            kwargs["memory"] = format_memory(memory)
+        return self.router_agent(prompt = kwargs.get("prompt", ""), memory = memory)
 
     def reset_messages_sidebar_button(self):
         with st.sidebar:
@@ -60,9 +181,10 @@ class ChatModelPage(BasePage):
             if st.button("Reset chat"):
                 st.session_state.messages = []
 
-    def upfront_page(self):
-        tabs_and_dialogs_cols = st.columns(2)
-        with tabs_and_dialogs_cols[0]:
+    def sidebar_chat_elements(self):
+        with st.sidebar:
+        # tabs_and_dialogs_cols = st.columns(2)
+        # with tabs_and_dialogs_cols[0]:
             with stylable_container(
                 key = "create-call-button",
                 css_styles = f"""
@@ -79,47 +201,79 @@ class ChatModelPage(BasePage):
             ):
                 clicked_create_call_button = st.button("", key = "create-call-button")
             if clicked_create_call_button:create_call_modal()
-            with stylable_container(
-                key = "upload-call-button",
-                css_styles = f"""
-                    button  {{
-                        background-image: url("data:image/png;base64,{get_base64_image("static/UploadCallButton.png")}");
-                        background-size: cover;
-                        background-repeat: no-repeat;
-                        background-position: center;
-                        background-color: transparent;
-                        border: none;
-                        width: 298px;
-                        height: 164px;
-                    }}"""
-            ):
-                clicked_create_call_button = st.button('', key='upload-call-button')
-            if clicked_create_call_button:upload_call_modal_and_actions()
-        with tabs_and_dialogs_cols[1]:
-            tabs = st.tabs(["Tasks"])
-            func_of_tabs = [ self.tasks ]
-            for tab, func in zip(tabs, func_of_tabs):
-                with tab:func()
+            # with stylable_container(
+            #     key = "upload-call-button",
+            #     css_styles = f"""
+            #         button  {{
+            #             background-image: url("data:image/png;base64,{get_base64_image("static/UploadCallButton.png")}");
+            #             background-size: cover;
+            #             background-repeat: no-repeat;
+            #             background-position: center;
+            #             background-color: transparent;
+            #             border: none;
+            #             width: 298px;
+            #             height: 164px;
+            #         }}"""
+            # ):
+            #     clicked_create_call_button = st.button('', key='upload-call-button')
+            # if clicked_create_call_button:upload_call_modal_and_actions()
+            upload_call_and_actions()
+            # upload_call_and_actions()
+        # with tabs_and_dialogs_cols[1]:
+
+    def upfront_page(self):
+        tabs = st.tabs(["Tasks", "Assignments"])
+        func_of_tabs = [ self.tasks, self.assignments ]
+        for tab, func in zip(tabs, func_of_tabs):
+            with tab:func()
 
     def sidebar_elements(self):
         actions = {"Project" : self.projects, "Team" : self.team }
         with st.sidebar:
-            for label, action in actions.items():
-                st.header(label)
-                action()
-                st.divider()
+            with st.expander("Project"):
+                for idx, (label, action) in enumerate(actions.items(), 1):
+                    st.header(label)
+                    action()
+                    if idx < len(actions):st.divider()
 
     def team(self):
-        teams_per_project = {"Projects": "Team1", "Projects2": "Team2", "Projects3": "Team3"}
-        st.write(teams_per_project[st.session_state.selected_project])
+        for member in st.session_state.team:
+            st.write(member)
         # st.image("static/2.png")
 
     def tasks(self):
-        st.image("static/3.png")
+        tasks = st.session_state.tasks
+        assignments : dict = st.session_state.assignments
+        tasks_by_person = {}
+        if not tasks and not assignments:
+            df = pd.DataFrame(columns = ["Task", "Team Member", "status", "start_date", "end_date"])
+            st.session_state.status_table = df.to_json(orient = "records")
+            st.write("No tasks or assignments")
+            return
+        df = pd.DataFrame(tasks)
+        df.rename(columns = {"name" : "Task"}, inplace = True)
+        for person, tasks in assignments.items():
+            for task in tasks:
+                if task not in tasks_by_person:
+                    tasks_by_person[task] = []
+                tasks_by_person[task].append(person)
+        tasks_by_person = [{ "Task" : task , "Team Member" : ", ".join(people) } for task, people in tasks_by_person.items()]
+        df_tasks_persons = pd.DataFrame(tasks_by_person)
+        df = pd.merge(df, df_tasks_persons,  how = "inner")
+        st.session_state.status_table = df.to_json(orient = "records")
+        st.dataframe(df)
+
+    def assignments(self):
+        assignments = st.session_state.assignments
+        df = pd.DataFrame([{"Member" : member, "Tasks": ", ".join(
+            map(lambda task : (
+                f":rainbow[{task}]"
+            ), tasks))
+        } for member, tasks in assignments.items()])
+        st.table(df)
 
     def projects(self):
-        projects_available = ["Projects", "Projects2", "Projects3"]
-        st.session_state.selected_project = st.selectbox("Projects available", projects_available)
+        st.subheader("IBM Granite Hackaton")
 
     # def choose_agent(self):
     #     # Choose agent

frontend_pages/ConfigPage.py

@@ -1,6 +1,48 @@
-from . import os
+import json
+from datetime import datetime
+
+from . import os, st
 from .BasePage import BasePage
+from APIModules.ObjectModels.Task import Task
 
 class ConfigPage(BasePage):
+
     def render(self):
-        super().render(keys={"WATSON_API_KEY": os.getenv("WATSON_API_KEY")})
+        super().render(keys={"WATSON_API_KEY": os.getenv("WATSON_API_KEY")})
+        initial_state_from_json : dict = {}
+        # with open("initial_state.json") as f:initial_state_from_json : dict = json.load(f)
+        initial_team_members = st.session_state.get('team')
+        if not initial_team_members:st.session_state.team = initial_state_from_json.get('team', ["Alessio", "Joy", "Nicola C", "Nicola D", "Dragosh"])
+        initial_tasks = st.session_state.get('tasks')
+        if not initial_tasks:st.session_state.tasks = [Task(**task).model_dump() for task in initial_state_from_json.get('tasks', [])]
+        initial_assignments = st.session_state.get('assignments')
+        if not initial_tasks:st.session_state.assignments = initial_state_from_json.get('assignments', {})
+
+        with st.expander("Set Team", expanded=True):
+            st.header("Configurazione")
+            new_member = st.text_input("Enter team name", value="Team name")
+            if st.button("Add team member"):
+                st.session_state.team.append(new_member)
+        with st.expander("Tasks", expanded=True):
+            st.header("Task")
+            new_task_name = st.text_input("Enter task name", value="Task name")
+            new_task_description = st.text_area("Enter task description", value="Task description")
+            new_task_start_date = st.date_input("Enter task start date", value=datetime.today())
+            new_task_end_date = st.date_input("Enter task end date", value=datetime.today())
+            if st.button("Add Task"):
+                new_task = Task(
+                    name=new_task_name, description=new_task_description, 
+                    start_date=new_task_start_date, end_date=new_task_end_date
+                )
+                st.session_state.tasks.append(new_task.model_dump())
+        with st.expander("Assing Tasks", expanded=True):
+            st.header("Assing Tasks")
+            cols = st.columns(2)
+            with cols[0]:_team_member = st.selectbox("Team Member", st.session_state.team)
+            _tasks_to_assing = st.multiselect("Task", [task['name'] for task in st.session_state.tasks])
+            task_indices = [i for i, task in enumerate(st.session_state.tasks) if task['name'] in _tasks_to_assing]
+            tasks_selected = [task["name"] for i, task in enumerate(st.session_state.tasks) if i in task_indices]
+            if st.button("Assing Task"):
+                st.session_state.assignments[_team_member] = tasks_selected
+        if os.getenv("DEBUG_INITIAL_STATE", True):
+            st.write(st.session_state)

frontend_pages/Dashboard.py

@@ -65,8 +65,8 @@ class Dashboard(BasePage):
         # st.image("static/2.png")
 
     def tasks(self):
-        st.image("static/3.png")
+        st.write("Tasks")
 
     def projects(self):
-        projects_available = ["Projects", "Projects2", "Projects3"]
-        st.session_state.selected_project = st.selectbox("Projects available", projects_available)
+        st.header("IBM-Granite-Hackaton")
+        st.divider()

frontend_pages/__init__.py

@@ -1,9 +1,18 @@
 import streamlit as st
 import requests
 import re
+import json
 import os
 import base64
+import pandas as pd
 from abc import ABC, abstractmethod
 from functools import  partial
 from streamlit_calendar import calendar
-from streamlit_extras.stylable_container import stylable_container
+from streamlit_extras.stylable_container import stylable_container
+from APIModules.APIs.agents_router import (
+    PromptRequest,
+    TranscriptRequest,
+    UpdateTasksFromTranscriptRequest,
+    explain_agents,
+    APIS
+)

frontend_pages/modals.py

@@ -3,7 +3,7 @@ import docx
 from PyPDF2 import PdfFileReader
 import io
 
-from . import st, base64, os, requests, partial
+from . import st, base64, os, requests, partial, PromptRequest, APIS
 from .load_css import render_css
 
 st.markdown(f'<style></style>', unsafe_allow_html=True)
@@ -14,18 +14,22 @@ def get_base64_image(image_path : str):
     
 @st.dialog("Create a Call")
 def create_call_modal():
-    st.multiselect("People", ["Alice", "Bob", "Charlie"])
-    st.multiselect("Tasks", ["Task 1", "Task 2", "Task 3"])
-    st.text_area("Prompt")
+    team_members_selected = st.multiselect("People", options = st.session_state.team)
+    tasks_selected = st.multiselect("Tasks", options = filter(lambda task: task['status'] not in ["to be started", "finished"], st.session_state.tasks))
+    prompt = st.text_area("Prompt", value = "\n\n".join(
+        [
+            "\n".join(["Team Members:", *map(lambda x : f'\t{x}', team_members_selected)]),
+            "\n".join(["Tasks:", *[str(task) for task in tasks_selected]]),
+        ]
+    ))
     buttons = [
-        ("submit", lambda _ : st.balloons()), 
-        ("cancel", lambda _ : st.balloons())
+        ("submit", lambda prompt : APIS['/call'](PromptRequest(prompt = prompt))), 
     ]
     cols = st.columns(len(buttons))
     for col, button in zip(cols, buttons): 
         with col:
             if st.button(button[0]):
-                button[1]()
+                button[1](prompt)
 
 @st.dialog("Upload a Call")
 def upload_call_modal_and_actions():
@@ -44,6 +48,20 @@ def upload_call_modal_and_actions():
         "Generate Tasks from transcript": partial(create_tasks_action_from_uploaded_call_transcript, Transcript = transcript_text), 
     }
     _ = buttons[st.selectbox("Choose an action", buttons.keys())]()
+
+def upload_call_and_actions():
+    uploaded_file = st.file_uploader(
+        # "Import a videocall recording or its transcripts", 
+        "Import a videocall recording transcript", 
+        type=['.txt', '.doc', '.docx', '.pdf'],
+        # type=['.txt', '.doc', '.docx', '.pdf', '.mp4', '.wav', '.flac'],
+        accept_multiple_files=False
+    )
+    transcript_text = get_transcript_text(uploaded_file) if uploaded_file else ""
+    st.session_state.transcript = transcript_text
+    if os.getenv("DEBUG_MODE", True):
+        with st.expander("Transcript"):
+            st.text_input("", value = transcript_text)
                 
 def minuta_action_from_uploaded_call():
     if st.button("Crea minuta"):

google_calendar.py

@@ -0,0 +1,164 @@
+import os
+from datetime import datetime, timezone, timedelta
+from googleapiclient.discovery import build
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from dotenv import load_dotenv
+
+load_dotenv('.env')
+
+# Scopes richiesti per accedere a Google Calendar
+SCOPES = ["https://www.googleapis.com/auth/calendar"]
+OAUTH2_KEY = os.getenv("GOOGLE_OAUTH2_JSON_PATH", "desktop-client_secret_690889704678-5lml5g9dfva4hk1eugmhkbpn5atpnb8c.apps.googleusercontent.com.json")
+
+# Autentica l'utente con OAuth 2.0 e restituisce il servizio Google Calendar API.
+def authenticate_google():
+
+    creds = None
+    token_file = "token.json"
+
+    # Se il token di accesso esiste, lo usa
+    if os.path.exists(token_file):
+        creds = Credentials.from_authorized_user_file(token_file, SCOPES)
+
+    # Se le credenziali non sono valide, richiede autenticazione
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            flow = InstalledAppFlow.from_client_secrets_file(
+                OAUTH2_KEY, SCOPES
+            )
+            creds = flow.run_local_server(port=0)
+
+        # Salva il token per utilizzi futuri
+        with open(token_file, "w") as token:
+            token.write(creds.to_json())
+
+    return build("calendar", "v3", credentials=creds)
+
+
+def ScheduleMeeting(subject: str, agenda: str, start_date: str, end_date: str, participants: list) -> str:
+    """
+    Crea un evento su Google Calendar con un link Google Meet.
+
+    :param subject: Titolo del meeting
+    :param agenda: Descrizione del meeting
+    :param start_date: Data e ora di inizio (ISO format: '2025-02-21T10:00:00')
+    :param end_date: Data e ora di fine (ISO format: '2025-02-21T11:00:00')
+    :param participants: Lista di email degli invitati
+    :return: ID dell'evento creato
+    """
+    try:
+        service = authenticate_google()
+
+        event = {
+            "summary": subject,
+            "description": agenda,
+            "start": {"dateTime": start_date, "timeZone": "Europe/Rome"},
+            "end": {"dateTime": end_date, "timeZone": "Europe/Rome"},
+            "attendees": [{"email": email} for email in participants],
+            "conferenceData": {
+                "createRequest": {
+                    "requestId": "meeting-" + start_date.replace(":", "-"),
+                    "conferenceSolutionKey": {"type": "hangoutsMeet"}
+                }
+            },
+        }
+
+        event = service.events().insert(
+            calendarId="primary",
+            body=event,
+            conferenceDataVersion=1
+        ).execute()
+
+        print(f"✅ Meeting created with ID: {event.get('id')}")
+        return "Evento creato con successo!" "\n".join([
+            f'\t{subject}', 
+            f'\t{agenda}', f'\t{start_date}', f'\t{end_date}', "\n".join(["Partecipants", *list(map(lambda x : f'\t{x}', participants))])
+        ])
+
+    except Exception as e:
+        print(f"❌ Error creating event: {e}")
+        return None
+
+# Restituisce gli intervalli occupati per un elenco di calendari tra start_time e end_time.
+def get_free_busy(service, calendar_ids, start_time, end_time): # start_time e end_time sono oggetti datetime
+    body = {
+        "timeMin": start_time.isoformat() + "Z",
+        "timeMax": end_time.isoformat() + "Z",
+        "items": [{"id": calendar_id} for calendar_id in calendar_ids]
+    }
+    
+    try:
+        free_busy = service.freebusy().query(body=body).execute()
+        busy_times = []
+
+        for calendar_id in calendar_ids:
+            if "busy" in free_busy["calendars"][calendar_id]:
+                busy_times.extend(free_busy["calendars"][calendar_id]["busy"])
+
+        # Converti i periodi occupati in datetime oggetti
+        busy_intervals = [
+            (datetime.fromisoformat(entry["start"][:-1]), datetime.fromisoformat(entry["end"][:-1]))
+            for entry in busy_times
+        ]
+
+        return sorted(busy_intervals)
+    
+    except Exception as e:
+        print(f"❌ Error fetching free/busy information: {e}")
+        return []
+
+# Trova il primo slot disponibile per tutti i partecipanti
+def find_first_available_slot(service, calendar_ids, duration_minutes=30):
+
+    now = datetime.now(timezone.utc)
+    end_search = now + timedelta(days=7)  # Cerca nei prossimi 7 giorni
+
+    step = timedelta(minutes=15)  # Incremento per il controllo
+    meeting_duration = timedelta(minutes=duration_minutes)
+
+    current_time = now.replace(second=0, microsecond=0) + timedelta(minutes=15)  # Evita slot troppo vicini
+    while current_time < end_search:
+        next_time = current_time + meeting_duration
+
+        busy_intervals = get_free_busy(service, calendar_ids, current_time, next_time)
+
+        # Se non ci sono sovrapposizioni, lo slot è libero
+        if not any(start < next_time and end > current_time for start, end in busy_intervals):
+            return current_time.isoformat()  # Primo slot disponibile
+
+        # Prova il prossimo slot
+        current_time += step
+
+    return None  # Nessuno slot trovato
+
+
+
+# Esempio di utilizzo:
+if __name__ == "__main__":
+    '''
+    #Test - find an available slot among team members
+    service = authenticate_google()
+    calendar_ids = [""]
+    slot = find_first_available_slot(service, calendar_ids)
+
+    if slot:
+        print(f"First available slot: {slot}")
+    else:
+        print("No slot found in the next 7 days")
+
+    '''
+    # #Test - schdule a meeting
+    # meeting_id = ScheduleMeeting(
+    #     subject="Project Kickoff Meeting",
+    #     agenda="Discuss project progress and upcoming tasks.",
+    #     start_date="2025-02-22T16:30:00",
+    #     end_date="2025-02-22T17:30:00",
+    #     participants=[""]
+    # )
+    # print("Meeting ID:", meeting_id)
+    authenticate_google()
+   # '''

initial_state.json

@@ -0,0 +1,81 @@
+{
+  "team": [
+    "joyciliani@gmail.com",
+    "chiovelli.alessio@gmail.com",
+    "Nicola.caione@gmail.com",
+    "nicola.decuzzi.nd@gmail.com",
+    "dragos.baicu@edu.unifi.it"
+  ],
+  "tasks": [
+    {
+      "name": "UX/UI design",
+      "status": "open",
+      "start_date": "2025-02-21",
+      "end_date": "2025-02-22"
+    },
+    {
+      "name": "UX/UI coding",
+      "status": "to be started",
+      "start_date": "2025-02-22",
+      "end_date": "2025-02-23"
+    },
+    {
+      "name": "AI agents design",
+      "status": "open",
+      "start_date": "2025-02-21",
+      "end_date": "2025-02-22"
+    },
+    {
+      "name": "AI agents coding",
+      "status": "to be started",
+      "start_date": "2025-02-22",
+      "end_date": "2025-02-23"
+    },
+    {
+      "name": "Script video",
+      "status": "open",
+      "start_date": "2025-02-21",
+      "end_date": "2025-02-22"
+    },
+    {
+      "name": "Video making",
+      "status": "to be started",
+      "start_date": "2025-02-22",
+      "end_date": "2025-02-23"
+    },
+    {
+      "name": "Presentation design",
+      "status": "open",
+      "start_date": "2025-02-21",
+      "end_date": "2025-02-22"
+    },
+    {
+      "name": "Presentation implementation",
+      "status": "to be started",
+      "start_date": "2025-02-22",
+      "end_date": "2025-02-23"
+    }
+  ],
+  
+  "assignments": {
+    "joyciliani@gmail.com": [
+      "UX/UI design",
+      "Script video",
+      "Presentation design"
+    ],
+    "chiovelli.alessio@gmail.com": [
+      "UX/UI coding",
+      "AI agents design",
+      "AI agents coding"
+    ],
+    "Nicola.caione@gmail.com": [
+      "AI agents design",
+      "AI agents coding",
+      "Script video",
+      "Presentation design"
+    ],
+    "dragos.baicu@edu.unifi.it": [
+      "Video making"
+    ]
+  }
+}