Update app.py

app.py

@@ -23,6 +23,7 @@ try:
 except Exception:
     _HAS_FOTOKENIZER = False
 
+
 def _patch_fotokenizer_for_py313() -> None:
     """FO-Tokenizer currently uses importlib.resources.open_text(package=..., resource=...).
     In Python 3.13, open_text no longer accepts the `package=` keyword.
@@ -30,7 +31,6 @@ def _patch_fotokenizer_for_py313() -> None:
     if not _HAS_FOTOKENIZER:
         return
     try:
-        # If open_text doesn't accept `package`, patch the reference inside fotokenizer.abbrev.
         if "package" not in inspect.signature(importlib_resources.open_text).parameters:
             def _open_text_compat(*args, **kwargs):
                 if "package" in kwargs:
@@ -41,12 +41,11 @@ def _patch_fotokenizer_for_py313() -> None:
                     return importlib_resources.open_text(pkg, res, encoding=encoding, errors=errors)
                 return importlib_resources.open_text(*args, **kwargs)
 
-            # Patch the function that fotokenizer.abbrev imported into its module namespace
             fo_abbrev.open_text = _open_text_compat  # type: ignore[attr-defined]
     except Exception:
-        # If patching fails, we'll fall back to a naive sentence split later.
         pass
 
+
 _patch_fotokenizer_for_py313()
 
 # ----------------------------
@@ -55,12 +54,9 @@ _patch_fotokenizer_for_py313()
 MODEL_ID = "Setur/BRAGD"
 TAGS_FILEPATH = "Sosialurin-BRAGD_tags.csv"
 LABELS_FILEPATH = "tag_labels.json"
-HF_TOKEN = os.getenv("BRAGD")
 
 TARGET_MAX_TOKENS = 256  # We will cap this to the model's max if needed.
 
-if not HF_TOKEN:
-    raise RuntimeError("Missing BRAGD token secret (Space → Settings → Secrets → BRAGD).")
 if not os.path.exists(LABELS_FILEPATH):
     raise RuntimeError(f"Missing {LABELS_FILEPATH}. Add it to the Space repo root.")
 
@@ -69,12 +65,15 @@ INTERVALS = (
     (51, 53), (54, 60), (61, 63), (64, 66), (67, 70), (71, 72)
 )
 
-GROUP_ORDER = ["subcategory","gender","number","case","article","proper","degree","declension","mood","voice","tense","person","definiteness"]
+GROUP_ORDER = [
+    "subcategory", "gender", "number", "case", "article", "proper",
+    "degree", "declension", "mood", "voice", "tense", "person", "definiteness"
+]
 HIDE_CODES = {"subcategory": {"B"}}  # Subcategory B to be removed
 
 UI = {
-    "fo": {"w":"Orð", "t":"Mark", "s":"Útgreining", "m":"Útgreinað marking"},
-    "en": {"w":"Word","t":"Tag", "s":"Analysis", "m":"Expanded tags"},
+    "fo": {"w": "Orð", "t": "Mark", "s": "Útgreining", "m": "Útgreinað marking"},
+    "en": {"w": "Word", "t": "Tag", "s": "Analysis", "m": "Expanded tags"},
 }
 
 MODEL_LINK = "https://huggingface.co/Setur/BRAGD"
@@ -84,7 +83,6 @@ MODEL_LINK = "https://huggingface.co/Setur/BRAGD"
 # ----------------------------
 CSS = """
 /* Keep Gradio default styling; only override our buttons. */
-
 #btn_tag, #lang_fo_on, #lang_en_on{
   background:#89AFA9 !important;
   border-color:#6F9992 !important;
@@ -95,7 +93,6 @@ CSS = """
   border-color:#6F9992 !important;
   color:#0b1b19 !important;
 }
-
 #lang_fo_off, #lang_en_off, #btn_dl_main, #btn_dl_exp{
   background:#C6DAD6 !important;
   border-color:#6F9992 !important;
@@ -106,8 +103,6 @@ CSS = """
   border-color:#6F9992 !important;
   color:#0b1b19 !important;
 }
-
-/* Dark mode: make the INACTIVE buttons match what you had before (darker, readable) */
 @media (prefers-color-scheme: dark){
   #lang_fo_off, #lang_en_off, #btn_dl_main, #btn_dl_exp{
     background:#2a3b38 !important;
@@ -120,8 +115,6 @@ CSS = """
     color:#0b1b19 !important;
   }
 }
-
-/* Minimal layout so the language buttons stay hard-right like before */
 #results_hdr{
   display:flex !important;
   align-items:center !important;
@@ -140,8 +133,6 @@ CSS = """
   min-width:120px !important;
   flex:0 0 auto !important;
 }
-
-/* Expanded-tags header: keep download button hard-right */
 #expanded_hdr{
   display:flex !important;
   align-items:center !important;
@@ -160,7 +151,6 @@ CSS = """
   min-width:120px !important;
   flex:0 0 auto !important;
 }
-/* Remove the big Gradio panel/frame around the textbox (keep textarea normal) */
 #input_col,
 #input_col > div,
 #input_col .gr-block,
@@ -172,9 +162,6 @@ CSS = """
   border: 0 !important;
   box-shadow: none !important;
 }
-
-
-/* Prevent the main "Marka / Tag" button from stretching vertically */
 #btn_tag{
   align-self:flex-start !important;
   flex:0 0 auto !important;
@@ -183,8 +170,6 @@ CSS = """
 #btn_tag button{
   height:auto !important;
 }
-
-/* Results tables (rendered as HTML so we fully control wrapping/scrolling). */
 #out_df .df-scroll, #out_mean_df .df-scroll{
   overflow-x:auto !important;
   width:100% !important;
@@ -237,7 +222,7 @@ def split_sentences(text: str):
     up with merged words (e.g. `Núriggarkanska`). This function therefore:
     - preserves `.txt` pieces as-is
     - converts descriptor-only whitespace-like tokens into a single space
-    - adds a **best-effort** inserted space between tokens in cases where whitespace
+    - adds a best-effort inserted space between tokens in cases where whitespace
       is missing but clearly intended (word→word, comma/semicolon/colon→word)
     """
 
@@ -256,17 +241,12 @@ def split_sentences(text: str):
             buf.append(piece)
             return
 
-        # If we already ended with whitespace, just append.
         last = buf[-1]
         last_char = last[-1] if last else ""
         if last_char.isspace():
             buf.append(piece)
             return
 
-        # If next token begins with a letter/number and previous token ends with:
-        # - a letter/number (word→word)
-        # - comma/semicolon/colon (",;:" → word)
-        # ...then insert a space (this fixes missing whitespace from some tokenizers).
         if piece[0].isalnum() and (last_char.isalnum() or last_char in {",", ";", ":"}):
             buf.append(" ")
 
@@ -283,11 +263,9 @@ def split_sentences(text: str):
                     _append_piece(cur, tok.txt)
                     continue
 
-                # Descriptor-only token (e.g., sentence boundary markers)
                 descr = FO_TOK.descr.get(tok.kind, "").replace(" ", "_")
 
                 if descr == "BEGIN_SENT":
-                    # Flush anything we may have buffered (robustness for odd streams)
                     if cur:
                         sent = "".join(cur).strip()
                         if sent:
@@ -302,7 +280,6 @@ def split_sentences(text: str):
                     cur = []
                     continue
 
-                # Best-effort: keep whitespace-like descriptor-only tokens.
                 up = descr.upper()
                 if "WHITESPACE" in up or "SPACE" in up or "TAB" in up:
                     _append_piece(cur, " ")
@@ -311,7 +288,6 @@ def split_sentences(text: str):
                 elif up == "DASH":
                     _append_piece(cur, "-")
                 else:
-                    # Ignore other descriptor-only tokens.
                     pass
 
             if cur:
@@ -319,13 +295,10 @@ def split_sentences(text: str):
                 if sent:
                     sents.append(sent)
 
-            # If fotokenizer didn't yield any markers, treat as one sentence.
             return sents or [s.strip()]
         except Exception:
-            # We'll fall back below
             pass
 
-    # Fallback: split on end punctuation followed by whitespace.
     parts = re.split(r"(?<=[.!?])\s+", s.strip())
     return [p.strip() for p in parts if p.strip()]
 
@@ -337,105 +310,122 @@ def run_model_multisentence(text: str):
         rows_all.extend(run_model(sent))
     return rows_all
 
+
 # ----------------------------
 # CSV mapping
 # ----------------------------
 def load_tag_mappings(path: str):
     df = pd.read_csv(path)
     feature_cols = list(df.columns[1:])
-    tag_to_features = {row["Original Tag"]: row[1:].values.astype(int) for _, row in df.iterrows()}
-    features_to_tag = {tuple(row[1:].values.astype(int)): row["Original Tag"] for _, row in df.iterrows()}
+    tag_to_features = {
+        row["Original Tag"]: row[1:].values.astype(int)
+        for _, row in df.iterrows()
+    }
+    features_to_tag = {
+        tuple(row[1:].values.astype(int)): row["Original Tag"]
+        for _, row in df.iterrows()
+    }
     return tag_to_features, features_to_tag, len(feature_cols), feature_cols
 
+
 def group_from_col(col: str):
-    if col == "Article": return ("article","A")
-    if col.startswith("No-Article "): return ("article", col.split()[-1])
-    if col == "Proper Noun": return ("proper","P")
-    if col.startswith("Not-Proper-Noun "): return ("proper", col.split()[-1])
+    if col == "Article":
+        return ("article", "A")
+    if col.startswith("No-Article "):
+        return ("article", col.split()[-1])
+    if col == "Proper Noun":
+        return ("proper", "P")
+    if col.startswith("Not-Proper-Noun "):
+        return ("proper", col.split()[-1])
 
     prefixes = [
-        ("Word Class ","word_class"),
-        ("Subcategory ","subcategory"), ("No-Subcategory ","subcategory"),
-        ("Gender ","gender"), ("No-Gender ","gender"),
-        ("Number ","number"), ("No-Number ","number"),
-        ("Case ","case"), ("No-Case ","case"),
-        ("Degree ","degree"), ("No-Degree ","degree"),
-        ("Declension ","declension"), ("No-Declension ","declension"),
-        ("Mood ","mood"),
-        ("Voice ","voice"), ("No-Voice ","voice"),
-        ("Tense ","tense"), ("No-Tense ","tense"),
-        ("Person ","person"), ("No-Person ","person"),
-        ("Definite ","definiteness"), ("Indefinite ","definiteness"),
+        ("Word Class ", "word_class"),
+        ("Subcategory ", "subcategory"), ("No-Subcategory ", "subcategory"),
+        ("Gender ", "gender"), ("No-Gender ", "gender"),
+        ("Number ", "number"), ("No-Number ", "number"),
+        ("Case ", "case"), ("No-Case ", "case"),
+        ("Degree ", "degree"), ("No-Degree ", "degree"),
+        ("Declension ", "declension"), ("No-Declension ", "declension"),
+        ("Mood ", "mood"),
+        ("Voice ", "voice"), ("No-Voice ", "voice"),
+        ("Tense ", "tense"), ("No-Tense ", "tense"),
+        ("Person ", "person"), ("No-Person ", "person"),
+        ("Definite ", "definiteness"), ("Indefinite ", "definiteness"),
     ]
-    for p,g in prefixes:
+    for p, g in prefixes:
         if col.startswith(p):
             return (g, col.split()[-1])
-    return (None,None)
+    return (None, None)
+
 
 def process_tag_features(tag_to_features: dict, intervals):
     arrs = [np.array(tpl) for tpl in set(tuple(a) for a in tag_to_features.values())]
-    wt_masks = {wt:[a for a in arrs if a[wt]==1] for wt in range(15)}
+    wt_masks = {wt: [a for a in arrs if a[wt] == 1] for wt in range(15)}
     out = {}
-    for wt,labels in wt_masks.items():
+    for wt, labels in wt_masks.items():
         if not labels:
-            out[wt]=[]
+            out[wt] = []
             continue
         sum_labels = np.sum(np.array(labels), axis=0)
-        out[wt] = [iv for iv in intervals if np.sum(sum_labels[iv[0]:iv[1]+1]) != 0]
+        out[wt] = [iv for iv in intervals if np.sum(sum_labels[iv[0]:iv[1] + 1]) != 0]
     return out
 
+
 def predict_vectors(logits, attention_mask, begin_tokens, dict_intervals, vec_len):
     softmax = torch.nn.Softmax(dim=0)
     vectors = []
     for idx in range(len(logits)):
-        if attention_mask[idx].item()!=1 or begin_tokens[idx]!=1:
+        if attention_mask[idx].item() != 1 or begin_tokens[idx] != 1:
             continue
         pred = logits[idx]
         vec = torch.zeros(vec_len, device=logits.device)
         wt = torch.argmax(softmax(pred[0:15])).item()
-        vec[wt]=1
-        for (a,b) in dict_intervals.get(wt, []):
-            seg = pred[a:b+1]
+        vec[wt] = 1
+        for (a, b) in dict_intervals.get(wt, []):
+            seg = pred[a:b + 1]
             k = torch.argmax(softmax(seg)).item()
-            vec[a+k]=1
+            vec[a + k] = 1
         vectors.append(vec)
     return vectors
 
+
 # ----------------------------
 # Load labels
 # ----------------------------
 with open(LABELS_FILEPATH, "r", encoding="utf-8") as f:
     LABELS = json.load(f)
 
+
 def label_for(lang: str, group: str, wc: str, code: str) -> str:
-    lang = "fo" if lang=="fo" else "en"
+    lang = "fo" if lang == "fo" else "en"
     by_wc = LABELS.get(lang, {}).get("by_word_class", {})
     glob = LABELS.get(lang, {}).get("global", {})
     if wc and wc in by_wc and code in by_wc[wc].get(group, {}):
         return by_wc[wc][group][code]
     return glob.get(group, {}).get(code, "")
 
+
 def clean_label(s: str) -> str:
     s = (s or "").strip()
     s = re.sub(r"\s+", " ", s)
     return s.strip(" -;,:").strip()
 
+
 # ----------------------------
 # Load model + mapping
 # ----------------------------
 tag_to_features, features_to_tag, VEC_LEN, FEATURE_COLS = load_tag_mappings(TAGS_FILEPATH)
 
-tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, token=HF_TOKEN)
-model = AutoModelForTokenClassification.from_pretrained(MODEL_ID, token=HF_TOKEN)
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+model = AutoModelForTokenClassification.from_pretrained(MODEL_ID)
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model.to(device); model.eval()
+model.to(device)
+model.eval()
 
-# Decide max token length (cap to model/tokenizer max if they define one)
 MAX_TOKENS = int(TARGET_MAX_TOKENS)
 _model_max = getattr(getattr(model, "config", None), "max_position_embeddings", None)
 _tok_max = getattr(tokenizer, "model_max_length", None)
 
-# Some tokenizers set model_max_length to a huge placeholder (e.g., 1e30). Ignore those.
 for _m in (_model_max, _tok_max):
     if isinstance(_m, int) and 0 < _m < 100000:
         MAX_TOKENS = min(MAX_TOKENS, _m)
@@ -446,57 +436,60 @@ if hasattr(model, "config") and hasattr(model.config, "num_labels") and model.co
 DICT_INTERVALS = process_tag_features(tag_to_features, INTERVALS)
 
 GROUPS = defaultdict(list)
-for i,col in enumerate(FEATURE_COLS):
-    g,code = group_from_col(col)
+for i, col in enumerate(FEATURE_COLS):
+    g, code = group_from_col(col)
     if g and code not in HIDE_CODES.get(g, set()):
         GROUPS[g].append((i, code, col))
 
+
 def vector_to_tag(vec: torch.Tensor) -> str:
     return features_to_tag.get(tuple(vec.int().tolist()), "Unknown Tag")
 
+
 def wc_code(vec: torch.Tensor) -> str:
-    for idx,code,_ in GROUPS["word_class"]:
-        if int(vec[idx].item())==1:
+    for idx, code, _ in GROUPS["word_class"]:
+        if int(vec[idx].item()) == 1:
             return code
     return ""
 
+
 def group_code(vec: torch.Tensor, group: str) -> str:
     hidden = HIDE_CODES.get(group, set())
-    for idx,code,_ in GROUPS.get(group, []):
+    for idx, code, _ in GROUPS.get(group, []):
         if code in hidden:
             continue
-        if int(vec[idx].item())==1:
+        if int(vec[idx].item()) == 1:
             return code
     return ""
 
-HIDE_IN_ANALYSIS = {("D","subcategory","G"), ("D","subcategory","N")}
+
+HIDE_IN_ANALYSIS = {("D", "subcategory", "G"), ("D", "subcategory", "N")}
 VOICE_ANALYSIS = {
     "fo": {"A": "gerðsøgn", "M": "miðalsøgn", "v": "orð luttøkuháttur"},
     "en": {"A": "active voice", "M": "middle voice", "v": "supine form"},
 }
 
+
 def analysis_text(vec: torch.Tensor, lang: str) -> str:
-    lang = "fo" if lang=="fo" else "en"
+    lang = "fo" if lang == "fo" else "en"
     tag = vector_to_tag(vec)
     wc = wc_code(vec)
 
-    # --- ADDED: compute mood_code and skip flag for infinitive/imperative verbs ---
     mood_code = group_code(vec, "mood") if wc == "V" else ""
-    skip_empty_verb_feats = (wc == "V" and mood_code in {"I", "M"})  # navnháttur or boðsháttur
-    # --- end added ---
+    skip_empty_verb_feats = (wc == "V" and mood_code in {"I", "M"})
 
     if tag == "DGd":
-        return "fyriseting" if lang=="fo" else "preposition"
+        return "fyriseting" if lang == "fo" else "preposition"
 
     mood = group_code(vec, "mood")
     if mood == "U":
-        sup = label_for(lang, "mood", wc, "U") or ("luttøkuháttur" if lang=="fo" else "supine")
+        sup = label_for(lang, "mood", wc, "U") or ("luttøkuháttur" if lang == "fo" else "supine")
         vcode = group_code(vec, "voice") or "v"
         vlabel = VOICE_ANALYSIS[lang].get(vcode, VOICE_ANALYSIS[lang]["v"])
         return f"{clean_label(sup)}, {clean_label(vlabel)}"
 
     parts = []
-    if wc in {"P","C"}:
+    if wc in {"P", "C"}:
         subc = group_code(vec, "subcategory")
         subl = clean_label(label_for(lang, "subcategory", wc, subc) or "")
         if subl:
@@ -511,12 +504,10 @@ def analysis_text(vec: torch.Tensor, lang: str) -> str:
         if not c:
             continue
 
-        # --- ADDED: skip only the generic "no" codes for verbs in infinitive/imperative ---
         if skip_empty_verb_feats and g in {"number", "tense", "person"} and c in {"n", "t", "p"}:
             continue
-        # --- end added ---
 
-        if wc in {"P","C"} and g == "subcategory":
+        if wc in {"P", "C"} and g == "subcategory":
             continue
         if (wc, g, c) in HIDE_IN_ANALYSIS:
             continue
@@ -526,8 +517,9 @@ def analysis_text(vec: torch.Tensor, lang: str) -> str:
 
     return ", ".join(parts)
 
+
 def expanded_text(vec: torch.Tensor, lang: str) -> str:
-    lang = "fo" if lang=="fo" else "en"
+    lang = "fo" if lang == "fo" else "en"
     wc = wc_code(vec)
     parts = []
     wc_lbl = label_for(lang, "word_class", wc, wc)
@@ -540,31 +532,34 @@ def expanded_text(vec: torch.Tensor, lang: str) -> str:
         parts.append(f"{c} – {lbl}" if lbl else c)
     return "; ".join([p for p in parts if p])
 
+
 def compute_codes_by_wc():
     codes = defaultdict(lambda: defaultdict(set))
     for arr in tag_to_features.values():
         arr = np.array(arr)
         wc = None
-        for idx,code,_ in GROUPS["word_class"]:
-            if arr[idx]==1:
+        for idx, code, _ in GROUPS["word_class"]:
+            if arr[idx] == 1:
                 wc = code
                 break
         if not wc:
             continue
         for g in GROUP_ORDER:
             hidden = HIDE_CODES.get(g, set())
-            for idx,code,_ in GROUPS.get(g, []):
+            for idx, code, _ in GROUPS.get(g, []):
                 if code in hidden:
                     continue
-                if arr[idx]==1:
+                if arr[idx] == 1:
                     codes[wc][g].add(code)
     return codes
 
+
 CODES_BY_WC = compute_codes_by_wc()
 
+
 def build_overview(lang: str) -> str:
-    lang = "fo" if lang=="fo" else "en"
-    title = "### Markayvirlit" if lang=="fo" else "### Tag Overview"
+    lang = "fo" if lang == "fo" else "en"
+    title = "### Markayvirlit" if lang == "fo" else "### Tag Overview"
     lines = [title, ""]
     for wc in sorted(CODES_BY_WC.keys()):
         wcl = label_for(lang, "word_class", wc, wc) or ""
@@ -574,12 +569,18 @@ def build_overview(lang: str) -> str:
             if not cs:
                 continue
             group_name = {
-                "fo": {"subcategory":"Undirflokkur","gender":"Kyn","number":"Tal","case":"Fall","article":"Bundni/óbundni",
-                       "proper":"Sernavn / felagsnavn","degree":"Stig","declension":"Bending","mood":"Háttur","voice":"Søgn",
-                       "tense":"Tíð","person":"Persónur","definiteness":"Bundni/óbundni"},
-                "en": {"subcategory":"Subcategory","gender":"Gender","number":"Number","case":"Case","article":"Definiteness",
-                       "proper":"Proper/common noun","degree":"Degree","declension":"Declension","mood":"Mood","voice":"Voice",
-                       "tense":"Tense","person":"Person","definiteness":"Definiteness"},
+                "fo": {
+                    "subcategory": "Undirflokkur", "gender": "Kyn", "number": "Tal", "case": "Fall",
+                    "article": "Bundni/óbundni", "proper": "Sernavn / felagsnavn", "degree": "Stig",
+                    "declension": "Bending", "mood": "Háttur", "voice": "Søgn", "tense": "Tíð",
+                    "person": "Persónur", "definiteness": "Bundni/óbundni"
+                },
+                "en": {
+                    "subcategory": "Subcategory", "gender": "Gender", "number": "Number", "case": "Case",
+                    "article": "Definiteness", "proper": "Proper/common noun", "degree": "Degree",
+                    "declension": "Declension", "mood": "Mood", "voice": "Voice", "tense": "Tense",
+                    "person": "Person", "definiteness": "Definiteness"
+                },
             }[lang].get(g, g)
             lines.append(f"**{group_name}**")
             for c in cs:
@@ -589,6 +590,7 @@ def build_overview(lang: str) -> str:
         lines.append("")
     return "\n".join(lines).strip()
 
+
 def run_model(sentence: str):
     s = (sentence or "").strip()
     if not s:
@@ -596,8 +598,17 @@ def run_model(sentence: str):
     tokens = simp_tok(s)
     if not tokens:
         return []
-    enc = tokenizer(tokens, is_split_into_words=True, add_special_tokens=True, max_length=MAX_TOKENS,
-                    padding="max_length", truncation=True, return_attention_mask=True, return_tensors="pt")
+
+    enc = tokenizer(
+        tokens,
+        is_split_into_words=True,
+        add_special_tokens=True,
+        max_length=MAX_TOKENS,
+        padding="max_length",
+        truncation=True,
+        return_attention_mask=True,
+        return_tensors="pt",
+    )
     input_ids = enc["input_ids"].to(device)
     attention_mask = enc["attention_mask"].to(device)
     word_ids = enc.word_ids(batch_index=0)
@@ -618,8 +629,8 @@ def run_model(sentence: str):
     vectors = predict_vectors(logits, attention_mask[0], begin, DICT_INTERVALS, VEC_LEN)
 
     rows, vec_i, seen = [], 0, set()
-    for i,wid in enumerate(word_ids):
-        if wid is None or begin[i]!=1 or wid in seen:
+    for i, wid in enumerate(word_ids):
+        if wid is None or begin[i] != 1 or wid in seen:
             continue
         seen.add(wid)
         word = tokens[wid] if wid < len(tokens) else "<UNK>"
@@ -628,10 +639,8 @@ def run_model(sentence: str):
         vec_i += 1
     return rows
 
+
 def _make_html_table(headers, rows):
-    # We render results as plain HTML so we can force:
-    # - no wrapping anywhere
-    # - horizontal scrolling when content is wider than the page
     th = "".join(f"<th>{html.escape(str(h))}</th>" for h in headers)
     body_rows = []
     for row in rows:
@@ -644,8 +653,9 @@ def _make_html_table(headers, rows):
         '</div>'
     )
 
+
 def render(rows_state, lang: str):
-    lang = "fo" if lang=="fo" else "en"
+    lang = "fo" if lang == "fo" else "en"
     cols_main = [UI[lang]["w"], UI[lang]["t"], UI[lang]["s"]]
     cols_mean = [UI[lang]["w"], UI[lang]["t"], UI[lang]["m"]]
     if not rows_state:
@@ -662,17 +672,14 @@ def render(rows_state, lang: str):
 
 
 def _write_tsv(df: pd.DataFrame, filename: str) -> str:
-    """Write a TSV file to a unique temp folder and return the absolute path."""
     tmpdir = os.path.join(tempfile.gettempdir(), "marka_downloads", str(uuid.uuid4()))
     os.makedirs(tmpdir, exist_ok=True)
     path = os.path.join(tmpdir, filename)
     df.to_csv(path, sep="\t", index=False, encoding="utf-8")
     return path
 
+
 def build_download_main(rows_state) -> str:
-    """TSV with 4 columns:
-    Orð, Mark, Útgreining (FO), Analysis (EN)
-    """
     words, tags, fo_vals, en_vals = [], [], [], []
     for r in (rows_state or []):
         vec = torch.tensor(r["vec"])
@@ -690,8 +697,8 @@ def build_download_main(rows_state) -> str:
     })
     return _write_tsv(df, "Markað.tsv")
 
+
 def build_download_expanded(rows_state, lang: str) -> str:
-    """TSV with 3 columns: Word/Orð, Tag/Mark, and Expanded tags in the UI language."""
     lang = "fo" if lang == "fo" else "en"
     words, tags, vals = [], [], []
     for r in (rows_state or []):
@@ -707,10 +714,16 @@ def build_download_expanded(rows_state, lang: str) -> str:
     })
     return _write_tsv(df, "Markað_útgreinað.tsv")
 
+
 with gr.Blocks(css=CSS, title="Marka") as demo:
     with gr.Row(equal_height=False):
         with gr.Column(scale=2, elem_id="input_col"):
-            inp = gr.Textbox(lines=6, placeholder="Skriva her ... / Type here ...", show_label=False, elem_id="input_box")
+            inp = gr.Textbox(
+                lines=6,
+                placeholder="Skriva her ... / Type here ...",
+                show_label=False,
+                elem_id="input_box",
+            )
         with gr.Column(scale=1, min_width=320):
             gr.Markdown(
                 "## Marka\n"
@@ -726,11 +739,11 @@ with gr.Blocks(css=CSS, title="Marka") as demo:
     with results_hdr:
         results_title = gr.Markdown("### Úrslit / Results")
         with gr.Row(elem_id="lang_buttons") as lang_buttons_row:
-            btn_lang_fo_on  = gr.Button("Føroyskt", variant="primary",   elem_id="lang_fo_on",  visible=False)
+            btn_lang_fo_on = gr.Button("Føroyskt", variant="primary", elem_id="lang_fo_on", visible=False)
             btn_lang_fo_off = gr.Button("Føroyskt", variant="secondary", elem_id="lang_fo_off", visible=False)
-            btn_lang_en_on  = gr.Button("English",  variant="primary",   elem_id="lang_en_on",  visible=False)
-            btn_lang_en_off = gr.Button("English",  variant="secondary", elem_id="lang_en_off", visible=False)
-            btn_dl_main    = gr.DownloadButton("Tak niður / Download", variant="secondary", elem_id="btn_dl_main", visible=False)
+            btn_lang_en_on = gr.Button("English", variant="primary", elem_id="lang_en_on", visible=False)
+            btn_lang_en_off = gr.Button("English", variant="secondary", elem_id="lang_en_off", visible=False)
+            btn_dl_main = gr.DownloadButton("Tak niður / Download", variant="secondary", elem_id="btn_dl_main", visible=False)
     out_df = gr.HTML(value="", elem_id="out_df", visible=False)
 
     expanded_acc = gr.Accordion("Útgreinað marking / Expanded tags", open=False, visible=False)
@@ -746,21 +759,15 @@ with gr.Blocks(css=CSS, title="Marka") as demo:
         overview_md = gr.Markdown(build_overview("fo"))
 
     def show_loading(lang_current):
-        """Instant feedback on click.
-
-        - Shows the (empty) results table immediately so Gradio can display its built-in loading overlay.
-        - Hides/collapses the Expanded tags section while processing (avoids duplicate loading skeletons).
-        - Disables the button + changes its label while the model runs.
-        """
         lang_current = "fo" if lang_current == "fo" else "en"
         cols_main = [UI[lang_current]["w"], UI[lang_current]["t"], UI[lang_current]["s"]]
         shell = _make_html_table(cols_main, [])
         return (
             gr.update(value=shell, visible=True),
-            gr.update(visible=False),                 # hide main download while processing
-            gr.update(visible=False),                 # hide expanded download while processing
-            gr.update(visible=False),     # hide + collapse expanded section while processing
-            gr.update(value=""),                      # clear expanded content (prevents flashing stale content)
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(value=""),
             gr.update(value="Markar... / Tagging...", interactive=False),
         )
 
@@ -780,7 +787,7 @@ with gr.Blocks(css=CSS, title="Marka") as demo:
             gr.update(value=df_main, visible=True),
             gr.update(value=df_mean),
             gr.update(value=overview),
-            gr.update(visible=True),   # expanded_acc
+            gr.update(visible=True),
             gr.update(visible=show_fo),
             gr.update(visible=not show_fo),
             gr.update(visible=show_en),
@@ -813,6 +820,7 @@ with gr.Blocks(css=CSS, title="Marka") as demo:
             gr.update(value=dl_main_path, visible=have_rows),
             gr.update(value=dl_exp_path, visible=have_rows),
         )
+
     def on_set_fo(rows):
         return on_set_lang(rows, "fo")
 
@@ -829,44 +837,54 @@ with gr.Blocks(css=CSS, title="Marka") as demo:
     _evt.then(
         on_tag,
         inputs=[inp, lang_state],
-        outputs=[state, out_df, out_mean_df, overview_md, expanded_acc,
-                 btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
-                 btn_dl_main, btn_dl_exp, lang_state, btn],
+        outputs=[
+            state, out_df, out_mean_df, overview_md, expanded_acc,
+            btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
+            btn_dl_main, btn_dl_exp, lang_state, btn
+        ],
         queue=False,
     )
 
     btn_lang_fo_on.click(
         on_set_fo,
         inputs=[state],
-        outputs=[lang_state, out_df, out_mean_df, overview_md,
-                 btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
-                 btn_dl_main, btn_dl_exp],
+        outputs=[
+            lang_state, out_df, out_mean_df, overview_md,
+            btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
+            btn_dl_main, btn_dl_exp
+        ],
         queue=False,
     )
     btn_lang_fo_off.click(
         on_set_fo,
         inputs=[state],
-        outputs=[lang_state, out_df, out_mean_df, overview_md,
-                 btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
-                 btn_dl_main, btn_dl_exp],
+        outputs=[
+            lang_state, out_df, out_mean_df, overview_md,
+            btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
+            btn_dl_main, btn_dl_exp
+        ],
         queue=False,
     )
     btn_lang_en_on.click(
         on_set_en,
         inputs=[state],
-        outputs=[lang_state, out_df, out_mean_df, overview_md,
-                 btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
-                 btn_dl_main, btn_dl_exp],
+        outputs=[
+            lang_state, out_df, out_mean_df, overview_md,
+            btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
+            btn_dl_main, btn_dl_exp
+        ],
         queue=False,
     )
     btn_lang_en_off.click(
         on_set_en,
         inputs=[state],
-        outputs=[lang_state, out_df, out_mean_df, overview_md,
-                 btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
-                 btn_dl_main, btn_dl_exp],
+        outputs=[
+            lang_state, out_df, out_mean_df, overview_md,
+            btn_lang_fo_on, btn_lang_fo_off, btn_lang_en_on, btn_lang_en_off,
+            btn_dl_main, btn_dl_exp
+        ],
         queue=False,
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()