Update app.py

app.py

@@ -6,7 +6,9 @@ import re
 import base64
 import difflib
 
+# --------------------------
 # 1️⃣ 저장소 설정
+# --------------------------
 UPLOAD_DIR = "uploaded_dbs"
 if not os.path.exists(UPLOAD_DIR):
     os.makedirs(UPLOAD_DIR)
@@ -14,15 +16,15 @@ if not os.path.exists(UPLOAD_DIR):
 db_registry = []
 
 # --------------------------
-# 유틸 함수
+# 유틸
 # --------------------------
 def blob_to_base64_html(blob_data):
     if blob_data is None or pd.isna(blob_data):
         return ""
     try:
         if isinstance(blob_data, (bytes, bytearray)):
-            encoded_string = base64.b64encode(blob_data).decode('utf-8')
-            return f'<img src="data:image/png;base64,{encoded_string}" width="200" />'
+            encoded = base64.b64encode(blob_data).decode('utf-8')
+            return f'<img src="data:image/png;base64,{encoded}" width="200" />'
         return str(blob_data)
     except:
         return str(blob_data)
@@ -30,39 +32,38 @@ def blob_to_base64_html(blob_data):
 def natural_sort_key(s):
     if s is None:
         return []
-    return [int(text) if text.isdigit() else text.lower()
-            for text in re.split(r'(\d+)', str(s))]
+    return [int(t) if t.isdigit() else t.lower()
+            for t in re.split(r'(\d+)', str(s))]
 
 def refresh_registry_data():
     global db_registry
     db_registry = []
-    db_files = [f for f in os.listdir(UPLOAD_DIR) if f.endswith(".db")]
 
-    for filename in db_files:
-        name_only = filename.replace(".db", "")
-        parts = name_only.split("_")
-        if len(parts) >= 2:
-            db_registry.append({
-                "path": os.path.join(UPLOAD_DIR, filename),
-                "standard": parts[0],
-                "version": parts[1]
-            })
+    for f in os.listdir(UPLOAD_DIR):
+        if f.endswith(".db"):
+            name = f.replace(".db", "")
+            parts = name.split("_")
+            if len(parts) >= 2:
+                db_registry.append({
+                    "path": os.path.join(UPLOAD_DIR, f),
+                    "standard": parts[0],
+                    "version": parts[1]
+                })
 
-    return sorted(list(set([db["standard"] for db in db_registry])))
+    return sorted(list(set([d["standard"] for d in db_registry])))
 
 # --------------------------
 # 드롭다운
 # --------------------------
 def on_load():
-    standards = refresh_registry_data()
-    return gr.Dropdown(choices=standards)
+    return gr.Dropdown(choices=refresh_registry_data())
 
 def update_version_dd(standard):
     if not standard:
         return gr.Dropdown(choices=[])
-    versions = sorted(list(set([
-        db["version"] for db in db_registry if db["standard"] == standard
-    ])))
+    versions = sorted(set(
+        d["version"] for d in db_registry if d["standard"] == standard
+    ))
     return gr.Dropdown(choices=versions)
 
 def update_category_dd(standard, version):
@@ -72,29 +73,25 @@ def update_category_dd(standard, version):
     choices = ["ALL"]
 
     try:
-        target_db = next(db for db in db_registry if db["standard"] == standard and db["version"] == version)
-        conn = sqlite3.connect(target_db["path"])
+        target = next(d for d in db_registry if d["standard"] == standard and d["version"] == version)
+        conn = sqlite3.connect(target["path"])
 
         tables = pd.read_sql("SELECT name FROM sqlite_master WHERE type='table';", conn)['name'].tolist()
         main_t = f"{standard}_{version}"
-
         if main_t not in tables:
             main_t = tables[0]
 
-        cols_info = pd.read_sql(f"PRAGMA table_info([{main_t}])", conn)
-        cols = cols_info['name'].tolist()
-        lower_cols = [c.lower() for c in cols]
+        cols = pd.read_sql(f"PRAGMA table_info([{main_t}])", conn)['name'].tolist()
+        lower = [c.lower() for c in cols]
 
-        if 'chapter' in lower_cols and 'category' in lower_cols:
-            ch = cols[lower_cols.index('chapter')]
-            ca = cols[lower_cols.index('category')]
+        if 'chapter' in lower and 'category' in lower:
+            ch = cols[lower.index('chapter')]
+            ca = cols[lower.index('category')]
 
             df = pd.read_sql(f"SELECT DISTINCT [{ch}], [{ca}] FROM [{main_t}]", conn)
 
-            for _, row in df.iterrows():
-                c = str(row[ch]).strip()
-                cat = str(row[ca]).strip()
-                choices.append(f"{c}.{cat}")
+            for _, r in df.iterrows():
+                choices.append(f"{str(r[ch]).strip()}.{str(r[ca]).strip()}")
 
         conn.close()
     except:
@@ -103,7 +100,7 @@ def update_category_dd(standard, version):
     return gr.Dropdown(choices=choices)
 
 # --------------------------
-# 초기화 함수
+# 초기화
 # --------------------------
 def reset_base():
     return None, None, None
@@ -112,51 +109,43 @@ def reset_comp():
     return None, None, None
 
 # --------------------------
-# 🔥 diff 함수
+# diff
 # --------------------------
-def highlight_diff(base_text, comp_text):
-    if pd.isna(base_text): base_text = ""
-    if pd.isna(comp_text): comp_text = ""
-
-    base_words = str(base_text).split()
-    comp_words = str(comp_text).split()
+def highlight_diff(base, comp):
+    base = "" if pd.isna(base) else str(base)
+    comp = "" if pd.isna(comp) else str(comp)
 
-    d = list(difflib.ndiff(base_words, comp_words))
+    b_words = base.split()
+    c_words = comp.split()
 
-    base_result = []
-    comp_result = []
+    d = list(difflib.ndiff(b_words, c_words))
 
+    b_res, c_res = [], []
     i = 0
+
     while i < len(d):
         code = d[i][0]
         word = d[i][2:]
 
         if code == ' ':
-            base_result.append(word)
-            comp_result.append(word)
-
-        elif code == '-' and i + 1 < len(d) and d[i + 1][0] == '+':
-            old_word = word
-            new_word = d[i + 1][2:]
-
-            base_result.append(f"<span style='color:#ff4d4f; font-weight:600'>{old_word}</span>")
-            comp_result.append(f"<span style='color:#ff4d4f; font-weight:600'>{new_word}</span>")
+            b_res.append(word)
+            c_res.append(word)
 
+        elif code == '-' and i+1 < len(d) and d[i+1][0] == '+':
+            new_word = d[i+1][2:]
+            b_res.append(f"<span style='color:#ff4d4f;font-weight:600'>{word}</span>")
+            c_res.append(f"<span style='color:#ff4d4f;font-weight:600'>{new_word}</span>")
             i += 1
 
         elif code == '-':
-            base_result.append(
-                f"<span style='color:#ff4d4f; font-weight:600'>{word}</span>"
-            )
+            b_res.append(f"<span style='color:#ff4d4f;font-weight:600'>{word}</span>")
 
         elif code == '+':
-            comp_result.append(
-                f"<span style='color:#2ecc71; font-weight:600'>{word}</span>"
-            )
+            c_res.append(f"<span style='color:#2ecc71;font-weight:600'>{word}</span>")
 
         i += 1
 
-    return " ".join(base_result), " ".join(comp_result)
+    return " ".join(b_res), " ".join(c_res)
 
 # --------------------------
 # 데이터 조회
@@ -164,51 +153,21 @@ def highlight_diff(base_text, comp_text):
 def display_data(standard, version, selection):
 
     if not all([standard, version, selection]):
-        return pd.DataFrame({"Info": ["선택을 완료하세요"]})
+        return pd.DataFrame({"Info": ["선택 필요"]})
 
     try:
-        target_db = next(db for db in db_registry if db["standard"] == standard and db["version"] == version)
-        conn = sqlite3.connect(target_db["path"])
+        target = next(d for d in db_registry if d["standard"] == standard and d["version"] == version)
+        conn = sqlite3.connect(target["path"])
 
         tables = pd.read_sql("SELECT name FROM sqlite_master WHERE type='table';", conn)['name'].tolist()
         main_t = f"{standard}_{version}"
-
         if main_t not in tables:
             main_t = tables[0]
 
-        cols_info = pd.read_sql(f"PRAGMA table_info([{main_t}])", conn)
-        cols = cols_info['name'].tolist()
-        lower_cols = [c.lower().strip() for c in cols]
-
-        real_ch, real_cat = None, None
-
-        for c, lc in zip(cols, lower_cols):
-            if lc == "chapter":
-                real_ch = c
-            elif lc == "category":
-                real_cat = c
-
-        if selection == "ALL":
-            df = pd.read_sql(f"SELECT * FROM [{main_t}]", conn)
-
-        elif "." in selection and real_ch and real_cat:
-            ch, ca = selection.split(".", 1)
-            df = pd.read_sql(
-                f"""
-                SELECT * FROM [{main_t}]
-                WHERE TRIM(CAST([{real_ch}] AS TEXT)) = ?
-                AND TRIM(CAST([{real_cat}] AS TEXT)) = ?
-                """,
-                conn,
-                params=[ch.strip(), ca.strip()]
-            )
-
-        else:
-            df = pd.read_sql(f"SELECT * FROM [{main_t}]", conn)
-
+        df = pd.read_sql(f"SELECT * FROM [{main_t}]", conn)
         conn.close()
 
-        if df is None or df.empty:
+        if df.empty:
             return pd.DataFrame({"Info": ["데이터 없음"]})
 
         df.columns = [c.lower().strip() for c in df.columns]
@@ -225,48 +184,67 @@ def display_data(standard, version, selection):
         return pd.DataFrame({"Error": [str(e)]})
 
 # --------------------------
-# 통합 조회
+# 🔥 통합 조회 (핵심 수정)
 # --------------------------
 def unified_search(bs, bv, bc, cs, cv, cc):
 
+    # ✅ 단일 조회
     if bs and bv and bc and not (cs and cv and cc):
-        return display_data(bs, bv, bc)
+        df = display_data(bs, bv, bc)
+
+        df = df.rename(columns={
+            "section": "Section",
+            "description": "Description"
+        })
+
+        return df
 
+    # ✅ 비교 조회
     if bs and bv and bc and cs and cv and cc:
 
         df_base = display_data(bs, bv, bc)
         df_comp = display_data(cs, cv, cc)
 
-        if df_base is None or df_comp is None:
-            return pd.DataFrame({"Error": ["데이터 없음"]})
-
         if 'section' not in df_base.columns or 'section' not in df_comp.columns:
-            return pd.DataFrame({"Error": ["section 컬럼 없음"]})
+            return pd.DataFrame({"Error": ["section 없음"]})
 
-        merged = pd.merge(df_base, df_comp, on="section", how="outer")
+        df_base = df_base.rename(columns={
+            "section": f"Section_{bv}",
+            "description": f"Description_{bv}"
+        })
 
-        merged = merged.rename(columns={
-            "description_x": f"Description_{bv}",
-            "description_y": f"Description_{cv}"
+        df_comp = df_comp.rename(columns={
+            "section": f"Section_{cv}",
+            "description": f"Description_{cv}"
         })
 
+        base_sec = f"Section_{bv}"
+        comp_sec = f"Section_{cv}"
         base_col = f"Description_{bv}"
         comp_col = f"Description_{cv}"
 
-        # 🔥 diff 적용
+        merged = pd.merge(
+            df_base,
+            df_comp,
+            left_on=base_sec,
+            right_on=comp_sec,
+            how="outer"
+        )
+
+        # diff 적용
         for idx, row in merged.iterrows():
             b, c = highlight_diff(row.get(base_col, ""), row.get(comp_col, ""))
             merged.at[idx, base_col] = b
             merged.at[idx, comp_col] = c
 
         merged = merged.sort_values(
-            by="section",
+            by=base_sec,
             key=lambda col: col.map(natural_sort_key)
         )
 
         return merged
 
-    return pd.DataFrame({"Info": ["선택을 완료하세요"]})
+    return pd.DataFrame({"Info": ["선택 필요"]})
 
 # --------------------------
 # UI
@@ -291,9 +269,6 @@ with gr.Blocks() as demo:
             comp_reset_btn = gr.Button("↺ 초기화")
 
     search_btn = gr.Button("🔍 조회")
-
-    gr.Markdown("### 📊 비교 결과")
-
     output_df = gr.Dataframe(wrap=True, interactive=False, datatype="html")
 
     demo.load(on_load, None, base_standard)
@@ -315,45 +290,39 @@ with gr.Blocks() as demo:
     base_reset_btn.click(reset_base, None, [base_standard, base_version, base_category])
     comp_reset_btn.click(reset_comp, None, [comp_standard, comp_version, comp_category])
 
+# --------------------------
 # 실행
+# --------------------------
 if __name__ == "__main__":
     demo.launch(
         theme=gr.themes.Soft(),
         share=True,
         css="""
-@import url('https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css');
-
-.gradio-container {
-    max-width: 100% !important;
-    font-family: 'Pretendard', sans-serif;
-}
-
-/* 테이블 고정 */
+/* 테이블 */
 table {
     table-layout: fixed !important;
     width: 100% !important;
 }
 
-/* section 고정 */
+/* 단일 조회 */
 th:nth-child(1), td:nth-child(1) {
-    width: 120px !important;
-    min-width: 120px !important;
-    max-width: 120px !important;
+    width: 20% !important;
+}
+th:nth-child(2), td:nth-child(2) {
+    width: 80% !important;
 }
 
-/* desc 2개 정확히 반반 */
-th:nth-child(2), td:nth-child(2),
-th:nth-child(3), td:nth-child(3) {
-    width: 50% !important;
+/* 비교 조회 (4컬럼) */
+th:nth-child(3), td:nth-child(3),
+th:nth-child(4), td:nth-child(4) {
+    width: 40% !important;
 }
 
-/* 헤더 고정 */
+/* header */
 thead th {
-    position: sticky !important;
+    position: sticky;
     top: 0;
-    background: white !important;
-    z-index: 2;
-    border-bottom: 2px solid #ddd;
+    background: white;
 }
 
 /* 스크롤 */