user-simulator 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

user_sim/cli/sensei_chat.py

@@ -1,143 +1,64 @@
 import timeit
-import yaml
-import pandas as pd
 from argparse import Namespace
-from collections import Counter
-# from cli import parse_chat_arguments
-from argparse import ArgumentParser
-from colorama import Fore, Style
-# from technologies.chatbot_connectors import (Chatbot, ChatbotRasa, ChatbotTaskyto, ChatbotMillionBot,
-#                                              ChatbotServiceform)
+from cli import parse_chat_arguments
+from importlib.resources import files
 from user_sim.core.data_extraction import DataExtraction
 from user_sim.core.role_structure import *
 from user_sim.core.user_simulator import UserSimulator
 from user_sim.utils.show_logs import *
 from user_sim.utils.utilities import *
+from user_sim.utils import config
 from user_sim.utils.token_cost_calculator import create_cost_dataset
 from user_sim.utils.register_management import clean_temp_files
 from chatbot_connectors.cli import ChatbotFactory, parse_connector_params
 
-
 # check_keys(["OPENAI_API_KEY"])
-current_script_dir = os.path.dirname(os.path.abspath(__file__))
-root_path = os.path.abspath(os.path.join(current_script_dir, ".."))
-
-def print_user(msg):
-    clean_text = re.sub(r'\(Web page content: [^)]*>>\)', '', msg)
-    clean_text = re.sub(r'\(PDF content: [^)]*>>\)', '', clean_text)
-    clean_text = re.sub(r'\(Image description[^)]*\)', '', clean_text)
-    print(f"{Fore.GREEN}User:{Style.RESET_ALL} {clean_text}")
-
-
-def print_chatbot(msg):
-    clean_text = re.sub(r'\(Web page content:.*?\>\>\)', '', msg, flags=re.DOTALL)
-    clean_text = re.sub(r'\(PDF content:.*?\>\>\)', '', clean_text, flags=re.DOTALL)
-    clean_text = re.sub(r'\(Image description[^)]*\)', '', clean_text)
-    print(f"{Fore.LIGHTRED_EX}Chatbot:{Style.RESET_ALL} {clean_text}")
-
-def load_yaml_arguments(project_path):
-    files = os.listdir(project_path)
-
-    run_file = next((f for f in files if f in ["run.yml", "run.yaml"]), None)
-
-    if not run_file:
-        raise FileNotFoundError(f"Couldn't find run.yml file.")
-
-    run_yaml_path = os.path.join(project_path, run_file)
-
-    with open(run_yaml_path, 'r', encoding='utf-8') as f:
-        yaml_args = yaml.safe_load(f)
-
-        if yaml_args:
-            if "execution_parameters" in yaml_args.keys():
-                parameters = yaml_args["execution_parameters"]
-                dict_parameters = {param: True for param in parameters}
-                del yaml_args["execution_parameters"]
-                yaml_args.update(dict_parameters)
-
-    yaml_args["project_path"] = project_path
-
-    return yaml_args or {}
 
+def configure_project(project_path):
+    # sensei
+    config.src_path = files("src")
+    config.cache_path = files("data") / "cache"
+    config.pdfs_path = files("data") / "pdfs"
+    config.audio_files_path = files("data") / "audio_files"
+    config.default_types_path = files("config") / "types"
+    config.default_personalities_path = files("config") / "personalities"
+
+    # project
+    config.project_folder_path = project_path
+    config.profiles_path = os.path.join(project_path, "profiles")
+    config.custom_personalities_path = os.path.join(project_path, "personalities")
+    config.custom_types_path = os.path.join(project_path, "types")
+    custom_types = load_yaml_files_from_folder(config.custom_types_path)
 
-def load_yaml_files_from_folder(folder_path, existing_keys=None):
-    types = {}
-    for filename in os.listdir(folder_path):
-        if filename.endswith((".yml", ".yaml")):
-            file_path = os.path.join(folder_path, filename)
-            try:
-                with open(file_path, "r", encoding="utf-8") as f:
-                    data = yaml.safe_load(f)
-                    name = data.get("name")
-                    if name:
-                        if not existing_keys or name not in existing_keys:
-                            types[name] = data
-            except yaml.YAMLError as e:
-                logger.error(f"Error reading {file_path}: {e}")
-    return types
 
+    default_types = load_yaml_files_from_folder(config.default_types_path, existing_keys=custom_types.keys())
+    config.types_dict = {**default_types, **custom_types}
 
-def configure_project(project_path):
 
-    config.project_folder_path = project_path
-    config.profiles_path = os.path.join(project_path, "profiles")
-    config.custom_personalities_folder = os.path.join(project_path, "personalities")
+def _setup_configuration() -> Namespace:
+    """Parse command line arguments, validate config, and create output dir.
 
-    config.root_path = os.path.abspath(os.path.join(current_script_dir, "../../.."))
-    config.src_path = os.path.abspath(os.path.join(current_script_dir, "../.."))
+    Returns:
+        The parsed and validated command line arguments
 
-    custom_types_path = os.path.join(project_path, "types")
-    default_types_path = os.path.join(config.src_path, "config", "types")
+    Raises:
+        TracerError: If the specified technology is invalid
+    """
 
-    custom_types = load_yaml_files_from_folder(custom_types_path)
-    default_types = load_yaml_files_from_folder(default_types_path, existing_keys=custom_types.keys())
-    config.types_dict = {**default_types, **custom_types}
+    args = parse_chat_arguments()
 
-# def configure_connector(*args):
-#     connec = args[0]
-#     with open(connec, 'r', encoding='utf-8') as f:
-#         con_yaml = yaml.safe_load(f)
-#
-#
-#     if len(args)<2 or not con_yaml["parameters"]:
-#         logger.warning("No parameters added for connector configuration. They may not have been set as input arguments "
-#                     "or declared as dynamic parameters in the connector file.")
-#         return con_yaml
-#
-#     parameters = args[1]
-#     if isinstance(parameters, str):
-#         parameters = json.loads(parameters)
-#
-#     param_key_list = list(parameters.keys())
-#     if Counter(con_yaml["parameters"]) != Counter(param_key_list):
-#         raise UnmachedList("Parameters in yaml don't match parameters input in execution")
-#
-#     def replace_values(obj_dict, src_dict):
-#         for key in obj_dict:
-#             if isinstance(obj_dict[key], dict):
-#                 replace_values(obj_dict[key], src_dict)
-#             elif key in src_dict:
-#                 obj_dict[key] = src_dict[key]
-#
-#     replace_values(con_yaml, parameters)
-#     return con_yaml
-
-# def _setup_configuration() -> Namespace:
-#     """Parse command line arguments, validate config, and create output dir.
-#
-#     Returns:
-#         The parsed and validated command line arguments
-#
-#     Raises:
-#         TracerError: If the specified technology is invalid
-#     """
-#     args = parse_chat_arguments()
-#
-#     logger = create_logger(args.verbose, 'Info Logger')
-#     logger.info('Logs enabled!')
+    logger = create_logger(args.verbose, 'Info Logger')
+    logger.info('Logs enabled!')
 
+    configure_project(args.project_path)
 
+    # check_keys(["OPENAI_API_KEY"])
+    config.test_cases_folder = args.extract
+    config.ignore_cache = args.ignore_cache
+    config.update_cache = args.update_cache
+    config.clean_cache = args.clean_cache
 
+    return args
 
 
 def get_conversation_metadata(user_profile, the_user, serial=None):
@@ -162,6 +83,7 @@ def get_conversation_metadata(user_profile, the_user, serial=None):
 
         return conversation_list
 
+
     def ask_about_metadata(up):
         if not up.ask_about.variable_list:
             return up.ask_about.str_list
@@ -196,9 +118,9 @@ def get_conversation_metadata(user_profile, the_user, serial=None):
         return data_list
 
     def total_cost_calculator():
+        import pandas as pd
         encoding = get_encoding(config.cost_ds_path)["encoding"]
         cost_df = pd.read_csv(config.cost_ds_path, encoding=encoding)
-
         total_sum_cost = cost_df[cost_df["Conversation"]==config.conversation_name]['Total Cost'].sum()
         total_sum_cost = round(float(total_sum_cost), 8)
 
@@ -226,57 +148,19 @@ def get_conversation_metadata(user_profile, the_user, serial=None):
     return metadata
 
 
-def parse_profiles(user_path):
-    def is_yaml(file):
-        if not file.endswith(('.yaml', '.yml')):
-            return False
-        try:
-            with open(file, 'r') as f:
-                yaml.safe_load(f)
-            return True
-        except yaml.YAMLError:
-            return False
-
-    list_of_files = []
-    if os.path.isfile(user_path):
-        if is_yaml(user_path):
-            yaml_file = read_yaml(user_path)
-            return [yaml_file]
-        else:
-            raise Exception(f'The user profile file is not a yaml: {user_path}')
-    elif os.path.isdir(user_path):
-        for root, _, files in os.walk(user_path):
-            for file in files:
-                if is_yaml(os.path.join(root, file)):
-                    path = root + '/' + file
-                    yaml_file = read_yaml(path)
-                    list_of_files.append(yaml_file)
-
-            return list_of_files
-    else:
-        raise Exception(f'Invalid path for user profile operation: {user_path}')
-
-
 def build_chatbot(technology, connector):
-    # chatbot_builder = {
-    #     'rasa': RasaChatbot,
-    #     'taskyto': ChatbotTaskyto,
-    #     # 'serviceform': ChatbotServiceform(connector),
-    #     'millionbot': MillionBot,
-    #     'custom': CustomChatbot
-    # }
-    # chatbot_class = chatbot_builder.get(technology, CustomChatbot)
     parsed_connector = parse_connector_params(connector)
     chatbot = ChatbotFactory.create_chatbot(chatbot_type=technology, **parsed_connector)
     return chatbot
 
+
 def generate_conversation(technology, connector, user,
-                          personality, extract, project_folder):
+                          personality, output, project_folder):
     profiles = parse_profiles(user)
     serial = generate_serial()
     config.serial = serial
-    create_cost_dataset(serial, extract)
-    my_execution_stat = ExecutionStats(extract, serial)
+    create_cost_dataset(serial, output)
+    my_execution_stat = ExecutionStats(output, serial)
     the_chatbot = build_chatbot(technology, connector)
 
 
@@ -386,7 +270,7 @@ def generate_conversation(technology, connector, user,
                             the_user.update_history("Assistant", "Error: The server did not respond.")
                         break
 
-            if extract:
+            if output:
                 end_time_conversation = timeit.default_timer()
                 conversation_time = end_time_conversation - start_time_conversation
                 formatted_time_conv = timedelta(seconds=conversation_time).total_seconds()
@@ -397,7 +281,7 @@ def generate_conversation(technology, connector, user,
                 dg_dataframe = the_user.data_gathering.gathering_register
                 csv_extraction = the_user.goal_style[1] if the_user.goal_style[0] == 'all_answered' else False
                 answer_validation_data = (dg_dataframe, csv_extraction)
-                save_test_conv(history, metadata, test_name, extract, serial,
+                save_test_conv(history, metadata, test_name, output, serial,
                                formatted_time_conv, response_time, answer_validation_data, counter=i)
 
             config.total_individual_cost = 0
@@ -419,93 +303,31 @@ def generate_conversation(technology, connector, user,
     if config.clean_cache:
         clean_temp_files()
 
-    if extract and len(my_execution_stat.test_names) == len(profiles):
+    if output and len(my_execution_stat.test_names) == len(profiles):
         my_execution_stat.show_global_stats()
         my_execution_stat.export_stats()
-    elif extract:
+    elif output:
         logger.warning("Stats export was enabled but couldn't retrieve all stats. No stats will be exported.")
     else:
         pass
 
     end_alarm()
 
-def main():
-    parser = ArgumentParser(description='Conversation generator for a chatbot')
-
-    parser.add_argument('--run_from_yaml', type=str, help='Carga los argumentos desde un archivo YAML')
-
-    parser.add_argument('--technology', required=False,
-                        choices=['rasa', 'taskyto', 'ada-uam', 'millionbot', 'genion', 'lola', 'serviceform', 'kuki', 'julie', 'rivas_catalina', 'saic_malaga'],
-                        help='Technology the chatbot is implemented in')
-    # parser.add_argument('--connector', required=False, help='path to the connector configuration file')
-    parser.add_argument('--connector-params', required=False, help='dynamic parameters for the selected chatbot connector')
-    parser.add_argument('--project_path', required=False, help='Project folder PATH where all testing data is stored')
-    parser.add_argument('--user_profile', required=False, help='User profile file or user profile folder to test the chatbot')
-    parser.add_argument('--personality', required=False, help='Personality file')
-    parser.add_argument('--extract', default=False, help='Path to store conversation user-chatbot')
-    parser.add_argument('--verbose', action='store_true', help='Shows debug prints')
-    parser.add_argument('--clean_cache', action='store_true', help='Deletes temporary files.')
-    parser.add_argument('--ignore_cache', action='store_true', help='Ignores cache for temporary files')
-    parser.add_argument('--update_cache', action='store_true', help='Overwrites temporary files in cache')
-    parser_args, unknown_args = parser.parse_known_args()
-
-    if parser_args.run_from_yaml:
-        if len(sys.argv) > 3:  # sys.argv[0] is script, sys.argv[1] is --run_from_yaml, sys.argv[2] is YAML
-            parser.error("No other arguments can be provided when using --run_from_yaml.")
-
-        yaml_args = load_yaml_arguments(parser_args.run_from_yaml)
-
-        default_flags = {
-            "connector_parameters": None,
-            "personality": None,
-            "verbose": False,
-            "clean_cache": False,
-            "ignore_cache": False,
-            "update_cache": False
-        }
-        for flag, default in default_flags.items():
-            yaml_args.setdefault(flag, default)
-
-        class ArgsNamespace:
-            def __init__(self, **entries):
-                self.__dict__.update(entries)
-
-        parser_args = ArgsNamespace(**yaml_args)
-
-    else:
-        required_args = ['technology', 'user_profile', 'connector_params']
-        missing_args = [arg for arg in required_args if getattr(parser_args, arg) is None]
-
-        if missing_args:
-            parser.error(f"The following arguments are required when not using --run_from_yaml: {', '.join(missing_args)}")
-
-    configure_project(parser_args.project_path)
-    # config.root_path = os.path.abspath(os.path.join(current_script_dir, "../../.."))
-    # config.src_path = os.path.abspath(os.path.join(current_script_dir, "../.."))
-    profile_path = os.path.join(config.profiles_path, parser_args.user_profile)
-
-    print(config.src_path)
-
-
-
-    # check_keys(["OPENAI_API_KEY"])
-    config.test_cases_folder = parser_args.extract
-    config.ignore_cache = parser_args.ignore_cache
-    config.update_cache = parser_args.update_cache
-    config.clean_cache = parser_args.clean_cache
-
-    # if parser_args.connector_parameters:
-    #     connector = configure_connector(parser_args.connector, parser_args.connector_parameters)
-    # else:
-    #     connector = configure_connector(parser_args.connector)
-
-    connector = parser_args.connector_params
 
+def main():
+    args = _setup_configuration()
     try:
-        generate_conversation(parser_args.technology, connector, profile_path,
-                          parser_args.personality, parser_args.extract, parser_args.project_path)
+        generate_conversation(
+            technology = args.technology,
+            connector = args.connector_params,
+            user = os.path.join(config.profiles_path, args.user_profile),
+            personality = None, #todo: check this
+            output = args.output,
+            project_folder = args.project_path
+        )
     except Exception as e:
         logger.error(f"An error occurred while generating the conversation: {e}")
 
+
 if __name__ == '__main__':
     main()

user_sim/core/role_structure.py

@@ -1,6 +1,7 @@
 import itertools
 from pydantic import BaseModel, ValidationError, field_validator
 from typing import List, Union, Dict, Optional
+from importlib.resources import files
 from user_sim.core.interaction_styles import *
 from user_sim.core.ask_about import *
 from user_sim.utils.exceptions import *
@@ -277,11 +278,11 @@ class RoleData:
             personality = context["personality"]
 
             path_list = []
-            if os.path.exists(config.custom_personalities_folder):
-                custom_personalities_path = config.custom_personalities_folder
+            if os.path.exists(config.custom_personalities_path):
+                custom_personalities_path = config.custom_personalities_path
                 path_list.append(custom_personalities_path)
 
-            default_personalities_path = os.path.join(config.root_path,"src", "config", "personalities")
+            default_personalities_path = files("config") / "personalities"
             path_list.append(default_personalities_path)
 
             try:

user_sim/handlers/asr_module.py

@@ -2,6 +2,8 @@ import speech_recognition as sr
 from pydantic import BaseModel, ValidationError
 from typing import List, Union, Dict, Optional
 import time
+
+from user_sim.utils import config
 from user_sim.utils.utilities import read_yaml
 from user_sim.utils.token_cost_calculator import calculate_cost, max_input_tokens_allowed
 from openai import OpenAI
@@ -15,6 +17,7 @@ pygame.mixer.init()
 warnings.filterwarnings("ignore", category=FutureWarning, module="whisper")
 warnings.filterwarnings("ignore", category=RuntimeWarning, module="pydub")
 client = OpenAI()
+audio_files_path = config.audio_files_path
 audio_format = "mp3"
 
 
@@ -116,11 +119,11 @@ class STTModule:
             input=message,
             response_format=audio_format
         ) as response:
-            response.stream_to_file("data/audio_files/output." + audio_format)
+            response.stream_to_file(audio_files_path / f"output.{audio_format}")
 
         calculate_cost(message, model=self.model, module="tts_module")
         logger.info("Playing...")
-        audio_path = f"audio_files/output.{audio_format}"
+        audio_path = audio_files_path / f"output.{audio_format}"
         with open(audio_path, 'rb') as audio_file:
             pygame.mixer.music.load(audio_file)
             pygame.mixer.music.play()

user_sim/handlers/pdf_parser_module.py

@@ -12,6 +12,7 @@ from user_sim.handlers.image_recognition_module import image_description
 logger = logging.getLogger('Info Logger')
 current_script_dir = os.path.dirname(os.path.abspath(__file__))
 project_root = os.path.abspath(os.path.join(current_script_dir, "../.."))
+pdfs_dir = config.pdfs_path
 pdf_register_name = "pdf_register.json"
 
 

user_sim/utils/config.py

@@ -14,11 +14,19 @@ clean_cache = False
 root_path = ""
 project_folder_path = ""
 src_path = ""
+#data
+cache_path = ""
+pdfs_path = ""
+audio_files_path = ""
+#custom
 profiles_path = ""
-types_folder_path = ""
+custom_personalities_path = ""
+custom_types_path = ""
 test_cases_folder = ""
 types_dict = {}
-custom_personalities_folder = ""
+#default
+default_types_path = ""
+default_personalities_path = ""
 
 
 # cost metrics

user_sim/utils/register_management.py

@@ -2,10 +2,9 @@ import os
 import json
 import hashlib
 import logging
+from user_sim.utils import config
 
-current_script_dir = os.path.dirname(os.path.abspath(__file__))
-project_root = os.path.abspath(os.path.join(current_script_dir, "../..")) #change
-temp_file_dir = os.path.join(project_root, "data/cache")
+temp_file_dir = config.cache_path
 
 logger = logging.getLogger('Info Logger')
 

user_sim/utils/utilities.py

@@ -9,7 +9,7 @@ import importlib.util
 import logging
 import platform
 
-from typing import Any
+from colorama import Fore, Style
 from datetime import datetime, timedelta, date
 from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
@@ -36,6 +36,19 @@ logger = logging.getLogger('Info Logger')
 #         if not os.environ.get(k):
 #             raise Exception(f"{k} not found")
 
+def print_user(msg):
+    clean_text = re.sub(r'\(Web page content: [^)]*>>\)', '', msg)
+    clean_text = re.sub(r'\(PDF content: [^)]*>>\)', '', clean_text)
+    clean_text = re.sub(r'\(Image description[^)]*\)', '', clean_text)
+    print(f"{Fore.GREEN}User:{Style.RESET_ALL} {clean_text}")
+
+
+def print_chatbot(msg):
+    clean_text = re.sub(r'\(Web page content:.*?\>\>\)', '', msg, flags=re.DOTALL)
+    clean_text = re.sub(r'\(PDF content:.*?\>\>\)', '', clean_text, flags=re.DOTALL)
+    clean_text = re.sub(r'\(Image description[^)]*\)', '', clean_text)
+    print(f"{Fore.LIGHTRED_EX}Chatbot:{Style.RESET_ALL} {clean_text}")
+
 
 def end_alarm():
     os_name = platform.system()
@@ -64,57 +77,58 @@ def init_model():
     return model, llm
 
 
-# def parse_connector_params(connector_params_str: str | None) -> dict[str, Any]:
-#     """Parse connector parameters from string input.
-#
-#     Args:
-#         connector_params_str: JSON string or key=value pairs
-#
-#     Returns:
-#         Dictionary of connector parameters
-#
-#     Raises:
-#         ValueError: If parameter parsing fails
-#     """
-#     params = {}
-#
-#     if connector_params_str:
-#         try:
-#             # Try to parse as JSON first
-#             if connector_params_str.strip().startswith("{"):
-#                 params = json.loads(connector_params_str)
-#             else:
-#                 # Parse as key=value pairs
-#                 for pair in connector_params_str.split(","):
-#                     if "=" not in pair:
-#                         continue
-#                     key, value = pair.split("=", 1)
-#                     key = key.strip()
-#                     value = value.strip()
-#
-#                     # Try to convert to appropriate types
-#                     if value.lower() in ("true", "false"):
-#                         params[key] = value.lower() == "true"
-#                     elif value.isdigit():
-#                         params[key] = int(value)
-#                     else:
-#                         try:
-#                             params[key] = float(value)
-#                         except ValueError:
-#                             params[key] = value
-#
-#         except (json.JSONDecodeError, ValueError) as e:
-#             logger.exception("Failed to parse connector parameters: %s", connector_params_str)
-#             msg = f"Invalid connector parameters format: {e}"
-#             raise ValueError(msg) from e
-#
-#     return params
+def load_yaml_files_from_folder(folder_path, existing_keys=None):
+    types = {}
+    for filename in os.listdir(folder_path):
+        if filename.endswith((".yml", ".yaml")):
+            file_path = os.path.join(folder_path, filename)
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    data = yaml.safe_load(f)
+                    name = data.get("name")
+                    if name:
+                        if not existing_keys or name not in existing_keys:
+                            types[name] = data
+            except yaml.YAMLError as e:
+                logger.error(f"Error reading {file_path}: {e}")
+    return types
 
 
 def parse_content_to_text(messages):
     return " ".join([message["content"] for message in messages if "content" in message])
 
 
+def parse_profiles(user_path):
+    def is_yaml(file):
+        if not file.endswith(('.yaml', '.yml')):
+            return False
+        try:
+            with open(file, 'r') as f:
+                yaml.safe_load(f)
+            return True
+        except yaml.YAMLError:
+            return False
+
+    list_of_files = []
+    if os.path.isfile(user_path):
+        if is_yaml(user_path):
+            yaml_file = read_yaml(user_path)
+            return [yaml_file]
+        else:
+            raise Exception(f'The user profile file is not a yaml: {user_path}')
+    elif os.path.isdir(user_path):
+        for root, _, files in os.walk(user_path):
+            for file in files:
+                if is_yaml(os.path.join(root, file)):
+                    path = root + '/' + file
+                    yaml_file = read_yaml(path)
+                    list_of_files.append(yaml_file)
+
+            return list_of_files
+    else:
+        raise Exception(f'Invalid path for user profile operation: {user_path}')
+
+
 def get_encoding(encoded_file):
     with open(encoded_file, 'rb') as file:
         detected = detect(file.read())

{user_simulator-0.2.5.dist-info → user_simulator-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: user-simulator
-Version: 0.2.5
+Version: 0.3.0
 Summary: LLM-based user simulator for chatbot testing.
 Author: Alejandro Del Pozzo Escalera, Juan de Lara Jaramillo, Esther Guerra Sánchez
 License: MIT License
@@ -41,13 +41,16 @@ Requires-Dist: openai>=1.0.0
 Requires-Dist: pandas>=2.3.0
 Requires-Dist: pillow>=11.2.1
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: pymupdf>=1.26.1
+Requires-Dist: pymupdf==1.26.1
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: requests>=2.32.4
 Requires-Dist: scikit-learn>=1.7.0
 Requires-Dist: selenium>=4.33.0
+Requires-Dist: sqlalchemy==2.0.41
 Requires-Dist: twine>=6.1.0
+Requires-Dist: typing-extensions==4.13.2
 Requires-Dist: webdriver-manager>=4.0.2
+Requires-Dist: zstandard==0.23.0
 Dynamic: license-file
 
 # User simulator for chatbot testing