bertrend 0.3.1__py3-none-any.whl

bertrend/__init__.py

@@ -0,0 +1,59 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+import os
+from pathlib import Path
+
+from bertrend.utils.config_utils import load_toml_config
+
+# Default config files path
+BERTOPIC_DEFAULT_CONFIG_PATH = (
+    Path(__file__).parent / "config" / "bertopic_default_config.toml"
+)
+BERTREND_DEFAULT_CONFIG_PATH = (
+    Path(__file__).parent / "config" / "bertrend_default_config.toml"
+)
+SERVICES_DEFAULT_CONFIG_PATH = (
+    Path(__file__).parent / "config" / "services_default_config.toml"
+)
+
+# Read config
+BERTOPIC_CONFIG = load_toml_config(BERTOPIC_DEFAULT_CONFIG_PATH)
+BERTREND_CONFIG = load_toml_config(BERTREND_DEFAULT_CONFIG_PATH)
+SERVICES_CONFIG = load_toml_config(SERVICES_DEFAULT_CONFIG_PATH)
+
+EMBEDDING_CONFIG = SERVICES_CONFIG["embedding_service"]
+LLM_CONFIG = SERVICES_CONFIG["llm_service"]
+
+# Linux command to find the index of the GPU device currently less used than the others
+BEST_CUDA_DEVICE = r"\`nvidia-smi --query-gpu=index,memory.used --format=csv,nounits | tail -n +2 | sort -t',' -k2 -n  | head -n 1 | cut -d',' -f1\`"
+
+BERTREND_BASE_DIR = os.getenv("BERTREND_BASE_DIR", None)
+BASE_PATH = (
+    Path(BERTREND_BASE_DIR)
+    if BERTREND_BASE_DIR
+    else Path(__file__).parent.parent.parent
+)
+
+# Base dirs
+DATA_PATH = BASE_PATH / "data"
+CACHE_PATH = BASE_PATH / "cache"
+OUTPUT_PATH = BASE_PATH / "output"
+CONFIG_PATH = BASE_PATH / "config"
+
+FEED_BASE_PATH = DATA_PATH / "feeds"
+BERTREND_LOG_PATH = BASE_PATH / "logs"
+
+# Weak signals
+MODELS_DIR = CACHE_PATH / "models"
+ZEROSHOT_TOPICS_DATA_DIR = CACHE_PATH / "zeroshot_topics_data"
+SIGNAL_EVOLUTION_DATA_DIR = CACHE_PATH / "signal_evolution_data"
+
+# Create directories if they do not exist
+DATA_PATH.mkdir(parents=True, exist_ok=True)
+OUTPUT_PATH.mkdir(parents=True, exist_ok=True)
+CACHE_PATH.mkdir(parents=True, exist_ok=True)
+CONFIG_PATH.mkdir(parents=True, exist_ok=True)
+BERTREND_LOG_PATH.mkdir(parents=True, exist_ok=True)
+MODELS_DIR.mkdir(parents=True, exist_ok=True)

bertrend/config/bertopic_default_config.toml

@@ -0,0 +1,48 @@
+# Default configuration file to be used for topic model
+
+# Global parameters
+[global]
+language = "French"
+
+# BERTopic parameters: https://maartengr.github.io/BERTopic/api/bertopic.html#bertopic._bertopic.BERTopic.__init__
+[bertopic_model]
+top_n_words = 10
+verbose = true
+representation_model = ["MaximalMarginalRelevance"] # KeyBERTInspired, OpenAI
+zeroshot_topic_list = []
+zeroshot_min_similarity = 0
+
+# UMAP parameters: https://umap-learn.readthedocs.io/en/latest/api.html
+[umap_model]
+n_neighbors = 5
+n_components = 5
+min_dist = 0.0
+metric = "cosine"
+random_state = 42
+
+# HDBSCAN parameters: https://hdbscan.readthedocs.io/en/latest/api.html
+[hdbscan_model]
+min_cluster_size = 5
+min_samples = 5
+metric = "euclidean"
+cluster_selection_method = "eom"
+prediction_data = true
+
+# CountVectorizer: https://scikit-learn.org/1.5/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html
+[vectorizer_model]
+ngram_range = [1, 1]
+stop_words = true # If true, will check `language` parameter and load associated stopwords file
+min_df = 2
+
+# ClassTfidfTransformer: https://maartengr.github.io/BERTopic/api/ctfidf.html
+[ctfidf_model]
+bm25_weighting = false
+reduce_frequent_words = true
+
+# MaximalMarginalRelevance: https://maartengr.github.io/BERTopic/api/representation/mmr.html
+[mmr_model]
+diversity = 0.3
+
+# Reduce outliers: https://maartengr.github.io/BERTopic/api/bertopic.html#bertopic._bertopic.BERTopic.reduce_outliers
+[reduce_outliers]
+strategy = "c-tf-idf"

bertrend/config/bertrend_default_config.toml

@@ -0,0 +1,16 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+
+# BERTrend Hyperparameters
+
+# Data split settings
+granularity = 2
+# Merge model settings
+min_similarity = 0.7
+# Signal popularity settings
+decay_factor = 0.01
+decay_power = 2
+signal_classif_lower_bound = 10
+signal_classif_upper_bound = 75

bertrend/config/parameters.py

@@ -0,0 +1,92 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+
+import json
+from pathlib import Path
+
+import torch
+
+from bertrend import BERTREND_CONFIG, EMBEDDING_CONFIG
+
+stopwords_en_file = Path(__file__).parent.parent / "resources" / "stopwords-en.json"
+stopwords_fr_file = Path(__file__).parent.parent / "resources" / "stopwords-fr.json"
+stopwords_rte_file = Path(__file__).parent.parent / "resources" / "stopwords-rte.json"
+common_ngrams_file = Path(__file__).parent.parent / "resources" / "common_ngrams.json"
+with open(stopwords_en_file, "r", encoding="utf-8") as file:
+    ENGLISH_STOPWORDS = json.load(file)
+with open(stopwords_fr_file, "r", encoding="utf-8") as file:
+    FRENCH_STOPWORDS = json.load(file)
+with open(stopwords_rte_file, "r", encoding="utf-8") as file:
+    STOP_WORDS_RTE = json.load(file)
+with open(common_ngrams_file, "r", encoding="utf-8") as file:
+    COMMON_NGRAMS = json.load(file)
+
+STOPWORDS = STOP_WORDS_RTE + COMMON_NGRAMS + FRENCH_STOPWORDS
+
+# File names
+STATE_FILE = "app_state.pkl"
+EMBEDDINGS_FILE = "embeddings.npy"
+BERTREND_FILE = "bertrend.dill"
+DOC_INFO_DF_FILE = "doc_info_df.pkl"
+TOPIC_INFO_DF_FILE = "topic_info_df.pkl"
+
+# Model file names
+ZEROSHOT_TOPICS_DATA_FILE = "zeroshot_topics_data.json"
+INDIVIDUAL_MODEL_TOPIC_COUNTS_FILE = "individual_topic_counts.json"
+CUMULATIVE_MERGED_TOPIC_COUNTS_FILE = "cumulative_topic_counts.json"
+
+# Embedding models
+ENGLISH_EMBEDDING_MODELS = [
+    "all-mpnet-base-v2",
+    "Alibaba-NLP/gte-base-en-v1.5",
+    "all-MiniLM-L12-v2",
+]
+FRENCH_EMBEDDING_MODELS = [
+    "OrdalieTech/Solon-embeddings-base-0.1",
+    "OrdalieTech/Solon-embeddings-large-0.1",
+    "dangvantuan/sentence-camembert-large",
+    "antoinelouis/biencoder-distilcamembert-mmarcoFR",
+]
+
+# MODEL REPRESENTATIONS
+MMR_REPRESENTATION_MODEL = "MaximalMarginalRelevance"
+KEYBERTINSPIRED_REPRESENTATION_MODEL = "KeyBERTInspired"
+OPENAI_REPRESENTATION_MODEL = "OpenAI"
+
+# BERTopic Hyperparameters
+BERTOPIC_SERIALIZATION = "safetensors"  # or pickle
+LANGUAGES = ["French", "English"]
+REPRESENTATION_MODELS = [
+    MMR_REPRESENTATION_MODEL,
+    KEYBERTINSPIRED_REPRESENTATION_MODEL,
+    OPENAI_REPRESENTATION_MODEL,
+]
+
+# BERTrend parameters
+SIGNAL_CLASSIF_LOWER_BOUND = BERTREND_CONFIG["signal_classif_lower_bound"]
+SIGNAL_CLASSIF_UPPER_BOUND = BERTREND_CONFIG["signal_classif_upper_bound"]
+
+# Embedding Settings
+EMBEDDING_DTYPES = EMBEDDING_CONFIG["embedding_dtypes"]
+EMBEDDING_BATCH_SIZE = EMBEDDING_CONFIG["embedding_batch_size"]
+EMBEDDING_MAX_SEQ_LENGTH = EMBEDDING_CONFIG["embedding_max_seq_length"]
+EMBEDDING_DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Representation models parameters
+KEYBERT_NR_REPR_DOCS = (5,)
+KEYBERT_NR_CANDIDATE_WORDS = (40,)
+KEYBERT_TOP_N_WORDS = 20
+OPENAI_NR_DOCS = 5
+
+# Data Processing
+MIN_CHARS_DEFAULT = 1
+SAMPLE_SIZE_DEFAULT = 1.0  # Or whatever default you want, None means all documents
+
+# Time Settings
+DEFAULT_WINDOW_SIZE = 7  # days
+MAX_WINDOW_SIZE = 365  # days
+
+# Data Analysis Settings
+POPULARITY_THRESHOLD = 0.1  # for weak signal detection, if applicable

bertrend/config/services_default_config.toml

@@ -0,0 +1,32 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+
+# Embedding service parameters
+[embedding_service]
+# Indicates if BERTrend shall use a local embedding service (run by BERTrend) or if the embedding service
+# is delegated to an external service. If set to false, the other properties shall be set properly.
+# It is generally more efficient to use a dedicated service for embeddings.
+use_local = true
+model_name = "OrdalieTech/Solon-embeddings-large-0.1"
+url = "https://10.132.5.44:6464"
+embedding_dtypes = ["float32", "float16", "bfloat16"]
+embedding_batch_size = 2048
+embedding_max_seq_length = 512
+
+# LLM service parameters
+[llm_service]
+# Specifies here the information about the LLM to be used to benefit from some LLM features such as
+# improved topic description and topic analysis over time
+# If empty, these features will not be available
+# BERTrend can use any kind of openai-compatible deployment such as
+# - local LLM deployed with VLLM or similar libraries
+# - the official OpenAI endpoint
+# - models deployed on Azure cloud
+api_key = "$AZURE_SE_WATTELSE_OPENAI_API_KEY_DEV"
+endpoint = "$AZURE_SE_WATTELSE_OPENAI_ENDPOINT_DEV"
+model = "$AZURE_SE_WATTELSE_OPENAI_DEFAULT_MODEL_NAME_DEV"
+temperature = 0.1
+max_output_tokens = 2048
+system_prompt = "You are a helpful assistant, skilled in detailing topic evolution over time for the detection of emerging trends and signals."

bertrend/demos/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.

bertrend/demos/demos_utils/__init__.py

@@ -0,0 +1,13 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+import streamlit as st
+
+
+def is_admin_mode() -> bool:
+    """Indicates whether the application is in an admin mode."""
+    admin_param = st.query_params.get("admin")
+    if not admin_param:
+        return False
+    return admin_param.lower() == "true"

bertrend/demos/demos_utils/data_loading_component.py

@@ -0,0 +1,267 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import pandas as pd
+import streamlit as st
+from streamlit.runtime.uploaded_file_manager import UploadedFile
+
+from bertrend import DATA_PATH
+from bertrend.demos.demos_utils.icons import (
+    WARNING_ICON,
+    JSON_ICON,
+    CSV_ICON,
+    PARQUET_ICON,
+    XLSX_ICON,
+    CLIENT_STORAGE_ICON,
+    SERVER_STORAGE_ICON,
+)
+from bertrend.demos.demos_utils.messages import NO_DATA_AFTER_PREPROCESSING_MESSAGE
+from bertrend.demos.demos_utils.state_utils import (
+    save_widget_state,
+    register_widget,
+    SessionStateManager,
+)
+from bertrend.config.parameters import MIN_CHARS_DEFAULT, SAMPLE_SIZE_DEFAULT
+from bertrend.utils.data_loading import (
+    find_compatible_files,
+    TEXT_COLUMN,
+    load_data,
+    split_data,
+    TIMESTAMP_COLUMN,
+)
+
+NO_DATASET_WARNING = "Please select at least one dataset to proceed."
+FORMAT_ICONS = {
+    "xlsx": XLSX_ICON,
+    "csv": CSV_ICON,
+    "parquet": PARQUET_ICON,
+    "json": JSON_ICON,
+    "jsonl": JSON_ICON,
+    "jsonlines": JSON_ICON,
+    "jsonl.gz": JSON_ICON,
+}
+
+
+def _process_uploaded_files(
+    files: list[UploadedFile],
+) -> list[pd.DataFrame]:
+    """Read a list of uploaded files and return a list of dataframes containing the associated data"""
+    dataframes = []
+    with TemporaryDirectory() as tmpdir:
+        for f in files:
+            with open(tmpdir + "/" + f.name, "wb") as tmp_file:
+                tmp_file.write(f.getvalue())
+            if tmp_file is not None:
+                df = load_data(
+                    Path(tmp_file.name),
+                    SessionStateManager.get("language", "French"),
+                )
+                if df is not None:
+                    dataframes.append(df)
+        return dataframes
+
+
+def _load_files(
+    files: list[Path],
+) -> list[pd.DataFrame]:
+    """Read a list of files from storage and return a list of dataframes containing the associated data"""
+    dfs = []
+    for selected_file in files:
+        file_path = DATA_PATH / selected_file
+        df = load_data(
+            file_path,
+            SessionStateManager.get("language", "French"),
+        )
+        if df is not None:
+            dfs.append(df)
+    return dfs
+
+
+# TODO: if loaded data column names do not match our default values, show a popup for column data mapping
+def display_data_loading_component():
+    """
+    Component for a streamlit app about topic modelling. It allows to choose data to load and preprocess data.
+    Preprocessing of data includes:
+    - concatenation of data from different files
+    - adding potentially missing columns to make all datasets homogeneous
+    - removal of duplicates
+    - splitting the dataset by paragraphs to avoid too long textes
+    - filtering based on timestamp range
+    - filtering based on a minimum number of characters
+
+    The initial dataframe (one line per document) is stored after filtering of bad data inside a Streamlit state
+    variable "initial_df". After split by paragraph, it is stored in "df_split". The final dataframe (possibly
+    split by paragraph from initial documents and in all cases filtered by dates) is stored inside the Streamlit
+    state variable "time_filtered_df".
+    """
+    # Data loading section
+    st.header("Data loading")
+
+    # Find files in the current directory and subdirectories
+    tab1, tab2 = st.tabs(
+        [
+            CLIENT_STORAGE_ICON + " Data from local storage",
+            SERVER_STORAGE_ICON + " Data from server data",
+        ]
+    )
+    compatible_extensions = FORMAT_ICONS.keys()
+
+    with tab1:
+        st.file_uploader(
+            label="Select dataset from local storage (.xlsx, .csv, .json, .jsonl, .parquet)",
+            type=compatible_extensions,
+            accept_multiple_files=True,
+            help="Drag and drop files to be used as dataset in this area",
+            on_change=save_widget_state,
+            key="uploaded_files",
+        )
+
+    with tab2:
+        register_widget("selected_files")
+        st.multiselect(
+            label="Select one or more datasets from the server data",
+            options=find_compatible_files(DATA_PATH, compatible_extensions),
+            default=SessionStateManager.get("selected_files", []),
+            key="selected_files",
+            format_func=lambda x: FORMAT_ICONS[x.suffix.lstrip(".")] + " " + str(x),
+            on_change=save_widget_state,
+        )
+
+    if (
+        not SessionStateManager.get("uploaded_files", [])
+        and not SessionStateManager.get("selected_files")
+        and "initial_df" not in st.session_state
+    ):
+        st.warning(NO_DATASET_WARNING, icon=WARNING_ICON)
+        st.stop()
+
+    # Load each selected file, then concatenate them
+    # Priority to local data if both are set
+    dfs = None
+    if SessionStateManager.get("uploaded_files"):
+        dfs = _process_uploaded_files(
+            SessionStateManager.get("uploaded_files"),
+        )
+    elif SessionStateManager.get("selected_files"):
+        dfs = _load_files(
+            SessionStateManager.get("selected_files"),
+        )
+
+    # If DataFrames found, concatenate them
+    if dfs:
+        # Concatenate DataFrames
+        df = pd.concat(dfs, ignore_index=True)
+
+        # Save state of initial DF (before split and data selection)
+        st.session_state["initial_df"] = df.copy()
+    # If dfs is None and there is no 'initial_df' in session_state, show warining
+    elif "initial_df" not in st.session_state:
+        st.warning(
+            NO_DATA_AFTER_PREPROCESSING_MESSAGE,
+            icon=WARNING_ICON,
+        )
+        st.stop()
+    # If dfs is None but there is initial_df, set it
+    else:
+        df = st.session_state["initial_df"]
+
+    # Show raw data info
+    st.write(
+        f"Number of documents in raw data: **{len(st.session_state['initial_df'])}**"
+    )
+
+    # Data filtering section
+    st.header("Data filtering")
+
+    # Display number input and checkbox for preprocessing options
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        register_widget("min_chars")
+        st.number_input(
+            "Minimum Characters",
+            value=MIN_CHARS_DEFAULT,
+            min_value=0,
+            max_value=1000,
+            key="min_chars",
+            on_change=save_widget_state,
+            help="Minimum number of characters each document must contain.",
+        )
+    with col2:
+        register_widget("sample_size")
+        sample_size = st.number_input(
+            "Sample ratio",
+            value=SAMPLE_SIZE_DEFAULT,
+            min_value=0.0,
+            max_value=1.0,
+            key="sample_size",
+            on_change=save_widget_state,
+            help="Fraction of raw data to use for computing topics. Randomly samples documents from raw data.",
+        )
+    with col3:
+        register_widget("split_by_paragraph")
+        SessionStateManager.get_or_set("split_by_paragraph", "no")
+        st.segmented_control(
+            "Split text by paragraphs",
+            key="split_by_paragraph",
+            options=["no", "yes", "enhanced"],
+            selection_mode="single",
+            help="'No split': No splitting on the documents ; 'Split by paragraphs': Split documents into paragraphs ; "
+            "'Enhanced split': uses a more advanced but slower method for splitting that considers the embedding "
+            "model's maximum input length.",
+            on_change=save_widget_state,
+        )
+
+    df = split_data(
+        df,
+        SessionStateManager.get("min_chars"),
+        SessionStateManager.get("split_by_paragraph"),
+        embedding_model_name=SessionStateManager.get("embedding_model_name"),
+    )
+
+    # Deduplicate using all columns
+    df = df.drop_duplicates()
+
+    # Save state of split dataframe (before time-based filtering)
+    st.session_state["split_df"] = df.copy()
+
+    # Select timeframe
+    min_date, max_date = st.session_state["initial_df"][TIMESTAMP_COLUMN].dt.date.agg(
+        ["min", "max"]
+    )
+    register_widget("timeframe_slider")
+    start_date, end_date = st.slider(
+        "Select Timeframe",
+        min_value=min_date,
+        max_value=max_date,
+        value=(min_date, max_date),
+        key="timeframe_slider",
+        on_change=save_widget_state,
+    )
+
+    # Filter and sample the DataFrame
+    df_filtered = df[
+        (df[TIMESTAMP_COLUMN].dt.date >= start_date)
+        & (df[TIMESTAMP_COLUMN].dt.date <= end_date)
+    ]
+    df_filtered = df_filtered.sort_values(by=TIMESTAMP_COLUMN).reset_index(drop=True)
+
+    if sample_size < 1:
+        df_filtered = df_filtered.sample(frac=sample_size, random_state=42)
+
+    df_filtered = df_filtered.sort_values(by=TIMESTAMP_COLUMN).reset_index(drop=True)
+
+    SessionStateManager.set("time_filtered_df", df_filtered)
+    st.write(
+        f"Number of documents in filtered data: **{len(SessionStateManager.get_dataframe('time_filtered_df'))}**"
+    )
+    st.dataframe(
+        SessionStateManager.get_dataframe("time_filtered_df")[
+            [TEXT_COLUMN, "timestamp"]
+        ],
+        use_container_width=True,
+    )

bertrend/demos/demos_utils/embed_documents_component.py

@@ -0,0 +1,52 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+import streamlit as st
+
+from bertrend.demos.demos_utils.icons import SUCCESS_ICON
+from bertrend.demos.demos_utils.messages import EMBEDDINGS_CALCULATED_MESSAGE
+from bertrend.demos.demos_utils.state_utils import SessionStateManager
+from bertrend.services.embedding_service import EmbeddingService
+from bertrend.utils.data_loading import TEXT_COLUMN
+
+
+def display_embed_documents_component():
+    """
+    Common Streamlit UI component for embedding documents.
+    """
+    # Embed documents
+    if st.button("Embed Documents"):
+        with st.spinner("Embedding documents..."):
+            embedding_dtype = SessionStateManager.get("embedding_dtype")
+            embedding_model_name = SessionStateManager.get("embedding_model_name")
+            if SessionStateManager.get("embedding_service_type", "remote") == "local":
+                embedding_service = EmbeddingService(
+                    local=True,
+                    model_name=embedding_model_name,
+                    embedding_dtype=embedding_dtype,
+                )
+            else:
+                embedding_service = EmbeddingService(
+                    local=False,
+                    url=SessionStateManager.get("embedding_service_url"),
+                )
+
+            texts = SessionStateManager.get_dataframe("time_filtered_df")[
+                TEXT_COLUMN
+            ].tolist()
+
+            embeddings, token_strings, token_embeddings = embedding_service.embed(
+                texts=texts,
+            )
+
+            SessionStateManager.set(
+                "embedding_model", embedding_service.embedding_model
+            )
+            SessionStateManager.set("embeddings", embeddings)
+            SessionStateManager.set("token_strings", token_strings)
+            SessionStateManager.set("token_embeddings", token_embeddings)
+
+            SessionStateManager.set("data_embedded", True)
+
+            st.success(EMBEDDINGS_CALCULATED_MESSAGE, icon=SUCCESS_ICON)

bertrend/demos/demos_utils/icons.py

@@ -0,0 +1,41 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+
+WARNING_ICON = ":material/warning:"
+ERROR_ICON = ":material/error:"
+INFO_ICON = ":material/info:"
+EDIT_ICON = ":material/edit:"
+ADD_ICON = ":material/add_circle:"
+DELETE_ICON = ":material/delete:"
+SUCCESS_ICON = ":material/check:"
+SETTINGS_ICON = ":material/settings:"
+TOPIC_ICON = ":material/speaker_notes:"
+TREND_ICON = ":material/trending_up:"
+MODELS_ICON = ":material/network_intelligence:"
+EMBEDDING_ICON = ":material/memory:"
+SAVE_ICON = ":material/save:"
+TOPIC_EXPLORATION_ICON = ":material/explore:"
+TOPIC_VISUALIZATION_ICON = ":material/monitoring:"
+TEMPORAL_VISUALIZATION_ICON = ":material/timelapse:"
+NEWSLETTER_ICON = ":material/newspaper:"
+ANALYSIS_ICON = ":material/query_stats:"
+DATA_LOADING_ICON = ":material/drive_folder_upload:"
+MODEL_TRAINING_ICON = ":material/cognition:"
+SERVER_STORAGE_ICON = ":material/database:"
+CLIENT_STORAGE_ICON = ":material/upload:"
+UNHAPPY_ICON = ":material/sentiment_extremely_dissatisfied:"
+TOGGLE_ON_ICON = ":material/toggle_on:"
+TOGGLE_OFF_ICON = ":material/toggle_off:"
+NOISE_ICON = ":material/signal_cellular_off:"
+WEAK_SIGNAL_ICON = ":material/signal_cellular_1_bar:"
+STRONG_SIGNAL_ICON = ":material/signal_cellular_3_bar:"
+DOWNLOAD_ICON = ":material/download:"
+EMAIL_ICON = ":material/mail:"
+RESTART_ICON = ":material/restart_alt:"
+
+JSON_ICON = "🧾"
+PARQUET_ICON = "📦️"
+CSV_ICON = "📉"
+XLSX_ICON = "📊"

bertrend/demos/demos_utils/messages.py

@@ -0,0 +1,11 @@
+#  Copyright (c) 2024, RTE (https://www.rte-france.com)
+#  See AUTHORS.txt
+#  SPDX-License-Identifier: MPL-2.0
+#  This file is part of BERTrend.
+
+EMBEDDINGS_CALCULATED_MESSAGE = "Embeddings calculated successfully!"
+NO_EMBEDDINGS_WARNING_MESSAGE = (
+    "Please embed data and train models before proceeding to analysis."
+)
+MODEL_TRAINING_COMPLETE_MESSAGE = "Model training complete!"
+NO_DATA_AFTER_PREPROCESSING_MESSAGE = "No data available after preprocessing. Please check the selected files and preprocessing options."