Implement Dutch Legal UI layer

presidio_streamlit.py

@@ -1,18 +1,14 @@
-"""Streamlit app for SolidPrivacy Scrub / Microsoft Presidio.
-
-Phase 1-3 v8 update:
-- adds an Audit & Candidate Review layer for suspicious values not automatically masked;
-- keeps candidate values unchecked by default, so the user decides whether to include them;
-- supports a structured observation workflow instead of one-off after-the-fact patches.
-
-Phase 1-3 update:
-- Dutch Legal Strict recognition profile;
-- Dutch legal test examples;
-- Dutch Legal Reference Taxonomy for context-based reference codes;
-- legal-aware replacement labels and scrub report download;
-- keeps current workflow: upload -> detect -> editable replacement table -> export.
+"""Streamlit app for SolidPrivacy Scrub Legal.
+
+v9 Dutch Legal UI Layer:
+- presents Scrub as a Dutch legal document scrubber instead of a technical demo;
+- keeps recognizer/engine internals under the hood;
+- adds Dutch workflow labels, Dutch review table labels and Dutch download labels;
+- preserves the existing detection, audit-candidate and export workflow.
 """
 
+from __future__ import annotations
+
 import ast
 import logging
 import os
@@ -51,6 +47,18 @@ from replacement_memory import (
     clear_remembered_replacements,
     get_memory_file_path,
 )
+from ui_texts_nl import (
+    APP_TITLE,
+    APP_SUBTITLE,
+    APP_INTRO,
+    LOCAL_PROCESSING_NOTE,
+    PROFILE_HELP,
+    PROFILE_DESCRIPTIONS,
+    OPERATOR_LABELS,
+    OPERATOR_HELP,
+    ADVANCED_SETTINGS_HELP,
+)
+from display_labels_nl import entity_label, source_label, confidence_label
 
 try:
     from candidate_scanner import scan_unmasked_candidates
@@ -64,7 +72,7 @@ try:
         get_dutch_general_entity_names,
         get_dutch_legal_entity_names,
     )
-except Exception:  # keep app usable while new file is being added
+except Exception:
     def get_dutch_entity_names(include_legal=True):
         return []
 
@@ -74,10 +82,11 @@ except Exception:  # keep app usable while new file is being added
     def get_dutch_legal_entity_names():
         return []
 
+
 LEGAL_EXAMPLES_IMPORT_ERROR = None
 
 EMBEDDED_LEGAL_TEST_CASES = {
-    "Fallback - referenties en administratieve nummers": """Cliëntnummer: CL-FAM-55201.
+    "Fallback - referenties en administratieve nummers": """Clientnummer: CL-FAM-55201.
 De schoolreferentie is HRZ-SAM-2026-04.
 In het verslag van Stichting Horizonzorg wordt dezelfde referentie HRZ-SAM-2026-04 genoemd.
 De factuur met nummer FACT-2026-4481 is onbetaald gebleven.
@@ -85,7 +94,7 @@ De interne klantreferentie van eiser is WR-KLANT-2026-7712.
 De zaakreferentie is ZK-WOON-55091.
 Het artikel 7:669 BW mag niet worden gemaskeerd.
 De datum 15-12-2026 mag niet als referentie worden gezien.
-Het bedrag € 1.250,00 mag niet als referentie worden gezien.
+Het bedrag EUR 1.250,00 mag niet als referentie worden gezien.
 """,
     "Fallback - familierecht contextbehoud": """Aan de Rechtbank Amsterdam
 
@@ -98,15 +107,17 @@ Verweerder Peter Bakker woont aan Laan van Meerdervoort 55, 2517 AM Den Haag.
 """,
 }
 
+PROFILE_OPTIONS = {
+    "Juridische controle — streng": "Dutch Legal Strict",
+    "Algemene Nederlandse controle": "Dutch / EU",
+    "Algemene internationale controle": "General / International",
+}
+INTERNAL_PROFILE_TO_LABEL = {value: key for key, value in PROFILE_OPTIONS.items()}
+OPERATOR_LABEL_TO_VALUE = {label: value for value, label in OPERATOR_LABELS.items()}
 
-def _load_legal_test_cases_from_file():
-    """Load legal examples as data instead of importing the module.
 
-    Streamlit can re-run scripts while modules are still initializing. A normal
-    `from legal_test_examples import TEST_CASES` can therefore fail with a
-    misleading circular-import warning. The examples file is pure data, so we
-    parse the TEST_CASES literal directly from disk and avoid executing imports.
-    """
+def _load_legal_test_cases_from_file():
+    """Load legal examples as data instead of importing the module."""
     examples_path = Path(__file__).with_name("legal_test_examples.py")
     if not examples_path.exists():
         raise FileNotFoundError(f"{examples_path} does not exist")
@@ -122,8 +133,7 @@ def _load_legal_test_cases_from_file():
             and node.target.id == "TEST_CASES"
         )
         if is_test_cases:
-            value = node.value
-            cases = ast.literal_eval(value)
+            cases = ast.literal_eval(node.value)
             if not isinstance(cases, list):
                 raise ValueError("TEST_CASES is not a list")
             return cases
@@ -139,7 +149,7 @@ except Exception as exc:
 
 def get_example_names():
     if TEST_CASES:
-        return [str(case.get("name", "Unnamed example")) for case in TEST_CASES]
+        return [str(case.get("name", "Naamloos voorbeeld")) for case in TEST_CASES]
     return list(EMBEDDED_LEGAL_TEST_CASES.keys())
 
 
@@ -150,117 +160,141 @@ def get_example_text(name: str):
     return EMBEDDED_LEGAL_TEST_CASES.get(name, "")
 
 
+def safe_cell(value):
+    if value is None:
+        return ""
+    try:
+        if pd.isna(value):
+            return ""
+    except Exception:
+        pass
+    return str(value).strip()
+
+
+def safe_bool(value):
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return False
+    try:
+        if pd.isna(value):
+            return False
+    except Exception:
+        pass
+    if isinstance(value, (int, float)):
+        return bool(value)
+    return str(value).strip().lower() in ("true", "1", "yes", "y", "checked", "ja")
+
+
 st.set_page_config(
-    page_title="SolidPrivacy Scrub",
+    page_title=APP_TITLE,
     layout="wide",
     initial_sidebar_state="expanded",
-    menu_items={"About": "https://microsoft.github.io/presidio/"},
+    menu_items={"About": "SolidPrivacy Scrub Legal"},
 )
 
 dotenv.load_dotenv()
-logger = logging.getLogger("presidio-streamlit")
+logger = logging.getLogger("solidprivacy-scrub")
 allow_other_models = os.getenv("ALLOW_OTHER_MODELS", False)
 
+st.sidebar.header(APP_TITLE)
+st.sidebar.caption(APP_SUBTITLE)
 
-# Sidebar
-st.sidebar.header(
-    """
-    SolidPrivacy Scrub
-    
-    PII De-Identification with [Microsoft Presidio](https://microsoft.github.io/presidio/)
-    """
+profile_label = st.sidebar.selectbox(
+    "Controlemodus",
+    list(PROFILE_OPTIONS.keys()),
+    index=0,
+    help=PROFILE_HELP,
 )
-
-model_help_text = """
-Select which Named Entity Recognition (NER) model to use for PII detection,
-in parallel to rule-based recognizers. The Dutch Legal Strict layer is rule-based
-and does not require a cloud model.
-"""
-
-st_ta_key = st_ta_endpoint = ""
-model_list = [
-    "spaCy/en_core_web_lg",
-    "flair/ner-english-large",
-    "HuggingFace/obi/deid_roberta_i2b2",
-    "HuggingFace/StanfordAIMI/stanford-deidentifier-base",
-    "stanza/en",
-    "Azure AI Language",
-    "Other",
-]
-if not allow_other_models:
-    model_list.pop()
-
-st_model = st.sidebar.selectbox(
-    "NER model package",
-    model_list,
-    index=1,
-    help=model_help_text,
+st_recognition_profile = PROFILE_OPTIONS[profile_label]
+st.sidebar.info(PROFILE_DESCRIPTIONS.get(profile_label, ""))
+
+operator_label = st.sidebar.selectbox(
+    "Manier van vervangen",
+    list(OPERATOR_LABELS.values()),
+    index=list(OPERATOR_LABELS.keys()).index("replace"),
+    help=OPERATOR_HELP,
 )
+st_operator = OPERATOR_LABEL_TO_VALUE[operator_label]
 
-st_model_package = st_model.split("/")[0]
-st_model = (
-    st_model
-    if st_model_package.lower() not in ("spacy", "stanza", "huggingface")
-    else "/".join(st_model.split("/")[1:])
-)
+st_threshold_default = 0.30 if st_recognition_profile == "Dutch Legal Strict" else 0.35
 
-if st_model == "Other":
-    st_model_package = st.sidebar.selectbox(
-        "NER model OSS package", options=["spaCy", "stanza", "Flair", "HuggingFace"]
+with st.sidebar.expander("Geavanceerde instellingen", expanded=False):
+    st.caption(ADVANCED_SETTINGS_HELP)
+    model_help_text = (
+        "Kies het NER-model dat naast regelherkenning wordt gebruikt. "
+        "De Nederlandse juridische herkenners zijn regelgebaseerd."
     )
-    st_model = st.sidebar.text_input("NER model name", value="")
-
-if st_model == "Azure AI Language":
-    st_ta_key = st.sidebar.text_input(
-        "Azure AI Language key", value=os.getenv("TA_KEY", ""), type="password"
+    st_ta_key = st_ta_endpoint = ""
+    model_list = [
+        "spaCy/en_core_web_lg",
+        "flair/ner-english-large",
+        "HuggingFace/obi/deid_roberta_i2b2",
+        "HuggingFace/StanfordAIMI/stanford-deidentifier-base",
+        "stanza/en",
+        "Azure AI Language",
+        "Other",
+    ]
+    if not allow_other_models:
+        model_list.pop()
+
+    st_model = st.selectbox(
+        "Technisch NER-model",
+        model_list,
+        index=1,
+        help=model_help_text,
     )
-    st_ta_endpoint = st.sidebar.text_input(
-        "Azure AI Language endpoint",
-        value=os.getenv("TA_ENDPOINT", default=""),
-        help="For more info: https://learn.microsoft.com/en-us/azure/cognitive-services/language-service/personally-identifiable-information/overview",
+
+    st_model_package = st_model.split("/")[0]
+    st_model = (
+        st_model
+        if st_model_package.lower() not in ("spacy", "stanza", "huggingface")
+        else "/".join(st_model.split("/")[1:])
     )
 
-st.sidebar.warning("Note: some NER models might take time to download/load.")
-analyzer_params = (st_model_package, st_model, st_ta_key, st_ta_endpoint)
-logger.debug("analyzer_params: %s", analyzer_params)
+    if st_model == "Other":
+        st_model_package = st.selectbox(
+            "NER-modelpakket", options=["spaCy", "stanza", "Flair", "HuggingFace"]
+        )
+        st_model = st.text_input("NER-modelnaam", value="")
 
-st_recognition_profile = st.sidebar.selectbox(
-    "Recognition profile",
-    ["Dutch Legal Strict", "Dutch / EU", "General / International"],
-    index=0,
-    help=(
-        "Dutch Legal Strict adds Dutch legal/matter identifiers such as zaaknummer, "
-        "rolnummer, parketnummer, dossiernummer, cliëntnummer, CJIB and ECLI. "
-        "Dutch / EU enables general Dutch identifiers such as BSN, postcode, KvK, BTW/VAT, "
-        "Dutch IBAN, Dutch phone numbers and Dutch address patterns."
-    ),
-)
+    if st_model == "Azure AI Language":
+        st_ta_key = st.text_input(
+            "Azure AI Language key", value=os.getenv("TA_KEY", ""), type="password"
+        )
+        st_ta_endpoint = st.text_input(
+            "Azure AI Language endpoint",
+            value=os.getenv("TA_ENDPOINT", default=""),
+        )
 
-st_operator = st.sidebar.selectbox(
-    "De-identification approach",
-    ["redact", "replace", "synthesize", "highlight", "mask", "hash", "encrypt"],
-    index=1,
-    help="""
-    Select which manipulation is requested after PII has been identified.
-    - Redact: completely remove the PII text
-    - Replace: replace PII with a placeholder
-    - Synthesize: replace with fake values; requires an OpenAI key
-    - Highlight: show original text with PII highlighted
-    - Mask: replace characters with a mask character
-    - Hash: replace with a hash
-    - Encrypt: replace with AES encryption, reversible with the key
-    """,
-)
+    st_threshold = st.slider(
+        label="Gevoeligheid van herkenning",
+        min_value=0.0,
+        max_value=1.0,
+        value=st_threshold_default,
+        help="Lagere waarde = meer gevonden gegevens, maar ook meer kans op fout-positieven.",
+    )
+    st_return_decision_process = st.checkbox(
+        "Toon technische beslisinformatie",
+        value=False,
+        help="Voegt technische uitlegvelden toe aan de resultatentabel.",
+    )
+    st_mask_char = st.text_input("Maskeringsteken", value="*", max_chars=1)
+    st_number_of_chars = st.number_input("Aantal te maskeren tekens", value=15, min_value=0, max_value=100)
+    st_encrypt_key = st.text_input("AES-sleutel", value="WmZq4t7w!z%C&F)J")
+
+    st_deny_allow_expander = st.expander("Woordenlijsten", expanded=False)
+    with st_deny_allow_expander:
+        st_allow_list = st_tags(label="Niet vervangen", text="Voer woord in en druk op Enter.")
+        st.caption("Woorden in deze lijst worden niet als gevoelig gegeven behandeld.")
+        st_deny_list = st_tags(label="Extra controleren", text="Voer woord in en druk op Enter.")
+        st.caption("Woorden in deze lijst krijgen extra aandacht bij de herkenning.")
 
-st_mask_char = "*"
-st_number_of_chars = 15
-st_encrypt_key = "WmZq4t7w!z%C&F)J"
+analyzer_params = (st_model_package, st_model, st_ta_key, st_ta_endpoint)
 open_ai_params = None
-logger.debug("st_operator: %s", st_operator)
 
 
 def set_up_openai_synthesis():
-    """Set up the OpenAI API key and model for text synthesis."""
     if os.getenv("OPENAI_TYPE", default="openai") == "Azure":
         openai_api_type = "azure"
         st_openai_api_base = st.sidebar.text_input(
@@ -279,16 +313,10 @@ def set_up_openai_synthesis():
         st_deployment_id = ""
         openai_key = os.getenv("OPENAI_KEY", default="")
 
-    st_openai_key = st.sidebar.text_input(
-        "OPENAI_KEY",
-        value=openai_key,
-        help="See https://help.openai.com/en/articles/4936850-where-do-i-find-my-secret-api-key for more info.",
-        type="password",
-    )
+    st_openai_key = st.sidebar.text_input("OPENAI_KEY", value=openai_key, type="password")
     st_openai_model = st.sidebar.text_input(
-        "OpenAI model for text synthesis",
+        "OpenAI-model voor synthetische tekst",
         value=os.getenv("OPENAI_MODEL", default="gpt-3.5-turbo-instruct"),
-        help="See more here: https://platform.openai.com/docs/models/",
     )
     return (
         openai_api_type,
@@ -300,14 +328,7 @@ def set_up_openai_synthesis():
     )
 
 
-if st_operator == "mask":
-    st_number_of_chars = st.sidebar.number_input(
-        "number of chars", value=st_number_of_chars, min_value=0, max_value=100
-    )
-    st_mask_char = st.sidebar.text_input("Mask character", value=st_mask_char, max_chars=1)
-elif st_operator == "encrypt":
-    st_encrypt_key = st.sidebar.text_input("AES key", value=st_encrypt_key)
-elif st_operator == "synthesize":
+if st_operator == "synthesize":
     (
         openai_api_type,
         st_openai_api_base,
@@ -325,122 +346,85 @@ elif st_operator == "synthesize":
         api_type=openai_api_type,
     )
 
-st_threshold_default = 0.30 if st_recognition_profile == "Dutch Legal Strict" else 0.35
-st_threshold = st.sidebar.slider(
-    label="Acceptance threshold",
-    min_value=0.0,
-    max_value=1.0,
-    value=st_threshold_default,
-    help="Define the threshold for accepting a detection as PII.",
-)
-
-st_return_decision_process = st.sidebar.checkbox(
-    "Add analysis explanations to findings",
-    value=False,
-    help=(
-        "Add the decision process to the output table. More information: "
-        "https://microsoft.github.io/presidio/analyzer/decision_process/"
-    ),
-)
-
-st_deny_allow_expander = st.sidebar.expander("Allowlists and denylists", expanded=False)
-with st_deny_allow_expander:
-    st_allow_list = st_tags(label="Add words to the allowlist", text="Enter word and press enter.")
-    st.caption("Allowlists contain words that are not considered PII, but are detected as such.")
-    st_deny_list = st_tags(label="Add words to the denylist", text="Enter word and press enter.")
-    st.caption("Denylists contain words that are considered PII, but are not detected as such.")
-
+st.title(APP_TITLE)
+st.subheader(APP_SUBTITLE)
+st.write(APP_INTRO)
+st.info(LOCAL_PROCESSING_NOTE)
 
-# Main panel
-with st.expander("About this demo", expanded=False):
-    st.info(
-        """
-        Presidio is an open source customizable framework for PII detection and de-identification.
-
-        [Code](https://aka.ms/presidio) | [Tutorial](https://microsoft.github.io/presidio/tutorial/) |
-        [Installation](https://microsoft.github.io/presidio/installation/) |
-        [FAQ](https://microsoft.github.io/presidio/faq/) |
-        [Feedback](https://forms.office.com/r/9ufyYjfDaY)
-        """
+with st.expander("Over deze app", expanded=False):
+    st.write(
+        "Scrub Legal helpt bij het controleerbaar opschonen van juridische tekst. "
+        "De herkenning combineert algemene patroonherkenning, Nederlandse herkenners, "
+        "juridische referentietaxonomie en een auditlaag voor mogelijke gemiste waarden."
     )
-    st.info(
-        """
-        SolidPrivacy Scrub extends the demo with Dutch/EU and Dutch legal recognizers.
-        For legal/confidential material, use fake documents in this public Space.
-        The recognizer pack is designed to be local/offline compatible for a future desktop/MSI version.
-        """
+    st.write(
+        "De technische detectie-engine blijft onder de motorkap. De gebruiker beoordeelt "
+        "altijd zelf de gevonden gegevens en mogelijke kandidaten in de vervangtabel."
     )
 
-analyzer_load_state = st.info("Starting Presidio analyzer...")
-analyzer_load_state.empty()
-
 if st_recognition_profile == "Dutch Legal Strict":
     st.info(
-        "Dutch Legal Strict mode is active. The app adds Dutch/EU recognizers plus legal/matter identifiers: "
-        "zaaknummer, rolnummer, rekestnummer, parketnummer, dossiernummer, cliëntnummer, CJIB, ECLI, "
-        "legal party references and court/authority references. It also shows possible unmasked "
-        "reference candidates for review. Always review the editable replacement table."
+        "Juridische controle is actief. Scrub zoekt extra naar zaaknummers, rolnummers, "
+        "rekestnummers, parketnummers, dossiernummers, clientnummers, CJIB, ECLI, "
+        "procespartijen, instanties en mogelijke juridische referenties."
     )
 elif st_recognition_profile == "Dutch / EU":
     st.info(
-        "Dutch / EU mode is active. The app adds Dutch pattern recognizers for BSN, postcode, KvK, BTW/VAT, "
-        "Dutch IBAN, Dutch phone numbers, addresses, license plates, rijbewijs-style numbers and BIG numbers. "
-        "Always review the editable replacement table before exporting."
+        "Algemene Nederlandse controle is actief. Scrub zoekt onder meer naar BSN, postcode, "
+        "KvK, btw-nummer, Nederlandse IBAN, telefoonnummers, adressen, kentekens en BIG-nummers."
     )
 
-# Read default text
-with open("demo_text.txt", encoding="utf-8") as f:
-    demo_text = f.readlines()
+try:
+    with open("demo_text.txt", encoding="utf-8") as f:
+        demo_text = f.readlines()
+except Exception:
+    demo_text = ["Plak of upload hier tekst om te controleren."]
 
-st.subheader("Document input")
+st.subheader("1. Voeg document of tekst toe")
 uploaded_file = st.file_uploader(
-    "Upload a .txt, .docx, or text-based .pdf file",
+    "Upload een .txt-, .docx- of tekstgebaseerd .pdf-bestand",
     type=["txt", "docx", "pdf"],
-    help="For legal/confidential material, use only approved environments. This public demo should be used with fake or test documents.",
+    help="Gebruik in deze publieke prototypeomgeving alleen synthetische of goedgekeurde testdocumenten.",
 )
 
 uploaded_file_type = None
 input_text = "".join(demo_text)
 
 if st_recognition_profile == "Dutch Legal Strict":
-    with st.expander("Use a fake Dutch legal test example", expanded=False):
+    with st.expander("Gebruik een synthetisch juridisch testvoorbeeld", expanded=False):
         example_names = get_example_names()
         if LEGAL_EXAMPLES_IMPORT_ERROR is not None:
             st.warning(
-                "Could not import legal_test_examples.py. Showing embedded fallback examples. "
-                "Check that legal_test_examples.py exists in the Space root. "
-                f"Import error: {LEGAL_EXAMPLES_IMPORT_ERROR}"
+                "Kon legal_test_examples.py niet laden. Ingebouwde fallback-voorbeelden worden getoond. "
+                f"Foutmelding: {LEGAL_EXAMPLES_IMPORT_ERROR}"
             )
         elif not example_names:
-            st.warning(
-                "No legal examples were loaded from legal_test_examples.py. "
-                "Check that TEST_CASES contains examples and that get_example_names() returns names."
-            )
+            st.warning("Er zijn geen juridische voorbeelden geladen.")
             example_names = list(EMBEDDED_LEGAL_TEST_CASES.keys())
 
         sample_name = st.selectbox(
-            "Load synthetic legal example",
-            ["Do not load a test example"] + example_names,
+            "Laad synthetisch juridisch voorbeeld",
+            ["Geen testvoorbeeld laden"] + example_names,
             index=0,
         )
-        if sample_name != "Do not load a test example" and uploaded_file is None:
+        if sample_name != "Geen testvoorbeeld laden" and uploaded_file is None:
             example_text = get_example_text(sample_name)
             if not example_text and sample_name in EMBEDDED_LEGAL_TEST_CASES:
                 example_text = EMBEDDED_LEGAL_TEST_CASES[sample_name]
             input_text = example_text
-            st.caption("Loaded synthetic example text. No real personal data is included.")
+            st.caption("Synthetische voorbeeldtekst geladen. Er staan geen echte persoonsgegevens in.")
 
 if uploaded_file is not None:
     try:
         input_text, uploaded_file_type = uploaded_file_to_text(uploaded_file)
-        st.success(f"Loaded file: {uploaded_file.name}")
+        st.success(f"Bestand geladen: {uploaded_file.name}")
     except Exception as upload_error:
-        st.error(f"Could not read uploaded file: {upload_error}")
+        st.error(f"Kon het bestand niet lezen: {upload_error}")
 
 col1, col2 = st.columns(2)
-col1.subheader("Input")
+col1.subheader("Invoer")
 st_text = col1.text_area(
-    label="Enter text or review extracted document text",
+    label="Plak tekst of controleer de uit het document gehaalde tekst",
     value=input_text,
     height=400,
     key="text_input",
@@ -449,7 +433,6 @@ st_text = col1.text_area(
 try:
     all_supported_entities = list(get_supported_entities(*analyzer_params))
     general_dutch_entities = set(get_dutch_general_entity_names())
-    legal_dutch_entities = set(get_dutch_legal_entity_names())
     all_dutch_entities = set(get_dutch_entity_names(include_legal=True))
 
     base_preferred_entities = {
@@ -474,26 +457,18 @@ try:
 
     default_entities = [entity for entity in all_supported_entities if entity in preferred_entities]
 
-    st_entities_expander = st.sidebar.expander("Choose entities to look for")
-    st_entities = st_entities_expander.multiselect(
-        label="Which entities to look for?",
-        options=all_supported_entities,
-        default=default_entities,
-        help=(
-            "Dutch / EU mode adds recognizers such as NL_BSN, NL_POSTCODE, NL_KVK_NUMBER, "
-            "NL_VAT_NUMBER, NL_IBAN and NL_PHONE_NUMBER. Dutch Legal Strict additionally adds "
-            "NL_ECLI, NL_LEGAL_CASE_NUMBER, NL_PARKETNUMMER, NL_DOSSIER_NUMBER, NL_CLIENT_NUMBER, "
-            "plus contextual references such as NL_CLIENT_REFERENCE, NL_SCHOOL_REFERENCE, "
-            "NL_INVOICE_NUMBER, NL_CASE_REFERENCE and related legal/admin IDs."
-        ),
-    )
+    with st.sidebar.expander("Te herkennen gegevenstypen", expanded=False):
+        st_entities = st.multiselect(
+            label="Welke typen gegevens moet Scrub zoeken?",
+            options=all_supported_entities,
+            default=default_entities,
+            help="Laat dit standaard staan, tenzij je gericht wilt testen of tunen.",
+        )
 
-    analyzer_load_state = st.info("Starting Presidio analyzer...")
+    analyzer_load_state = st.info("Herkenningsengine starten...")
     analyzer = analyzer_engine(*analyzer_params)
     analyzer_load_state.empty()
 
-    # The current demo uses English NER models. Dutch/EU pattern recognizers are
-    # registered under language="en" so they can run without a separate Dutch NLP model.
     st_analyze_results = analyze(
         *analyzer_params,
         text=st_text,
@@ -507,7 +482,7 @@ try:
 
     if st_operator not in ("highlight", "synthesize"):
         with col2:
-            st.subheader("Output")
+            st.subheader("Directe voorbeeldweergave")
             st_anonymize_results = anonymize(
                 text=st_text,
                 operator=st_operator,
@@ -516,7 +491,7 @@ try:
                 encrypt_key=st_encrypt_key,
                 analyze_results=st_analyze_results,
             )
-            st.text_area(label="De-identified", value=st_anonymize_results.text, height=400)
+            st.text_area(label="Automatisch resultaat", value=st_anonymize_results.text, height=400)
 
         _, report_rows = build_placeholder_replacements(st_text, st_analyze_results)
         candidate_rows = []
@@ -524,36 +499,38 @@ try:
             candidate_rows = scan_unmasked_candidates(st_text, st_analyze_results, max_candidates=50)
 
         st.divider()
-        st.subheader("Review replacement table before export")
+        st.subheader("2. Controleer gevonden gegevens")
         st.caption(
-            "Untick false positives, change placeholders, add your own word pairs, "
-            "and tick Remember for pairs you want to reuse in future documents. "
-            "Candidate rows are suggestions and are unchecked by default."
+            "Vink fout-positieven uit, pas placeholders aan, voeg handmatige vervangingen toe "
+            "en vink Onthouden aan voor vervangingen die je opnieuw wilt gebruiken. "
+            "Mogelijke kandidaten staan standaard uitgevinkt."
         )
 
         if st_recognition_profile == "Dutch Legal Strict":
-            with st.expander("Audit: possible unmasked candidates", expanded=bool(candidate_rows)):
+            with st.expander("Mogelijke gemiste waarden", expanded=bool(candidate_rows)):
                 if candidate_rows:
                     st.warning(
-                        "These values were not automatically masked, but look like possible legal/admin references. "
-                        "They are added to the review table below as unchecked suggestions."
+                        "Deze waarden zijn niet automatisch vervangen, maar lijken mogelijk op juridische of administratieve referenties. "
+                        "Controleer ze en vink ze alleen aan als ze echt vervangen moeten worden."
                     )
                     candidate_display_df = pd.DataFrame(candidate_rows)
+                    candidate_display_df["type_gegeven"] = candidate_display_df["entity_type"].map(entity_label)
+                    candidate_display_df["zekerheid"] = candidate_display_df["score"].map(confidence_label)
                     candidate_display_df = candidate_display_df[
-                        ["entity_type", "text", "placeholder", "score", "reason", "context"]
+                        ["type_gegeven", "text", "placeholder", "zekerheid", "reason", "context"]
                     ].rename(
                         columns={
-                            "entity_type": "Candidate type",
-                            "text": "Text",
-                            "placeholder": "Suggested replacement",
-                            "score": "Score",
-                            "reason": "Reason",
-                            "context": "Nearby context",
+                            "type_gegeven": "Type gegeven",
+                            "text": "Gevonden tekst",
+                            "placeholder": "Voorgestelde vervanging",
+                            "zekerheid": "Zekerheid",
+                            "reason": "Reden",
+                            "context": "Context",
                         }
                     )
                     st.dataframe(candidate_display_df, use_container_width=True)
                 else:
-                    st.success("No suspicious unmasked reference candidates found by the audit layer.")
+                    st.success("Geen mogelijke gemiste referenties gevonden door de auditlaag.")
 
         remembered_rows = load_remembered_replacements()
         default_editor_rows = []
@@ -564,16 +541,20 @@ try:
             replace_with = str(row.get("replace_with", "")).strip()
             if not find_text or not replace_with:
                 continue
+            entity_type = row.get("entity_type", "REMEMBERED")
             default_editor_rows.append(
                 {
                     "include": row.get("include", True),
                     "remember": row.get("remember", True),
                     "find": find_text,
                     "replace_with": replace_with,
-                    "entity_type": row.get("entity_type", "REMEMBERED"),
+                    "type_label": entity_label(entity_type),
+                    "entity_type": entity_type,
+                    "confidence": "",
                     "score": None,
+                    "source_label": source_label("remembered"),
                     "source": "remembered",
-                    "reason": "Saved reusable replacement",
+                    "reason": "Opgeslagen herbruikbare vervanging",
                     "context": "",
                 }
             )
@@ -583,34 +564,45 @@ try:
             find_text = str(row.get("detected_text", "")).strip()
             if not find_text or find_text in seen_find_values:
                 continue
+            entity_type = row.get("entity_type", "")
+            score = row.get("score", None)
             default_editor_rows.append(
                 {
                     "include": True,
                     "remember": False,
                     "find": find_text,
                     "replace_with": row.get("placeholder", ""),
-                    "entity_type": row.get("entity_type", ""),
-                    "score": row.get("score", None),
+                    "type_label": entity_label(entity_type),
+                    "entity_type": entity_type,
+                    "confidence": confidence_label(score),
+                    "score": score,
+                    "source_label": source_label("detected"),
                     "source": "detected",
-                    "reason": "Automatically detected by recognizer",
+                    "reason": "Automatisch herkend",
                     "context": "",
                 }
             )
+            seen_find_values.add(find_text)
 
         for candidate in candidate_rows:
             find_text = str(candidate.get("text", "")).strip()
             if not find_text or find_text in seen_find_values:
                 continue
+            entity_type = candidate.get("entity_type", "NL_SUSPICIOUS_REFERENCE_CANDIDATE")
+            score = candidate.get("score", None)
             default_editor_rows.append(
                 {
                     "include": False,
                     "remember": False,
                     "find": find_text,
                     "replace_with": candidate.get("placeholder", "<MOGELIJKE_REFERENTIE>"),
-                    "entity_type": candidate.get("entity_type", "NL_SUSPICIOUS_REFERENCE_CANDIDATE"),
-                    "score": candidate.get("score", None),
+                    "type_label": entity_label(entity_type),
+                    "entity_type": entity_type,
+                    "confidence": confidence_label(score),
+                    "score": score,
+                    "source_label": source_label("candidate"),
                     "source": "candidate",
-                    "reason": candidate.get("reason", "Possible unmasked value"),
+                    "reason": candidate.get("reason", "Mogelijke gemiste waarde"),
                     "context": candidate.get("context", ""),
                 }
             )
@@ -623,10 +615,13 @@ try:
                     "remember": False,
                     "find": "",
                     "replace_with": "",
+                    "type_label": entity_label("MANUAL"),
                     "entity_type": "MANUAL",
+                    "confidence": "",
                     "score": None,
+                    "source_label": source_label("manual"),
                     "source": "manual",
-                    "reason": "Manual replacement row",
+                    "reason": "Handmatige vervangingsregel",
                     "context": "",
                 }
             ]
@@ -637,63 +632,59 @@ try:
             hide_index=True,
             num_rows="dynamic",
             use_container_width=True,
-            column_order=["include", "remember", "find", "replace_with", "entity_type", "score", "source", "reason", "context"],
+            column_order=[
+                "include",
+                "remember",
+                "find",
+                "replace_with",
+                "type_label",
+                "confidence",
+                "source_label",
+                "reason",
+                "context",
+                "entity_type",
+                "score",
+                "source",
+            ],
             column_config={
                 "include": st.column_config.CheckboxColumn(
-                    "Use", help="Untick to exclude this replacement from the export.", default=True
+                    "Meenemen", help="Vink uit om deze vervanging niet toe te passen.", default=True
                 ),
                 "remember": st.column_config.CheckboxColumn(
-                    "Remember", help="Save this replacement pair for future documents/sessions.", default=False
+                    "Onthouden", help="Bewaar deze vervanging voor later gebruik.", default=False
                 ),
                 "find": st.column_config.TextColumn(
-                    "Find text", help="The exact text that should be replaced."
+                    "Gevonden tekst", help="Exacte tekst die vervangen moet worden."
                 ),
                 "replace_with": st.column_config.TextColumn(
-                    "Replace with", help="The placeholder to insert."
+                    "Vervangen door", help="Placeholder of vervangende tekst."
                 ),
-                "entity_type": st.column_config.TextColumn(
-                    "Entity type", help="Presidio entity type or MANUAL."
+                "type_label": st.column_config.TextColumn(
+                    "Type gegeven", help="Gebruiksvriendelijke categorie."
                 ),
-                "score": st.column_config.NumberColumn(
-                    "Score", help="Presidio/candidate confidence score, if available.", format="%.3f"
+                "confidence": st.column_config.TextColumn(
+                    "Zekerheid", help="Globale inschatting van de herkenningszekerheid."
                 ),
-                "source": st.column_config.TextColumn(
-                    "Source", help="detected, candidate, remembered or manual."
+                "source_label": st.column_config.TextColumn(
+                    "Bron", help="Automatisch herkend, mogelijke kandidaat, onthouden of handmatig."
                 ),
                 "reason": st.column_config.TextColumn(
-                    "Reason", help="Why this row was suggested or detected."
+                    "Reden", help="Waarom deze regel is voorgesteld."
                 ),
                 "context": st.column_config.TextColumn(
-                    "Nearby context", help="Nearby text for candidate-review rows."
+                    "Context", help="Nabije tekst voor kandidaatregels."
+                ),
+                "entity_type": st.column_config.TextColumn(
+                    "Technisch type", help="Interne herkennercategorie."
+                ),
+                "score": st.column_config.NumberColumn(
+                    "Technische score", help="Numerieke score, indien beschikbaar.", format="%.3f"
                 ),
+                "source": st.column_config.TextColumn("Technische bron"),
             },
             key="replacement_editor",
         )
 
-        def safe_cell(value):
-            if value is None:
-                return ""
-            try:
-                if pd.isna(value):
-                    return ""
-            except Exception:
-                pass
-            return str(value).strip()
-
-        def safe_bool(value):
-            if isinstance(value, bool):
-                return value
-            if value is None:
-                return False
-            try:
-                if pd.isna(value):
-                    return False
-            except Exception:
-                pass
-            if isinstance(value, (int, float)):
-                return bool(value)
-            return str(value).strip().lower() in ("true", "1", "yes", "y", "checked")
-
         edited_replacements = {}
         edited_report_rows = []
         for _, row in edited_replacements_df.iterrows():
@@ -716,13 +707,13 @@ try:
                 }
             )
 
-        st.info(f"{len(edited_replacements)} replacement pair(s) will be applied to the exports.")
+        st.info(f"{len(edited_replacements)} vervanging(en) worden toegepast op de exports.")
 
         export_text = apply_replacements_to_text(st_text, edited_replacements)
-        with st.expander("Preview anonymized text generated from edited table", expanded=False):
-            st.text_area(label="Preview", value=export_text, height=300, key="edited_export_preview")
+        with st.expander("Voorbeeld op basis van de gecontroleerde vervangtabel", expanded=False):
+            st.text_area(label="Gecontroleerde voorbeeldtekst", value=export_text, height=300, key="edited_export_preview")
 
-        st.subheader("Remember reusable replacements")
+        st.subheader("3. Onthoud herbruikbare vervangingen")
         remember_rows_to_save = []
         for _, row in edited_replacements_df.iterrows():
             include = safe_bool(row.get("include", False))
@@ -731,49 +722,47 @@ try:
             replace_text = safe_cell(row.get("replace_with", ""))
             entity_type = safe_cell(row.get("entity_type", "REMEMBERED")) or "REMEMBERED"
             if include and remember and find_text and replace_text:
-                remember_rows_to_save.append(
-                    {"find": find_text, "replace_with": replace_text, "entity_type": entity_type}
-                )
+                remember_rows_to_save.append({"find": find_text, "replace_with": replace_text, "entity_type": entity_type})
 
         memory_col1, memory_col2 = st.columns(2)
         with memory_col1:
-            if st.button("Save remembered replacements"):
+            if st.button("Onthouden vervangingen opslaan"):
                 saved_count = save_remembered_replacements(remember_rows_to_save)
-                st.success(f"Saved {saved_count} remembered replacement pair(s).")
-                st.info(f"Memory file: {get_memory_file_path()}")
+                st.success(f"{saved_count} vervanging(en) opgeslagen.")
+                st.info(f"Geheugenbestand: {get_memory_file_path()}")
         with memory_col2:
-            if st.button("Clear remembered replacements"):
+            if st.button("Onthouden vervangingen wissen"):
                 clear_remembered_replacements()
-                st.warning("Remembered replacements cleared.")
+                st.warning("Onthouden vervangingen gewist.")
 
-        st.subheader("Export anonymized files")
+        st.subheader("4. Download opgeschoonde bestanden")
         if uploaded_file is not None:
-            st.info(f"Uploaded file detected for export: {uploaded_file.name}")
+            st.info(f"Bestand beschikbaar voor export: {uploaded_file.name}")
         else:
-            st.info("No uploaded file detected for export. Exporting from text area only.")
+            st.info("Geen uploadbestand aanwezig. Export wordt gemaakt op basis van het tekstvak.")
 
         st.download_button(
-            label="Download anonymized text (.txt)",
+            label="Download opgeschoonde tekst (.txt)",
             data=export_text.encode("utf-8"),
-            file_name="anonymized_text.txt",
+            file_name="opgeschoonde_tekst.txt",
             mime="text/plain",
             key="download_txt",
         )
         st.download_button(
-            label="Download replacement table (.csv)",
+            label="Download vervangtabel (.csv)",
             data=replacement_report_csv(edited_report_rows),
-            file_name="replacement_table.csv",
+            file_name="vervangtabel.csv",
             mime="text/csv",
             key="download_csv",
         )
         st.download_button(
-            label="Download scrub report (.txt)",
+            label="Download scrubrapport (.txt)",
             data=scrub_report_txt(
                 edited_report_rows,
-                profile=st_recognition_profile,
+                profile=profile_label,
                 source_filename=uploaded_file.name if uploaded_file is not None else None,
             ),
-            file_name="scrub_report.txt",
+            file_name="scrubrapport.txt",
             mime="text/plain",
             key="download_scrub_report",
         )
@@ -781,63 +770,67 @@ try:
         try:
             if uploaded_file is not None and uploaded_file.name.lower().endswith(".docx"):
                 docx_bytes = anonymized_docx_from_original(uploaded_file, edited_replacements)
-                docx_filename = "anonymized_" + uploaded_file.name
+                docx_filename = "opgeschoond_" + uploaded_file.name
             else:
                 docx_bytes = docx_from_text(export_text)
-                docx_filename = "anonymized_text.docx"
+                docx_filename = "opgeschoonde_tekst.docx"
             st.download_button(
-                label="Download anonymized Word file (.docx)",
+                label="Download opgeschoond Word-bestand (.docx)",
                 data=docx_bytes,
                 file_name=docx_filename,
                 mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
                 key="download_docx",
             )
         except Exception as docx_error:
-            st.error(f"Could not create DOCX export: {docx_error}")
+            st.error(f"Kon geen DOCX-export maken: {docx_error}")
 
         try:
             st.download_button(
-                label="Download anonymized PDF (.pdf)",
+                label="Download opgeschoonde PDF (.pdf)",
                 data=pdf_from_text(export_text),
-                file_name="anonymized_text.pdf",
+                file_name="opgeschoonde_tekst.pdf",
                 mime="application/pdf",
                 key="download_pdf",
             )
         except Exception as pdf_error:
-            st.error(f"Could not create PDF export: {pdf_error}")
+            st.error(f"Kon geen PDF-export maken: {pdf_error}")
 
     elif st_operator == "synthesize":
         with col2:
-            st.subheader("OpenAI Generated output")
+            st.subheader("Synthetische tekst")
             fake_data = create_fake_data(st_text, st_analyze_results, open_ai_params)
-            st.text_area(label="Synthetic data", value=fake_data, height=400)
+            st.text_area(label="Synthetische data", value=fake_data, height=400)
     else:
-        st.subheader("Highlighted")
+        st.subheader("Gemarkeerde tekst")
         annotated_tokens = annotate(text=st_text, analyze_results=st_analyze_results)
         annotated_text(*annotated_tokens)
 
-    st.subheader("Findings" if not st_return_decision_process else "Findings with decision factors")
-    if st_analyze_results:
-        df = pd.DataFrame.from_records([r.to_dict() for r in st_analyze_results])
-        df["text"] = [st_text[res.start : res.end] for res in st_analyze_results]
-        df_subset = df[["entity_type", "text", "start", "end", "score"]].rename(
-            {
-                "entity_type": "Entity type",
-                "text": "Text",
-                "start": "Start",
-                "end": "End",
-                "score": "Confidence",
-            },
-            axis=1,
-        )
-        if st_return_decision_process:
-            analysis_explanation_df = pd.DataFrame.from_records(
-                [r.analysis_explanation.to_dict() for r in st_analyze_results]
+    with st.expander("Technische herkenningen", expanded=False):
+        if st_analyze_results:
+            df = pd.DataFrame.from_records([r.to_dict() for r in st_analyze_results])
+            df["text"] = [st_text[res.start : res.end] for res in st_analyze_results]
+            df["type_gegeven"] = df["entity_type"].map(entity_label)
+            df["zekerheid"] = df["score"].map(confidence_label)
+            df_subset = df[["type_gegeven", "text", "start", "end", "score", "zekerheid", "entity_type"]].rename(
+                {
+                    "type_gegeven": "Type gegeven",
+                    "text": "Gevonden tekst",
+                    "start": "Start",
+                    "end": "Einde",
+                    "score": "Score",
+                    "zekerheid": "Zekerheid",
+                    "entity_type": "Technisch type",
+                },
+                axis=1,
             )
-            df_subset = pd.concat([df_subset, analysis_explanation_df], axis=1)
-        st.dataframe(df_subset.reset_index(drop=True), use_container_width=True)
-    else:
-        st.text("No findings")
+            if st_return_decision_process:
+                analysis_explanation_df = pd.DataFrame.from_records(
+                    [r.analysis_explanation.to_dict() for r in st_analyze_results]
+                )
+                df_subset = pd.concat([df_subset, analysis_explanation_df], axis=1)
+            st.dataframe(df_subset.reset_index(drop=True), use_container_width=True)
+        else:
+            st.text("Geen herkenningen gevonden.")
 
 except Exception as e:
     print(e)