Update app.py

app.py

@@ -1,235 +1,49 @@
 import gradio as gr
 import pandas as pd
-import os
 
-try:
-    import docx
-except ImportError:
-    docx = None
+# Default codes
+CODES = ["Theme: Communication Barrier","Theme: Emotional Support"]
 
-# ------------------------------
-# CONFIGURATION
-# ------------------------------
-DEFAULT_CODES = [
-    "Theme: Communication Barrier",
-    "Theme: Emotional Support",
-    "Theme: Future Aspirations",
-    "Theme: Financial Stress",
-    "Other: Follow-up Needed",
-]
+# State
+coded_df_state = pd.DataFrame(columns=["Segment","Code"])
 
-METADATA_FIELDS = {
-    "interview_id": "Interview ID (e.g., I-001)",
-    "interview_date": "Date of Interview (YYYY-MM-DD)",
-    "occupation": "Participant Occupation",
-    "age": "Participant Age",
-}
-
-COLOR_MAP = {
-    "Theme: Communication Barrier": "lightblue",
-    "Theme: Emotional Support": "lightgreen",
-    "Theme: Future Aspirations": "khaki",
-    "Theme: Financial Stress": "lightpink",
-    "Other: Follow-up Needed": "orange",
-}
-
-# ------------------------------
-# FILE READERS
-# ------------------------------
-def read_docx(path):
-    if not docx:
-        return "Error: python-docx not installed."
-    d = docx.Document(path)
-    return "\n".join([p.text for p in d.paragraphs])
-
-def read_vtt(path):
-    with open(path, "r", encoding="utf-8") as f:
-        lines = f.read().split("\n")
-    cleaned = [
-        l.strip()
-        for l in lines
-        if l and "WEBVTT" not in l and "-->" not in l and not l.strip().isdigit()
-    ]
-    return " ".join(cleaned)
-
-def get_empty_df():
-    return pd.DataFrame(
-        columns=["File ID", "Coded Segment", "Code", "Context (100 chars)"] + list(METADATA_FIELDS.keys())
-    )
-
-# ------------------------------
-# PROCESS FILE
-# ------------------------------
-def process_file(file_obj):
-    if file_obj is None:
-        return "", "", get_empty_df()
-    path = file_obj.name
-    name = os.path.basename(path)
-    if name.lower().endswith(".docx"):
-        text = read_docx(path)
-    elif name.lower().endswith(".vtt"):
-        text = read_vtt(path)
-    else:
-        with open(path, "r", encoding="utf-8") as f:
-            text = f.read()
-    return text, name, get_empty_df()
-
-# ------------------------------
-# BUILD HTML TRANSCRIPT
-# ------------------------------
-def build_transcript_html(text, coded_df):
-    display_text = text
-    if coded_df is not None and not coded_df.empty:
-        for _, row in coded_df.iterrows():
-            seg = row["Coded Segment"]
-            color = COLOR_MAP.get(row["Code"], "yellow")
-            display_text = display_text.replace(seg, f"<span style='background-color:{color}'>{seg}</span>", 1)
-    safe_text = display_text.replace("\n", "<br>")
+# Build transcript HTML with JS to store selection
+def build_transcript_html(text):
     html = f"""
-    <div id='transcript' style='white-space: pre-wrap; font-size:16px; line-height:1.5; max-height:600px; overflow:auto; border:1px solid #ccc; padding:5px;'>
-        {safe_text}
-    </div>
+    <div id="transcript" style='white-space: pre-wrap; border:1px solid #ccc; padding:5px; max-height:400px; overflow:auto;'>{text}</div>
     <script>
-    const transcript = document.getElementById('transcript');
-    transcript.addEventListener('mouseup', function() {{
-        const selection = window.getSelection().toString();
-        if(selection.length>0){{
-            const tb = document.querySelector('textarea[placeholder="Selected segment"]');
-            if(tb) {{
-                tb.value = selection;
-                tb.dispatchEvent(new Event("input", {{bubbles:true}}));
-            }}
+    const transcript = document.getElementById("transcript");
+    transcript.addEventListener("mouseup", function() {{
+        const sel = window.getSelection().toString();
+        if(sel.length>0){{
+            document.querySelector("#selected_segment").value = sel;
         }}
     }});
     </script>
     """
     return html
 
-# ------------------------------
-# APPLY CODE
-# ------------------------------
-def apply_code(coded_df, file_id, full_text, segment, code, code_list, *metadata_values):
-    if not segment:
-        return coded_df, code_list, "⚠️ Select a segment first."
-    if not code:
-        return coded_df, code_list, "⚠️ Enter or select a code first."
-    if not file_id:
-        return coded_df, code_list, "⚠️ Upload a file first."
-
-    # Add new code to code list if not exists
-    if code not in code_list:
-        code_list.append(code)
-
-    meta_dict = dict(zip(METADATA_FIELDS.keys(), metadata_values))
-    context = "Context unavailable"
-    try:
-        n_full = " ".join(full_text.split())
-        n_seg = " ".join(segment.split())
-        idx = n_full.index(n_seg)
-        context = "..." + n_full[max(0, idx-100):idx]
-    except:
-        pass
-
-    new_row = {
-        "File ID": file_id,
-        "Coded Segment": segment,
-        "Code": code,
-        "Context (100 chars)": context,
-        **meta_dict
-    }
-    new_df = pd.concat([coded_df, pd.DataFrame([new_row])], ignore_index=True)
-    return new_df, code_list, f"✅ Segment coded as '{code}'!"
-
-# ------------------------------
-# EXPORT XLSX
-# ------------------------------
-def export_excel(df):
-    if df.empty:
-        return None, "Nothing to export."
-    path = "qualitative_codes.xlsx"
-    df.to_excel(path, index=False)
-    return path, "Excel ready."
-
-# ------------------------------
-# GRADIO INTERFACE
-# ------------------------------
-with gr.Blocks(title="Direct Selection Coding") as demo:
-    gr.Markdown("# 📑 Direct Selection Coding Tool")
-
-    # States
-    file_id = gr.State("")
-    full_text = gr.State("")
-    coded_df_state = gr.State(get_empty_df())
-    code_categories_state = gr.State(DEFAULT_CODES)
+# Apply code to selected segment
+def apply_code(selected_segment, code, df):
+    if not selected_segment or not code:
+        return df, "⚠️ Select segment and code first"
+    new_row = {"Segment": selected_segment, "Code": code}
+    df = pd.concat([df, pd.DataFrame([new_row])], ignore_index=True)
+    return df, f"✅ Segment coded as {code}"
 
-    # ---------------- METADATA TOP ----------------
-    with gr.Row():
-        metadata_inputs = []
-        for k, lbl in METADATA_FIELDS.items():
-            metadata_inputs.append(gr.Textbox(label=lbl))
+# Gradio interface
+with gr.Blocks() as demo:
+    transcript_text = "This is a sample transcript. You can select any part of this text to code it."
 
-    # ---------------- TRANSCRIPT + CODING ----------------
     with gr.Row():
-        # LEFT: transcript
         with gr.Column(scale=3):
-            transcript_html = gr.HTML()
-
-        # RIGHT: coding panel
+            transcript_html = gr.HTML(build_transcript_html(transcript_text))
         with gr.Column(scale=2):
-            gr.Markdown("## 🏷️ Code Categories")
-            code_input = gr.Textbox(label="Enter code or select from dropdown", value="", interactive=True)
-            code_dropdown = gr.Dropdown(label="Select existing code", choices=DEFAULT_CODES)
-            segment_box = gr.Textbox(label="Selected Segment", placeholder="Selected segment", lines=3, interactive=False)
+            selected_segment = gr.Textbox(label="Selected Segment", interactive=False, elem_id="selected_segment")
+            code_dropdown = gr.Dropdown(label="Select Code", choices=CODES)
             code_btn = gr.Button("Apply Code")
+            coded_table = gr.Dataframe(headers=["Segment","Code"])
 
-            gr.Markdown("## 📊 Coded Segments")
-            table = gr.Dataframe(interactive=False)
-
-            export_btn = gr.Button("Export XLSX")
-            export_file = gr.File(visible=False)
-
-            file_input = gr.File(label="Upload transcript (.docx, .vtt, .txt)", file_types=[".docx",".vtt",".txt"])
-            status = gr.Textbox(label="Status", value="Ready")
-
-    # ---------------- CALLBACKS ----------------
-    file_input.change(fn=process_file, inputs=file_input, outputs=[full_text, file_id, coded_df_state])
-
-    # Update transcript when text or coded_df changes
-    def update_transcript(text, df):
-        return build_transcript_html(text, df)
-
-    full_text.change(update_transcript, inputs=[full_text, coded_df_state], outputs=transcript_html)
-    coded_df_state.change(update_transcript, inputs=[full_text, coded_df_state], outputs=transcript_html)
-
-    # Fill code input when selecting dropdown
-    code_dropdown.change(lambda x: x, inputs=code_dropdown, outputs=code_input)
-
-    # Apply code
-    code_btn.click(
-        fn=apply_code,
-        inputs=[coded_df_state, file_id, full_text, segment_box, code_input, code_categories_state] + metadata_inputs,
-        outputs=[coded_df_state, code_categories_state, status]
-    )
-
-    # Update dropdown when code list changes
-    code_categories_state.change(lambda codes: gr.update(choices=codes), inputs=code_categories_state, outputs=code_dropdown)
-
-    # Update table
-    coded_df_state.change(lambda x: x, inputs=coded_df_state, outputs=table)
-
-    # Export
-    export_btn.click(
-        export_excel,
-        inputs=coded_df_state,
-        outputs=[export_file, status]
-    ).then(
-        lambda f: gr.update(visible=f is not None),
-        inputs=export_file,
-        outputs=export_file
-    )
+    code_btn.click(apply_code, inputs=[selected_segment, code_dropdown, coded_table], outputs=[coded_table, gr.Textbox(label="Status")])
 
-# ------------------------------
-# LAUNCH
-# ------------------------------
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()