save new rule integrated with cdss

cdss.py

@@ -307,12 +307,16 @@ def state_to_panels(state: PatientState) -> Tuple:
     )
 
 
-def inject_scenario(tag: str, cdss_on: bool, history_df: pd.DataFrame, historic_text: str):
+def inject_scenario(
+    tag: str, cdss_on: bool, history_df: pd.DataFrame, historic_text: str
+):
     ps = SCENARIOS[tag]()
-    if historic_text: # Add a newline if text already exists
+    if historic_text:  # Add a newline if text already exists
         historic_text += f"\n[{datetime.now().strftime('%H:%M:%S')}] Scenario Injected: {ps.scenario}"
     else:
-        historic_text = f"[{datetime.now().strftime('%H:%M:%S')}] Scenario Injected: {ps.scenario}"
+        historic_text = (
+            f"[{datetime.now().strftime('%H:%M:%S')}] Scenario Injected: {ps.scenario}"
+        )
     return process_and_update(ps, history_df, historic_text, cdss_on)
 
 
@@ -349,7 +353,7 @@ def manual_edit(
 
 def tick_timer(cdss_on, current_state, history_df, historic_text):
     if not current_state:
-        return [gr.update()] * 18
+        return [gr.update()] * 22
     ps = PatientState(**current_state)
     ps.vitals = Vitals(**ps.vitals)
     ps = drift_vitals(ps)
@@ -383,9 +387,8 @@ def countdown_tick(last_tick_ts: float):
 import json
 import ast
 
-import graphviz
 
-def parse_rules(return_json=False):
+def parse_rules():
     with open("rules.py", "r") as f:
         tree = ast.parse(f.read())
 
@@ -394,92 +397,132 @@ def parse_rules(return_json=False):
     for node in ast.walk(tree):
         if isinstance(node, ast.FunctionDef) and node.name == "rule_based_cdss":
             for body_item in node.body:
-                if isinstance(body_item, ast.If) and hasattr(body_item.test, 'left') and hasattr(body_item.test.left, 'id') and body_item.test.left.id == 'state':
-                    patient_type = body_item.test.comparators[0].s
+                if (
+                    isinstance(body_item, ast.If)
+                    and isinstance(body_item.test, ast.Compare)
+                    and isinstance(body_item.test.left, ast.Attribute)
+                    and isinstance(body_item.test.left.value, ast.Name)
+                    and body_item.test.left.value.id == "state"
+                    and body_item.test.left.attr == "patient_type"
+                    and isinstance(body_item.test.ops[0], ast.Eq)
+                    and isinstance(body_item.test.comparators[0], ast.Constant)
+                ):
+
+                    patient_type = body_item.test.comparators[0].value
                     if patient_type in rules:
                         for rule_node in body_item.body:
                             if isinstance(rule_node, ast.If):
                                 conditions = ast.unparse(rule_node.test)
                                 alert = ""
                                 for item in rule_node.body:
-                                    if (isinstance(item, ast.Expr) and
-                                        isinstance(item.value, ast.Call) and
-                                        hasattr(item.value.func, 'value') and
-                                        hasattr(item.value.func.value, 'id') and
-                                        item.value.func.value.id == 'alerts' and
-                                        item.value.func.attr == 'append'):
-                                        alert = item.value.args[0].s
-                                rules[patient_type].append({"conditions": conditions, "alert": alert})
-    
-    if return_json:
-        return rules
-
-    dot = graphviz.Digraph(comment='Rule Based CDSS')
-    dot.attr(rankdir='TB', splines='ortho')
-
-    for patient_type, rule_list in rules.items():
-        with dot.subgraph(name=f'cluster_{patient_type}') as c:
-            c.attr(label=patient_type, style='filled', color='lightgrey')
-            for i, rule in enumerate(rule_list):
-                c.node(f'{patient_type}_{i}_cond', rule['conditions'], shape='box')
-                c.node(f'{patient_type}_{i}_alert', rule['alert'], shape='plaintext')
-                c.edge(f'{patient_type}_{i}_cond', f'{patient_type}_{i}_alert')
-
-    return dot
-
-def save_rules(rules_json):
-    rules = json.loads(rules_json)
-    
-    # Read the original file
+                                    if (
+                                        isinstance(item, ast.Expr)
+                                        and isinstance(item.value, ast.Call)
+                                        and hasattr(item.value.func, "value")
+                                        and hasattr(item.value.func.value, "id")
+                                        and item.value.func.value.id == "alerts"
+                                        and item.value.func.attr == "append"
+                                        and isinstance(item.value.args[0], ast.Constant)
+                                    ):
+                                        alert = item.value.args[0].value
+                                rules[patient_type].append(
+                                    {"conditions": conditions, "alert": alert}
+                                )
+    return rules
+
+
+def rules_to_dataframes(rules):
+    dataframes = {}
+    for patient_type, rules_list in rules.items():
+        data = {"Conditions": [], "Alert": []}
+        for rule in rules_list:
+            data["Conditions"].append(rule["conditions"])
+            data["Alert"].append(rule["alert"])
+        df = pd.DataFrame(data)
+        dataframes[patient_type] = df
+    return dataframes
+
+
+def dataframes_to_rules(dfs):
+    rules = {"Mother": [], "Neonate": [], "Gyn": []}
+    for patient_type, df in dfs.items():
+        if df is not None:
+            for index, row in df.iterrows():
+                if row["Conditions"] and row["Alert"]:
+                    rules[patient_type].append(
+                        {"conditions": row["Conditions"], "alert": row["Alert"]}
+                    )
+    return rules
+
+
+def add_row(df):
+    if df is None:
+        df = pd.DataFrame(columns=["Conditions", "Alert"])
+    df.loc[len(df)] = ["", ""]
+    return df
+
+
+def save_rules(df_mother, df_neonate, df_gyn):
+    dfs = {"Mother": df_mother, "Neonate": df_neonate, "Gyn": df_gyn}
+    for patient_type, df in dfs.items():
+        if not isinstance(df, pd.DataFrame):
+            dfs[patient_type] = pd.DataFrame(df, columns=["Conditions", "Alert"])
+
+    rules = dataframes_to_rules(dfs)
+
     with open("rules.py", "r") as f:
         tree = ast.parse(f.read())
 
-    # Find the function definition
     for node in ast.walk(tree):
         if isinstance(node, ast.FunctionDef) and node.name == "rule_based_cdss":
-            # Clear the existing body
             node.body = []
-
-            # Add the initial variable assignments
             node.body.append(ast.parse("v = state.vitals").body[0])
             node.body.append(ast.parse("labs = state.labs").body[0])
             node.body.append(ast.parse("alerts = []").body[0])
 
-            # Add the rules
             for patient_type, rule_list in rules.items():
                 if_patient_type_body = []
                 for rule in rule_list:
-                    if_rule = ast.parse(f"if {rule['conditions']}:\n    alerts.append(\"{rule['alert']}\")").body[0]
+                    conditions = (
+                        rule["conditions"].replace("\r", " ").replace("\n", " ")
+                    )
+                    if_rule_str = f"if {conditions}:\n    alerts.append({json.dumps(rule['alert'])})"
+                    if_rule = ast.parse(if_rule_str).body[0]
                     if_patient_type_body.append(if_rule)
 
-                if_patient_type = ast.If(
-                    test=ast.Compare(
-                        left=ast.Attribute(value=ast.Name(id='state', ctx=ast.Load()), attr='patient_type', ctx=ast.Load()),
-                        ops=[ast.Eq()],
-                        comparators=[ast.Constant(value=patient_type)]
-                    ),
-                    body=if_patient_type_body,
-                    orelse=[]
-                )
-                node.body.append(if_patient_type)
+                if if_patient_type_body:
+                    if_patient_type = ast.If(
+                        test=ast.Compare(
+                            left=ast.Attribute(
+                                value=ast.Name(id="state", ctx=ast.Load()),
+                                attr="patient_type",
+                                ctx=ast.Load(),
+                            ),
+                            ops=[ast.Eq()],
+                            comparators=[ast.Constant(value=patient_type)],
+                        ),
+                        body=if_patient_type_body,
+                        orelse=[],
+                    )
+                    node.body.append(if_patient_type)
 
-            # Add the return statement
-            node.body.append(ast.parse("if not alerts:\n    return \"Tidak ada alert prioritas tinggi. Lanjutkan pemantauan dan dokumentasi.\"").body[0])
-            node.body.append(ast.parse("return \"\\n- \".join([\"ALERT:\"] + alerts)\"").body[0])
+            node.body.append(
+                ast.parse(
+                    'if not alerts:\n    return "Tidak ada alert prioritas tinggi. Lanjutkan pemantauan dan dokumentasi."'
+                ).body[0]
+            )
+            node.body.append(
+                ast.parse(
+                    'return "\\n- ".join(["ALERT:"] + alerts)', mode="single"
+                ).body[0]
+            )
 
-    # Unparse the modified AST
     new_code = ast.unparse(tree)
-
-    # Write the new code back to the file
     with open("rules.py", "w") as f:
         f.write(new_code)
 
     return "Rules saved successfully."
 
-def generate_and_display_rules():
-    dot = parse_rules()
-    dot.render('rules_visualization', format='svg', cleanup=True)
-    return 'rules_visualization.svg'
 
 # --- Build UI ---
 with gr.Blocks(
@@ -507,67 +550,57 @@ with gr.Blocks(
                             temp_plot = gr.Plot()
                         with gr.Tab("SpO₂"):
                             spo2_plot = gr.Plot()
-            with gr.Row():
-                with gr.Column(scale=2):
-                    with gr.Accordion("Inject New Scenario (resets chart)", open=True):
-                        with gr.Row():
-                            btn_A0 = gr.Button("A0: Normal", elem_classes="small-btn")
-                            btn_A1 = gr.Button("A1: PPH", elem_classes="small-btn")
-                            btn_A2 = gr.Button("A2: Preeklampsia", elem_classes="small-btn")
-                            btn_A3 = gr.Button("A3: Sepsis", elem_classes="small-btn")
-                        with gr.Row():
-                            btn_B1 = gr.Button("B1: Prematuritas", elem_classes="small-btn")
-                            btn_B2 = gr.Button("B2: Asfiksia", elem_classes="small-btn")
-                            btn_B3 = gr.Button("B3: Sepsis", elem_classes="small-btn")
-                        with gr.Row():
-                            btn_C1 = gr.Button("C1: Bedah Komplikasi", elem_classes="small-btn")
-                            btn_C2 = gr.Button(
-                                "C2: Infeksi Pasca-Bedah", elem_classes="small-btn"
-                            )
-                            btn_C3 = gr.Button("C3: Kanker", elem_classes="small-btn")
-                    notes = gr.Textbox(label="Catatan Klinis", lines=2)
-                    labs_text = gr.Textbox(label="Lab (dict or text)", value="{}")
-                    labs_show = gr.Textbox(label="Labs (Parsed)", interactive=False)
-                with gr.Column(scale=1):
-                    with gr.Group():
-                        patient_type_radio = gr.Radio(
-                            ["Mother", "Neonate", "Gyn"], label="Patient Type", value="Mother"
-                        )
-                        sbp = gr.Number(label="SBP")
-                        dbp = gr.Number(label="DBP")
-                        hr = gr.Number(label="HR")
-                        rr = gr.Number(label="RR")
-                        temp_c = gr.Number(label="Temp (°C)")
-                        spo2 = gr.Number(label="SpO₂ (%)")
-                    apply_manual = gr.Button("Apply Manual Edits", variant="secondary")
-            with gr.Row():
-                csv_file = gr.File(label="Load CSV to Graph")
-                df_view = gr.Dataframe(label="History Table", wrap=True, interactive=False)
-                cdss_toggle = gr.Checkbox(value=False, label="With CDSS (Gemini)")
-                scenario_lbl = gr.Textbox(label="Active Scenario", interactive=False)
-                countdown_lbl = gr.Label()
-                historic_box = gr.Textbox(label="Historic Text", lines=12, interactive=False)
-
-        with gr.TabItem("Rule Visualizer"):
-            gr.Markdown("## CDSS Rule Visualizer and Editor")
-    
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Current Rules Visualization")
-                    rules_display = gr.Image(interactive=False)
-                with gr.Column():
-                    gr.Markdown("### Edit Rules (JSON)")
-                    rules_editor = gr.Textbox(lines=20, label="Edit Rules in JSON format")
-                    save_button = gr.Button("Save Rules")
-
-            def update_editor_and_rules():
-                return generate_and_display_rules(), json.dumps(parse_rules(return_json=True), indent=2)
-
-            demo.load(update_editor_and_rules, None, [rules_display, rules_editor])
-            save_button.click(save_rules, inputs=rules_editor, outputs=gr.Textbox()).then(
-                update_editor_and_rules, None, [rules_display, rules_editor]
-            )
 
+        with gr.TabItem("Rule Editor"):
+            gr.Markdown("## CDSS Rule Editor")
+
+            initial_rules = parse_rules()
+            initial_dfs = rules_to_dataframes(initial_rules)
+
+            with gr.Tabs():
+                with gr.Tab("Mother"):
+                    df_mother = gr.DataFrame(
+                        value=initial_dfs["Mother"],
+                        headers=["Conditions", "Alert"],
+                        interactive=True,
+                        row_count=(len(initial_dfs["Mother"]) + 1, "dynamic"),
+                        type="pandas",
+                    )
+                    add_mother_btn = gr.Button("➕ Add Mother Rule")
+                    add_mother_btn.click(add_row, inputs=df_mother, outputs=df_mother)
+
+                with gr.Tab("Neonate"):
+                    df_neonate = gr.DataFrame(
+                        value=initial_dfs["Neonate"],
+                        headers=["Conditions", "Alert"],
+                        interactive=True,
+                        row_count=(len(initial_dfs["Neonate"]) + 1, "dynamic"),
+                        type="pandas",
+                    )
+                    add_neonate_btn = gr.Button("➕ Add Neonate Rule")
+                    add_neonate_btn.click(
+                        add_row, inputs=df_neonate, outputs=df_neonate
+                    )
+
+                with gr.Tab("Gyn"):
+                    df_gyn = gr.DataFrame(
+                        value=initial_dfs["Gyn"],
+                        headers=["Conditions", "Alert"],
+                        interactive=True,
+                        row_count=(len(initial_dfs["Gyn"]) + 1, "dynamic"),
+                        type="pandas",
+                    )
+                    add_gyn_btn = gr.Button("➕ Add Gyn Rule")
+                    add_gyn_btn.click(add_row, inputs=df_gyn, outputs=df_gyn)
+
+            save_button = gr.Button("💾 Save Rules")
+            status_textbox = gr.Textbox(label="Status", interactive=False)
+
+            save_button.click(
+                save_rules,
+                inputs=[df_mother, df_neonate, df_gyn],
+                outputs=status_textbox,
+            )
 
     with gr.Row():
         with gr.Column(scale=2):
@@ -669,7 +702,11 @@ with gr.Blocks(
             btn_C3,
         ],
     ):
-        btn.click(inject_scenario, [gr.State(tag), cdss_toggle, history_df, historic_text], ui_outputs)
+        btn.click(
+            inject_scenario,
+            [gr.State(tag), cdss_toggle, history_df, historic_text],
+            ui_outputs,
+        )
 
     csv_outputs = [history_df, df_view, bp_plot, hr_plot, rr_plot, temp_plot, spo2_plot]
     csv_file.change(load_csv, [csv_file, history_df], csv_outputs)

rules.py

@@ -5,25 +5,25 @@ def rule_based_cdss(state: PatientState) -> str:
     labs = state.labs
     alerts = []
     if state.patient_type == 'Mother':
-        if v.sbp < 100 and v.hr > 110 and ('Hb' in labs and labs['Hb'] <= 9 or state.scenario.startswith('A1')):
+        if v.sbp < 100 and v.hr > 110 and ('Hb' in labs and labs['Hb'] <= 9):
             alerts.append('PPH suspected: lakukan uterotonik, massage uterus, siapkan transfusi, monitoring 5 menit.')
-        if v.sbp >= 160 or v.dbp >= 110 or state.scenario.startswith('A2'):
-            alerts.append('no alert')
-        if v.temp_c >= 38.5 and v.sbp <= 100 or state.scenario.startswith('A3'):
+        if v.sbp >= 150 or v.dbp >= 110:
+            alerts.append('Preeklampsia')
+        if v.temp_c >= 38.5 and v.sbp <= 100:
             alerts.append('Sepsis maternal: kultur darah & luka, antibiotik spektrum luas dalam 1 jam, monitor MAP & urine.')
     if state.patient_type == 'Neonate':
-        if labs.get('BB', 9999) < 2500 or labs.get('UsiaGestasi_mgg', 99) < 37 or state.scenario.startswith('B1'):
+        if labs.get('BB', 9999) < 2500 or labs.get('UsiaGestasi_mgg', 99) < 37:
             alerts.append('Prematurity/BBLR')
-        if v.spo2 < 90 or v.hr < 100 or state.scenario.startswith('B2'):
+        if v.spo2 < 90 or v.hr < 100:
             alerts.append('Asfiksia: resusitasi neonatal sesuai NRP, ventilasi tekanan positif, evaluasi setiap 30 detik.')
-        if v.temp_c >= 38.0 and labs.get('CRP', 0) >= 10 or state.scenario.startswith('B3'):
+        if v.temp_c >= 38.0 and labs.get('CRP', 0) >= 10:
             alerts.append('Sepsis neonatal: kultur darah, antibiotik empiris NICU, monitor tanda vital ketat.')
     if state.patient_type == 'Gyn':
-        if state.scenario.startswith('C1') or labs.get('UrineOutput_ml_hr', 9999) < 20:
+        if labs.get('UrineOutput_ml_hr', 9999) < 20:
             alerts.append('Komplikasi pasca bedah (curiga ureter): evaluasi segera, USG/CT urografi, konsult urologi.')
-        if v.temp_c >= 38.0 and (state.scenario.startswith('C2') or labs.get('Luka') == 'bengkak+kemerahan'):
+        if v.temp_c >= 38.0 or labs.get('Luka') == 'bengkak+kemerahan':
             alerts.append('Infeksi pasca-bedah: kultur luka, antibiotik, pertimbangkan debridement.')
-        if state.scenario.startswith('C3') or labs.get('PapSmear', '').startswith('abnormal'):
+        if labs.get('PapSmear', '').startswith('abnormal'):
             alerts.append('Pap smear abnormal tanpa follow-up: lakukan kolposkopi & biopsi, aktifkan notifikasi rujukan.')
     if not alerts:
         return 'Tidak ada alert prioritas tinggi. Lanjutkan pemantauan dan dokumentasi.'

validator.py

@@ -0,0 +1,152 @@
+import gradio as gr
+import pandas as pd
+from models import PatientState, Vitals
+from rules import rule_based_cdss
+import json
+import ast
+
+
+def test_condition(
+    patient_type, sbp, dbp, hr, rr, temp_c, spo2, labs_text, condition, alert_text
+):
+    """
+    Tests a single condition against a manually defined patient state.
+    """
+    try:
+        labs = json.loads(labs_text)
+    except json.JSONDecodeError:
+        return "Error: Invalid JSON in Labs field."
+
+    vitals = Vitals(
+        sbp=int(sbp),
+        dbp=int(dbp),
+        hr=int(hr),
+        rr=int(rr),
+        temp_c=float(temp_c),
+        spo2=int(spo2),
+    )
+    state = PatientState(
+        scenario="Validation",
+        patient_type=patient_type,
+        notes="",
+        labs=labs,
+        vitals=vitals,
+    )
+
+    # Dynamically create a rule function for testing
+    rule_fnc_str = f"""
+def dynamic_rule(state):
+    v = state.vitals
+    labs = state.labs
+    alerts = []
+    if {condition}:
+        alerts.append("{alert_text}")
+    if not alerts:
+        return "No alert triggered."
+    return "\n- ".join(["ALERT:"] + alerts)
+"""
+    try:
+        exec(rule_fnc_str, globals())
+        result = dynamic_rule(state)
+        return result
+    except Exception as e:
+        return f"Error in condition syntax: {e}"
+
+
+def add_rule_to_set(patient_type, condition, alert_text):
+    """
+    Adds the new rule to the rules.py file.
+    """
+    if not condition or not alert_text:
+        return "Error: Condition and Alert text cannot be empty."
+
+    try:
+        with open("rules.py", "r") as f:
+            tree = ast.parse(f.read())
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) and node.name == "rule_based_cdss":
+                for body_item in node.body:
+                    if (
+                        isinstance(body_item, ast.If)
+                        and hasattr(body_item.test, "comparators")
+                        and body_item.test.comparators
+                        and isinstance(body_item.test.comparators[0], ast.Constant)
+                        and body_item.test.comparators[0].value == patient_type
+                    ):
+
+                        new_rule_str = (
+                            f'if {condition}:\n    alerts.append("{alert_text}")'
+                        )
+                        new_rule_node = ast.parse(new_rule_str).body[0]
+                        body_item.body.append(new_rule_node)
+                        break
+
+        new_code = ast.unparse(tree)
+        with open("rules.py", "w") as f:
+            f.write(new_code)
+
+        return f"Rule added to {patient_type} ruleset and saved to rules.py."
+
+    except Exception as e:
+        return f"Failed to add rule: {e}"
+
+
+def validator_tab():
+    with gr.TabItem("Rule Validator"):
+        gr.Markdown("## Validate and Add New Rules")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 1. Define Patient State")
+                patient_type_validate = gr.Radio(
+                    ["Mother", "Neonate", "Gyn"], label="Patient Type", value="Mother"
+                )
+                sbp_validate = gr.Number(label="SBP", value=120)
+                dbp_validate = gr.Number(label="DBP", value=80)
+                hr_validate = gr.Number(label="HR", value=80)
+                rr_validate = gr.Number(label="RR", value=18)
+                temp_c_validate = gr.Number(label="Temp (°C)", value=37.0)
+                spo2_validate = gr.Number(label="SpO₂ (%)", value=98)
+                labs_validate = gr.Textbox(
+                    label="Labs (JSON format)", value='{"Hb": 12.0}', lines=3
+                )
+
+            with gr.Column():
+                gr.Markdown("### 2. Define and Test Rule")
+                condition_validate = gr.Textbox(
+                    label="Condition (Python expression)", value="v.sbp > 140", lines=3
+                )
+                alert_validate = gr.Textbox(
+                    label="Alert Message", value="Preeclampsia suspected", lines=3
+                )
+                test_button = gr.Button("Test Rule", variant="secondary")
+                validation_result = gr.Textbox(
+                    label="Validation Result", interactive=False
+                )
+
+                gr.Markdown("### 3. Add Rule to Ruleset")
+                add_rule_button = gr.Button("Add Rule to Ruleset", variant="primary")
+                add_rule_status = gr.Textbox(label="Status", interactive=False)
+
+        test_button.click(
+            test_condition,
+            inputs=[
+                patient_type_validate,
+                sbp_validate,
+                dbp_validate,
+                hr_validate,
+                rr_validate,
+                temp_c_validate,
+                spo2_validate,
+                labs_validate,
+                condition_validate,
+                alert_validate,
+            ],
+            outputs=validation_result,
+        )
+
+        add_rule_button.click(
+            add_rule_to_set,
+            inputs=[patient_type_validate, condition_validate, alert_validate],
+            outputs=add_rule_status,
+        )

visualizer.py

@@ -1,184 +0,0 @@
-import gradio as gr
-import json
-import ast
-import pandas as pd
-
-
-def parse_rules():
-    with open("rules.py", "r") as f:
-        tree = ast.parse(f.read())
-
-    rules = {"Mother": [], "Neonate": [], "Gyn": []}
-
-    for node in ast.walk(tree):
-        if isinstance(node, ast.FunctionDef) and node.name == "rule_based_cdss":
-            for body_item in node.body:
-                if (
-                    isinstance(body_item, ast.If)
-                    and isinstance(body_item.test, ast.Compare)
-                    and isinstance(body_item.test.left, ast.Attribute)
-                    and isinstance(body_item.test.left.value, ast.Name)
-                    and body_item.test.left.value.id == "state"
-                    and body_item.test.left.attr == "patient_type"
-                    and isinstance(body_item.test.ops[0], ast.Eq)
-                    and isinstance(body_item.test.comparators[0], ast.Constant)
-                ):
-
-                    patient_type = body_item.test.comparators[0].value
-                    if patient_type in rules:
-                        for rule_node in body_item.body:
-                            if isinstance(rule_node, ast.If):
-                                conditions = ast.unparse(rule_node.test)
-                                alert = ""
-                                for item in rule_node.body:
-                                    if (
-                                        isinstance(item, ast.Expr)
-                                        and isinstance(item.value, ast.Call)
-                                        and hasattr(item.value.func, "value")
-                                        and hasattr(item.value.func.value, "id")
-                                        and item.value.func.value.id == "alerts"
-                                        and item.value.func.attr == "append"
-                                        and isinstance(item.value.args[0], ast.Constant)
-                                    ):
-                                        alert = item.value.args[0].value
-                                rules[patient_type].append(
-                                    {"conditions": conditions, "alert": alert}
-                                )
-    return rules
-
-
-def rules_to_dataframes(rules):
-    dataframes = {}
-    for patient_type, rules_list in rules.items():
-        data = {"Conditions": [], "Alert": []}
-        for rule in rules_list:
-            data["Conditions"].append(rule["conditions"])
-            data["Alert"].append(rule["alert"])
-        df = pd.DataFrame(data)
-        dataframes[patient_type] = df
-    return dataframes
-
-
-def dataframes_to_rules(dfs):
-    rules = {"Mother": [], "Neonate": [], "Gyn": []}
-    for patient_type, df in dfs.items():
-        if df is not None:
-            for index, row in df.iterrows():
-                if row["Conditions"] and row["Alert"]:
-                    rules[patient_type].append(
-                        {"conditions": row["Conditions"], "alert": row["Alert"]}
-                    )
-    return rules
-
-
-def add_row(df):
-    if df is None:
-        df = pd.DataFrame(columns=["Conditions", "Alert"])
-    df.loc[len(df)] = ["", ""]
-    return df
-
-
-def save_dataframes(df_mother, df_neonate, df_gyn):
-    dfs = {"Mother": df_mother, "Neonate": df_neonate, "Gyn": df_gyn}
-    rules = dataframes_to_rules(dfs)
-
-    with open("rules.py", "r") as f:
-        tree = ast.parse(f.read())
-
-    for node in ast.walk(tree):
-        if isinstance(node, ast.FunctionDef) and node.name == "rule_based_cdss":
-            node.body = []
-            node.body.append(ast.parse("v = state.vitals").body[0])
-            node.body.append(ast.parse("labs = state.labs").body[0])
-            node.body.append(ast.parse("alerts = []").body[0])
-
-            for patient_type, rule_list in rules.items():
-                if_patient_type_body = []
-                for rule in rule_list:
-                    conditions = (
-                        rule["conditions"].replace("\r", " ").replace("\n", " ")
-                    )
-                    if_rule_str = f"if {conditions}:\n    alerts.append({json.dumps(rule['alert'])})"
-                    if_rule = ast.parse(if_rule_str).body[0]
-                    if_patient_type_body.append(if_rule)
-
-                if if_patient_type_body:
-                    if_patient_type = ast.If(
-                        test=ast.Compare(
-                            left=ast.Attribute(
-                                value=ast.Name(id="state", ctx=ast.Load()),
-                                attr="patient_type",
-                                ctx=ast.Load(),
-                            ),
-                            ops=[ast.Eq()],
-                            comparators=[ast.Constant(value=patient_type)],
-                        ),
-                        body=if_patient_type_body,
-                        orelse=[],
-                    )
-                    node.body.append(if_patient_type)
-
-            node.body.append(
-                ast.parse(
-                    'if not alerts:\n    return "Tidak ada alert prioritas tinggi. Lanjutkan pemantauan dan dokumentasi."'
-                ).body[0]
-            )
-            node.body.append(
-                ast.parse(
-                    'return "\\n- ".join(["ALERT:"] + alerts)', mode="single"
-                ).body[0]
-            )
-
-    new_code = ast.unparse(tree)
-    with open("rules.py", "w") as f:
-        f.write(new_code)
-
-    return "Rules saved successfully."
-
-
-with gr.Blocks() as demo:
-    gr.Markdown("## CDSS Rule Editor")
-
-    initial_rules = parse_rules()
-    initial_dfs = rules_to_dataframes(initial_rules)
-
-    with gr.Tabs():
-        with gr.Tab("Mother"):
-            df_mother = gr.DataFrame(
-                value=initial_dfs["Mother"],
-                headers=["Conditions", "Alert"],
-                interactive=True,
-                row_count=(len(initial_dfs["Mother"]) + 1, "dynamic"),
-            )
-            add_mother_btn = gr.Button("➕ Add Mother Rule")
-            add_mother_btn.click(add_row, inputs=df_mother, outputs=df_mother)
-
-        with gr.Tab("Neonate"):
-            df_neonate = gr.DataFrame(
-                value=initial_dfs["Neonate"],
-                headers=["Conditions", "Alert"],
-                interactive=True,
-                row_count=(len(initial_dfs["Neonate"]) + 1, "dynamic"),
-            )
-            add_neonate_btn = gr.Button("➕ Add Neonate Rule")
-            add_neonate_btn.click(add_row, inputs=df_neonate, outputs=df_neonate)
-
-        with gr.Tab("Gyn"):
-            df_gyn = gr.DataFrame(
-                value=initial_dfs["Gyn"],
-                headers=["Conditions", "Alert"],
-                interactive=True,
-                row_count=(len(initial_dfs["Gyn"]) + 1, "dynamic"),
-            )
-            add_gyn_btn = gr.Button("➕ Add Gyn Rule")
-            add_gyn_btn.click(add_row, inputs=df_gyn, outputs=df_gyn)
-
-    save_button = gr.Button("💾 Save Rules")
-    status_textbox = gr.Textbox(label="Status", interactive=False)
-
-    save_button.click(
-        save_dataframes, inputs=[df_mother, df_neonate, df_gyn], outputs=status_textbox
-    )
-
-if __name__ == "__main__":
-    demo.launch()