Updated cleaned up code

app.py

@@ -16,6 +16,64 @@ _TABS = ["Chat", "Compare", "Extract"]
 _TAB_ICONS = [":material/chat:", ":material/search:", ":material/tune:"]
 
 
+def _remote_model_input(remote_models: list[str]) -> str:
+    """Return the active remote model id, picking from running NDIF deployments or a custom value."""
+
+    last_remote = st.session_state.get(_LAST_REMOTE_MODEL_KEY, REMOTE_DEFAULT_MODEL)
+
+    if not remote_models:
+        st.warning("No running NDIF models found.")
+        model_name = st.text_input(
+            "Model",
+            value=st.session_state.get(
+                "sidebar__remote_model_custom_value", last_remote
+            ),
+            key="sidebar__remote_model_custom_value",
+            help="NDIF model id. Use this to cold-load a remote model.",
+        )
+        st.session_state[_LAST_REMOTE_MODEL_KEY] = model_name
+        return model_name
+
+    custom = st.toggle(
+        "Custom remote model",
+        value=False,
+        key="sidebar__remote_model_custom_enabled",
+        help="Enter any NDIF-loadable model id, even if it is not currently running.",
+    )
+    if custom:
+        model_name = st.text_input(
+            "Model",
+            value=st.session_state.get(
+                "sidebar__remote_model_custom_value", last_remote
+            ),
+            key="sidebar__remote_model_custom_value",
+            help="NDIF model id. Example: openai/gpt-oss-20b",
+        )
+        st.caption(
+            f"{len(remote_models)} running NDIF model(s) detected. "
+            "Custom model ids can cold-load if your NDIF account allows it."
+        )
+    else:
+        default_model = st.session_state.get("sidebar__remote_model", last_remote)
+        if default_model not in remote_models:
+            default_model = (
+                REMOTE_DEFAULT_MODEL
+                if REMOTE_DEFAULT_MODEL in remote_models
+                else remote_models[0]
+            )
+        if st.session_state.get("sidebar__remote_model") not in remote_models:
+            st.session_state["sidebar__remote_model"] = default_model
+        model_name = st.selectbox(
+            "Model",
+            options=remote_models,
+            index=remote_models.index(default_model),
+            key="sidebar__remote_model",
+            help="Running NDIF model.",
+        )
+    st.session_state[_LAST_REMOTE_MODEL_KEY] = model_name
+    return model_name
+
+
 def _sidebar_controls() -> tuple[bool, str, str, str]:
     from utils.runtime import list_remote_models
 
@@ -44,68 +102,7 @@ def _sidebar_controls() -> tuple[bool, str, str, str]:
         remote = st.toggle("Remote (NDIF)", value=False, key="sidebar__remote")
 
         if remote:
-            remote_models = list_remote_models()
-            custom_remote_key = "sidebar__remote_model_custom_enabled"
-            custom_remote_model = st.toggle(
-                "Custom remote model",
-                value=False,
-                key=custom_remote_key,
-                help="Enter any NDIF-loadable model id, even if it is not currently running.",
-            )
-            if remote_models:
-                if custom_remote_model:
-                    model_name = st.text_input(
-                        "Model",
-                        value=st.session_state.get(
-                            "sidebar__remote_model_custom_value",
-                            st.session_state.get(
-                                _LAST_REMOTE_MODEL_KEY, REMOTE_DEFAULT_MODEL
-                            ),
-                        ),
-                        key="sidebar__remote_model_custom_value",
-                        help="NDIF model id. Example: openai/gpt-oss-20b",
-                    )
-                    st.caption(
-                        f"{len(remote_models)} running NDIF model(s) detected. Custom model ids can cold-load if your NDIF account allows it."
-                    )
-                else:
-                    default_model = st.session_state.get(
-                        "sidebar__remote_model",
-                        st.session_state.get(_LAST_REMOTE_MODEL_KEY),
-                    )
-                    if default_model not in remote_models:
-                        default_model = (
-                            REMOTE_DEFAULT_MODEL
-                            if REMOTE_DEFAULT_MODEL in remote_models
-                            else remote_models[0]
-                        )
-                    if (
-                        st.session_state.get("sidebar__remote_model")
-                        not in remote_models
-                    ):
-                        st.session_state["sidebar__remote_model"] = default_model
-                    selected_remote_model = st.selectbox(
-                        "Model",
-                        options=remote_models,
-                        index=remote_models.index(default_model),
-                        key="sidebar__remote_model",
-                        help="Running NDIF model.",
-                    )
-                    model_name = selected_remote_model
-            else:
-                st.warning("No running NDIF models found.")
-                model_name = st.text_input(
-                    "Model",
-                    value=st.session_state.get(
-                        "sidebar__remote_model_custom_value",
-                        st.session_state.get(
-                            _LAST_REMOTE_MODEL_KEY, REMOTE_DEFAULT_MODEL
-                        ),
-                    ),
-                    key="sidebar__remote_model_custom_value",
-                    help="NDIF model id. Use this to cold-load a remote model.",
-                )
-            st.session_state[_LAST_REMOTE_MODEL_KEY] = model_name
+            model_name = _remote_model_input(list_remote_models())
         else:
             model_name = st.text_input(
                 "Model",

pyproject.toml

@@ -5,8 +5,8 @@ description = "Streamlit UI for persona-vectors"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-    "persona-vectors>=0.6.1",
-    "persona-data>=0.4.1",
+    "persona-vectors>=0.6.3",
+    "persona-data>=0.4.2",
     "streamlit>=1.44.0",
     "plotly>=6.6.0",
     "python-dotenv>=1.2.2",

state.py

@@ -1,6 +1,7 @@
-import streamlit as st
 from typing import Literal, NotRequired, TypedDict
 
+import streamlit as st
+
 _CHAT_STATE_PREFIX = "chat_state::"
 PendingChatAction = Literal["new_user_prompt", "regenerate_after_edit"]
 
@@ -50,9 +51,7 @@ def reset_chat_context_state(
         st.session_state.pop(key, None)
 
 
-def get_chat_state(
-    model_name: str, remote: bool, dataset_source: str
-) -> ChatState:
+def get_chat_state(model_name: str, remote: bool, dataset_source: str) -> ChatState:
     """Return the mutable chat state for the active context."""
 
     key = chat_session_key(model_name, dataset_source)

tabs/chat.py

@@ -128,8 +128,6 @@ def _handle_single_chat_generation(
     st.rerun()
 
 
-
-
 def render_chat_tab(remote: bool, model_name: str, dataset_source: str) -> None:
     """Render the chat tab."""
 

tabs/chat_ui.py

@@ -269,76 +269,46 @@ def render_chat_message(
 ) -> None:
     if not message.get("content"):
         return
-    role = message["role"]
     contrast: TokenContrast | None = message.get("_contrast") if show_contrast else None
-    with st.chat_message(role):
+    with st.chat_message(message["role"]):
         if contrast is not None:
             st.html(render_contrast_html(contrast))
         else:
             st.markdown(message["content"])
 
 
-def _render_editable_message(
-    message: dict[str, str],
-    msg_index: int,
-    messages: list[dict[str, str]],
-    chat_state: dict[str, object],
-    edit_key: str,
-    pending_key: str,
-    show_contrast: bool = False,
-    column_ratio: tuple[int, int] = (25, 1),
-) -> None:
-    if not message.get("content"):
-        return
-    role = message["role"]
-    contrast: TokenContrast | None = message.get("_contrast") if show_contrast else None
-    msg_col, edit_col = st.columns(
-        list(column_ratio), gap="xsmall", vertical_alignment="center"
-    )
-
-    with msg_col:
-        with st.chat_message(role):
-            if contrast is not None:
-                st.html(render_contrast_html(contrast))
-            else:
-                st.markdown(message["content"])
-    with edit_col:
-        if st.button(
-            "", icon=":material/edit:", key=f"{edit_key}_edit_{msg_index}", help="Edit"
-        ):
-            _open_edit_dialog(
-                msg_index=msg_index,
-                messages=messages,
-                chat_state=chat_state,
-                pending_key=pending_key,
-            )
-
-
 def render_chat_window(
     *,
     chat_log: Any,
     messages: list[dict[str, str]],
-    chat_state: dict[str, object] | None = None,
-    edit_key: str | None = None,
-    pending_key: str | None = None,
+    chat_state: dict[str, object],
+    edit_key: str,
+    pending_key: str,
     show_contrast: bool = False,
     edit_column_ratio: tuple[int, int] = (25, 1),
 ) -> None:
     with chat_log:
         for i, message in enumerate(messages):
-            if edit_key and pending_key and chat_state is not None:
-                _render_editable_message(
-                    message,
-                    i,
-                    messages,
-                    chat_state,
-                    edit_key,
-                    pending_key,
-                    show_contrast=show_contrast,
-                    column_ratio=edit_column_ratio,
-                )
-            else:
+            if not message.get("content"):
+                continue
+            msg_col, edit_col = st.columns(
+                list(edit_column_ratio), gap="xsmall", vertical_alignment="center"
+            )
+            with msg_col:
                 render_chat_message(message, show_contrast=show_contrast)
+            with edit_col:
+                if st.button(
+                    "",
+                    icon=":material/edit:",
+                    key=f"{edit_key}_edit_{i}",
+                    help="Edit",
+                ):
+                    _open_edit_dialog(
+                        msg_index=i,
+                        messages=messages,
+                        chat_state=chat_state,
+                        pending_key=pending_key,
+                    )
 
 
 def _assistant_first(personas: list[PersonaData]) -> list[PersonaData]:

tabs/compare.py

@@ -5,10 +5,7 @@ from itertools import combinations
 
 import streamlit as st
 from persona_data.environment import get_artifacts_dir
-from persona_vectors.analysis import (
-    load_persona_vectors,
-    load_variant_vectors,
-)
+from persona_vectors.analysis import load_persona_vectors, load_variant_vectors
 from persona_vectors.artifacts import ActivationStore, HFActivationStore
 from persona_vectors.artifacts import list_layers as list_local_layers
 from persona_vectors.extraction import MaskStrategy

tabs/extract.py

@@ -102,7 +102,9 @@ def _render_variant_controls(
     return selected_variants, include_baseline
 
 
-def _load_qa_dataset_personas(dataset_source: str) -> tuple[object, list[PersonaData]] | None:
+def _load_qa_dataset_personas(
+    dataset_source: str,
+) -> tuple[object, list[PersonaData]] | None:
     try:
         dataset, dataset_status = load_dataset(
             dataset_source,
@@ -237,7 +239,9 @@ def _collect_runs(
     runs, skipped = [], []
     for persona in selected_personas:
         if persona.id == BASELINE_PERSONA_ID:
-            qa = list(dataset.get_qa(BASELINE_PERSONA_ID, item_type="mcq", scope="shared"))
+            qa = list(
+                dataset.get_qa(BASELINE_PERSONA_ID, item_type="mcq", scope="shared")
+            )
         elif hasattr(dataset, "train_test_split"):
             qa, _ = dataset.train_test_split(persona.id)
         else:
@@ -268,28 +272,15 @@ def _render_max_questions(
         "Max questions (train split)",
         min_value=1,
         max_value=max_q,
-        value=min(max(st.session_state.get(_LAST_MAX_QUESTIONS_KEY, default), 1), max_q),
+        value=min(
+            max(st.session_state.get(_LAST_MAX_QUESTIONS_KEY, default), 1), max_q
+        ),
         key=_extract_widget_key(model_name, remote, dataset_source, "max_questions"),
     )
     st.session_state[_LAST_MAX_QUESTIONS_KEY] = max_questions
     return max_questions
 
 
-def _render_advanced_settings(
-    *,
-    model_name: str,
-    remote: bool,
-    dataset_source: str,
-) -> MaskStrategy:
-    with st.expander("Advanced", expanded=False):
-        mask_strategy = _render_mask_strategy_select(
-            model_name=model_name,
-            remote=remote,
-            dataset_source=dataset_source,
-        )
-    return mask_strategy
-
-
 def _render_extract_actions() -> tuple[bool, bool]:
     run_col, preview_col, _spacer = st.columns([1, 1, 4], gap="small")
     with run_col:
@@ -439,11 +430,12 @@ def render_extract_tab(remote: bool, model_name: str, dataset_source: str) -> No
         dataset_source=dataset_source,
         runs=runs,
     )
-    mask_strategy = _render_advanced_settings(
-        model_name=model_name,
-        remote=remote,
-        dataset_source=dataset_source,
-    )
+    with st.expander("Advanced", expanded=False):
+        mask_strategy = _render_mask_strategy_select(
+            model_name=model_name,
+            remote=remote,
+            dataset_source=dataset_source,
+        )
     settings = ExtractSettings(
         mask_strategy=mask_strategy,
         max_questions=max_questions,

utils/chat.py

@@ -74,9 +74,7 @@ def _format_plain_messages(
         else:
             lines.append(f"{role.title()}: {content}")
 
-    if add_generation_prompt and (
-        not lines or not lines[-1].startswith("Assistant:")
-    ):
+    if add_generation_prompt and (not lines or not lines[-1].startswith("Assistant:")):
         lines.append("Assistant:")
 
     return "\n\n".join(lines)
@@ -130,6 +128,26 @@ def format_generation_prompt(
     return prompt, prompt_token_count
 
 
+def resolve_saved_tensor(value: object) -> torch.Tensor:
+    """Resolve an nnsight ``.save()`` proxy (or raw tensor) to a CPU tensor."""
+    resolved = value.value if getattr(value, "value", None) is not None else value
+    if not isinstance(resolved, torch.Tensor):
+        raise TypeError(f"Trace result did not resolve to a tensor: {type(resolved)!r}")
+    return resolved.detach().cpu()
+
+
+def decode_token(tokenizer: object, token_id: int) -> str:
+    """Decode a single token id, falling back when ``clean_up_tokenization_spaces`` is unsupported."""
+    try:
+        return tokenizer.decode(
+            [token_id],
+            skip_special_tokens=False,
+            clean_up_tokenization_spaces=False,
+        )
+    except TypeError:
+        return tokenizer.decode([token_id], skip_special_tokens=False)
+
+
 @contextmanager
 def _seeded_rng(seed: int | None):
     """Context manager that forks the RNG state and sets a deterministic seed."""

utils/contrast.py

@@ -17,7 +17,7 @@ from html import escape
 import torch
 from nnterp import StandardizedTransformer
 
-from utils.chat import format_generation_prompt
+from utils.chat import decode_token, format_generation_prompt, resolve_saved_tensor
 
 
 @dataclass
@@ -43,18 +43,6 @@ def _normalise_diffs(diffs: torch.Tensor) -> list[float]:
     return (diffs.float().clamp(-clip_val, clip_val) / clip_val).tolist()
 
 
-def _decode_ids(tokenizer: object, ids: list[int]) -> str:
-    """Decode token IDs, falling back when clean_up_tokenization_spaces is unsupported."""
-    try:
-        return tokenizer.decode(
-            ids,
-            skip_special_tokens=False,
-            clean_up_tokenization_spaces=False,
-        )
-    except TypeError:
-        return tokenizer.decode(ids, skip_special_tokens=False)
-
-
 def _strip_special_ids(
     ids: torch.Tensor,
     tokenizer: object,
@@ -96,7 +84,7 @@ def _build_contrast(
     display_ids, keep_mask = _strip_special_ids(response_ids, tokenizer)
     display_diffs = diffs[keep_mask]
     return TokenContrast(
-        tokens=[_token_display(tokenizer, tid.item()) for tid in display_ids],
+        tokens=[decode_token(tokenizer, tid.item()) for tid in display_ids],
         weights=_normalise_diffs(display_diffs),
         raw_diffs=display_diffs.float().tolist(),
         label_a=label_a,
@@ -104,11 +92,6 @@ def _build_contrast(
     )
 
 
-def _token_display(tokenizer: object, token_id: int) -> str:
-    """Render a single token id as normal decoded text."""
-    return _decode_ids(tokenizer, [token_id])
-
-
 # Each spec: (key, input_ids, n_ctx, n_resp, target_ids).
 PassSpec = tuple[str, torch.Tensor, int, int, torch.Tensor]
 
@@ -140,14 +123,7 @@ def _score_passes(
             targets = target_ids.to(log_probs.device).view(-1, 1)
             picked = log_probs.gather(1, targets).view(-1)
             out = picked.detach().cpu().save()
-
-        if getattr(out, "value", None) is not None:
-            out = out.value
-        if not isinstance(out, torch.Tensor):
-            raise TypeError(
-                f"contrast score did not resolve to a tensor: {type(out)!r}"
-            )
-        return out.detach().cpu()
+        return resolve_saved_tensor(out)
 
     return {
         key: _score_pass(input_ids, n_ctx, n_resp, target_ids)

utils/datasets.py

@@ -17,24 +17,10 @@ from .helpers import DATASET_SOURCES
 
 
 @st.cache_resource(show_spinner=False)
-def cached_hf_dataset() -> SynthPersonaDataset:
-    """Load the default SynthPersona HuggingFace dataset once."""
+def _cached_dataset(cls: type) -> Any:
+    """Instantiate and cache a HuggingFace dataset class once per session."""
 
-    return SynthPersonaDataset()
-
-
-@st.cache_resource(show_spinner=False)
-def cached_nemotron_dataset() -> NemotronPersonasFranceDataset:
-    """Load the Nemotron France HuggingFace dataset once."""
-
-    return NemotronPersonasFranceDataset()
-
-
-@st.cache_resource(show_spinner=False)
-def cached_nemotron_usa_dataset() -> NemotronPersonasUSADataset:
-    """Load the Nemotron USA HuggingFace dataset once."""
-
-    return NemotronPersonasUSADataset()
+    return cls()
 
 
 def _upload_cache_dir() -> Path:
@@ -74,13 +60,13 @@ def load_dataset(
     """Load the selected dataset source for the UI."""
 
     if dataset_source == DATASET_SOURCES[0]:
-        return cached_hf_dataset(), "SynthPersona"
+        return _cached_dataset(SynthPersonaDataset), "SynthPersona"
 
     if dataset_source == DATASET_SOURCES[1]:
-        return cached_nemotron_dataset(), "Nemotron France"
+        return _cached_dataset(NemotronPersonasFranceDataset), "Nemotron France"
 
     if dataset_source == DATASET_SOURCES[2]:
-        return cached_nemotron_usa_dataset(), "Nemotron USA"
+        return _cached_dataset(NemotronPersonasUSADataset), "Nemotron USA"
 
     if personas_file is None or qa_file is None:
         raise ValueError("Upload both personas.jsonl and qa.jsonl files")

utils/helpers.py

@@ -13,9 +13,7 @@ VARIANT_LABELS = {
 
 CHAT_PROMPT_MODES = ("empty", "templated", "biography", "custom")
 CHAT_PROMPT_MODE_LABELS = [VARIANT_LABELS[key] for key in CHAT_PROMPT_MODES]
-CHAT_PROMPT_MODE_LABEL_TO_KEY = {
-    VARIANT_LABELS[key]: key for key in CHAT_PROMPT_MODES
-}
+CHAT_PROMPT_MODE_LABEL_TO_KEY = {VARIANT_LABELS[key]: key for key in CHAT_PROMPT_MODES}
 
 
 DATASET_SOURCES = [

utils/probe_trace.py

@@ -7,7 +7,7 @@ import streamlit as st
 import torch
 from nnterp import StandardizedTransformer
 
-from utils.chat import format_generation_prompt
+from utils.chat import decode_token, format_generation_prompt, resolve_saved_tensor
 
 _TRACE_CACHE_KEY = "probe:trace_cache"
 _MAX_CACHED_TRACES = 3
@@ -74,8 +74,8 @@ def trace_conversation(
         saved_ids = model.input_ids[0].detach().cpu().save()
         saved_acts = accessor[layer][0].detach().float().cpu().save()
 
-    input_ids = _resolve_saved_tensor(saved_ids)
-    activations = _resolve_saved_tensor(saved_acts)
+    input_ids = resolve_saved_tensor(saved_ids)
+    activations = resolve_saved_tensor(saved_acts)
     if input_ids.ndim != 1:
         raise ValueError(
             f"Expected traced input ids to be [seq], got {tuple(input_ids.shape)}"
@@ -125,17 +125,6 @@ def vectorize_token(
     )
 
 
-def decode_token(tokenizer: object, token_id: int) -> str:
-    try:
-        return tokenizer.decode(
-            [token_id],
-            skip_special_tokens=False,
-            clean_up_tokenization_spaces=False,
-        )
-    except TypeError:
-        return tokenizer.decode([token_id], skip_special_tokens=False)
-
-
 def _select_accessor(model: StandardizedTransformer, location: str):
     normalized = location.lower()
     if normalized in {"pre_reasoning", "pre", "input", "layers_input"}:
@@ -145,13 +134,6 @@ def _select_accessor(model: StandardizedTransformer, location: str):
     raise ValueError(f"Unsupported trace location: {location!r}")
 
 
-def _resolve_saved_tensor(value) -> torch.Tensor:
-    resolved = value.value if getattr(value, "value", None) is not None else value
-    if not isinstance(resolved, torch.Tensor):
-        raise TypeError(f"Trace result did not resolve to a tensor: {type(resolved)!r}")
-    return resolved.detach().cpu()
-
-
 def _trace_cache_key(
     *,
     model_name: str,

utils/probes.py

@@ -225,15 +225,28 @@ def _load_probe_payload(
         num_classes=num_classes,
     )
     labels = _normalize_labels(payload.get("idx_to_label"), num_classes)
+
+    raw_layer = payload.get("layer")
+    try:
+        layer = int(raw_layer) if raw_layer is not None else metadata.layer
+    except (TypeError, ValueError):
+        layer = metadata.layer
+    raw_location = payload.get("location")
+    location = (
+        raw_location
+        if isinstance(raw_location, str) and raw_location
+        else metadata.location
+    )
+
     return LoadedProbe(
         model=model,
         input_dim=input_dim,
         labels=labels,
         model_type=str(payload.get("model_type") or metadata.model_type),
-        layer=_coerce_optional_int(payload.get("layer"), metadata.layer),
-        location=_coerce_location(payload.get("location"), metadata.location),
-        scaler_mean=_coerce_tensor(payload.get("scaler_mean")),
-        scaler_std=_coerce_tensor(payload.get("scaler_std")),
+        layer=layer,
+        location=location,
+        scaler_mean=_as_cpu_tensor(payload.get("scaler_mean")),
+        scaler_std=_as_cpu_tensor(payload.get("scaler_std")),
     )
 
 
@@ -296,7 +309,9 @@ def _coerce_probe_dim(
     weights = [
         tensor
         for key, tensor in state_dict.items()
-        if key.endswith("weight") and isinstance(tensor, torch.Tensor) and tensor.ndim == 2
+        if key.endswith("weight")
+        and isinstance(tensor, torch.Tensor)
+        and tensor.ndim == 2
     ]
     if not weights:
         raise ValueError(f"Cannot infer probe {dim} dimension from state dict")
@@ -349,27 +364,12 @@ def _coerce_hidden_dims(value: Any) -> list[int]:
     raise TypeError(f"Unsupported hidden_dims value: {type(value)!r}")
 
 
-def _coerce_tensor(value: Any) -> torch.Tensor | None:
-    if value is None or not isinstance(value, torch.Tensor):
+def _as_cpu_tensor(value: Any) -> torch.Tensor | None:
+    if not isinstance(value, torch.Tensor):
         return None
     return value.detach().cpu()
 
 
-def _coerce_optional_int(value: Any, fallback: int | None) -> int | None:
-    if value is None:
-        return fallback
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return fallback
-
-
-def _coerce_location(value: Any, fallback: str | None) -> str | None:
-    if isinstance(value, str) and value:
-        return value
-    return fallback
-
-
 def _normalize_labels(raw_labels: Any, num_classes: int) -> list[str | None]:
     if isinstance(raw_labels, (list, tuple)):
         labels = [str(label) for label in raw_labels[:num_classes]]

uv.lock

@@ -1120,11 +1120,11 @@ wheels = [
 
 [[package]]
 name = "narwhals"
-version = "2.20.0"
+version = "2.21.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e9/f3/257adc69a71011b4c8cda321b00f02c5bf1980ae38ffd05a58d9632d4de8/narwhals-2.20.0.tar.gz", hash = "sha256:c10994975fa7dc5a68c2cffcddbd5908fc8ebb2d463c5bab085309c0ee1f551e", size = 627848, upload-time = "2026-04-20T12:11:45.427Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/0e/3ad61eb87088cc4932e0d851531fa82f845a6230b68b091a0e298cc7e537/narwhals-2.21.0.tar.gz", hash = "sha256:7c6e7f50528e62b7a967dd864d7e117d2955d38d4f730653ce46a9861358e2dc", size = 633083, upload-time = "2026-05-08T12:29:02.587Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/69/f24d3d1c38ad69e256138b4ec2452a8c7cf66be49dc214771ae99dd4f0a0/narwhals-2.20.0-py3-none-any.whl", hash = "sha256:16e750ea5507d4ba6e8d03455b5f93a535e0405976561baea235bca5dc9f475d", size = 449373, upload-time = "2026-04-20T12:11:43.596Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/e1/68c2256b69a314eba133673377ba9118c356f6342a0c02b61de449cf2bf2/narwhals-2.21.0-py3-none-any.whl", hash = "sha256:1e6617d0fca68ae1fda29e5397c4eaacd3ffc9fffe6bcd6ded0c690475e853be", size = 451943, upload-time = "2026-05-08T12:29:01.058Z" },
 ]
 
 [[package]]
@@ -1550,7 +1550,7 @@ wheels = [
 
 [[package]]
 name = "persona-data"
-version = "0.4.1"
+version = "0.4.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "huggingface-hub" },
@@ -1559,9 +1559,9 @@ dependencies = [
     { name = "python-dotenv" },
     { name = "torch" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d5/9b/b9bc22cf6393cbd38529dfdc1128963c2935060f96b6896b81349bd34050/persona_data-0.4.1.tar.gz", hash = "sha256:1e98a8999f498f95eeaaa4f46931818b2b1296b5ad500a89c7ad1e87b5aa405f", size = 9294, upload-time = "2026-05-07T10:27:00.746Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/2f/099a74e54846172a20b697b46b285eb2f0004e1db530308d6b4ff1f19079/persona_data-0.4.2.tar.gz", hash = "sha256:7870292a79b3943a77c31595140de3b2243b783222590248d09891de70e7fe1b", size = 9276, upload-time = "2026-05-08T13:59:27.58Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/a9/10a586bfb4a585931dbc0f657c71a35946880cbb7b25316594042cc1a00a/persona_data-0.4.1-py3-none-any.whl", hash = "sha256:53780689988e487b68d826c0cd980dfe6bb13a340e01a10c042e4dc86f46e765", size = 11937, upload-time = "2026-05-07T10:26:59.865Z" },
+    { url = "https://files.pythonhosted.org/packages/57/03/e76a48b41ee00684a4430269007e217e70f59e2597d7c862d93cfc5ac78b/persona_data-0.4.2-py3-none-any.whl", hash = "sha256:c881d6fb71af87a6fa773284076e4cb55794db6dc447a7eb0047eee2b389c855", size = 11914, upload-time = "2026-05-08T13:59:28.198Z" },
 ]
 
 [[package]]
@@ -1578,8 +1578,8 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
-    { name = "persona-data", specifier = ">=0.4.1" },
-    { name = "persona-vectors", specifier = ">=0.6.1" },
+    { name = "persona-data", specifier = ">=0.4.2" },
+    { name = "persona-vectors", specifier = ">=0.6.3" },
     { name = "plotly", specifier = ">=6.6.0" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
     { name = "streamlit", specifier = ">=1.44.0" },
@@ -1587,7 +1587,7 @@ requires-dist = [
 
 [[package]]
 name = "persona-vectors"
-version = "0.6.1"
+version = "0.6.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "datasets" },
@@ -1606,9 +1606,9 @@ dependencies = [
     { name = "transformers" },
     { name = "umap-learn" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/69/f3/6da35af90c8ea5333db1763ece04a3230353ac5a76c0dc8fea705a6e86cf/persona_vectors-0.6.1.tar.gz", hash = "sha256:552ac9a0d739a453c5d9eb612cb0d0d2820a1b53ce84f490295a84105a71f7cc", size = 24311, upload-time = "2026-05-07T15:07:29.951Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/42/f5/57836026dc1b8c716ff6e443ba3cc8fafef108078e52f872c101f66ab61c/persona_vectors-0.6.3.tar.gz", hash = "sha256:2389aaa4ab5e83c4541556a000e0268ad3f1f2d5e741ade9830cb3da972332c5", size = 24509, upload-time = "2026-05-08T14:10:37.09Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/86/66/91df378258e2c0cbc7860652b07b5e65ee1949ba14be2efdb6c646a933f1/persona_vectors-0.6.1-py3-none-any.whl", hash = "sha256:593977ad19c9f23df7d86e302fe4bcf49159425da67d83281a11858026c5e85e", size = 28683, upload-time = "2026-05-07T15:07:30.791Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/92/912d2a6998bcc103631597125bad5b5644c981b52e62fff229aee64139ae/persona_vectors-0.6.3-py3-none-any.whl", hash = "sha256:9a7f275c7e58990e1228a0d35ca2a8898eb8330fd4a9a627fb28fc574883d260", size = 29366, upload-time = "2026-05-08T14:10:38.184Z" },
 ]
 
 [[package]]
@@ -2912,11 +2912,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.6.3"
+version = "2.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
 ]
 
 [[package]]