Update app.py

app.py

@@ -3,85 +3,102 @@ import sqlite3
 import pandas as pd
 import os
 import re
-import base64 # 추가됨
+import base64
 
 # 1️⃣ 저장소 설정
 UPLOAD_DIR = "uploaded_dbs"
 if not os.path.exists(UPLOAD_DIR):
-    os.makedirs(UPLOAD_DIR)
+    os.makedirs(UPLOAD_DIR)
 
 db_registry = []
 
-# BLOB 데이터를 Base64 HTML 이미지 태그로 변환하는 함수
+# BLOB 데이터를 Base64 HTML 이미지 태그로 변환
 def blob_to_base64_html(blob_data):
-    if blob_data is None:
-        return ""
-    try:
-        # 데이터가 이미 바이트 형태인지 확인 (b'\x89PNG' 등)
-        if isinstance(blob_data, bytes):
-            encoded_string = base64.b64encode(blob_data).decode('utf-8')
-            # 너비(width)는 원하시는 대로 조절하세요.
-            return f'<img src="data:image/png;base64,{encoded_string}" width="150" />'
-        return str(blob_data) # 바이트가 아니면 그냥 문자열로 반환
-    except:
-        return "[이미지 변환 에러]"
+    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" height="auto" />'
+        return str(blob_data)
+    except:
+        return str(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))]
+    if s is None: return []
+    return [int(text) if text.isdigit() else text.lower()
+            for text in re.split(r'(\d+)', str(s))]
 
 def refresh_registry_data():
-    global db_registry
-    db_registry = []
-    if not os.path.exists(UPLOAD_DIR): return []
-    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]
-            })
-    return sorted(list(set([db["standard"] for db in db_registry])))
+    global db_registry
+    db_registry = []
+    if not os.path.exists(UPLOAD_DIR): return []
+    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]
+            })
+    return sorted(list(set([db["standard"] for db in db_registry])))
 
 # 2️⃣ UI 업데이트 함수
 def on_load():
-    standards = refresh_registry_data()
-    return gr.Dropdown(choices=standards, value=None)
+    standards = refresh_registry_data()
+    return gr.Dropdown(choices=standards, value=None)
 
 def update_version_dd(standard):
-    if not standard: return gr.Dropdown(choices=[], value=None)
-    versions = sorted(list(set([db["version"] for db in db_registry if db["standard"] == standard])))
-    return gr.Dropdown(choices=versions, value=None)
+    if not standard: return gr.Dropdown(choices=[], value=None)
+    versions = sorted(list(set([db["version"] for db in db_registry if db["standard"] == standard])))
+    return gr.Dropdown(choices=versions, value=None)
 
 def update_category_dd(standard, version):
-    if not standard or not version: return gr.Dropdown(choices=[], value=None)
-    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"])
-        all_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 all_tables: main_t = all_tables[0]
-        
-        cols = pd.read_sql(f"PRAGMA table_info([{main_t}])", conn)['name'].tolist()
-        if 'chapter' in cols and 'category' in cols:
-            df_cat = pd.read_sql(f"SELECT DISTINCT chapter, category FROM [{main_t}]", conn)
-            cats = [f"{row['chapter']}.{row['category']}" for _, row in df_cat.iterrows()]
-            cats.sort(key=natural_sort_key)
-            choices.extend(cats)
-        
-        prefix = f"{standard}_{version}_"
-        sub_tables = [t.replace(prefix, "") for t in all_tables if t != main_t]
-        choices.extend(sorted(sub_tables))
-        conn.close()
-    except: pass
-    return gr.Dropdown(choices=choices, value=None)
-
-# 3️⃣ 데이터 조회 로직 (BLOB 처리 추가)
+    if not standard or not version: return gr.Dropdown(choices=[], value=None)
+    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"])
+        all_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 all_tables:
+            candidates = [t for t in all_tables if standard.lower() in t.lower() and version.lower() in t.lower()]
+            main_t = candidates[0] if candidates else all_tables[0]
+        
+        cols_info = pd.read_sql(f"PRAGMA table_info([{main_t}])", conn)
+        orig_cols = cols_info['name'].tolist()
+        lower_cols = [c.lower() for c in orig_cols]
+        
+        if 'chapter' in lower_cols and 'category' in lower_cols:
+            real_ch = orig_cols[lower_cols.index('chapter')]
+            real_cat = orig_cols[lower_cols.index('category')]
+            query = f"SELECT DISTINCT [{real_ch}], [{real_cat}] FROM [{main_t}] WHERE [{real_ch}] IS NOT NULL"
+            df_cat = pd.read_sql(query, conn)
+            
+            cats = []
+            for _, row in df_cat.iterrows():
+                val_ch = str(row[real_ch]).strip()
+                val_cat = str(row[real_cat]).strip()
+                if val_ch:
+                    cats.append(f"{val_ch}.{val_cat}")
+            
+            cats.sort(key=natural_sort_key)
+            choices.extend(cats)
+        
+        for t in all_tables:
+            if t == main_t: continue
+            clean_name = t.replace(f"{standard}_{version}_", "").replace(f"{standard}{version}_", "")
+            choices.append(clean_name)
+            
+        conn.close()
+    except:
+        pass
+    return gr.Dropdown(choices=choices, value=None)
+
+# 3️⃣ 데이터 조회 로직
 def display_data(standard, version, selection):
     if not all([standard, version, selection]): return None
     try:
@@ -90,67 +107,56 @@ def display_data(standard, version, selection):
         all_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 all_tables: main_t = all_tables[0]
+        if main_t not in all_tables:
+            candidates = [t for t in all_tables if standard.lower() in t.lower() and version.lower() in t.lower()]
+            main_t = candidates[0] if candidates else all_tables[0]
 
         is_sub_table = False 
         if selection == "ALL":
-            df = pd.read_sql(f"SELECT * FROM [{main_t}]", conn)
+            df = pd.read_sql(f"SELECT * FROM [{main_t}] ORDER BY rowid", conn)
         elif "." in selection:
             ch, ca = selection.split('.', 1)
-            df = pd.read_sql(f"SELECT * FROM [{main_t}] WHERE chapter=? AND category=?", conn, params=[ch, ca])
+            cols_info = pd.read_sql(f"PRAGMA table_info([{main_t}])", conn)
+            cols_lower = [c.lower() for c in cols_info['name'].tolist()]
+            real_ch = cols_info['name'].tolist()[cols_lower.index('chapter')]
+            real_cat = cols_info['name'].tolist()[cols_lower.index('category')]
+            
+            df = pd.read_sql(f"SELECT * FROM [{main_t}] WHERE CAST([{real_ch}] AS TEXT)=? AND CAST([{real_cat}] AS TEXT)=? ORDER BY rowid", 
+                             conn, params=[ch, ca])
         else:
             is_sub_table = True
-            actual_table = next((t for t in all_tables if t.endswith(selection)), selection)
-            df = pd.read_sql(f"SELECT * FROM [{actual_table}]", conn)
+            actual_table = next((t for t in all_tables if selection in t), selection)
+            df = pd.read_sql(f"SELECT * FROM [{actual_table}] ORDER BY rowid", conn)
         conn.close()
 
         if not df.empty:
-            # 1. 먼저 BLOB(이미지) 데이터를 HTML로 변환
             for col in df.columns:
                 df[col] = df[col].apply(blob_to_base64_html)
 
-            # 2. 정렬 로직 적용
-            sort_col = 'section' if 'section' in df.columns else df.columns[0]
-            df['sort_key'] = df[sort_col].apply(natural_sort_key)
-            df = df.sort_values(by='sort_key').drop(columns=['sort_key'])
-            
-            # 3. 💡 [열 필터링 로직]
             if not is_sub_table:
-                # 기본적으로 보여줄 열 정의
                 base_cols = [c for c in ['section', 'description'] if c in df.columns]
-                
-                # 만약 'image'나 'blob' 같은 다른 열에 이미지가 변환되어 들어갔다면 그 열도 포함
-                image_cols = [
-                    c for c in df.columns 
-                    if c not in base_cols and df[c].astype(str).str.contains('<img', na=False).any()
-                ]
-                
-                # 최종적으로 section, description + 이미지 열만 표시
-                df = df[base_cols + image_cols]
-            else:
-                # 부속 테이블(Table A 등)은 모든 열을 보여주되, 정렬용 임시 열만 제거
-                df = df[[c for c in df.columns if not c.startswith('sort_')]]
+                image_cols = [c for c in df.columns if c not in base_cols and '<img' in str(df[c].tolist())]
+                df = df[base_cols + [c for c in image_cols if c not in base_cols]]
                 
         return df
     except Exception as e:
         return pd.DataFrame({"Error": [f"조회 실패: {str(e)}"]})
-        
+
 # 4️⃣ UI 구성
-with gr.Blocks() as demo:
-    gr.Markdown("# 📜 Regulation Viewer (Image Support)")
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 📜 Regulation Viewer")
 
-    with gr.Row():
-        standard_dd = gr.Dropdown(label="1. 법규 선택")
-        version_dd = gr.Dropdown(label="2. Version 선택")
-        category_dd = gr.Dropdown(label="3. Category / Table 선택")
+    with gr.Row():
+        standard_dd = gr.Dropdown(label="1. 법규 선택")
+        version_dd = gr.Dropdown(label="2. Version 선택")
+        category_dd = gr.Dropdown(label="3. Category / Table 선택")
 
-    # 💡 [중요] datatype="html"을 추가하여 <img> 태그가 이미지로 보이게 함
-    output_df = gr.Dataframe(wrap=True, interactive=False, datatype="html")
+    output_df = gr.Dataframe(wrap=True, interactive=False, datatype="html")
 
-    demo.load(on_load, None, standard_dd)
-    standard_dd.change(update_version_dd, standard_dd, version_dd)
-    version_dd.change(update_category_dd, [standard_dd, version_dd], category_dd)
-    category_dd.change(display_data, [standard_dd, version_dd, category_dd], output_df)
+    demo.load(on_load, None, standard_dd)
+    standard_dd.change(update_version_dd, standard_dd, version_dd)
+    version_dd.change(update_category_dd, [standard_dd, version_dd], category_dd)
+    category_dd.change(display_data, [standard_dd, version_dd, category_dd], output_df)
 
 if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Soft())
+    demo.launch()