Upload app.py

app.py

@@ -11,29 +11,23 @@ from transformers import AutoTokenizer, AutoModelForTokenClassification
 # Config
 # ----------------------------
 MODEL_ID = "Setur/BRAGD"
-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
+TAGS_FILEPATH = "Sosialurin-BRAGD_tags.csv"
+LABELS_FILEPATH = "tag_labels.json"
+HF_TOKEN = os.getenv("BRAGD")
 
 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 demo.py intervals
 INTERVALS = (
     (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)
 )
 
 GROUP_ORDER = ["subcategory","gender","number","case","article","proper","degree","declension","mood","voice","tense","person","definiteness"]
+HIDE_CODES = {"subcategory": {"B"}}  # Subcategory B to be removed
 
-# You said Subcategory B doesn't exist and will be deleted from the CSV:
-HIDE_CODES = {"subcategory": {"B"}}
-
-# ----------------------------
-# UI text
-# ----------------------------
 UI = {
     "fo": {"w":"Orð", "t":"Mark", "s":"Útgreining", "m":"Útgreinað marking"},
     "en": {"w":"Word","t":"Tag", "s":"Analysis", "m":"Expanded tags"},
@@ -41,24 +35,21 @@ UI = {
 
 MODEL_LINK = "https://huggingface.co/Setur/BRAGD"
 
-# Theme color: #89AFA9 (+ close shades) + system font
 CSS = """
 :root{
   --primary-500:#89AFA9; --primary-600:#6F9992; --primary-700:#5B7F79;
   --primary-100:#E1ECEA; --primary-200:#C6DAD6;
-  --page-bg: #f7f7f8;
+  --page-bg:#f7f7f8;
 }
 
-/* Force a consistent page background (and remove white "cards" where possible) */
-html, body{
-  background: var(--page-bg) !important;
-}
-.gradio-container{
+/* Page background */
+html, body, .gradio-container{
   background: var(--page-bg) !important;
 }
 body, .gradio-container, .prose, .markdown, textarea, input, select, button, table{
   font-family:-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Arial, "Noto Sans", sans-serif !important;
 }
+a{ color:var(--primary-700)!important; }
 
 /* Primary button */
 .gr-button-primary, button.primary, .primary{
@@ -67,105 +58,79 @@ body, .gradio-container, .prose, .markdown, textarea, input, select, button, tab
   color:#0b1b19!important;
 }
 .gr-button-primary:hover, button.primary:hover, .primary:hover{ background:var(--primary-600)!important; }
-a{ color:var(--primary-700)!important; }
+.gr-button-primary{ padding:0.35rem 0.85rem!important; font-size:0.95rem!important; }
 
-/* Remove "card" background around textbox wrapper; keep textarea readable */
+/* --- Make the entire left input area blend with page background --- */
+#input_col, #input_col *{
+  background: transparent !important;
+}
+#input_col .gr-block, #input_col .gr-panel, #input_col .gr-box, #input_col .gr-group, #input_col .gr-form{
+  background: transparent !important;
+  box-shadow:none !important;
+  border:0 !important;
+}
 #input_box, #input_box > div, #input_box .wrap, #input_box .container{
   background: transparent !important;
-  box-shadow: none !important;
-  border: 0 !important;
+  box-shadow:none !important;
+  border:0 !important;
 }
+/* Keep the actual typing area white */
 #input_box textarea{
-  background: #ffffff !important;
+  background:#ffffff !important;
 }
 
-/* Dataframe column wrapping: keep Orð + Mark on one line */
-.gr-dataframe table td:nth-child(1),
-.gr-dataframe table th:nth-child(1){
-  white-space: nowrap !important;
-  width: 18% !important;
+/* Dataframe columns: keep Orð + Mark single-line */
+.gr-dataframe table td:nth-child(1), .gr-dataframe table th:nth-child(1){
+  white-space: nowrap !important; width: 18% !important;
 }
-.gr-dataframe table td:nth-child(2),
-.gr-dataframe table th:nth-child(2){
-  white-space: nowrap !important;
-  width: 18% !important;
+.gr-dataframe table td:nth-child(2), .gr-dataframe table th:nth-child(2){
+  white-space: nowrap !important; width: 18% !important;
   font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace !important;
 }
-.gr-dataframe table td:nth-child(3),
-.gr-dataframe table th:nth-child(3){
-  white-space: normal !important;
-  width: 64% !important;
+.gr-dataframe table td:nth-child(3), .gr-dataframe table th:nth-child(3){
+  white-space: normal !important; width: 64% !important;
 }
 
-/* Results header: clean left-title / right-language bar (no white container blocks) */
+/* Results header row: no card backgrounds */
 #results_hdr{
   display:flex;
   align-items:center;
   justify-content:space-between;
-  gap: 12px;
-  padding: 0;
-  background: transparent !important;
+  gap:12px;
+  padding:0;
+  background:transparent !important;
 }
-#results_hdr *{
-  background: transparent !important;
-}
-#results_hdr .gr-block,
-#results_hdr .gr-form,
-#results_hdr .gr-box,
-#results_hdr .gr-panel,
-#results_hdr .gr-group{
-  background: transparent !important;
-  box-shadow: none !important;
-  border: 0 !important;
+#results_hdr .gr-block, #results_hdr .gr-panel, #results_hdr .gr-box, #results_hdr .gr-group, #results_hdr .gr-form{
+  background:transparent !important;
+  box-shadow:none !important;
+  border:0 !important;
 }
 
-/* Language toggle: segmented buttons, selected matches primary button */
-.lang_toggle{
-  display:flex;
-  justify-content:flex-end;
-  align-items:center;
-}
-.lang_toggle fieldset{
-  border: 0 !important;
-  padding: 0 !important;
-  margin: 0 !important;
-  background: transparent !important;
-}
-.lang_toggle .wrap{
-  display:flex !important;
-  gap: 10px !important;
-  background: transparent !important;
-}
-.lang_toggle input{
-  display:none !important; /* no cursor ever */
-}
-.lang_toggle label{
-  cursor:pointer;
-  padding: 9px 14px;
-  border-radius: 12px;
-  border: 1px solid rgba(0,0,0,.14);
-  background: transparent !important; /* match page background */
-  user-select:none;
-  font-size: 0.98rem;
-  box-shadow: none !important;
-}
-.lang_toggle label:hover{
-  border-color: rgba(0,0,0,.22);
-}
-.lang_toggle input:checked + span{
-  background: var(--primary-500) !important;
-  color:#0b1b19 !important;
-  border-radius: 12px;
-  padding: 9px 14px;
-  border: 1px solid var(--primary-600) !important;
+/* Language toggle: look like the Marka button */
+.lang_toggle fieldset{ border:0!important; padding:0!important; margin:0!important; background:transparent!important; }
+.lang_toggle .wrap{ display:flex!important; gap:10px!important; background:transparent!important; }
+.lang_toggle input{ display:none!important; }
+
+/* Base button style (same geometry as Marka button) */
+.lang_toggle label span{
   display:inline-block;
+  padding:0.35rem 0.85rem;
+  font-size:0.95rem;
+  border-radius:10px;
+  border:1px solid var(--primary-600);
+  background:transparent;
+  color:#0b1b19;
 }
 
-/* Slightly smaller primary button */
-.gr-button-primary{ padding: 0.35rem 0.85rem !important; font-size: 0.95rem !important; }
-
-/* Make the right-side title "Marka" slightly bigger */
-#info_panel h2{ margin-top: 0.2rem; }
+/* Selected = exactly like Marka button */
+.lang_toggle input:checked + span{
+  background:var(--primary-500)!important;
+  border-color:var(--primary-600)!important;
+  color:#0b1b19!important;
+}
+.lang_toggle label:hover span{
+  background:var(--primary-200);
+}
 """
 
 # ----------------------------
@@ -209,9 +174,6 @@ def group_from_col(col: str):
             return (g, col.split()[-1])
     return (None,None)
 
-# ----------------------------
-# Decode helpers (your logic)
-# ----------------------------
 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)}
@@ -230,23 +192,19 @@ def predict_vectors(logits, attention_mask, begin_tokens, dict_intervals, vec_le
     for idx in range(len(logits)):
         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]
             k = torch.argmax(softmax(seg)).item()
             vec[a+k]=1
-
         vectors.append(vec)
     return vectors
 
 # ----------------------------
-# Load labels (FO/EN)
+# Load labels
 # ----------------------------
 with open(LABELS_FILEPATH, "r", encoding="utf-8") as f:
     LABELS = json.load(f)
@@ -262,8 +220,7 @@ def label_for(lang: str, group: str, wc: str, code: str) -> str:
 def clean_label(s: str) -> str:
     s = (s or "").strip()
     s = re.sub(r"\s+", " ", s)
-    s = s.strip(" -;,:")
-    return s
+    return s.strip(" -;,:").strip()
 
 # ----------------------------
 # Load model + mapping
@@ -275,14 +232,12 @@ 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()
 
-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?")
+if hasattr(model, "config") and hasattr(model.config, "num_labels") and 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)
 
-# Build GROUPS from CSV headers
-GROUPS = defaultdict(list)  # group -> [(idx, code, colname)]
+GROUPS = defaultdict(list)
 for i,col in enumerate(FEATURE_COLS):
     g,code = group_from_col(col)
     if g and code not in HIDE_CODES.get(g, set()):
@@ -306,14 +261,7 @@ def group_code(vec: torch.Tensor, group: str) -> str:
             return code
     return ""
 
-# ----------------------------
-# Display rules
-# ----------------------------
-HIDE_IN_ANALYSIS = {
-    ("D", "subcategory", "G"),  # stýrir falli
-    ("D", "subcategory", "N"),  # stýrir ikki falli
-}
-
+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"},
@@ -324,20 +272,17 @@ def analysis_text(vec: torch.Tensor, lang: str) -> str:
     tag = vector_to_tag(vec)
     wc = wc_code(vec)
 
-    # DGd override
     if tag == "DGd":
         return "fyriseting" if lang=="fo" else "preposition"
 
     mood = group_code(vec, "mood")
-    if mood == "U":  # luttøkuháttur / supine
+    if mood == "U":
         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 = []
-
-    # Pronouns + conjunctions: subcategory already carries the head noun
     if wc in {"P","C"}:
         subc = group_code(vec, "subcategory")
         subl = clean_label(label_for(lang, "subcategory", wc, subc) or "")
@@ -356,13 +301,8 @@ def analysis_text(vec: torch.Tensor, lang: str) -> str:
             continue
         if (wc, g, c) in HIDE_IN_ANALYSIS:
             continue
-
-        lbl = label_for(lang, g, wc, c) or label_for(lang, g, "", c) or ""
-        lbl = clean_label(lbl)
-        if not lbl:
-            continue
-
-        if lbl not in parts:
+        lbl = clean_label(label_for(lang, g, wc, c) or label_for(lang, g, "", c) or "")
+        if lbl and lbl not in parts:
             parts.append(lbl)
 
     return ", ".join(parts)
@@ -371,24 +311,20 @@ def expanded_text(vec: torch.Tensor, lang: str) -> str:
     lang = "fo" if lang=="fo" else "en"
     wc = wc_code(vec)
     parts = []
-
     wc_lbl = label_for(lang, "word_class", wc, wc)
     parts.append(f"{wc} – {wc_lbl}" if wc_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([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:
@@ -396,7 +332,6 @@ def compute_codes_by_wc():
                 break
         if not wc:
             continue
-
         for g in GROUP_ORDER:
             hidden = HIDE_CODES.get(g, set())
             for idx,code,_ in GROUPS.get(g, []):
@@ -404,7 +339,6 @@ def compute_codes_by_wc():
                     continue
                 if arr[idx]==1:
                     codes[wc][g].add(code)
-
     return codes
 
 CODES_BY_WC = compute_codes_by_wc()
@@ -413,43 +347,29 @@ def build_overview(lang: str) -> str:
     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 ""
         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
             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:
                 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()
 
-# ----------------------------
-# Inference
-# ----------------------------
 def run_model(sentence: str):
     s = (sentence or "").strip()
     if not s:
@@ -457,24 +377,13 @@ 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=128,
-        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=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 = []
-    last = None
+    begin, last = [], None
     for wid in word_ids:
         if wid is None:
             begin.append(0)
@@ -489,9 +398,7 @@ def run_model(sentence: str):
 
     vectors = predict_vectors(logits, attention_mask[0], begin, DICT_INTERVALS, VEC_LEN)
 
-    rows = []
-    vec_i = 0
-    seen = set()
+    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:
             continue
@@ -506,41 +413,23 @@ def render(rows_state, lang: str):
     lang = "fo" if lang=="fo" else "en"
     df_cols = [UI[lang]["w"], UI[lang]["t"], UI[lang]["s"]]
     dfm_cols = [UI[lang]["w"], UI[lang]["t"], UI[lang]["m"]]
-
     if not rows_state:
-        empty_main = pd.DataFrame(columns=df_cols)
-        empty_mean = pd.DataFrame(columns=dfm_cols)
-        return empty_main, empty_mean, build_overview(lang)
-
+        return (pd.DataFrame(columns=df_cols), pd.DataFrame(columns=dfm_cols), build_overview(lang))
     out_main, out_mean = [], []
     for r in rows_state:
         vec = torch.tensor(r["vec"])
         tag = vector_to_tag(vec)
         out_main.append([r["word"], tag, analysis_text(vec, lang)])
         out_mean.append([r["word"], tag, expanded_text(vec, lang)])
+    return (pd.DataFrame(out_main, columns=df_cols), pd.DataFrame(out_mean, columns=dfm_cols), build_overview(lang))
 
-    return (
-        pd.DataFrame(out_main, columns=df_cols),
-        pd.DataFrame(out_mean, columns=dfm_cols),
-        build_overview(lang),
-    )
-
-# ----------------------------
-# Gradio UI
-# ----------------------------
 theme = gr.themes.Soft()
 
 with gr.Blocks(theme=theme, css=CSS, title="Marka") as demo:
-    # Layout: textbox left, info right, button under info
     with gr.Row(equal_height=True):
-        with gr.Column(scale=2):
-            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, elem_id="info_panel"):
+        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")
+        with gr.Column(scale=1, min_width=320):
             gr.Markdown(
                 "## Marka\n"
                 "Skriv ein setning í kassan og fá hann markaðan.\n\n"
@@ -550,9 +439,10 @@ with gr.Blocks(theme=theme, css=CSS, title="Marka") as demo:
 
     state = gr.State([])
 
-    # Results header row (always visible; table stays hidden until Tag)
-    with gr.Row(elem_id="results_hdr"):
-        gr.Markdown("### Úrslit / Results")
+    # Hide results header + toggle until Tag
+    results_hdr = gr.Row(elem_id="results_hdr", visible=False)
+    with results_hdr:
+        results_title = gr.Markdown("### Úrslit / Results")
         lang = gr.Radio(
             choices=[("Føroyskt","fo"), ("English","en")],
             value="fo",
@@ -562,27 +452,19 @@ with gr.Blocks(theme=theme, css=CSS, title="Marka") as demo:
 
     out_df = gr.Dataframe(
         value=pd.DataFrame(columns=[UI["fo"]["w"], UI["fo"]["t"], UI["fo"]["s"]]),
-        wrap=True,
-        interactive=False,
-        show_label=False,
-        row_count=(0, "fixed"),
-        col_count=(3, "fixed"),
+        wrap=True, interactive=False, show_label=False,
+        row_count=(0, "fixed"), col_count=(3, "fixed"),
         visible=False,
     )
 
-    # Expanded tags: hidden until tagged
     expanded_acc = gr.Accordion("Útgreinað marking / Expanded tags", open=False, visible=False)
     with expanded_acc:
         out_mean_df = gr.Dataframe(
             value=pd.DataFrame(columns=[UI["fo"]["w"], UI["fo"]["t"], UI["fo"]["m"]]),
-            wrap=True,
-            interactive=False,
-            show_label=False,
-            row_count=(0, "fixed"),
-            col_count=(3, "fixed"),
+            wrap=True, interactive=False, show_label=False,
+            row_count=(0, "fixed"), col_count=(3, "fixed"),
         )
 
-    # Markayvirlit: always visible
     overview_acc = gr.Accordion("Markayvirlit / Tag Overview", open=False, visible=True)
     with overview_acc:
         overview_md = gr.Markdown(build_overview("fo"))
@@ -596,20 +478,17 @@ with gr.Blocks(theme=theme, css=CSS, title="Marka") as demo:
             gr.update(value=df_mean),
             gr.update(value=overview),
             gr.update(visible=True),   # expanded_acc
+            gr.update(visible=True),   # results_hdr
         )
 
     def on_lang(rows, lang_choice):
         df_main, df_mean, overview = render(rows, lang_choice)
-        return (
-            gr.update(value=df_main),
-            gr.update(value=df_mean),
-            gr.update(value=overview),
-        )
+        return (gr.update(value=df_main), gr.update(value=df_mean), gr.update(value=overview))
 
     btn.click(
         on_tag,
         inputs=[inp, lang],
-        outputs=[state, out_df, out_mean_df, overview_md, expanded_acc],
+        outputs=[state, out_df, out_mean_df, overview_md, expanded_acc, results_hdr],
         queue=False,
     )