Fixes and improvements

app.py

@@ -3,12 +3,21 @@ App for plotting confusion matrix with `cvms::plot_confusion_matrix()`.
 
 TODO:
 - IMPORTANT! Allow specifying which class probabilities are of! (See plot prob_of_class)
+- IMPORTANT! Use json/txt file to pass settings to r instead?
+- IMPORTANT! Allow saving and uploading design settings - so many of them
+  that one shouldn't have to enter all the changes for every plot
+  when making multiple at a time!
 - Allow setting threshold - manual, max J, spec/sens
 - Add bg box around confusion matrix plot as text dissappears on dark mode!
 - ggsave does not use dpi??
 - allow svg, pdf?
 - entered count -> counts (upload as well)
-- Add full reset button (empty cache on different files)
+- Add full reset button (empty cache on different files) - callback?
+- Handle <2 classes in design box (add st.error)
+- Handle classes with spaces in them?
+
+NOTE: 
+
 
 """
 
@@ -61,6 +70,7 @@ def set_tmp_dir():
 temp_dir, temp_dir_path = set_tmp_dir()
 gen_data_store_path = pathlib.Path(f"{temp_dir_path}/generated_data.csv")
 data_store_path = pathlib.Path(f"{temp_dir_path}/data.csv")
+design_settings_store_path = pathlib.Path(f"{temp_dir_path}/design_settings.json")
 conf_mat_path = pathlib.Path(f"{temp_dir_path}/confusion_matrix.png")
 
 
@@ -312,65 +322,43 @@ if st.session_state["step"] >= 2:
         )
 
     # Section for specifying design settings
-    design_settings = design_section(
+
+    design_settings, design_ready, selected_classes, prob_of_class = design_section(
         num_classes=num_classes,
         predictions_are_probabilities=predictions_are_probabilities,
+        design_settings_store_path=design_settings_store_path,
     )
 
-    # design_ready tells us whether to proceed or wait 
+    # design_ready tells us whether to proceed or wait
     # for user to fix issues
-    if st.session_state["step"] >= 3 and design_settings["design_ready"]:
-        # TODO Fix and update these flags
-        element_flags = [
-            key
-            for key, val in {
-                "--add_counts": design_settings["show_counts"],
-                "--add_normalized": design_settings["show_normalized"],
-                "--add_sums": design_settings["show_sums"],
-                "--add_row_percentages": design_settings["show_row_percentages"],
-                "--add_col_percentages": design_settings["show_col_percentages"],
-                "--add_arrows": design_settings["show_arrows"],
-                "--add_zero_percentages": design_settings["show_zero_percentages"],
-                "--add_zero_text": design_settings["show_zero_text"],
-                "--add_zero_shading": design_settings["show_zero_shading"],
-                "--add_tile_border": design_settings["show_tile_border"],
-                "--counts_on_top": design_settings["counts_on_top"],
-                "--diag_percentages_only": design_settings["diag_percentages_only"],
-                "--rotate_y_text": design_settings["rotate_y_text"],
-                "--place_x_axis_above": design_settings["place_x_axis_above"],
-            }.items()
-            if val
-        ]
+    if st.session_state["step"] >= 3 and design_ready:
+        DownloadHeader.header_and_json_download(
+            header="Confusion Matrix Plot",
+            data=design_settings,
+            file_name="design_settings.json",
+            label="Download design settings",
+            help="Download the design settings to allow reusing setttings in future plots.",
+        )
 
         plotting_args = [
             "--data_path",
             f"'{data_store_path}'",
             "--out_path",
             f"'{conf_mat_path}'",
+            "--settings_path",
+            f"'{design_settings_store_path}'",
             "--target_col",
             f"'{target_col}'",
             "--prediction_col",
             f"'{prediction_col}'",
-            "--width",
-            f"{design_settings['width']}",
-            "--height",
-            f"{design_settings['height']}",
-            "--dpi",
-            f"{design_settings['dpi']}",
             "--classes",
-            f"{','.join(design_settings['selected_classes'])}",
-            "--digits",
-            f"{design_settings['num_digits']}",
-            "--palette",
-            f"{design_settings['palette']}",
+            f"{','.join(selected_classes)}",
         ]
 
         if st.session_state["input_type"] == "counts":
             # The input data are counts
             plotting_args += ["--n_col", f"{n_col}", "--data_are_counts"]
 
-        plotting_args += element_flags
-
         plotting_args = " ".join(plotting_args)
 
         call_subprocess(

data.py

@@ -1,3 +1,4 @@
+import json
 import pathlib
 import pandas as pd
 import streamlit as st
@@ -70,3 +71,21 @@ class DownloadHeader:
                 key=key,
                 help=help,
             )
+
+    @staticmethod
+    def header_and_json_download(
+        header, data: dict, file_name, download_col_size=4, key=None, label="Download", help="Download json file"
+    ):
+        col1, col2 = st.columns([9, download_col_size])
+        with col1:
+            st.subheader(header)
+        with col2:
+            data_json = json.dumps(data)
+            st.download_button(
+                label=label,
+                data=data_json,
+                file_name=file_name,
+                key=key,
+                mime="application/json",
+                help=help,
+            )

design.py

@@ -1,28 +1,78 @@
+from typing import List, Callable, Any, Tuple
+import json
+import numpy as np
 import streamlit as st
 
 from text_sections import (
     design_text,
 )
 
-# arrow_size = 0.048,
-# arrow_nudge_from_text = 0.065,
-# sums_settings = sum_tile_settings(),
-# intensity_by
 
-# darkness = 0.8
+def _add_select_box(
+    key: str,
+    label: str,
+    default: Any,
+    options: List[Any],
+    get_setting_fn: Callable,
+    type_=str,
+):
+    """
+    Add selectbox with selection of default value from setting function.
+    """
+    chosen_default = get_setting_fn(
+        key=key,
+        default=default,
+        type_=type_,
+        options=options,
+    )
+    return st.selectbox(
+        label, options=options, index=options.index(chosen_default), key=key
+    )
 
 
 def design_section(
     num_classes,
     predictions_are_probabilities,
+    design_settings_store_path,
 ):
     output = {}
 
-    with st.form(key="settings_form"):
+    with st.form(key="settings_upload_form"):
         design_text()
+        uploaded_settings_path = st.file_uploader(
+            "Upload design settings", type=["json"]
+        )
+        # TODO: Allow resetting settings!
+        if st.form_submit_button(label="Apply settings"):
+            if uploaded_settings_path is not None:
+                uploaded_design_settings = json.load(uploaded_settings_path)
+            else:
+                st.warning("No settings were uploaded. Uploading settings is optional.")
+
+    def get_uploaded_setting(key, default, type_=None, options=None):
+        # NOTE: Must be placed here, to have `uploaded_design_settings` in locals
+
+        if "uploaded_design_settings" in locals() and key in uploaded_design_settings:
+            out = uploaded_design_settings[key]
+            if type_ is not None:
+                if not isinstance(out, type_):
+                    st.warning(
+                        f"An uploaded setting ({key}) had the wrong type. Using default value."
+                    )
+                    return default
+            if options is not None:
+                if out not in options:
+                    st.warning(
+                        f"An uploaded setting ({key}) was not a valid choice. Using default value."
+                    )
+                    return default
+            return out
+        return default
+
+    with st.form(key="settings_form"):
         col1, col2 = st.columns(2)
         with col1:
-            output["selected_classes"] = st.multiselect(
+            selected_classes = st.multiselect(
                 "Select classes (min=2, order is respected)",
                 options=st.session_state["classes"],
                 default=st.session_state["classes"],
@@ -35,43 +85,67 @@ def design_section(
                 st.session_state["input_type"] == "data"
                 and predictions_are_probabilities
             ):
-                output["prob_of_class"] = st.selectbox(
+                prob_of_class = st.selectbox(
                     "Probabilities are of (not working)",
                     options=st.session_state["classes"],
                     index=1,
                 )
             else:
-                output["prob_of_class"] = None
+                prob_of_class = None
 
-        output["palette"] = st.selectbox(
-            "Color Palette",
+        # Color palette
+        output["palette"] = _add_select_box(
+            key="palette",
+            label="Color Palette",
+            default="Blues",
             options=["Blues", "Greens", "Oranges", "Greys", "Purples", "Reds"],
+            get_setting_fn=get_uploaded_setting,
+            type_=str,
         )
 
         # Ask for output parameters
-        # TODO: Set default based on number of classes and sum tiles
         col1, col2, col3 = st.columns(3)
         with col1:
             output["width"] = st.number_input(
-                "Width (px)", value=1200 + 100 * (num_classes - 2), step=50
+                "Width (px)",
+                value=get_uploaded_setting(
+                    key="width", default=1200 + 100 * (num_classes - 2), type_=int
+                ),
+                step=50,
             )
         with col2:
             output["height"] = st.number_input(
-                "Height (px)", value=1200 + 100 * (num_classes - 2), step=50
+                "Height (px)",
+                value=get_uploaded_setting(
+                    key="width", default=1200 + 100 * (num_classes - 2), type_=int
+                ),
+                step=50,
             )
         with col3:
-            output["dpi"] = st.number_input("DPI (not working)", value=320, step=10)
+            output["dpi"] = st.number_input(
+                "DPI (not working)",
+                value=get_uploaded_setting(key="dpi", default=320, type_=int),
+                step=10,
+            )
 
         st.write(" ")  # Slightly bigger gap between the two sections
         col1, col2, col3 = st.columns(3)
         with col1:
-            output["show_counts"] = st.checkbox("Show Counts", value=True)
+            output["show_counts"] = st.checkbox(
+                "Show Counts",
+                value=get_uploaded_setting(key="show_counts", default=True, type_=bool),
+            )
         with col2:
-            output["show_normalized"] = st.checkbox("Show Normalized (%)", value=True)
+            output["show_normalized"] = st.checkbox(
+                "Show Normalized (%)",
+                value=get_uploaded_setting(
+                    key="show_normalized", default=True, type_=bool
+                ),
+            )
         with col3:
             output["show_sums"] = st.checkbox(
                 "Show Sum Tiles",
-                value=False,
+                value=get_uploaded_setting(key="show_sums", default=False, type_=bool),
                 help="Show extra row and column with the "
                 "totals for that row/column.",
             )
@@ -82,19 +156,32 @@ def design_section(
         with st.expander("Elements"):
             col1, col2 = st.columns(2)
             with col1:
-                output["rotate_y_text"] = st.checkbox("Rotate y-axis text", value=True)
+                output["rotate_y_text"] = st.checkbox(
+                    "Rotate y-axis text",
+                    value=get_uploaded_setting(
+                        key="rotate_y_text", default=True, type_=bool
+                    ),
+                )
                 output["place_x_axis_above"] = st.checkbox(
-                    "Place x-axis on top", value=True
+                    "Place x-axis on top",
+                    value=get_uploaded_setting(
+                        key="place_x_axis_above", default=True, type_=bool
+                    ),
                 )
                 output["counts_on_top"] = st.checkbox(
                     "Counts on top (not working)",
+                    value=get_uploaded_setting(
+                        key="counts_on_top", default=False, type_=bool
+                    ),
                     help="Whether to switch the positions of the counts and normalized counts (%). "
                     "The counts become the big centralized numbers and the "
                     "normalized counts go below with a smaller font size.",
                 )
             with col2:
                 output["num_digits"] = st.number_input(
-                    "Digits", value=2, help="Number of digits to round percentages to."
+                    "Digits",
+                    value=get_uploaded_setting(key="num_digits", default=2, type_=int),
+                    help="Number of digits to round percentages to.",
                 )
 
             st.markdown("""---""")
@@ -103,20 +190,36 @@ def design_section(
             with col1:
                 st.write("Row and column percentages:")
                 output["show_row_percentages"] = st.checkbox(
-                    "Show row percentages", value=num_classes < 6
+                    "Show row percentages",
+                    value=get_uploaded_setting(
+                        key="show_row_percentages", default=num_classes < 6, type_=bool
+                    ),
                 )
                 output["show_col_percentages"] = st.checkbox(
-                    "Show column percentages", value=num_classes < 6
+                    "Show column percentages",
+                    value=get_uploaded_setting(
+                        key="show_col_percentages", default=num_classes < 6, type_=bool
+                    ),
+                )
+                output["show_arrows"] = st.checkbox(
+                    "Show arrows",
+                    value=get_uploaded_setting(
+                        key="show_arrows", default=True, type_=bool
+                    ),
                 )
-                output["show_arrows"] = st.checkbox("Show arrows", value=True)
                 output["diag_percentages_only"] = st.checkbox(
-                    "Diagonal row/column percentages only"
+                    "Diagonal row/column percentages only",
+                    value=get_uploaded_setting(
+                        key="diag_percentages_only", default=False, type_=bool
+                    ),
                 )
             with col2:
                 output["arrow_size"] = (
                     st.slider(
                         "Arrow size",
-                        value=0.048 * 10,
+                        value=get_uploaded_setting(
+                            key="arrow_size", default=0.048 * 10, type_=float
+                        ),
                         min_value=0.03 * 10,
                         max_value=0.06 * 10,
                         step=0.001 * 10,
@@ -126,7 +229,9 @@ def design_section(
                 output["arrow_nudge_from_text"] = (
                     st.slider(
                         "Arrow nudge from text",
-                        value=0.065 * 10,
+                        value=get_uploaded_setting(
+                            key="arrow_nudge_from_text", default=0.065 * 10, type_=float
+                        ),
                         min_value=0.00,
                         max_value=0.1 * 10,
                         step=0.001 * 10,
@@ -135,45 +240,60 @@ def design_section(
                 )
 
         with st.expander("Tiles"):
-            col1, col2, col3 = st.columns(3)
+            col1, col2 = st.columns(2)
             with col1:
-                pass
-            with col2:
-                output["intensity_by"] = st.selectbox(
-                    "Intensity based on", options=["Counts", "Normalized (%)"]
+                output["intensity_by"] = _add_select_box(
+                    key="intensity_by",
+                    label="Intensity based on",
+                    default="Counts",
+                    options=["Counts", "Normalized (%)"],
+                    get_setting_fn=get_uploaded_setting,
+                    type_=str,
                 )
-            with col3:
+            with col2:
                 output["darkness"] = st.slider(
                     "Darkness",
                     min_value=0.0,
                     max_value=1.0,
-                    value=0.8,
+                    value=get_uploaded_setting(
+                        key="darkness", default=0.8, type_=float
+                    ),
                     step=0.01,
                     help="How dark the darkest colors should be, between 0 and 1, where 1 is darkest.",
                 )
 
             st.markdown("""---""")
 
-            col1, col2, col3, col4 = st.columns(4)
+            output["show_tile_border"] = st.checkbox(
+                "Add tile borders",
+                value=get_uploaded_setting(
+                    key="show_tile_border", default=False, type_=bool
+                ),
+            )
+
+            col1, col2, col3 = st.columns(3)
             with col1:
-                output["show_tile_border"] = st.checkbox(
-                    "Add tile borders", value=False
-                )
-            with col2:
                 output["tile_border_color"] = st.color_picker(
-                    "Border color", value="#000000"
+                    "Border color",
+                    value=get_uploaded_setting(
+                        key="tile_border_color", default="#000000", type_=str
+                    ),
                 )
-            with col3:
+            with col2:
                 output["tile_border_size"] = st.slider(
                     "Border size",
                     min_value=0.0,
                     max_value=3.0,
-                    value=0.1,
+                    value=get_uploaded_setting(
+                        key="tile_border_size", default=0.1, type_=float
+                    ),
                     step=0.01,
                 )
-            with col4:
-                output["tile_border_linetype"] = st.selectbox(
-                    "Border linetype",
+            with col3:
+                output["tile_border_linetype"] = _add_select_box(
+                    key="tile_border_linetype",
+                    label="Border linetype",
+                    default="solid",
                     options=[
                         "solid",
                         "dashed",
@@ -182,6 +302,8 @@ def design_section(
                         "longdash",
                         "twodash",
                     ],
+                    get_setting_fn=get_uploaded_setting,
+                    type_=str,
                 )
 
             st.markdown("""---""")
@@ -190,19 +312,24 @@ def design_section(
 
             col1, col2 = st.columns(2)
             with col1:
-                output["sum_tile_palette"] = st.selectbox(
-                    "Color Palette",
-                    key="sum_tiles_color_palette",
+                output["sum_tile_palette"] = _add_select_box(
+                    key="sum_tile_palette",
+                    label="Color Palette",
+                    default="Greens",
                     options=["Greens", "Oranges", "Greys", "Purples", "Reds", "Blues"],
+                    get_setting_fn=get_uploaded_setting,
+                    type_=str,
                 )
+
             with col2:
                 output["sum_tile_label"] = st.text_input(
                     "Label",
-                    value="Σ",
+                    value=get_uploaded_setting(
+                        key="sum_tile_label", default="Σ", type_=str
+                    ),
                     key="sum_tiles_label",
                 )
 
-            #   label = NULL,
             #   tile_fill = NULL,
             #   font_color = NULL,
             #   tile_border_color = NULL,
@@ -218,48 +345,118 @@ def design_section(
             st.write("Special settings for tiles where the count is 0:")
             col1, col2, col3 = st.columns(3)
             with col1:
-                output["show_zero_shading"] = st.checkbox("Add shading", value=True)
+                output["show_zero_shading"] = st.checkbox(
+                    "Add shading",
+                    value=get_uploaded_setting(
+                        key="show_zero_shading", default=True, type_=bool
+                    ),
+                )
             with col2:
                 output["show_zero_text"] = st.checkbox(
                     "Show text",
-                    value=False,
+                    value=get_uploaded_setting(
+                        key="show_zero_text", default=False, type_=bool
+                    ),
                     help="Whether to show counts, normalized (%), etc.",
                 )
             with col3:
                 output["show_zero_percentages"] = st.checkbox(
                     "Show row/column percentages",
-                    value=False,
+                    value=get_uploaded_setting(
+                        key="show_zero_percentages", default=False, type_=bool
+                    ),
                     help="Only relevant when row/column percentages are enabled.",
                 )
 
-        with st.expander("Fonts"):
-            font_dicts = {}
-            font_types = [
-                "Counts",
-                "Normalized (%)",
-                "Row Percentage",
-                "Column Percentage",
-            ]
-            for font_type in font_types:
-                st.subheader(font_type)
-                num_cols = 3
-                font_dicts[font_type] = font_inputs(key_prefix=font_type)
-                for i, (_, setting_widget) in enumerate(font_dicts[font_type].items()):
-                    if i % num_cols == 0:
-                        cols = st.columns(num_cols)
-                    with cols[i % num_cols]:
-                        setting_widget()
-
-                if font_type != font_types[-1]:
-                    st.markdown("""---""")
+        if True:
+            with st.expander("Fonts"):
+                # Specify available settings and defaults per font
+                font_types = {
+                    "Top Font": {
+                        "key_prefix": "font_top",
+                        "description": "The big text in the middle (normalized (%) by default).",
+                        "settings": {
+                            "size": 4.3,  # 2.8
+                            "color": "#000000",
+                            "alpha": 1.0,
+                            "bold": False,
+                            "italics": False,
+                        },
+                    },
+                    "Bottom Font": {
+                        "key_prefix": "font_bottom",
+                        "description": "The text just below the top font (counts by default).",
+                        "settings": {
+                            "size": 2.8,
+                            "color": "#000000",
+                            "alpha": 1.0,
+                            "bold": False,
+                            "italics": False,
+                        },
+                    },
+                    "Percentages Font": {
+                        "key_prefix": "font_percentage",
+                        "description": "The row and column percentages.",
+                        "settings": {
+                            "size": 2.35,
+                            "color": "#000000",
+                            "alpha": 0.85,
+                            "bold": False,
+                            "italics": True,
+                            "suffix": "%",
+                            "prefix": "",
+                        },
+                    },
+                    "Normalized (%)": {
+                        "key_prefix": "font_normalized",
+                        "description": "Special settings for the normalized (%) text.",
+                        "settings": {"suffix": "%", "prefix": ""},
+                    },
+                    "Counts": {
+                        "key_prefix": "font_counts",
+                        "description": "Special settings for the counts text.",
+                        "settings": {"suffix": "", "prefix": ""},
+                    },
+                }
+
+                for font_type_title, font_type_spec in font_types.items():
+                    st.markdown(f"**{font_type_title}**")
+                    st.markdown(font_type_spec["description"])
+                    num_cols = 3
+                    font_settings = create_font_settings(
+                        key_prefix=font_type_spec["key_prefix"],
+                        get_setting_fn=get_uploaded_setting,
+                        settings_to_get=list(font_type_spec["settings"].keys()),
+                    )
+
+                    for i, (setting_name, setting_widget) in enumerate(
+                        font_settings.items()
+                    ):
+                        if i % num_cols == 0:
+                            cols = st.columns(num_cols)
+                        with cols[i % num_cols]:
+                            default = font_type_spec["settings"][
+                                setting_name[len(font_type_spec["key_prefix"]) + 1 :]
+                            ]
+                            output[setting_name] = setting_widget(
+                                k=setting_name, d=default
+                            )
+
+                    if font_type_title != list(font_types.keys())[-1]:
+                        st.markdown("""---""")
 
         st.markdown("""---""")
 
         if st.form_submit_button(label="Generate plot"):
             st.session_state["step"] = 3
+            if output["show_sums"] and output["sum_tile_palette"] == output["palette"]:
+                # Save settings as json
+                with open(design_settings_store_path, "w") as f:
+                    json.dump(output, f)
 
+        design_ready = False
         if st.session_state["step"] >= 3:
-            output["design_ready"] = True
+            design_ready = True
             if output["show_sums"] and output["sum_tile_palette"] == output["palette"]:
                 st.error(
                     "The color palettes (background colors) "
@@ -267,26 +464,77 @@ def design_section(
                     "Please select a different color palette for "
                     "the sum tiles under **Tiles** >> *Sum tile settings*."
                 )
-                output["design_ready"] = False
+                design_ready = False
+
+    return output, design_ready, selected_classes, prob_of_class
 
-        return output
 
+# defaults: dict,
+def create_font_settings(
+    key_prefix: str, get_setting_fn: Callable, settings_to_get: List[str]
+) -> Tuple[dict, dict]:
+    # TODO: Defaults must be set based on font type! Also,
+    # we probably need to allow not setting the argument so the
+    # plotting function can handle the defaulting?
+    def make_key(key):
+        return f"{key_prefix}_{key}"
 
-def font_inputs(key_prefix: str):
-    return {
-        "color": lambda: st.color_picker("Color", key=f"{key_prefix}_color"),
-        "bold": lambda: st.checkbox("Bold", key=f"{key_prefix}_bold"),
-        "cursive": lambda: st.checkbox("Italics", key=f"{key_prefix}_italics"),
-        "size": lambda: st.number_input("Size", key=f"{key_prefix}_size"),
-        "nudge_x": lambda: st.number_input(
-            "Nudge on x-axis", key=f"{key_prefix}_nudge_x"
+    font_settings = {
+        make_key("color"): lambda k, d: st.color_picker(
+            "Color",
+            key=k,
+            value=get_setting_fn(key=k, default=d, type_=str),
+        ),
+        make_key("bold"): lambda k, d: st.checkbox(
+            "Bold",
+            key=k,
+            value=get_setting_fn(key=k, default=d, type_=bool),
+        ),
+        make_key("italics"): lambda k, d: st.checkbox(
+            "Italics",
+            key=k,
+            value=get_setting_fn(key=k, default=d, type_=bool),
+        ),
+        make_key("size"): lambda k, d: st.number_input(
+            "Size",
+            key=k,
+            value=get_setting_fn(key=k, default=float(d), type_=float),
+        ),
+        make_key("nudge_x"): lambda k, d: st.number_input(
+            "Nudge on x-axis",
+            key=k,
+            value=get_setting_fn(key=k, default=d, type_=float),
         ),
-        "nudge_y": lambda: st.number_input(
-            "Nudge on y-axis", key=f"{key_prefix}_nudge_y"
+        make_key("nudge_y"): lambda k, d: st.number_input(
+            "Nudge on y-axis",
+            key=k,
+            value=get_setting_fn(key=k, default=d, type_=float),
         ),
-        "alpha": lambda: st.slider(
-            "Transparency", min_value=0, max_value=1, value=1, key=f"{key_prefix}_alpha"
+        make_key("alpha"): lambda k, d: st.slider(
+            "Transparency",
+            min_value=0.0,
+            max_value=1.0,
+            value=get_setting_fn(key=k, default=d, type_=float),
+            step=0.01,
+            key=k,
+        ),
+        make_key("prefix"): lambda k, d: st.text_input(
+            "Prefix",
+            key=k,
+            value=get_setting_fn(key=k, default=d, type_=str),
+        ),
+        make_key("suffix"): lambda k, d: st.text_input(
+            "Suffix",
+            key=k,
+            value=get_setting_fn(key=k, default=d, type_=str),
         ),
-        "prefix": lambda: st.text_input("Prefix", key=f"{key_prefix}_prefix"),
-        "suffix": lambda: st.text_input("Suffix", key=f"{key_prefix}_suffix"),
     }
+
+    # Filter settings
+    font_settings = {
+        k: v
+        for k, v in font_settings.items()
+        if f"{k[len(key_prefix)+1:]}" in settings_to_get
+    }
+
+    return font_settings