Upload 7 files

APIModules/APIs/BasePage.py

@@ -0,0 +1,28 @@
+from . import st, ABC, abstractmethod
+
+class BasePage(ABC):
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(BasePage, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, 'initialized'):
+            self.api_keys = []
+            self.initialized = True
+
+    @abstractmethod
+    def render(self, keys : dict[str, str | None], **kwargs):
+        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")
+            st.divider()

APIModules/APIs/ChatModelPage.py

@@ -0,0 +1,302 @@
+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, 
+    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 = }')
+
+        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):
+        super().__init__()
+        self.model = None
+        self.router_agent = RouterAgent()
+
+    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"]):
+                st.markdown(message["content"])
+        # React to user input
+        if prompt := st.chat_input("type 'commands' or 'explain' to see the available commands"):
+            # Display user message in chat message container
+            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, 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
+            st.session_state.messages.append({"role": "assistant", "content": response})
+    
+    def init_messages(self):
+        # Initialize chat history
+        if "messages" not in st.session_state:
+            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
+        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:
+            # Reset chat history
+            if st.button("Reset chat"):
+                st.session_state.messages = []
+
+    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"""
+                    button {{
+                        background-image: url("data:image/png;base64,{get_base64_image("static/NewCallButton.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 = "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()
+            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:
+            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):
+        for member in st.session_state.team:
+            st.write(member)
+        # st.image("static/2.png")
+
+    def tasks(self):
+        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):
+        st.subheader("IBM Granite Hackaton")
+
+    # def choose_agent(self):
+    #     # Choose agent
+    #     class RouterAgent:
+    #         def __call__(self, **kwargs):
+    #             agent_prompt_slash_code = re.findall(r"(\/[\w\-_]*) *(.*)", kwargs.get('prompt'))
+    #             uri = agent_prompt_slash_code[0][0]
+    #             prompt = agent_prompt_slash_code[0][1]
+    #             response = requests.post(os.getenv("BACKEND_URL") + f'/{uri}', json = {"prompt" : prompt})
+    #             if response.status_code != 200:
+    #                 st.error(f"Error: {response.text}")
+    #                 return
+    #             return response.json()
+    #     # agents = {
+    #     #     "Dummy Agent": {
+    #     #         "_class" : RouterAgent,
+    #     #     },
+    #     #     "Meeting Scheduler Agent": {
+    #     #         "_class" : DummyAgent,
+    #     #     }
+    #     # }
+    #     # agent_selected = st.sidebar.selectbox("Select agent", list(agents.keys()))
+    #     # agent_init_js = agents[agent_selected]
+    #     RouterAgent()
+    #     agent_class = agent_init_js.pop("_class")
+    #     return agent_class(**agent_init_js)

APIModules/APIs/ConfigPage.py

@@ -0,0 +1,50 @@
+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")})
+        initial_state_from_json : dict = st.session_state.get("INITIAL_STATE", {})
+        if st.button("use_preloaded_state"):
+            with open("initial_state.json") as f:
+                initial_state_from_json : dict = json.load(f)
+                st.session_state.INITIAL_STATE = initial_state_from_json
+                st.rerun()
+        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

APIModules/APIs/Dashboard.py

@@ -0,0 +1,72 @@
+from . import os, st, stylable_container
+from .BasePage import BasePage
+
+from .modals import get_base64_image, create_call_modal, upload_call_modal_and_actions
+
+class Dashboard(BasePage):
+    def render(self):
+        st.title("Dashboard")
+        self.sidebar_elements()
+        self.upfront_page()
+
+    def upfront_page(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"""
+                    #     button {{
+                    #         background-image: url("data:image/png;base64,{get_base64_image("static/NewCallButton.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("create-call-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('upload-call-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()
+
+    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()
+
+    def team(self):
+        teams_per_project = {"Projects": "Team1", "Projects2": "Team2", "Projects3": "Team3"}
+        st.write(teams_per_project[st.session_state.selected_project])
+        # st.image("static/2.png")
+
+    def tasks(self):
+        st.write("Tasks")
+
+    def projects(self):
+        st.header("IBM-Granite-Hackaton")
+        st.divider()

APIModules/APIs/__init__.py

@@ -0,0 +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 APIModules.APIs.agents_router import (
+    PromptRequest,
+    TranscriptRequest,
+    UpdateTasksFromTranscriptRequest,
+    explain_agents,
+    APIS
+)

APIModules/APIs/load_css.py

@@ -0,0 +1,10 @@
+from . import  st
+
+def render_css(file_path):
+    with open(file_path, 'r') as file:
+        css_content = file.read()
+        st.markdown(f'<style>{css_content}</style>', unsafe_allow_html=True)
+
+# Example usage
+if __name__ == "__main__":
+    render_css('path_to_your_css_file.css')

APIModules/APIs/modals.py

@@ -0,0 +1,131 @@
+import random
+import docx
+from PyPDF2 import PdfFileReader
+import io
+
+from . import st, base64, os, requests, partial, PromptRequest, APIS
+from .load_css import render_css
+
+st.markdown(f'<style></style>', unsafe_allow_html=True)
+
+def get_base64_image(image_path : str):
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode()
+    
+@st.dialog("Create a Call")
+def create_call_modal():
+    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 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](prompt)
+
+@st.dialog("Upload a Call")
+def upload_call_modal_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 ""
+    buttons = {
+        # "Crea minuta": minuta_action_from_uploaded_call, 
+        # "Genera trascritto": transcript_action_from_uploaded_call, 
+        "QA from transcripts": partial(qa_from_transcripts, Transcript = transcript_text), 
+        "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"):
+        st.download_button("Scarica minuta", data = "moc_minuta.txt")
+
+def transcript_action_from_uploaded_call():
+    if st.button("Crea transcript"):
+        st.download_button("Scarica transcript", data = "moc_transcript.txt")
+    
+def get_transcript_text(uploaded_file):
+    if uploaded_file is not None:
+        file_extension = os.path.splitext(uploaded_file.name)[1].lower()
+        if file_extension == '.txt':
+            return get_text_from_txt(uploaded_file)
+        elif file_extension in ['.doc', '.docx']:
+            return get_text_from_doc(uploaded_file)
+        elif file_extension == '.pdf':
+            return get_text_from_pdf(uploaded_file)
+    return ""
+
+def get_text_from_txt(uploaded_file):
+    return uploaded_file.read().decode("utf-8")
+
+def get_text_from_doc(uploaded_file):
+    doc = docx.Document(uploaded_file)
+    return "\n".join([para.text for para in doc.paragraphs])
+
+def get_text_from_pdf(uploaded_file):
+    reader = PdfFileReader(io.BytesIO(uploaded_file.read()))
+    text = ""
+    for page_num in range(reader.getNumPages()):
+        text += reader.getPage(page_num).extract_text()
+    return text
+
+
+def qa_from_transcripts(Transcript : str):
+    Prompt = st.text_area("Prompt")
+    Transcript = st.text_area("Transcript")
+    Tasks = "\n\n".join(st.multiselect("Tasks", options = ["Task 1", "Task 2", "Task 3"]))
+    if st.button("QA from transcripts"):
+        response = requests.post(os.getenv("QA_TRANSCRIPT_ENDPOINT", "http://127.0.0.1:5000/transcript") , 
+            json = {
+                "prompt": Prompt,
+                "transcript" : Transcript or "",
+                "tasks": Tasks or [],
+            })
+        st.success(response.json())
+        return 
+
+def create_tasks_action_from_uploaded_call_transcript(Transcript : str):
+
+    if st.button("create_tasks"):
+        response = requests.post(os.getenv("QA_TRANSCRIPT_ENDPOINT", "http://127.0.0.1:5000/tasks/from_transcript") , json = {"transcript" : Transcript})
+        st.session_state.tasks = st.success(response.json())
+        return 
+    if st.session_state.get('tasks'):
+        task = st.selectbox("Select a task", st.session_state.tasks)
+        task_matchmaking(task)
+
+def task_matchmaking(task : str):
+    cols = st.columns(2)
+    with cols[0]:
+        st.markdown("### Task matchmaking")
+    with cols[1]:
+        st.multiselect("People", ["Alice", "Bob", "Charlie"])
+    if st.button("Assign"):
+        st.success("Task assigned")