Update app.py

app.py

@@ -123,7 +123,6 @@ def fetch_database_records(std, ver, cat, table_type):
         
         real_anchors = [c for c in df.columns if any(a.lower() == c.lower() for a in anchors)]
         
-        # 💡 [핵심 해결] UI 텍스트박스에 Status가 표기되므로, 아래 표에서는 Status 열을 싹 지워줍니다.
         status_cols = [c for c in df.columns if c.lower() == 'status']
         if status_cols:
             df = df.drop(columns=status_cols)
@@ -255,27 +254,15 @@ def update_comp_standard_dropdown(base_std, base_ver):
         conn.close()
 
         mapped_stds = sorted(df['Comp_std'].dropna().unique().tolist()) if not df.empty else []
-        
-        if base_std not in mapped_stds:
-            mapped_stds.append(base_std)
-            mapped_stds.sort()
-            
         return gr.update(choices=mapped_stds, value=None, interactive=bool(mapped_stds))
     except Exception:
-        return gr.update(choices=[base_std], value=None, interactive=True)
+        return gr.update(choices=[], value=None, interactive=False)
 
 def update_comp_version_dropdown(base_std, base_ver, comp_std):
     if not all([base_std, base_ver, comp_std]):
         return gr.update(choices=[], value=None, interactive=False)
 
     try:
-        if base_std.strip() == comp_std.strip():
-            versions = []
-            for file_name in os.listdir(UPLOAD_DIR):
-                if file_name.startswith(comp_std + "_") and file_name.endswith(".db"):
-                    versions.append(file_name.replace(comp_std + "_", "").replace(".db", ""))
-            return gr.update(choices=sorted(list(set(versions))), value=None, interactive=True)
-
         conn = sqlite3.connect(os.path.join(UPLOAD_DIR, "mapping.db"))
         query = "SELECT DISTINCT TRIM(Comp_ver) AS Comp_ver FROM Mapping_registry WHERE TRIM(Base_std)=TRIM(?) AND TRIM(Base_ver)=TRIM(?) AND TRIM(Comp_std)=TRIM(?)"
         df = pd.read_sql(query, conn, params=[base_std, base_ver, comp_std])
@@ -315,33 +302,6 @@ def update_comp_category_dropdown(base_std, base_ver, base_cat, comp_std, comp_v
                     pass
             c_conn.close()
 
-        if base_std.strip() == comp_std.strip():
-            final_choices = ["ALL"]
-            if os.path.exists(comp_db_path) and c_main_table:
-                c_conn = sqlite3.connect(comp_db_path)
-                cols = pd.read_sql(f"PRAGMA table_info([{c_main_table}])", c_conn)['name'].tolist()
-                lower_cols = [c.lower() for c in cols]
-                if 'chapter' in lower_cols and 'category' in lower_cols:
-                    ch_col = cols[lower_cols.index('chapter')]
-                    ca_col = cols[lower_cols.index('category')]
-                    c_df = pd.read_sql(f"SELECT DISTINCT [{ch_col}], [{ca_col}] FROM [{c_main_table}]", c_conn)
-                    for _, row in c_df.iterrows():
-                        ch = str(row[ch_col]).strip()
-                        ca = str(row[ca_col]).strip()
-                        if ch and ca and ch.lower() not in ['none', 'nan'] and ca.lower() not in ['none', 'nan']:
-                            final_choices.append(f"{ch}.{ca}")
-                
-                pattern = re.compile(f"^{comp_std}[_\\s-]*{comp_ver}[_\\s-]*", re.IGNORECASE)
-                for t in c_valid_tables:
-                    if t == c_main_table: continue
-                    short_name = pattern.sub("", t).strip(" _")
-                    if short_name and short_name not in final_choices:
-                        final_choices.append(short_name)
-                    elif t not in final_choices:
-                        final_choices.append(t)
-                c_conn.close()
-            return gr.update(choices=final_choices, value=final_choices[0] if final_choices else None, interactive=True), gr.update(value=status_value)
-
         conn = sqlite3.connect(os.path.join(UPLOAD_DIR, "mapping.db"))
         query = """
         SELECT DISTINCT TRIM(Comp_Type) AS Comp_Type 
@@ -460,9 +420,8 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
                     s = s[:-2]
                 return s.replace(" ", "")
 
-            # 💡 [해결 1] 같은 이름 충돌 방지: 병합 전 각각 (기준), (비교) 태그를 달아줍니다.
-            rename_b = {c: f"{c}_{base_ver}(기준)" for c in df_base.columns if c != 'merge_key'}
-            rename_c = {c: f"{c}_{comp_ver}(비교)" for c in df_comp.columns if c != 'merge_key'}
+            internal_rename_b = {c: f"{c}_INTERNAL_BASE" for c in df_base.columns if c != 'merge_key'}
+            internal_rename_c = {c: f"{c}_INTERNAL_COMP" for c in df_comp.columns if c != 'merge_key'}
             
             df_base['merge_key'] = df_base[real_anchors_b].apply(lambda row: '-'.join([clean_key_val(x) for x in row]), axis=1)
             df_comp['merge_key'] = df_comp[real_anchors_c].apply(lambda row: '-'.join([clean_key_val(x) for x in row]), axis=1)
@@ -495,7 +454,7 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
                     df_rv = pd.read_sql(q_rv, conn_map, params=[base_std.strip(), base_ver.strip(), comp_std.strip(), comp_ver.strip()])
                 except Exception as sql_e:
                     conn_map.close()
-                    return pd.DataFrame({"Error": [f"매핑 장부 '{target_table_name}'을 여는 데 실패했습니다. 테이블 이름을 확인하세요: {str(sql_e)}"]})
+                    return pd.DataFrame({"Error": [f"매핑 '{target_table_name}'을 여는 데 실패했습니다. 테이블 이름을 확인하세요: {str(sql_e)}"]})
                 conn_map.close()
 
                 cols_fw_lower = {c.lower(): c for c in df_fw.columns}
@@ -517,7 +476,7 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
                 c_sec = cols_fw_lower.get('comp_section', 'Comp_section')
                 
                 if b_sec not in df_fw.columns or c_sec not in df_fw.columns:
-                    return pd.DataFrame({"Error": [f"'{target_table_name}' 장부에 '{b_sec}' 또는 '{c_sec}' 열이 없습니다. 대소문자를 확인하세요."]})
+                    return pd.DataFrame({"Error": [f"'{target_table_name}' 에 '{b_sec}' 또는 '{c_sec}' 열이 없습니다. 대소문자를 확인하세요."]})
                 
                 df_fw = df_fw[[b_sec, c_sec]].rename(columns={b_sec: 'Base_section', c_sec: 'Comp_section'})
                 if not df_rv.empty:
@@ -540,8 +499,8 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
                 else:
                     bridge = pd.DataFrame(columns=['Base_section', 'Comp_section'])
 
-            df_base = df_base.rename(columns=rename_b)
-            df_comp = df_comp.rename(columns=rename_c)
+            df_base = df_base.rename(columns=internal_rename_b)
+            df_comp = df_comp.rename(columns=internal_rename_c)
 
             df_base['base_idx'], df_comp['comp_idx'] = range(len(df_base)), range(len(df_comp))
             merged = pd.merge(bridge, df_base, left_on='Base_section', right_on='merge_key', how='outer')
@@ -557,22 +516,21 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
                 has_b = not pd.isna(row.get('base_idx')) and row.get('base_idx') != float('inf')
                 has_c = not pd.isna(row.get('comp_idx')) and row.get('comp_idx') != float('inf')
                 
-                for c in rename_b.values(): row_dict[c] = str(row[c]) if has_b and not pd.isna(row[c]) else ""
-                for c in rename_c.values(): row_dict[c] = str(row[c]) if has_c and not pd.isna(row[c]) else ""
+                for c in internal_rename_b.values(): row_dict[c] = str(row[c]) if has_b and not pd.isna(row[c]) else ""
+                for c in internal_rename_c.values(): row_dict[c] = str(row[c]) if has_c and not pd.isna(row[c]) else ""
                 
                 if mapped_only:
-                    b_has_val = any(str(row_dict[c]).strip() not in ["", "nan", "None", " "] for c in rename_b.values())
-                    c_has_val = any(str(row_dict[c]).strip() not in ["", "nan", "None", " "] for c in rename_c.values())
-                    
+                    b_has_val = any(str(row_dict[c]).strip() not in ["", "nan", "None", " "] for c in internal_rename_b.values())
+                    c_has_val = any(str(row_dict[c]).strip() not in ["", "nan", "None", " "] for c in internal_rename_c.values())
                     if not (b_has_val and c_has_val):
                         continue
                 
                 if has_b and has_c:
-                    for orig_col in rename_b.keys():
-                        if ('description' in orig_col.lower() or '내용' in orig_col) and rename_c.get(orig_col) in row_dict:
-                            b_v, c_v = row_dict[rename_b[orig_col]], row_dict[rename_c[orig_col]]
+                    for orig_col in internal_rename_b.keys():
+                        if ('description' in orig_col.lower() or '내용' in orig_col) and internal_rename_c.get(orig_col) in row_dict:
+                            b_v, c_v = row_dict[internal_rename_b[orig_col]], row_dict[internal_rename_c[orig_col]]
                             if b_v and c_v and "<img" not in b_v and "<img" not in c_v and b_v != c_v:
-                                row_dict[rename_b[orig_col]], row_dict[rename_c[orig_col]] = generate_html_diff(b_v, c_v)
+                                row_dict[internal_rename_b[orig_col]], row_dict[internal_rename_c[orig_col]] = generate_html_diff(b_v, c_v)
                 result_rows.append(row_dict)
 
             final_df = combine_code_desc(pd.DataFrame(result_rows))
@@ -586,9 +544,17 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
                 if final_df.empty:
                     return pd.DataFrame({"Info": ["💡 선택하신 조건 간에 변경된 내용이 없습니다. (100% 동일)"]})
             
-            # 💡 [해결 1 호환] 새롭게 지정한 (기준), (비교) 태그로 병합 셀 처리
-            b_cols_final = [c for c in final_df.columns if c.endswith(f"_{base_ver}(기준)")]
-            c_cols_final = [c for c in final_df.columns if c.endswith(f"_{comp_ver}(비교)")]
+            final_rename_map = {}
+            for col in final_df.columns:
+                if col.endswith("_INTERNAL_BASE"):
+                    final_rename_map[col] = f"{col.replace('_INTERNAL_BASE', '')}_{base_ver}"
+                elif col.endswith("_INTERNAL_COMP"):
+                    final_rename_map[col] = f"{col.replace('_INTERNAL_COMP', '')}_{comp_ver}"
+            
+            final_df = final_df.rename(columns=final_rename_map)
+
+            b_cols_final = [c for c in final_df.columns if c.endswith(f"_{base_ver}")]
+            c_cols_final = [c for c in final_df.columns if c.endswith(f"_{comp_ver}")]
 
             final_df = apply_visual_merge(final_df, b_cols_final)
             final_df = apply_visual_merge(final_df, c_cols_final)