Upload 2 files

app.py

@@ -1,7 +1,4 @@
-import os
-import re
-import string
-import json
+import os, re, string, json
 from collections import defaultdict
 
 import gradio as gr
@@ -10,445 +7,327 @@ import numpy as np
 import pandas as pd
 from transformers import AutoTokenizer, AutoModelForTokenClassification
 
-# ----------------------------
-# Config
-# ----------------------------
 MODEL_ID = "Setur/BRAGD"
-TAGS_FILEPATH = "Sosialurin-BRAGD_tags.csv"          # must be in the Space repo
-LABELS_FILEPATH = "tag_labels.json"                 # add this file to the Space repo
+TAGS_FILEPATH = "Sosialurin-BRAGD_tags.csv"   # must match model labels
+LABELS_FILEPATH = "tag_labels.json"           # add to repo root (FO+EN labels)
+HF_TOKEN = os.getenv("BRAGD")                 # Space secret
 
-HF_TOKEN = os.getenv("BRAGD")  # Space secret name
 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.")
 
-# Match your UPDATED demo.py intervals
+# Match your demo.py intervals
 INTERVALS = (
-    (15, 29),  # Subcategories
-    (30, 33),  # Gender
-    (34, 36),  # Number
-    (37, 41),  # Case
-    (42, 43),  # Article/No-Article
-    (44, 45),  # Proper/Not Proper
-    (46, 50),  # Degree
-    (51, 53),  # Declension
-    (54, 60),  # Mood
-    (61, 63),  # Voice
-    (64, 66),  # Tense
-    (67, 70),  # Person
-    (71, 72),  # Definiteness
+    (15, 29), (30, 33), (34, 36), (37, 41), (42, 43), (44, 45), (46, 50),
+    (51, 53), (54, 60), (61, 63), (64, 66), (67, 70), (71, 72)
 )
 
-# ----------------------------
-# Load model + tokenizer
-# ----------------------------
-tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, token=HF_TOKEN)
-model = AutoModelForTokenClassification.from_pretrained(MODEL_ID, token=HF_TOKEN)
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model.to(device)
-model.eval()
-
-# ----------------------------
-# Tag mapping (CSV)
-# ----------------------------
-def load_tag_mappings(tags_filepath: str):
-    tags_df = pd.read_csv(tags_filepath)
-
-    feature_cols = list(tags_df.columns[1:])
-
-    tag_to_features = {
-        row["Original Tag"]: row[1:].values.astype(int)
-        for _, row in tags_df.iterrows()
-    }
-    features_to_tag = {
-        tuple(row[1:].values.astype(int)): row["Original Tag"]
-        for _, row in tags_df.iterrows()
-    }
-
-    vec_len = len(feature_cols)
-    return tag_to_features, features_to_tag, vec_len, feature_cols
-
-
-tag_to_features, features_to_tag, VEC_LEN, FEATURE_COLS = load_tag_mappings(TAGS_FILEPATH)
-
-# Safety check
-if hasattr(model, "config") and hasattr(model.config, "num_labels"):
-    if model.config.num_labels != VEC_LEN:
-        raise RuntimeError(
-            f"Label size mismatch: model has num_labels={model.config.num_labels}, "
-            f"but {TAGS_FILEPATH} implies {VEC_LEN}. "
-            "You likely uploaded the wrong tag mapping CSV."
-        )
-
-
-def vector_to_tag(vec: torch.Tensor) -> str:
-    return features_to_tag.get(tuple(vec.int().tolist()), "Unknown Tag")
-
-# ----------------------------
-# Compute allowed intervals per POS
-# ----------------------------
-def process_tag_features(tag_to_features: dict, intervals):
-    list_of_tags = list(tag_to_features.values())
-    unique_arrays = [np.array(tpl) for tpl in set(tuple(arr) for arr in list_of_tags)]
-
-    word_type_masks = {}
-    for wt in range(15):
-        word_type_masks[wt] = [arr for arr in unique_arrays if arr[wt] == 1]
-
-    dict_intervals = {}
-    for wt in range(15):
-        labels = word_type_masks[wt]
-        if len(labels) == 0:
-            dict_intervals[wt] = []
-            continue
-
-        sum_labels = np.sum(np.array(labels), axis=0)
-
-        allowed = [
-            interval
-            for interval in intervals
-            if np.sum(sum_labels[interval[0] : interval[1] + 1]) != 0
-        ]
-        dict_intervals[wt] = allowed
-
-    return dict_intervals
-
-
-DICT_INTERVALS = process_tag_features(tag_to_features, INTERVALS)
-
-# ----------------------------
-# Load bilingual labels
-# ----------------------------
-def load_labels(path: str):
-    with open(path, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-
-try:
-    LABELS = load_labels(LABELS_FILEPATH)
-except Exception:
-    LABELS = {"fo": {"global": {}, "by_wc": {}}, "en": {"global": {}, "by_wc": {}}}
-
-
-def label_for(lang: str, group: str, wc_code: str, code: str) -> str:
-    """Word-class-specific first, then global. Always safe to return ""."""
-    lang = lang if lang in ("fo", "en") else "fo"
-    d = LABELS.get(lang, {})
-    by_wc = d.get("by_wc", {})
-    glob = d.get("global", {})
-
-    if wc_code and group in by_wc and wc_code in by_wc[group] and code in by_wc[group][wc_code]:
-        return by_wc[group][wc_code][code]
-
-    if group in glob and code in glob[group]:
-        return glob[group][code]
-
-    return ""
-
-# ----------------------------
-# Feature column groups (from CSV headers)
-# ----------------------------
-def _group_from_colname(col: str):
-    if col == "Article":
-        return ("article", "A")
-    if col == "Proper Noun":
-        return ("proper", "P")
-    if col.startswith("Not-Proper-Noun "):
-        return ("proper", col.split()[-1])  # usually r
-    if col.startswith("No-Article "):
-        return ("article", col.split()[-1])  # usually a
+GROUP_ORDER = ["subcategory","gender","number","case","article","proper","degree","declension","mood","voice","tense","person","definiteness"]
+
+# You said Subcategory B doesn't exist and will be deleted from the CSV:
+HIDE_CODES = {"subcategory": {"B"}}
+
+GROUP_TITLES = {
+    "en": {"subcategory":"Subcategory","gender":"Gender","number":"Number","case":"Case","article":"Article suffix","proper":"Proper 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":"Bundið eftirlið","proper":"Sernavn",
+           "degree":"Stig","declension":"Bending","mood":"Háttur","voice":"Søgn","tense":"Tíð","person":"Persónur","definiteness":"Bundni/óbundni"},
+}
+
+UI = {
+    "fo": {"w":"Orð","t":"Mark","s":"Vís sum","m":"Merking","def":"bundið","ind":"óbundið"},
+    "en": {"w":"Word","t":"Tag","s":"Show as","m":"Meaning","def":"definite","ind":"indefinite"},
+}
+
+CSS = """
+:root{
+  --primary-500:#89AFA9; --primary-600:#6F9992; --primary-700:#5B7F79;
+  --primary-100:#E1ECEA; --primary-200:#C6DAD6;
+}
+.gr-button-primary, button.primary, .primary{
+  background:var(--primary-500)!important; border-color:var(--primary-600)!important; color:#0b1b19!important;
+}
+.gr-button-primary:hover, button.primary:hover, .primary:hover{ background:var(--primary-600)!important; }
+a{ color:var(--primary-700)!important; }
+"""
+
+def simp_tok(s: str):
+    return re.findall(r"\w+|[" + re.escape(string.punctuation) + "]", s)
+
+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()}
+    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])
 
     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):
-            code = col.split()[-1]
-            return (g, code)
+            return (g, col.split()[-1])
+    return (None,None)
 
-    return (None, None)
-
-
-GROUPS = defaultdict(list)  # group -> list[(idx, code)]
-for i, col in enumerate(FEATURE_COLS):
-    g, code = _group_from_colname(col)
-    if g:
-        GROUPS[g].append((i, code))
-
-# ----------------------------
-# Tokenization
-# ----------------------------
-def simp_tok(sentence: str):
-    return re.findall(r"\w+|[" + re.escape(string.punctuation) + "]", sentence)
+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)}
+    out = {}
+    for wt,labels in wt_masks.items():
+        if not labels: 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]
+    return out
 
-# ----------------------------
-# Decoding
-# ----------------------------
-def predict_vectors(logits: torch.Tensor, attention_mask: torch.Tensor, begin_tokens, dict_intervals, vec_len: int):
+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:
-            continue
-        if begin_tokens[idx] != 1:
+        if attention_mask[idx].item()!=1 or begin_tokens[idx]!=1:
             continue
 
-        pred_logits = logits[idx]
+        pred = logits[idx]
         vec = torch.zeros(vec_len, device=logits.device)
 
-        # POS
-        probs = softmax(pred_logits[0:15])
-        wt = torch.argmax(probs).item()
-        vec[wt] = 1
+        wt = torch.argmax(softmax(pred[0:15])).item()
+        vec[wt]=1
 
-        # Allowed feature groups
-        for (a, b) in dict_intervals.get(wt, []):
-            seg = pred_logits[a : b + 1]
-            probs = softmax(seg)
-            k = torch.argmax(probs).item()
-            vec[a + k] = 1
+        for (a,b) in dict_intervals.get(wt, []):
+            seg = pred[a:b+1]
+            k = torch.argmax(softmax(seg)).item()
+            vec[a+k]=1
 
         vectors.append(vec)
-
     return vectors
 
+# Load labels (extracted from your XLSX)
+with open(LABELS_FILEPATH, "r", encoding="utf-8") as f:
+    LABELS = json.load(f)
 
-def describe_vector(vec: torch.Tensor, lang: str) -> str:
-    # word class code
-    wc_code = ""
-    for idx, code in GROUPS.get("word_class", []):
-        if int(vec[idx].item()) == 1:
-            wc_code = code
-            break
+def label_for(lang: str, group: str, wc: str, code: str) -> str:
+    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, "")
 
-    parts = []
+# Load CSV mappings (authoritative)
+tag_to_features, features_to_tag, VEC_LEN, FEATURE_COLS = load_tag_mappings(TAGS_FILEPATH)
 
-    wc_label = label_for(lang, "word_class", wc_code, wc_code)
-    if wc_code:
-        parts.append(f"{wc_code} – {wc_label}" if wc_label else wc_code)
-
-    order = [
-        "subcategory",
-        "gender",
-        "number",
-        "case",
-        "article",
-        "proper",
-        "degree",
-        "declension",
-        "mood",
-        "voice",
-        "tense",
-        "person",
-        "definiteness",
-    ]
+# Load model
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, token=HF_TOKEN)
+model = AutoModelForTokenClassification.from_pretrained(MODEL_ID, token=HF_TOKEN)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model.to(device); model.eval()
 
-    for g in order:
-        chosen = None
-        for idx, code in GROUPS.get(g, []):
-            if int(vec[idx].item()) == 1:
-                chosen = code
-                break
-        if not chosen:
-            continue
+if hasattr(model, "config") and hasattr(model.config, "num_labels"):
+    if model.config.num_labels != VEC_LEN:
+        raise RuntimeError(f"Label size mismatch: model={model.config.num_labels}, csv={VEC_LEN}. Wrong CSV?")
+
+DICT_INTERVALS = process_tag_features(tag_to_features, INTERVALS)
 
-        lbl = label_for(lang, g, wc_code, chosen)
-
-        # Always keep this correct even if labels are missing
-        if not lbl:
-            if lang == "en":
-                FALLBACK = {
-                    "definiteness": {"D": "definite", "I": "indefinite"},
-                    "article": {"A": "with suffixed definite article", "a": "no definite suffix"},
-                    "proper": {"P": "proper noun", "r": "not proper noun"},
-                    "gender": {"g": "no gender"},
-                    "number": {"n": "no number"},
-                    "case": {"c": "no case"},
-                    "degree": {"d": "no degree"},
-                    "declension": {"e": "no declension"},
-                    "voice": {"v": "no voice"},
-                    "tense": {"t": "no tense"},
-                    "person": {"p": "no person"},
-                    "subcategory": {"s": "no subcategory"},
-                }
-            else:
-                FALLBACK = {
-                    "definiteness": {"D": "bundið", "I": "óbundið"},
-                    "article": {"A": "við bundnum eftirlið", "a": "uttan bundið eftirlið"},
-                    "proper": {"P": "sernavn", "r": "ikki sernavn"},
-                    "gender": {"g": "einki kyn"},
-                    "number": {"n": "einki tal"},
-                    "case": {"c": "einki fall"},
-                    "degree": {"d": "einki stig"},
-                    "declension": {"e": "eingin bending"},
-                    "voice": {"v": "eingin søgn"},
-                    "tense": {"t": "eingin tíð"},
-                    "person": {"p": "eingin persónur"},
-                    "subcategory": {"s": "eingin undirflokkur"},
-                }
-            lbl = FALLBACK.get(g, {}).get(chosen, "")
-
-        parts.append(f"{chosen} – {lbl}" if lbl else chosen)
+# Build GROUPS from CSV headers
+GROUPS = defaultdict(list)  # group -> [(idx, code, colname)]
+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))
 
-    return "; ".join(parts)
+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:
+            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, []):
+        if code in hidden:
+            continue
+        if int(vec[idx].item())==1:
+            return code
+    return ""
 
+def describe(vec: torch.Tensor, lang: str) -> str:
+    wc = wc_code(vec)
+    parts = []
+    if wc:
+        lbl = label_for(lang, "word_class", wc, wc)
+        parts.append(f"{wc} – {lbl}" if lbl else wc)
+    for g in GROUP_ORDER:
+        c = group_code(vec, g)
+        if not c:
+            continue
+        lbl = label_for(lang, g, wc, c) or label_for(lang, g, "", c)
+        parts.append(f"{c} – {lbl}" if lbl else c)
+    return "; ".join(parts)
 
-def tag_sentence(sentence: str, lang: str = "fo", max_len: int = 128):
-    sentence = (sentence or "").strip()
-    if not sentence:
-        return pd.DataFrame(columns=["Word", "Tag", "Meaning"]), ""
+def show_as(vec: torch.Tensor, lang: str) -> str:
+    lang = "fo" if lang=="fo" else "en"
+    wc = wc_code(vec)
+    wc_lbl = label_for(lang, "word_class", wc, wc) or wc
+    raw = vector_to_tag(vec)
+
+    # Exact override you requested:
+    if raw == "DGd":
+        return "Fyriseting" if lang=="fo" else "Preposition"
+
+    # S...a. / S...A. mapping (nouns): show definite/indefinite by Article (A/a)
+    if wc == "S":
+        art = group_code(vec, "article")  # A or a
+        if art == "A": return f"{wc_lbl} — {UI[lang]['def']}"
+        if art == "a": return f"{wc_lbl} — {UI[lang]['ind']}"
+        return wc_lbl
+
+    return wc_lbl
+
+def compute_codes_by_wc():
+    codes = defaultdict(lambda: defaultdict(set))  # wc -> group -> set(code)
+    for arr in tag_to_features.values():
+        arr = np.array(arr)
+
+        wc = None
+        for idx,code,_ in GROUPS["word_class"]:
+            if arr[idx]==1:
+                wc = code
+                break
+        if not wc:
+            continue
 
-    tokens = simp_tok(sentence)
+        for g in GROUP_ORDER:
+            hidden = HIDE_CODES.get(g, set())
+            for idx,code,_ in GROUPS.get(g, []):
+                if code in hidden:
+                    continue
+                if arr[idx]==1:
+                    codes[wc][g].add(code)
+
+    return codes
+
+CODES_BY_WC = compute_codes_by_wc()
+
+def build_legend(lang: str) -> str:
+    lang = "fo" if lang=="fo" else "en"
+    lines = ["### Markingaryvirlit / Legend", ""]
+    for wc in sorted(CODES_BY_WC.keys()):
+        wcl = label_for(lang, "word_class", wc, wc) or ""
+        lines.append(f"#### {wc} — {wcl}" if wcl else f"#### {wc}")
+
+        for g in GROUP_ORDER:
+            cs = sorted(CODES_BY_WC[wc].get(g, set()))
+            if not cs:
+                continue
+            lines.append(f"**{GROUP_TITLES[lang].get(g, g)}**")
+            for c in cs:
+                lbl = label_for(lang, g, wc, c) or label_for(lang, g, "", c)
+                lines.append(f"- `{c}` — {lbl}" if lbl else f"- `{c}`")
+            lines.append("")
+        lines.append("")
+    return "\n".join(lines).strip()
+
+def run_model(sentence: str):
+    s = (sentence or "").strip()
+    if not s:
+        return []
+    tokens = simp_tok(s)
     if not tokens:
-        return pd.DataFrame(columns=["Word", "Tag", "Meaning"]), ""
-
-    enc = tokenizer(
-        tokens,
-        is_split_into_words=True,
-        add_special_tokens=True,
-        max_length=max_len,
-        padding="max_length",
-        truncation=True,
-        return_attention_mask=True,
-        return_tensors="pt",
-    )
+        return []
+
+    enc = tokenizer(tokens, is_split_into_words=True, add_special_tokens=True, max_length=128,
+                    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)
 
-    begin_tokens = []
+    begin = []
     last = None
     for wid in word_ids:
-        if wid is None:
-            begin_tokens.append(0)
-        elif wid != last:
-            begin_tokens.append(1)
-        else:
-            begin_tokens.append(0)
+        if wid is None: begin.append(0)
+        elif wid != last: begin.append(1)
+        else: begin.append(0)
         last = wid
 
     with torch.no_grad():
-        out = model(input_ids=input_ids, attention_mask=attention_mask)
-        logits = out.logits[0]
+        logits = model(input_ids=input_ids, attention_mask=attention_mask).logits[0]
 
-    vectors = predict_vectors(logits, attention_mask[0], begin_tokens, DICT_INTERVALS, VEC_LEN)
+    vectors = predict_vectors(logits, attention_mask[0], begin, DICT_INTERVALS, VEC_LEN)
 
     rows = []
     vec_i = 0
-    seen_word_ids = set()
-
-    for i, wid in enumerate(word_ids):
-        if wid is None:
-            continue
-        if begin_tokens[i] != 1:
+    seen = set()
+    for i,wid in enumerate(word_ids):
+        if wid is None or begin[i]!=1 or wid in seen:
             continue
-        if wid in seen_word_ids:
-            continue
-
-        seen_word_ids.add(wid)
+        seen.add(wid)
         word = tokens[wid] if wid < len(tokens) else "<UNK>"
-
         vec = vectors[vec_i] if vec_i < len(vectors) else torch.zeros(VEC_LEN, device=device)
-        tag = vector_to_tag(vec)
-        meaning = describe_vector(vec, lang)
-
-        rows.append([word, tag, meaning])
+        rows.append({"word": word, "vec": vec.int().tolist()})
         vec_i += 1
+    return rows
 
-    df = pd.DataFrame(rows, columns=["Word", "Tag", "Meaning"])
-    tsv = "\n".join([f"{w}\t{t}\t{m}" for w, t, m in rows])
-    return df, tsv
-
-
-def build_legend(lang: str):
-    lang = lang if lang in ("fo", "en") else "fo"
-
-    if lang == "en":
-        title = "### Legend (what the codes mean)"
-        hint = "- Tip: hover/copy from the TSV box if you want to paste into spreadsheets or docs."
-        wc_title = "#### Word classes"
-        missing = "(No label file loaded — add tag_labels.json to the repo root.)"
-    else:
-        title = "### Markingaryvirlit (hvat kóðurnar merkja)"
-        hint = "- Tips: tú kanst copy/paste úr TSV-kassanum inn í skjøl ella rokniskjøl."
-        wc_title = "#### Orðaflokkar"
-        missing = "(Eingin label-fíla er innlisin — legg tag_labels.json í rótina á repo.)"
-
-    wc_map = LABELS.get(lang, {}).get("global", {}).get("word_class", {})
+def render(rows_state, lang: str):
+    lang = "fo" if lang=="fo" else "en"
+    cols = [UI[lang]["w"], UI[lang]["t"], UI[lang]["s"], UI[lang]["m"]]
+    if not rows_state:
+        return pd.DataFrame(columns=cols), build_legend(lang)
 
-    lines = [title, hint, "", wc_title]
-    if wc_map:
-        for code in sorted(wc_map.keys()):
-            lines.append(f"- **{code}**: {wc_map[code]}")
-    else:
-        lines.append(f"- {missing}")
+    out = []
+    for r in rows_state:
+        vec = torch.tensor(r["vec"])
+        out.append([r["word"], vector_to_tag(vec), show_as(vec, lang), describe(vec, lang)])
+    return pd.DataFrame(out, columns=cols), build_legend(lang)
 
-    return "\n".join(lines)
-
-
-# ----------------------------
-# Gradio UI
-# ----------------------------
 theme = gr.themes.Soft()
 
-with gr.Blocks(theme=theme, title="BRAGD-markarin") as demo:
-    gr.Markdown(
-        "## BRAGD-markarin\n"
-        "Skriv ein setning og fá hann markaðan.\n\n"
-        "**Model:** `Setur/BRAGD`"
-    )
-
-    with gr.Row():
-        lang = gr.Dropdown(
-            choices=[("Føroyskt", "fo"), ("English", "en")],
-            value="fo",
-            label="Mál / Language",
-        )
-
-    inp = gr.Textbox(lines=3, label="Setningur / Sentence", placeholder="Skriv her…")
+with gr.Blocks(theme=theme, css=CSS, title="BRAGD-markarin") as demo:
+    gr.Markdown("## BRAGD-markarin\nSkriv ein setning og fá hann markaðan.\n\n**Model:** `Setur/BRAGD`")
+
+    inp = gr.Textbox(lines=3, label="Setningur / Sentence", placeholder="Skriv her… / Type here…")
     btn = gr.Button("Marka / Tag", variant="primary")
 
-    out_df = gr.Dataframe(
-        headers=["Word", "Tag", "Meaning"],
-        wrap=True,
-        interactive=False,
-        label="Úrslit / Results",
-    )
-    out_tsv = gr.Textbox(lines=10, label="Copy/paste (TSV)", interactive=False)
+    state = gr.State([])
+    out_df = gr.Dataframe(wrap=True, interactive=False, label="Úrslit / Results")
+
+    # Under results + can be changed AFTER tagging (no rerun; just re-render)
+    lang = gr.Dropdown(choices=[("Føroyskt","fo"), ("English","en")], value="fo", label="Mál / Language")
 
     with gr.Accordion("Markingaryvirlit / Legend", open=False):
         legend_md = gr.Markdown(build_legend("fo"))
 
-    def _run(sentence, lang_choice):
-        df, tsv = tag_sentence(sentence, lang_choice)
-        return df, tsv, build_legend(lang_choice)
+    def on_tag(sentence, lang_choice):
+        rows = run_model(sentence)
+        df, legend = render(rows, lang_choice)
+        return rows, df, legend
+
+    def on_lang(rows, lang_choice):
+        df, legend = render(rows, lang_choice)
+        return df, legend
 
-    btn.click(_run, inputs=[inp, lang], outputs=[out_df, out_tsv, legend_md])
-    lang.change(lambda l: build_legend(l), inputs=[lang], outputs=[legend_md])
+    btn.click(on_tag, inputs=[inp, lang], outputs=[state, out_df, legend_md])
+    lang.change(on_lang, inputs=[state, lang], outputs=[out_df, legend_md])
 
 if __name__ == "__main__":
     demo.launch()

tag_labels.json

@@ -1,610 +1,607 @@
 {
   "en": {
-    "by_wc": {
-      "gender": {
-        "S": {
-          "M": "masculine",
-          "F": "feminine",
-          "N": "neuter"
+    "global": {
+      "word_class": {
+        "S": "substantive",
+        "R": "article",
+        "A": "adjective",
+        "P": "pronoun",
+        "N": "numeral",
+        "V": "verb (except for participle)",
+        "L": "participle",
+        "D": "adverb",
+        "C": "conjunction",
+        "F": "Foreign word",
+        "X": "Unanalysed word",
+        "T": "abbreviation",
+        "W": "e-mail, web address",
+        "K": "punctuation",
+        "M": "Symbol"
+      },
+      "gender": {},
+      "number": {},
+      "case": {},
+      "article": {},
+      "proper": {},
+      "degree": {},
+      "declension": {},
+      "subcategory": {},
+      "person": {},
+      "mood": {},
+      "voice": {},
+      "tense": {},
+      "definiteness": {
+        "D": "definite",
+        "I": "indefinite"
+      }
+    },
+    "by_word_class": {
+      "S": {
+        "word_class": {
+          "S": "substantive"
         },
-        "R": {
+        "gender": {
           "M": "masculine",
           "F": "feminine",
           "N": "neuter"
         },
-        "A": {
-          "M": "masculine",
-          "F": "feminine",
-          "N": "neuter"
+        "number": {
+          "S": "singular",
+          "P": "plural"
         },
-        "P": {
-          "M": "masculine",
-          "F": "feminine",
-          "N": "neuter"
+        "case": {
+          "N": "nominative",
+          "A": "accusative",
+          "D": "dative",
+          "G": "genitive"
         },
-        "N": {
-          "M": "masculine",
-          "F": "feminine",
-          "N": "neuter"
+        "article": {
+          "A": "with suffixed definite article"
         },
-        "L": {
+        "proper": {
+          "P": "Proper Noun"
+        }
+      },
+      "R": {
+        "word_class": {
+          "R": "article"
+        },
+        "gender": {
           "M": "masculine",
           "F": "feminine",
           "N": "neuter"
-        }
-      },
-      "number": {
-        "S": {
-          "S": "singular",
-          "P": "plural"
         },
-        "R": {
+        "number": {
           "S": "singular",
           "P": "plural"
         },
-        "A": {
-          "S": "singular",
-          "P": "plural"
+        "case": {
+          "N": "nominative",
+          "A": "accusative",
+          "D": "dative",
+          "G": "genitive"
         },
-        "P": {
-          "S": "singular",
-          "P": "plural"
+        "article": {
+          "I": "indefinite",
+          "D": "definite"
+        }
+      },
+      "A": {
+        "word_class": {
+          "A": "adjective"
         },
-        "N": {
-          "S": "singular",
-          "P": "plural"
+        "degree": {
+          "P": "positive",
+          "C": "comparative",
+          "S": "superlative",
+          "A": "absolute superlative"
         },
-        "V": {
-          "S": "singular",
-          "P": "plural"
+        "declension": {
+          "S": "strong",
+          "W": "weak",
+          "e": "no-declension"
         },
-        "L": {
+        "gender": {
+          "M": "masculine",
+          "F": "feminine",
+          "N": "neuter"
+        },
+        "number": {
           "S": "singular",
           "P": "plural"
-        }
-      },
-      "case": {
-        "S": {
-          "N": "nominative",
-          "A": "accusative",
-          "D": "dative",
-          "G": "genitive"
-        },
-        "R": {
-          "N": "nominative",
-          "A": "accusative",
-          "D": "dative",
-          "G": "genitive"
         },
-        "A": {
+        "case": {
           "N": "nominative",
           "A": "accusative",
           "D": "dative",
           "G": "genitiv"
+        }
+      },
+      "P": {
+        "word_class": {
+          "P": "pronoun"
         },
-        "P": {
-          "N": "nominative",
-          "A": "accusative",
-          "D": "dative",
-          "G": "genitive"
+        "subcategory": {
+          "D": "demonstrative",
+          "E": "possessive",
+          "I": "indefinite"
         },
-        "N": {
+        "gender": {
+          "M": "masculine",
+          "F": "feminine",
+          "N": "neuter"
+        },
+        "person": {
+          "1": "1st pers",
+          "2": "2nd pers",
+          "3": "3rd pers"
+        },
+        "number": {
+          "S": "singular",
+          "P": "plural"
+        },
+        "case": {
           "N": "nominative",
           "A": "accusative",
           "D": "dative",
           "G": "genitive"
+        }
+      },
+      "N": {
+        "word_class": {
+          "N": "numeral"
+        },
+        "subcategory": {
+          "C": "cardinal number",
+          "O": "Date and other indeclinable number"
         },
-        "L": {
+        "gender": {
+          "M": "masculine",
+          "F": "feminine",
+          "N": "neuter"
+        },
+        "number": {
+          "S": "singular",
+          "P": "plural"
+        },
+        "case": {
           "N": "nominative",
           "A": "accusative",
           "D": "dative",
           "G": "genitive"
         }
       },
-      "article": {
-        "S": {
-          "A": "with suffixed definite article"
-        }
-      },
-      "proper": {
-        "S": {
-          "P": "Proper Noun"
-        }
-      },
-      "definiteness": {
-        "R": {
-          "I": "indefinite",
-          "D": "definite"
-        }
-      },
-      "degree": {
-        "A": {
-          "P": "positive",
-          "C": "comparative",
-          "S": "superlative",
-          "A": "absolute superlative"
+      "V": {
+        "word_class": {
+          "V": "verb (except for participle)"
         },
-        "D": {
-          "C": "comparative",
-          "S": "superlative",
-          "A": "absolute superlative"
+        "mood": {
+          "I": "infinitive",
+          "M": "imperative",
+          "N": "indicative",
+          "S": "subjunctive",
+          "U": "supine"
+        },
+        "voice": {
+          "A": "active",
+          "M": "mediopassive"
+        },
+        "tense": {
+          "P": "present",
+          "A": "past"
+        },
+        "number": {
+          "S": "singular",
+          "P": "plural"
+        },
+        "person": {
+          "1": "1st person",
+          "2": "2nd person",
+          "3": "3rd person"
         }
       },
-      "declension": {
-        "A": {
-          "S": "strong",
-          "W": "weak",
-          "e": "no-declension"
+      "L": {
+        "word_class": {
+          "L": "participle"
         },
-        "L": {
+        "voice": {
+          "A": "active",
+          "M": "mediopassive"
+        },
+        "declension": {
           "S": "strong",
           "W": "weak",
           "e": "no-declension"
+        },
+        "gender": {
+          "M": "masculine",
+          "F": "feminine",
+          "N": "neuter"
+        },
+        "number": {
+          "S": "singular",
+          "P": "plural"
+        },
+        "case": {
+          "N": "nominative",
+          "A": "accusative",
+          "D": "dative",
+          "G": "genitive"
         }
       },
-      "subcategory": {
-        "P": {
-          "D": "demonstrative",
-          "E": "possessive",
-          "I": "indefinite"
-        },
-        "N": {
-          "C": "cardinal number",
-          "O": "Date and other indeclinable number"
+      "D": {
+        "word_class": {
+          "D": "adverb"
         },
-        "D": {
+        "subcategory": {
           "N": "does not govern case",
           "G": "governs case",
           "I": "interjection/exclamation"
         },
-        "C": {
+        "degree": {
+          "C": "comparative",
+          "S": "superlative",
+          "A": "absolute superlative"
+        }
+      },
+      "C": {
+        "word_class": {
+          "C": "conjunction"
+        },
+        "subcategory": {
           "C": "coordinative",
           "S": "subordinative",
           "I": "infinitive (only \"at\" infinitive)",
           "R": "relative"
-        },
-        "T": {
-          "S": "abbreviation",
-          "T": "short form"
-        },
-        "K": {
-          "E": "End of sentence",
-          "C": "comma",
-          "Q": "quotes",
-          "O": "other"
         }
       },
-      "person": {
-        "P": {
-          "1": "1st pers",
-          "2": "2nd pers",
-          "3": "3rd pers"
+      "F": {
+        "word_class": {
+          "F": "Foreign word"
+        }
+      },
+      "X": {
+        "word_class": {
+          "X": "Unanalysed word"
+        }
+      },
+      "T": {
+        "word_class": {
+          "T": "abbreviation"
         },
-        "V": {
-          "1": "1st person",
-          "2": "2nd person",
-          "3": "3rd person"
+        "subcategory": {
+          "S": "abbreviation",
+          "T": "short form"
         }
       },
-      "mood": {
-        "V": {
-          "I": "infinitive",
-          "M": "imperative",
-          "N": "indicative",
-          "S": "subjunctive",
-          "U": "supine"
+      "W": {
+        "word_class": {
+          "W": "e-mail, web address"
         }
       },
-      "voice": {
-        "V": {
-          "A": "active",
-          "M": "mediopassive"
+      "K": {
+        "word_class": {
+          "K": "punctuation"
         },
-        "L": {
-          "A": "active",
-          "M": "mediopassive"
+        "subcategory": {
+          "E": "End of sentence",
+          "C": "comma",
+          "Q": "quotes",
+          "O": "other"
         }
       },
-      "tense": {
-        "V": {
-          "P": "present",
-          "A": "past"
+      "M": {
+        "word_class": {
+          "M": "Symbol"
         }
       }
-    },
+    }
+  },
+  "fo": {
     "global": {
       "word_class": {
-        "S": "substantive",
-        "R": "article",
-        "A": "adjective",
-        "P": "pronoun",
-        "N": "numeral",
-        "V": "verb (except for participle)",
-        "L": "participle",
-        "D": "adverb",
-        "C": "conjunction",
-        "F": "Foreign word",
-        "X": "Unanalysed word",
-        "T": "abbreviation",
-        "W": "e-mail, web address",
-        "K": "punctuation",
-        "M": "Symbol"
-      },
-      "gender": {
-        "M": "masculine",
-        "F": "feminine",
-        "N": "neuter"
-      },
-      "number": {
-        "S": "singular",
-        "P": "plural"
-      },
-      "case": {
-        "N": "nominative",
-        "A": "accusative",
-        "D": "dative",
-        "G": "genitive"
-      },
-      "article": {
-        "A": "with suffixed definite article"
-      },
-      "proper": {
-        "P": "Proper Noun"
+        "S": "navnorð",
+        "R": "kenniorð",
+        "A": "lýsingarorð",
+        "P": "fornavn",
+        "N": "talorð",
+        "V": "sagnorð (ikki lýsingarháttur)",
+        "L": "lýsingarháttur",
+        "D": "hjáorð",
+        "C": "sambindingarorð",
+        "F": "útlendskt orð",
+        "X": "ómarkað orð",
+        "T": "stytting",
+        "W": "teldupostur, heimasíðua",
+        "K": "teknseting",
+        "M": "symbol"
       },
+      "gender": {},
+      "number": {},
+      "case": {},
+      "article": {},
+      "proper": {},
+      "degree": {},
+      "declension": {},
+      "subcategory": {},
+      "person": {},
+      "mood": {},
+      "voice": {},
+      "tense": {},
       "definiteness": {
-        "I": "indefinite",
-        "D": "definite"
-      },
-      "degree": {
-        "P": "positive",
-        "C": "comparative",
-        "S": "superlative",
-        "A": "absolute superlative"
-      },
-      "declension": {
-        "S": "strong",
-        "W": "weak",
-        "e": "no-declension"
-      },
-      "subcategory": {
-        "D": "demonstrative",
-        "E": "possessive",
-        "I": "indefinite",
-        "C": "cardinal number",
-        "O": "Date and other indeclinable number",
-        "N": "does not govern case",
-        "G": "governs case",
-        "S": "subordinative",
-        "R": "relative",
-        "T": "short form",
-        "Q": "quotes"
-      },
-      "person": {
-        "1": "1st pers",
-        "2": "2nd pers",
-        "3": "3rd pers"
-      },
-      "mood": {
-        "I": "infinitive",
-        "M": "imperative",
-        "N": "indicative",
-        "S": "subjunctive",
-        "U": "supine"
-      },
-      "voice": {
-        "A": "active",
-        "M": "mediopassive"
-      },
-      "tense": {
-        "P": "present",
-        "A": "past"
+        "D": "bundið",
+        "I": "óbundið"
       }
-    }
-  },
-  "fo": {
-    "by_wc": {
-      "gender": {
-        "S": {
-          "M": "kallkyn",
-          "F": "kvennkyn",
-          "N": "hvørkikyn"
-        },
-        "R": {
-          "M": "kallkyn",
-          "F": "kvennkyn",
-          "N": "hvørkikyn"
-        },
-        "A": {
-          "M": "kallkyn",
-          "F": "kvennkyn",
-          "N": "hvørkikyn"
-        },
-        "P": {
-          "M": "kallkyn",
-          "F": "kvennkyn",
-          "N": "hvørkikyn"
-        },
-        "N": {
-          "M": "kallkyn",
-          "F": "kvennkyn",
-          "N": "hvørkikyn"
+    },
+    "by_word_class": {
+      "S": {
+        "word_class": {
+          "S": "navnorð"
         },
-        "L": {
+        "gender": {
           "M": "kallkyn",
           "F": "kvennkyn",
           "N": "hvørkikyn"
-        }
-      },
-      "number": {
-        "S": {
-          "S": "eintal",
-          "P": "fleirtal"
         },
-        "R": {
+        "number": {
           "S": "eintal",
           "P": "fleirtal"
         },
-        "A": {
-          "S": "eintal",
-          "P": "fleirtal"
-        },
-        "P": {
-          "S": "eintal",
-          "P": "fleirtal"
-        },
-        "N": {
-          "S": "eintal",
-          "P": "fleirtal"
-        },
-        "V": {
-          "S": "eintal",
-          "P": "fleirtal"
-        },
-        "L": {
-          "S": "eintal",
-          "P": "fleirtal"
-        }
-      },
-      "case": {
-        "S": {
+        "case": {
           "N": "hvørfall",
           "A": "hvønnfall",
           "D": "hvørjumfall",
           "G": "hvørsfall"
         },
-        "R": {
-          "N": "hvørfall",
-          "A": "hvønnfall",
-          "D": "hvørjumfall",
-          "G": "hvørsfall"
+        "article": {
+          "A": "bundið"
         },
-        "A": {
-          "N": "hvørfall",
-          "A": "hvønnfall",
-          "D": "hvørjumfall",
-          "G": "hvørsfall"
+        "proper": {
+          "P": "sernavn"
+        }
+      },
+      "R": {
+        "word_class": {
+          "R": "kenniorð"
         },
-        "P": {
-          "N": "hvørfall",
-          "A": "hvønnfall",
-          "D": "hvørjumfall",
-          "G": "hvørsfall"
+        "gender": {
+          "M": "kallkyn",
+          "F": "kvennkyn",
+          "N": "hvørkikyn"
         },
-        "N": {
-          "N": "hvørfall",
-          "A": "hvønnfall",
-          "D": "hvørjumfall",
-          "G": "hvørsfall"
+        "number": {
+          "S": "eintal",
+          "P": "fleirtal"
         },
-        "L": {
+        "case": {
           "N": "hvørfall",
           "A": "hvønnfall",
           "D": "hvørjumfall",
           "G": "hvørsfall"
-        }
-      },
-      "article": {
-        "S": {
-          "A": "bundið"
-        }
-      },
-      "proper": {
-        "S": {
-          "P": "sernavn"
-        }
-      },
-      "definiteness": {
-        "R": {
+        },
+        "article": {
           "I": "óbundið",
           "D": "bundið"
         }
       },
-      "degree": {
-        "A": {
+      "A": {
+        "word_class": {
+          "A": "lýsingarorð"
+        },
+        "degree": {
           "P": "grundstig",
           "C": "miðstig",
           "S": "hástig",
           "A": "absolutt hástig"
         },
-        "D": {
-          "C": "miðstig",
-          "S": "hástig",
-          "A": "absolutt hástig"
-        }
-      },
-      "declension": {
-        "A": {
+        "declension": {
           "S": "sterk",
           "W": "veik",
           "e": "eingin-bending"
         },
-        "L": {
-          "S": "sterk",
-          "W": "veik",
-          "e": "eingin-bending"
+        "gender": {
+          "M": "kallkyn",
+          "F": "kvennkyn",
+          "N": "hvørkikyn"
+        },
+        "number": {
+          "S": "eintal",
+          "P": "fleirtal"
+        },
+        "case": {
+          "N": "hvørfall",
+          "A": "hvønnfall",
+          "D": "hvørjumfall",
+          "G": "hvørsfall"
         }
       },
-      "subcategory": {
-        "P": {
+      "P": {
+        "word_class": {
+          "P": "fornavn"
+        },
+        "subcategory": {
           "D": "ávísingarfornavn",
           "E": "ognarfornavn",
           "I": "óbundið fornavn"
         },
-        "N": {
-          "C": "grundtal",
-          "O": "dagfesting og onnur óbendandi tøl"
-        },
-        "D": {
-          "N": "stýrir ikki falli",
-          "G": "stýrir falli",
-          "I": "miðalvarping"
+        "gender": {
+          "M": "kallkyn",
+          "F": "kvennkyn",
+          "N": "hvørkikyn"
         },
-        "C": {
-          "C": "javnskipandi",
-          "S": "innskipandi",
-          "I": "navnháttarmerki (bara \"at\")",
-          "R": "afturbeint fornavn"
+        "person": {
+          "1": "fyrsti persónur",
+          "2": "annar persónur",
+          "3": "triði persónur"
         },
-        "T": {
-          "S": "stytting",
-          "T": "stytting við punktum"
+        "number": {
+          "S": "eintal",
+          "P": "fleirtal"
         },
-        "K": {
-          "E": "endi av setningi",
-          "C": "komma",
-          "Q": "gásareyga",
-          "O": "annað"
+        "case": {
+          "N": "hvørfall",
+          "A": "hvønnfall",
+          "D": "hvørjumfall",
+          "G": "hvørsfall"
         }
       },
-      "person": {
-        "P": {
-          "1": "fyrsti persónur",
-          "2": "annar persónur",
-          "3": "triði persónur"
+      "N": {
+        "word_class": {
+          "N": "talorð"
         },
-        "V": {
-          "1": "fyrsti persónur",
-          "2": "annar persónur",
-          "3": "triði persónur"
+        "subcategory": {
+          "C": "grundtal",
+          "O": "dagfesting og onnur óbendandi tøl"
+        },
+        "gender": {
+          "M": "kallkyn",
+          "F": "kvennkyn",
+          "N": "hvørkikyn"
+        },
+        "number": {
+          "S": "eintal",
+          "P": "fleirtal"
+        },
+        "case": {
+          "N": "hvørfall",
+          "A": "hvønnfall",
+          "D": "hvørjumfall",
+          "G": "hvørsfall"
         }
       },
-      "mood": {
-        "V": {
+      "V": {
+        "word_class": {
+          "V": "sagnorð (ikki lýsingarháttur)"
+        },
+        "mood": {
           "I": "navnháttur",
           "M": "boðsháttur",
           "N": "søguháttur",
           "S": "hugsháttur",
           "U": "luttøkuháttur"
-        }
-      },
-      "voice": {
-        "V": {
-          "A": "gerðsøgn",
-          "M": "miðalsøgn"
         },
-        "L": {
+        "voice": {
           "A": "gerðsøgn",
           "M": "miðalsøgn"
-        }
-      },
-      "tense": {
-        "V": {
+        },
+        "tense": {
           "P": "nútíð",
           "A": "tátíð"
         },
-        "L": {
+        "number": {
+          "S": "eintal",
+          "P": "fleirtal"
+        },
+        "person": {
+          "1": "fyrsti persónur",
+          "2": "annar persónur",
+          "3": "triði persónur"
+        }
+      },
+      "L": {
+        "word_class": {
+          "L": "lýsingarháttur"
+        },
+        "tense": {
           "P": "nútíð",
           "A": "tátíð"
+        },
+        "voice": {
+          "A": "gerðsøgn",
+          "M": "miðalsøgn"
+        },
+        "declension": {
+          "S": "sterk",
+          "W": "veik",
+          "e": "eingin-bending"
+        },
+        "gender": {
+          "M": "kallkyn",
+          "F": "kvennkyn",
+          "N": "hvørkikyn"
+        },
+        "number": {
+          "S": "eintal",
+          "P": "fleirtal"
+        },
+        "case": {
+          "N": "hvørfall",
+          "A": "hvønnfall",
+          "D": "hvørjumfall",
+          "G": "hvørsfall"
         }
-      }
-    },
-    "global": {
-      "word_class": {
-        "S": "navnorð",
-        "R": "kenniorð",
-        "A": "lýsingarorð",
-        "P": "fornavn",
-        "N": "talorð",
-        "V": "sagnorð (ikki lýsingarháttur)",
-        "L": "lýsingarháttur",
-        "D": "hjáorð",
-        "C": "sambindingarorð",
-        "F": "útlendskt orð",
-        "X": "ómarkað orð",
-        "T": "stytting",
-        "W": "teldupostur, heimasíðua",
-        "K": "teknseting",
-        "M": "symbol"
-      },
-      "gender": {
-        "M": "kallkyn",
-        "F": "kvennkyn",
-        "N": "hvørkikyn"
-      },
-      "number": {
-        "S": "eintal",
-        "P": "fleirtal"
-      },
-      "case": {
-        "N": "hvørfall",
-        "A": "hvønnfall",
-        "D": "hvørjumfall",
-        "G": "hvørsfall"
-      },
-      "article": {
-        "A": "bundið"
-      },
-      "proper": {
-        "P": "sernavn"
       },
-      "definiteness": {
-        "I": "óbundið",
-        "D": "bundið"
+      "D": {
+        "word_class": {
+          "D": "hjáorð"
+        },
+        "subcategory": {
+          "N": "stýrir ikki falli",
+          "G": "stýrir falli",
+          "I": "miðalvarping"
+        },
+        "degree": {
+          "C": "miðstig",
+          "S": "hástig",
+          "A": "absolutt hástig"
+        }
       },
-      "degree": {
-        "P": "grundstig",
-        "C": "miðstig",
-        "S": "hástig",
-        "A": "absolutt hástig"
+      "C": {
+        "word_class": {
+          "C": "sambindingarorð"
+        },
+        "subcategory": {
+          "C": "javnskipandi",
+          "S": "innskipandi",
+          "I": "navnháttarmerki (bara \"at\")",
+          "R": "afturbeint fornavn"
+        }
       },
-      "declension": {
-        "S": "sterk",
-        "W": "veik",
-        "e": "eingin-bending"
+      "F": {
+        "word_class": {
+          "F": "útlendskt orð"
+        }
       },
-      "subcategory": {
-        "D": "ávísingarfornavn",
-        "E": "ognarfornavn",
-        "I": "óbundið fornavn",
-        "C": "grundtal",
-        "O": "dagfesting og onnur óbendandi tøl",
-        "N": "stýrir ikki falli",
-        "G": "stýrir falli",
-        "S": "innskipandi",
-        "R": "afturbeint fornavn",
-        "T": "stytting við punktum",
-        "Q": "gásareyga"
+      "X": {
+        "word_class": {
+          "X": "ómarkað orð"
+        }
       },
-      "person": {
-        "1": "fyrsti persónur",
-        "2": "annar persónur",
-        "3": "triði persónur"
+      "T": {
+        "word_class": {
+          "T": "stytting"
+        },
+        "subcategory": {
+          "S": "stytting",
+          "T": "stytting við punktum"
+        }
       },
-      "mood": {
-        "I": "navnháttur",
-        "M": "boðsháttur",
-        "N": "søguháttur",
-        "S": "hugsháttur",
-        "U": "luttøkuháttur"
+      "W": {
+        "word_class": {
+          "W": "teldupostur, heimasíðua"
+        }
       },
-      "voice": {
-        "A": "gerðsøgn",
-        "M": "miðalsøgn"
+      "K": {
+        "word_class": {
+          "K": "teknseting"
+        },
+        "subcategory": {
+          "E": "endi av setningi",
+          "C": "komma",
+          "Q": "gásareyga",
+          "O": "annað"
+        }
       },
-      "tense": {
-        "P": "nútíð",
-        "A": "tátíð"
+      "M": {
+        "word_class": {
+          "M": "symbol"
+        }
       }
     }
+  },
+  "meta": {
+    "source_en_xlsx": "Sosialurin-GOLD tagset.xlsx",
+    "source_fo_xlsx": "Sosialurin-GOLD markingaryvirlit.xlsx",
+    "notes": "Extracted from XLSX; FO mood U added manually: luttøkuháttur."
   }
 }