added posibility to select older multilingual spaces

README.md

@@ -22,11 +22,15 @@ The app does not use `aligned_all.vec`.
 
 ## Runtime configuration
 
-By default, the app scans the stage 6 prefix and downloads the newest artifact
-folder that contains `config.json`:
+By default, the app scans the stage 6 prefix, downloads the newest artifact
+folder that contains `config.json`, and selects it in the UI:
 
 `s3://131-component-staging/multilingual-static-word-embeddings/stage-6/`
 
+Older artifact folders found under the same prefix are available from the
+Dictionary artifact dropdown. Switching artifacts reloads the aligned space and
+updates the displayed load time.
+
 Set these Hugging Face Space secrets for S3-compatible storage:
 
 - `SE_ACCESS_KEY`

app.py

@@ -5,6 +5,7 @@ import json
 import os
 import re
 import sys
+import time
 import unicodedata
 from dataclasses import dataclass
 from functools import lru_cache
@@ -26,6 +27,9 @@ DEFAULT_LOCAL_SPACE = Path("multilingual_dict_20260603_122323")
 DEFAULT_LANGS = ["de", "en", "fr", "lb"]
 REQUIRED_FILES = ("aligned_all.faiss", "all_metadata.jsonl", "config.json")
 CACHE_DIR = Path(os.getenv("ARTIFACT_CACHE_DIR", "/tmp/multilingual_space_artifacts"))
+ARTIFACT_PATTERN = re.compile(
+    r"(.*multilingual_(?:dict|space)_(\d{8}_\d{6})(?:\.json)?)/config\.json$"
+)
 
 
 @dataclass
@@ -96,24 +100,21 @@ def make_s3_client():
     return boto3.client(**kwargs)
 
 
-def latest_artifact_uri(client) -> str:
+def list_s3_artifact_uris(client) -> list[str]:
     explicit = os.getenv("SPACE_ARTIFACT_S3_URI", "").strip().rstrip("/")
     if explicit:
-        return explicit
+        return [explicit]
 
     prefix_override = os.getenv("SPACE_ARTIFACT_S3_PREFIX", "").strip()
     prefix_uri = prefix_override or DEFAULT_ARTIFACT_PREFIX
     bucket, prefix = parse_s3_uri(prefix_uri)
     prefix = prefix.rstrip("/") + "/"
-    pattern = re.compile(
-        r"(.*multilingual_(?:dict|space)_(\d{8}_\d{6})(?:\.json)?)/config\.json$"
-    )
     candidates: list[tuple[str, str]] = []
 
     paginator = client.get_paginator("list_objects_v2")
     for page in paginator.paginate(Bucket=bucket, Prefix=prefix):
         for obj in page.get("Contents", []):
-            match = pattern.match(obj["Key"])
+            match = ARTIFACT_PATTERN.match(obj["Key"])
             if match:
                 candidates.append((match.group(2), match.group(1)))
 
@@ -123,20 +124,74 @@ def latest_artifact_uri(client) -> str:
         )
 
     # Run ids are timestamps: YYYYMMDD_HHMMSS. Lexicographic sort gives newest run.
-    run_id, key = sorted(candidates)[-1]
-    uri = f"s3://{bucket}/{key}"
-    print(f"Selected latest stage 6 artifact {run_id}: {uri}", file=sys.stderr)
+    return [f"s3://{bucket}/{key}" for _, key in sorted(candidates, reverse=True)]
+
+
+def latest_artifact_uri(client) -> str:
+    uri = list_s3_artifact_uris(client)[0]
+    print(f"Selected latest stage 6 artifact: {uri}", file=sys.stderr)
     return uri
 
 
+def local_artifact_uris() -> list[str]:
+    local_override = os.getenv("SPACE_DIR", "").strip()
+    if local_override:
+        path = Path(local_override)
+        if path.exists():
+            return [str(path)]
+
+    local_candidates = sorted(
+        [*Path(".").glob("multilingual_dict_*"), *Path(".").glob("multilingual_space_*.json")],
+        reverse=True,
+    )
+    if DEFAULT_LOCAL_SPACE.exists():
+        local_candidates = [
+            DEFAULT_LOCAL_SPACE,
+            *[path for path in local_candidates if path != DEFAULT_LOCAL_SPACE],
+        ]
+    return [str(path) for path in local_candidates]
+
+
+def available_artifact_uris() -> list[str]:
+    local_uris = local_artifact_uris()
+    if local_uris:
+        return local_uris
+    return list_s3_artifact_uris(make_s3_client())
+
+
+def artifact_name(uri: str) -> str:
+    uri = str(uri or "").strip().rstrip("/")
+    if not uri:
+        return "latest artifact"
+    if uri.startswith("s3://"):
+        parsed = urlparse(uri)
+        return Path(parsed.path).name or uri
+    return Path(uri).name or uri
+
+
+def artifact_choices() -> tuple[list[tuple[str, str]], str]:
+    uris = available_artifact_uris()
+    choices = [
+        (f"{artifact_name(uri)}{' (default)' if index == 0 else ''}", uri)
+        for index, uri in enumerate(uris)
+    ]
+    return choices, uris[0]
+
+
+def format_duration(seconds: float) -> str:
+    if seconds < 1:
+        return f"{seconds * 1000:.0f} ms"
+    return f"{seconds:.1f}s"
+
+
 def local_cache_for_uri(uri: str) -> Path:
     _, key = parse_s3_uri(uri)
     return CACHE_DIR / Path(key.rstrip("/")).name
 
 
-def download_space_from_s3() -> tuple[Path, str]:
+def download_space_from_s3(uri: str | None = None) -> tuple[Path, str]:
     client = make_s3_client()
-    uri = latest_artifact_uri(client)
+    uri = uri or latest_artifact_uri(client)
     local_dir = local_cache_for_uri(uri)
     local_dir.mkdir(parents=True, exist_ok=True)
 
@@ -153,7 +208,16 @@ def download_space_from_s3() -> tuple[Path, str]:
     return local_dir, uri
 
 
-def find_space_dir() -> tuple[Path, str]:
+def find_space_dir(artifact_uri: str = "") -> tuple[Path, str]:
+    artifact_uri = str(artifact_uri or "").strip()
+    if artifact_uri:
+        if artifact_uri.startswith("s3://"):
+            return download_space_from_s3(artifact_uri)
+        path = Path(artifact_uri)
+        if path.exists():
+            return path, str(path)
+        raise FileNotFoundError(f"Selected artifact does not exist: {artifact_uri}")
+
     local_override = os.getenv("SPACE_DIR", "").strip()
     if local_override:
         path = Path(local_override)
@@ -303,8 +367,8 @@ def build_lookup(languages: dict[str, LangVectors]) -> dict[str, dict[str, list[
 
 
 @lru_cache(maxsize=1)
-def load_space() -> Space:
-    space_dir, artifact_uri = find_space_dir()
+def load_space(artifact_uri: str = "") -> Space:
+    space_dir, artifact_uri = find_space_dir(artifact_uri)
     config = read_config(space_dir)
     metadata, ids_by_lang = read_metadata(space_dir)
     vectors_by_lang = load_vectors_from_faiss(space_dir, ids_by_lang)
@@ -527,9 +591,10 @@ def translate_like_terminal(
     filter_stopwords: bool,
     filter_bad_tokens: bool,
     use_surface: bool,
+    artifact_uri: str,
 ) -> tuple[str, list[list[Any]]]:
     try:
-        space = load_space()
+        space = load_space(artifact_uri)
         use_surface = bool(use_surface and space.has_surface_forms)
         opts = make_options(
             top_k,
@@ -617,17 +682,23 @@ def translate_like_terminal(
         return f"Error: {exc}", []
 
 
-def initialize() -> tuple[Any, ...]:
+def loaded_status(space: Space, elapsed: float) -> str:
+    total_vectors = sum(len(item.metas) for item in space.by_lang.values())
+    return (
+        f"Loaded {artifact_name(space.artifact_uri)} in {format_duration(elapsed)} "
+        f"with {total_vectors:,} vectors."
+    )
+
+
+def load_artifact_settings(artifact_uri: str) -> tuple[Any, ...]:
+    start = time.perf_counter()
     try:
-        space = load_space()
+        space = load_space(artifact_uri)
         opts = default_options(space.config)
         source_lang = space.config.get("pivot_lang", "de")
         if source_lang not in space.languages:
             source_lang = space.languages[0]
-        status = (
-            f"Loaded {space.artifact_uri} with "
-            f"{sum(len(item.metas) for item in space.by_lang.values()):,} vectors."
-        )
+        status = loaded_status(space, time.perf_counter() - start)
         return (
             status,
             gr.update(choices=space.languages, value=source_lang),
@@ -665,6 +736,40 @@ def initialize() -> tuple[Any, ...]:
         )
 
 
+def initialize() -> tuple[Any, ...]:
+    try:
+        choices, artifact_uri = artifact_choices()
+        settings = load_artifact_settings(artifact_uri)
+        return (
+            settings[0],
+            gr.update(choices=choices, value=artifact_uri),
+            *settings[1:],
+        )
+    except Exception as exc:
+        return (
+            f"Load error: {exc}",
+            gr.update(choices=[], value=None),
+            gr.update(choices=DEFAULT_LANGS, value="de"),
+            3,
+            0.15,
+            10,
+            9,
+            50,
+            True,
+            gr.update(
+                value=False,
+                interactive=False,
+                label="show surface forms (no aligned space loaded)",
+            ),
+        )
+
+
+def mark_artifact_loading(artifact_uri: str) -> tuple[str, str, list[list[Any]]]:
+    load_space.cache_clear()
+    gc.collect()
+    return f"Loading {artifact_name(artifact_uri)}...", "", []
+
+
 CSS = """
 body { background: #f7f5ef; }
 .gradio-container { max-width: 1120px !important; }
@@ -681,6 +786,12 @@ with gr.Blocks(title="Multilingual Dictionary Explorer", css=CSS) as demo:
         elem_classes=["app-title"],
     )
     status = gr.Markdown("Loading artifacts...", elem_classes=["status"])
+    artifact_version = gr.Dropdown(
+        label="Dictionary artifact",
+        choices=[],
+        value=None,
+        interactive=True,
+    )
 
     with gr.Row():
         with gr.Column(scale=1, min_width=320):
@@ -808,14 +919,35 @@ with gr.Blocks(title="Multilingual Dictionary Explorer", css=CSS) as demo:
         filter_stopwords,
         filter_bad_tokens,
         use_surface,
+        artifact_version,
     ]
     search.click(translate_like_terminal, inputs=inputs, outputs=[output_text, output_table])
     query.submit(translate_like_terminal, inputs=inputs, outputs=[output_text, output_table])
+    artifact_version.change(
+        mark_artifact_loading,
+        inputs=[artifact_version],
+        outputs=[status, output_text, output_table],
+    ).then(
+        load_artifact_settings,
+        inputs=[artifact_version],
+        outputs=[
+            status,
+            source_lang,
+            top_k,
+            min_score,
+            csls_k,
+            candidate_retrieval_k,
+            csls_prefetch_k,
+            bidirectional,
+            use_surface,
+        ],
+    ).then(translate_like_terminal, inputs=inputs, outputs=[output_text, output_table])
 
     demo.load(
         initialize,
         outputs=[
             status,
+            artifact_version,
             source_lang,
             top_k,
             min_score,