Fix remembered replacement table setup bugfix

presidio_streamlit.py

@@ -363,280 +363,276 @@ try:
             st.text_area(
                 label="De-identified", value=st_anonymize_results.text, height=400
             )
-            # Build stable placeholder exports
-            # Build stable placeholder suggestions from Presidio
-            replacements, report_rows = build_placeholder_replacements(
-                st_text,
-                st_analyze_results,
-            )
-            
-            st.divider()
-            st.subheader("Review replacement table before export")
-            
-            st.caption(
-                "Untick false positives, change placeholders, or add your own word pairs. "
-                "The downloads below are generated from this edited table."
+        # Build stable placeholder suggestions from Presidio
+        replacements, report_rows = build_placeholder_replacements(
+            st_text,
+            st_analyze_results,
+        )
+
+        st.divider()
+        st.subheader("Review replacement table before export")
+
+        st.caption(
+            "Untick false positives, change placeholders, add your own word pairs, "
+            "and tick Remember for pairs you want to reuse in future documents."
+        )
+
+        # Build editable table rows from remembered replacements + Presidio suggestions
+        remembered_rows = load_remembered_replacements()
+
+        default_editor_rows = []
+        seen_find_values = set()
+
+        # First load remembered pairs
+        for row in remembered_rows:
+            find_text = str(row.get("find", "")).strip()
+            replace_with = str(row.get("replace_with", "")).strip()
+
+            if not find_text or not replace_with:
+                continue
+
+            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"),
+                    "score": None,
+                }
             )
-            
-            # Convert detected replacements into editable table rows
-            default_editor_rows = []
-            
-            for row in report_rows:
-                default_editor_rows.append(
-                    {
-                        "include": True,
-                        "find": row.get("detected_text", ""),
-                        "replace_with": row.get("placeholder", ""),
-                        "entity_type": row.get("entity_type", ""),
-                        "score": row.get("score", None),
-                    }
-                )
-            
-            # If nothing was detected, still show an empty editable row
-            if not default_editor_rows:
-                remembered_rows = load_remembered_replacements()
-                
-                # Build editable table rows from remembered replacements + Presidio suggestions
-                remembered_rows = load_remembered_replacements()
-                
-                default_editor_rows = []
-                seen_find_values = set()
-                
-                # First load remembered pairs
-                for row in remembered_rows:
-                    find_text = str(row.get("find", "")).strip()
-                
-                    if not find_text:
-                        continue
-                
-                    default_editor_rows.append(
-                        {
-                            "include": row.get("include", True),
-                            "remember": row.get("remember", True),
-                            "find": find_text,
-                            "replace_with": row.get("replace_with", ""),
-                            "entity_type": row.get("entity_type", "REMEMBERED"),
-                            "score": row.get("score", ""),
-                        }
-                    )
-                    seen_find_values.add(find_text)
-                
-                # Then add Presidio suggestions
-                for row in report_rows:
-                    find_text = str(row.get("detected_text", "")).strip()
-                
-                    if not find_text:
-                        continue
-                
-                    # Avoid duplicate rows if a remembered replacement already exists
-                    if find_text in seen_find_values:
-                        continue
-                
-                    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),
-                        }
-                    )
-                
-                # If nothing was detected and nothing was remembered, still show an empty editable row
-                if not default_editor_rows:
-                    default_editor_rows = [
-                        {
-                            "include": True,
-                            "remember": False,
-                            "find": "",
-                            "replace_with": "",
-                            "entity_type": "MANUAL",
-                            "score": None,
-                        }
-                    ]
-                
-                replacement_editor_df = pd.DataFrame(default_editor_rows)
-            
-            edited_replacements_df = st.data_editor(
-                replacement_editor_df,
-                hide_index=True,
-                num_rows="dynamic",
-                use_container_width=True,
-                column_order=["include", "remember", "find", "replace_with", "entity_type", "score"],
-                column_config={
-                    "remember": st.column_config.CheckboxColumn(
-                        "Remember",
-                        help="Save this replacement pair for future documents/sessions.",
-                        default=False,
-                    ),
-                    "find": st.column_config.TextColumn(
-                        "Find text",
-                        help="The exact text that should be replaced.",
-                    ),
-                    "replace_with": st.column_config.TextColumn(
-                        "Replace with",
-                        help="The placeholder to insert.",
-                    ),
-                    "entity_type": st.column_config.TextColumn(
-                        "Entity type",
-                        help="Presidio entity type or MANUAL.",
-                    ),
-                    "score": st.column_config.NumberColumn(
-                        "Score",
-                        help="Presidio confidence score, if available.",
-                        format="%.3f",
-                    ),
-                },
-                key="replacement_editor",
+            seen_find_values.add(find_text)
+
+        # Then add Presidio suggestions, unless already covered by a remembered pair
+        for row in report_rows:
+            find_text = str(row.get("detected_text", "")).strip()
+
+            if not find_text:
+                continue
+
+            if find_text in seen_find_values:
+                continue
+
+            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),
+                }
             )
-            
-            def safe_cell(value):
-                if value is None:
+
+        # If nothing was detected and nothing was remembered, still show an empty editable row
+        if not default_editor_rows:
+            default_editor_rows = [
+                {
+                    "include": True,
+                    "remember": False,
+                    "find": "",
+                    "replace_with": "",
+                    "entity_type": "MANUAL",
+                    "score": None,
+                }
+            ]
+
+        replacement_editor_df = pd.DataFrame(default_editor_rows)
+
+        edited_replacements_df = st.data_editor(
+            replacement_editor_df,
+            hide_index=True,
+            num_rows="dynamic",
+            use_container_width=True,
+            column_order=["include", "remember", "find", "replace_with", "entity_type", "score"],
+            column_config={
+                "include": st.column_config.CheckboxColumn(
+                    "Use",
+                    help="Untick to exclude this replacement from the export.",
+                    default=True,
+                ),
+                "remember": st.column_config.CheckboxColumn(
+                    "Remember",
+                    help="Save this replacement pair for future documents/sessions.",
+                    default=False,
+                ),
+                "find": st.column_config.TextColumn(
+                    "Find text",
+                    help="The exact text that should be replaced.",
+                ),
+                "replace_with": st.column_config.TextColumn(
+                    "Replace with",
+                    help="The placeholder to insert.",
+                ),
+                "entity_type": st.column_config.TextColumn(
+                    "Entity type",
+                    help="Presidio entity type or MANUAL.",
+                ),
+                "score": st.column_config.NumberColumn(
+                    "Score",
+                    help="Presidio confidence score, if available.",
+                    format="%.3f",
+                ),
+            },
+            key="replacement_editor",
+        )
+
+        def safe_cell(value):
+            if value is None:
+                return ""
+            try:
+                if pd.isna(value):
                     return ""
-                try:
-                    if pd.isna(value):
-                        return ""
-                except Exception:
-                    pass
-                return str(value).strip()
-            
-            
-            # Build final replacements from edited table
-            edited_replacements = {}
-            edited_report_rows = []
-            
-            for _, row in edited_replacements_df.iterrows():
-                include = bool(row.get("include", False))
-                find_text = safe_cell(row.get("find", ""))
-                replace_text = safe_cell(row.get("replace_with", ""))
-                entity_type = safe_cell(row.get("entity_type", "MANUAL")) or "MANUAL"
-                score = row.get("score", None)
-            
-                if not include:
-                    continue
-            
-                if not find_text or not replace_text:
-                    continue
-            
-                edited_replacements[find_text] = replace_text
-            
-                edited_report_rows.append(
+            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")
+
+        # Build final replacements from edited table
+        edited_replacements = {}
+        edited_report_rows = []
+
+        for _, row in edited_replacements_df.iterrows():
+            include = safe_bool(row.get("include", False))
+            find_text = safe_cell(row.get("find", ""))
+            replace_text = safe_cell(row.get("replace_with", ""))
+            entity_type = safe_cell(row.get("entity_type", "MANUAL")) or "MANUAL"
+            score = row.get("score", None)
+
+            if not include:
+                continue
+
+            if not find_text or not replace_text:
+                continue
+
+            edited_replacements[find_text] = replace_text
+
+            edited_report_rows.append(
+                {
+                    "entity_type": entity_type,
+                    "detected_text": find_text,
+                    "placeholder": replace_text,
+                    "score": score if score is not None else "",
+                }
+            )
+
+        st.info(f"{len(edited_replacements)} replacement pair(s) will be applied to the exports.")
+
+        # Apply edited replacements
+        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",
+            )
+
+        st.subheader("Remember reusable replacements")
+
+        remember_rows_to_save = []
+
+        for _, row in edited_replacements_df.iterrows():
+            include = safe_bool(row.get("include", False))
+            remember = safe_bool(row.get("remember", False))
+            find_text = safe_cell(row.get("find", ""))
+            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,
-                        "detected_text": find_text,
-                        "placeholder": replace_text,
-                        "score": score if score is not None else "",
                     }
                 )
-            
-            st.info(f"{len(edited_replacements)} replacement pair(s) will be applied to the exports.")
-            
-            # Apply edited replacements
-            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",
-                )
-            
-            st.subheader("Export anonymized files")
-            
-            if uploaded_file is not None:
-                st.info(f"Uploaded file detected for export: {uploaded_file.name}")
+
+        memory_col1, memory_col2 = st.columns(2)
+
+        with memory_col1:
+            if st.button("Save remembered replacements"):
+                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()}")
+
+        with memory_col2:
+            if st.button("Clear remembered replacements"):
+                clear_remembered_replacements()
+                st.warning("Remembered replacements cleared.")
+
+        st.subheader("Export anonymized files")
+
+        if uploaded_file is not None:
+            st.info(f"Uploaded file detected for export: {uploaded_file.name}")
+        else:
+            st.info("No uploaded file detected for export. Exporting from text area only.")
+
+        # TXT export
+        st.download_button(
+            label="Download anonymized text (.txt)",
+            data=export_text.encode("utf-8"),
+            file_name="anonymized_text.txt",
+            mime="text/plain",
+            key="download_txt",
+        )
+
+        # CSV replacement report / reusable mapping
+        st.download_button(
+            label="Download replacement table (.csv)",
+            data=replacement_report_csv(edited_report_rows),
+            file_name="replacement_table.csv",
+            mime="text/csv",
+            key="download_csv",
+        )
+
+        # DOCX export
+        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
             else:
-                st.info("No uploaded file detected for export. Exporting from text area only.")
-
-            
-            remember_rows_to_save = []
-            
-            for _, row in edited_replacements_df.iterrows():
-                include = bool(row.get("include", False))
-                remember = bool(row.get("remember", False))
-                find_text = safe_cell(row.get("find", ""))
-                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,
-                        }
-                    )
-            
-            memory_col1, memory_col2 = st.columns(2)
-            
-            with memory_col1:
-                if st.button("Save remembered replacements"):
-                    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()}")
-            
-            with memory_col2:
-                if st.button("Clear remembered replacements"):
-                    clear_remembered_replacements()
-                    st.warning("Remembered replacements cleared.")
-
-
-            # TXT export            
+                docx_bytes = docx_from_text(export_text)
+                docx_filename = "anonymized_text.docx"
+
             st.download_button(
-                label="Download anonymized text (.txt)",
-                data=export_text.encode("utf-8"),
-                file_name="anonymized_text.txt",
-                mime="text/plain",
-                key="download_txt",
+                label="Download anonymized Word file (.docx)",
+                data=docx_bytes,
+                file_name=docx_filename,
+                mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                key="download_docx",
             )
-            
-            # CSV replacement report / reusable mapping
+
+        except Exception as docx_error:
+            st.error(f"Could not create DOCX export: {docx_error}")
+
+        # PDF export
+        try:
             st.download_button(
-                label="Download replacement table (.csv)",
-                data=replacement_report_csv(edited_report_rows),
-                file_name="replacement_table.csv",
-                mime="text/csv",
-                key="download_csv",
+                label="Download anonymized PDF (.pdf)",
+                data=pdf_from_text(export_text),
+                file_name="anonymized_text.pdf",
+                mime="application/pdf",
+                key="download_pdf",
             )
-            
-            # DOCX export
-            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
-                else:
-                    docx_bytes = docx_from_text(export_text)
-                    docx_filename = "anonymized_text.docx"
-            
-                st.download_button(
-                    label="Download anonymized Word file (.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}")
-            
-            # PDF export
-            try:
-                st.download_button(
-                    label="Download anonymized PDF (.pdf)",
-                    data=pdf_from_text(export_text),
-                    file_name="anonymized_text.pdf",
-                    mime="application/pdf",
-                    key="download_pdf",
-                )
-            
-            except Exception as pdf_error:
-                st.error(f"Could not create PDF export: {pdf_error}")
-
 
+        except Exception as pdf_error:
+            st.error(f"Could not create PDF export: {pdf_error}")
 
-            
     elif st_operator == "synthesize":
         with col2:
             st.subheader(f"OpenAI Generated output")