now saving personal, location and contractor details in the browser local storage correctly 😅

app.py

@@ -1,19 +1,21 @@
-import json
+import re
 
 import streamlit as st
 from streamlit import session_state as ss
-from streamlit_local_storage import LocalStorage
 
 from form.form import build_form_data_from_answers, write_pdf_form, work_categories
 from llm_manager.llm_parser import LlmParser
 from local_storage.entities import PersonalDetails, LocationDetails, ContractorDetails
+from local_storage.ls_manager import save_details, get_detail
 from prompts.prompts_manager import PromptsManager, Questions as Q
 from repository.repository import build_repo_from_environment, get_repository
 from repository import ModelRoles, Model
 from utils.parsing_utils import check_for_missing_answers
 
 user_msg = "Please describe what you need to do. To get the best results try to answer all the following questions:"
-ls: LocalStorage = LocalStorage()
+
+find_tags_regex = re.compile(r"(@\S)")
+
 class UIManager:
     def __init__(self):
         self.pm: PromptsManager = PromptsManager(work_categories=work_categories)
@@ -45,10 +47,14 @@ class UIManager:
 
     def build_ui_for_parsing_answers(self):
         self._build_base_ui()
+        with st.status("parsing user input for tags"):
+            tags = find_tags_regex.findall(ss["user_input"])
+            details = [get_detail(t) for t in tags]
+            ss["details"] = details
         with st.status("initialising LLM"):
             self.repository.init()
         with st.status("waiting for LLM"):
-            answer = self.repository.send_prompt(self.pm.verify_user_input_prompt(ss["user_input"]))
+            answer = self.repository.send_prompt(self.pm.verify_user_input_prompt(ss["user_input"], details))
             st.write(f"answers from LLM: {answer['content']}")
         with st.status("Checking for missing answers"):
             answers = LlmParser.parse_verification_prompt_answers(answer['content'])
@@ -80,15 +86,8 @@ class UIManager:
         with st.status("finding the work categories applicable to your work"):
             answer = self.repository.send_prompt(self.pm.get_work_category(ss["answers"][Q.WORK_TO_DO]))
             categories = LlmParser.parse_get_categories_answer(answer['content'])
-
-        with st.status("categories found, creating PDF form"):
-            form_data, filename = build_form_data_from_answers(ss["answers"], categories,
-                                                               ss.get("signature"))
-            pdf_form = write_pdf_form(form_data)
-            pdf_form_filename = filename
-            ss["pdf_form"] = pdf_form
-            ss["pdf_form_filename"] = pdf_form_filename
-            ss["step"] = "form_created"
+            ss["categories"] = categories
+            ss["step"] = "validate_data"
             st.rerun()
 
     def build_ui_for_form_created(self):
@@ -104,44 +103,44 @@ class UIManager:
                 del ss["signature"]
             st.rerun()
 
-    def build_ui_for_parsing_error(self):
-        def build_form_fragment(form_, col, title, add_save, *questions):
-            form_.text(title)
-            for user_data in questions:
-                with col:
-                    form_.text_input(self.pm.questions_to_field_labels()[user_data], value=ss.get("answers", {})
-                                     .get(user_data), key=f"fq_{user_data.name}")
-            if add_save:
-                with col:
-                    form_.text_input("Save as", key=title.replace(" ", "_"))
+    def _integrate_llm_answers_with_user_corrections(self):
+        for i in range(len(Q)):
+            ss["answers"][Q(i)] = ss[f"fq_{Q(i).name}"]
+
+        for details_key, func in [("your_details", self._get_personal_details),
+                                  ("location_details", self._get_location_details),
+                                  ("contractor_details", self._get_contractor_details)]:
+            details = func(details_key)
+            if details:
+                key = ss[details_key]  # get the name under which this data should be saved
+                save_details(details, key)
+        ss["step"] = "check_categories"
+        st.rerun()
 
-        self._build_base_ui()
-        f = st.form("Please check the following information and correct fix any inaccuracies")
-        col1, col2 = f.columns(2)
-        build_form_fragment(f, col1, "your details", True, Q.FULL_NAME, Q.CONTACT_NUMBER, Q.YOUR_EMAIL)
-        build_form_fragment(f, col2, "work details", False, Q.WORK_TO_DO, Q.START_DATE, Q.END_DATE)
-        build_form_fragment(f, col1, "location details",  True, Q.COMMUNITY, Q.BUILDING, Q.UNIT_APT_NUMBER,
-                            Q.OWNER_OR_TENANT)
-        build_form_fragment(f, col2, "contractor details", True, Q.COMPANY_NAME, Q.COMPANY_NUMBER, Q.COMPANY_EMAIL)
-        submit_data = f.form_submit_button()
-        if submit_data:
-            for i in range(len(Q)):
-                ss["answers"][Q(i)] = ss[f"fq_{Q(i).name}"]
-
-            for details_key, func in [("your_details", self._get_personal_details),
-                                      ("location_details", self._get_location_details),
-                                      ("contractor_details", self._get_contractor_details)]:
-                details = func(details_key)
-                if details:
-                    key = ss[details_key]  # get the name under which this data should be saved
-                    ls.setItem(key, json.dumps(details.__dict__), key)
-            ss["step"] = "check_category"
+    def _create_pdf_form(self):
+        with st.status("categories found, creating PDF form"):
+            form_data, filename = build_form_data_from_answers(ss["answers"], ss["categories"],
+                                                               ss.get("signature"))
+            pdf_form = write_pdf_form(form_data)
+            pdf_form_filename = filename
+            ss["pdf_form"] = pdf_form
+            ss["pdf_form_filename"] = pdf_form_filename
+            ss["step"] = "form_created"
             st.rerun()
 
+    def build_ui_for_validate_data_after_correction(self):
+        self._build_validation_form(False, self._integrate_llm_answers_with_user_corrections)
+
+    def build_ui_to_confirm_form_data(self):
+        self._build_validation_form(True, self._create_pdf_form)
+
+
     @staticmethod
     def _get_personal_details(personal_details_key) -> PersonalDetails | None:
-        if ss.get(personal_details_key):
-            return PersonalDetails(ss[f"fq_{Q.FULL_NAME.name}"], ss[f"fq_{Q.YOUR_EMAIL.name}"], ss[f"fq_{Q.CONTACT_NUMBER.name}"])
+        key_ = ss.get(personal_details_key)
+        if key_:
+            details = PersonalDetails(ss[f"fq_{Q.FULL_NAME.name}"], ss[f"fq_{Q.YOUR_EMAIL.name}"], ss[f"fq_{Q.CONTACT_NUMBER.name}"])
+            return details
         return None
 
     @staticmethod
@@ -159,6 +158,34 @@ class UIManager:
         return None
 
 
+
+    def _build_validation_form(self, show_categories:bool, onsubmit):
+        def build_form_fragment(form_, col, title, add_save, *questions):
+            form_.text(title)
+            for user_data in questions:
+                with col:
+                    form_.text_input(self.pm.questions_to_field_labels()[user_data], value=ss.get("answers", {})
+                                     .get(user_data), key=f"fq_{user_data.name}")
+            if add_save:
+                with col:
+                    form_.text_input("Save as", key=title.replace(" ", "_"))
+
+        self._build_base_ui()
+        f = st.form("Please check the following information and correct fix any inaccuracies")
+        col1, col2 = f.columns(2)
+        build_form_fragment(f, col1, "your details", True, Q.FULL_NAME, Q.CONTACT_NUMBER, Q.YOUR_EMAIL)
+        build_form_fragment(f, col2, "work details", False, Q.WORK_TO_DO, Q.START_DATE, Q.END_DATE)
+        build_form_fragment(f, col1, "location details",  True, Q.COMMUNITY, Q.BUILDING, Q.UNIT_APT_NUMBER,
+                            Q.OWNER_OR_TENANT)
+        build_form_fragment(f, col2, "contractor details", True, Q.COMPANY_NAME, Q.COMPANY_NUMBER, Q.COMPANY_EMAIL)
+        if show_categories:
+            for k, wc in work_categories.items():
+                f.checkbox(label=wc, key=k, value=k in ss["categories"])
+
+        submit_data = f.form_submit_button()
+        if submit_data:
+            onsubmit()
+
 def use_streamlit():
 
     um = UIManager()
@@ -168,11 +195,13 @@ def use_streamlit():
     if um.get_current_step() == "parsing_answers":
         um.build_ui_for_parsing_answers()
     if um.get_current_step() == "parsing_error":
-        um.build_ui_for_parsing_error()
+        um.build_ui_for_validate_data_after_correction()
     if um.get_current_step() == "ask_again":
         um.build_ui_for_ask_again()
     if um.get_current_step() == "check_category":
         um.build_ui_for_check_category()
+    if um.get_current_step() == "validate_form_data":
+        um.build_ui_to_confirm_form_data()
     if um.get_current_step() == "form_created":
         um.build_ui_for_form_created()
 

form/form.py

@@ -116,4 +116,5 @@ work_categories = {"other_work": "other work", "civil": "Civil work, masonry",
                    "kitchen_refurbish": "kitchen renovation or refurbishment",
                    "lights_and_sockets": "installation of lights, ceiling lights, power sockets",
                    "painting_wallpapering": "painting, wallpaper installation",
-                   "seating_area_barbecuing_fountain": "installation or renovation of outdoor structures such as seating area, barbecuing area or fountains"}
+                   "seating_area_barbecuing_fountain": "installation or renovation of outdoor structures such "
+                                                       "as seating area, barbecuing area or fountains"}

local_storage/entities.py

@@ -1,31 +1,37 @@
 import abc
-import json
+from enum import Enum
 
-from streamlit_local_storage import LocalStorage
 
-ls: LocalStorage = LocalStorage()
+class DetailsType(Enum):
+    PERSONAL_DETAILS = 1
+    LOCATION_DETAILS = 2
+    CONTRACTOR_DETAILS = 3
+
+    @classmethod
+    def values(cls):
+        return [cls.PERSONAL_DETAILS, cls.LOCATION_DETAILS, cls.CONTRACTOR_DETAILS]
 
 
 class SavedDetails(abc.ABC):
-    def __init__(self, type_: str):
-        self.type_ = type_
 
-    def save_to_local_storage(self, key: str):
-        ls.setItem(key, json.dumps(self.__dict__))
+    excluded_fields = ["type_"]
+    def __init__(self, type_: DetailsType):
+        self.type_ = type_
 
     @classmethod
-    def load(cls, json_data: str):
-        data = json.loads(json_data)
+    def load(cls, data: dict):
         type_ = data.get("type_")
         if not type_ or type_ != cls.type_:
             raise ValueError(f"the expected type is {cls.type_} but is actually {type_}")
         return cls.__init__(**{k: v for k, v in data if k != "type"})
 
+    def to_json(self):
+        return {k:v for k,v in self.__dict__.items() if k not in self.excluded_fields}
 
 class PersonalDetails(SavedDetails):
-    type_ = "personal_details"
+    type_ = DetailsType.PERSONAL_DETAILS
 
-    def __init__(self, full_name, email, contact_number):
+    def __init__(self, full_name, email, contact_number, *_):
         super().__init__(self.type_)
         self.full_name = full_name
         self.email = email
@@ -33,9 +39,9 @@ class PersonalDetails(SavedDetails):
 
 
 class LocationDetails(SavedDetails):
-    type_ = "location_details"
+    type_ = DetailsType.LOCATION_DETAILS
 
-    def __init__(self, owner_or_tenant: str, community: str, building: str, unit_number: str):
+    def __init__(self, owner_or_tenant: str, community: str, building: str, unit_number: str, *_):
         super().__init__(self.type_)
         self.owner_or_tenant = owner_or_tenant
         self.community = community
@@ -44,9 +50,9 @@ class LocationDetails(SavedDetails):
 
 
 class ContractorDetails(SavedDetails):
-    type_ = "contractor_details"
+    type_ = DetailsType.CONTRACTOR_DETAILS
 
-    def __init__(self, contractor_name:str, contractor_contact_number:str, contractor_email:str):
+    def __init__(self, contractor_name: str, contractor_contact_number: str, contractor_email: str, *_):
         super().__init__(self.type_)
         self.contractor_name = contractor_name
         self.contractor_contact_number = contractor_contact_number

local_storage/ls_manager.py

@@ -0,0 +1,41 @@
+import json
+
+from streamlit_local_storage import LocalStorage
+
+from local_storage.entities import DetailsType, SavedDetails, PersonalDetails, LocationDetails, ContractorDetails
+
+ls = LocalStorage()
+
+
+def get_detail(key: str):
+    for detail_type in DetailsType.values():
+        detail = json.loads((ls.getItem(detail_type.name) or {}).get(key))
+        if detail:
+            type_ = detail["type"]
+            if type_ == DetailsType.PERSONAL_DETAILS.name:
+                return PersonalDetails(**detail)
+            elif type_ == DetailsType.LOCATION_DETAILS.name:
+                return LocationDetails(**detail)
+            elif type_ == DetailsType.CONTRACTOR_DETAILS.name:
+                return ContractorDetails(**detail)
+            return None
+    return None
+
+
+def save_details(details: SavedDetails, key: str):
+    if isinstance(details, PersonalDetails):
+        type_ = DetailsType.PERSONAL_DETAILS
+    elif isinstance(details, LocationDetails):
+        type_ = DetailsType.LOCATION_DETAILS
+    elif isinstance(details, ContractorDetails):
+        type_ = DetailsType.CONTRACTOR_DETAILS
+    else:
+        raise ValueError("Unexpected type: {}", type(details))
+    existing_data = json.loads(ls.getItem(type_.name) or "{}")
+    existing_data[key] = details.to_json()
+    ls.setItem(type_.name, existing_data, type_.name)
+
+
+def get_details(type_: DetailsType):
+    return json.loads((ls.getItem(type_.name) or "{}"))
+

prompts/prompts_manager.py

@@ -2,6 +2,7 @@ import datetime
 from enum import Enum
 from pathlib import Path
 
+from local_storage.entities import DetailsType, SavedDetails
 from utils.date_utils import get_today_date_as_dd_mm_yyyy
 
 
@@ -33,13 +34,18 @@ class PromptsManager:
             todays_date = get_today_date_as_dd_mm_yyyy()
             verification_prompt = verification_prompt.replace("{today}", todays_date)
             self.verification_prompt: str = verification_prompt
+            self.verification_prompt_questions = self.verification_prompt.split("\n")
 
-    def verify_user_input_prompt(self, user_prompt) -> str:
-        return (
-            f"Using only this information \n {user_prompt} \n answer the following questions, for each question that you cannot answer just answer 'null'. "
-            f"Put each answer in a new line, keep the answer brief "
-            f"and maintain the order in which the questions are asked. Do not add any preamble: "
-            f"{self.verification_prompt}")
+    def verify_user_input_prompt(self, user_prompt, exclude_questions_group: list[SavedDetails] = None) -> str:
+        prompt = f"""
+            Using only this information \n {user_prompt} \n answer the following questions, for each question that you cannot answer just answer 'null'.
+            Put each answer in a new line, keep the answer brief 
+            and maintain the order in which the questions are asked. Do not add any preamble:
+        """
+
+        skip_questions = [self.get_questions(d) for d in exclude_questions_group]
+        questions = [q for idx, q in enumerate(self.verification_prompt_questions) if idx not in skip_questions]
+        return prompt + "\n".join(questions)
 
     def get_work_category(self, work_description: str) -> str:
         return (
@@ -57,4 +63,11 @@ class PromptsManager:
             Questions.COMPANY_NAME: "Contractor company name", Questions.COMPANY_EMAIL: "Contracting company email",
             Questions.COMPANY_NUMBER: "Contracting company contact number", Questions.YOUR_EMAIL: "Your email"
         }
+    def get_questions(self, type_:DetailsType):
+        if type_ == DetailsType.PERSONAL_DETAILS:
+            return [Questions.FULL_NAME, Questions.CONTACT_NUMBER, Questions.YOUR_EMAIL]
+        if type_ == DetailsType.CONTRACTOR_DETAILS:
+            return [Questions.COMPANY_NAME, Questions.COMPANY_NUMBER, Questions.COMPANY_EMAIL]
+        if type_ == DetailsType.LOCATION_DETAILS:
+            return [Questions.OWNER_OR_TENANT, Questions.COMMUNITY, Questions.BUILDING, Questions.UNIT_APT_NUMBER]