Update app.py

app.py

@@ -316,8 +316,18 @@ def fetch_database_records(standard, version, selection, table_type):
 
 def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, comp_cat):
     try:
-        is_main = base_cat == "ALL" or (base_cat and base_cat[0].isdigit() and "." in base_cat)
-        table_type = "Main" if is_main else base_cat
+        # [핵심 수정] 왼쪽(Base)과 오른쪽(Comp)의 타입을 각각 독립적으로 판단
+        def get_type_by_cat(cat):
+            if not cat: return "Main"
+            is_main = cat == "ALL" or (cat[0].isdigit() and "." in cat)
+            return "Main" if is_main else cat
+
+        type_b = get_type_by_cat(base_cat)
+        type_c = get_type_by_cat(comp_cat)
+        
+        # 각각의 기준 열(Anchor) 정보를 가져옴
+        anchor_col_b, _ = get_table_config(type_b)
+        anchor_col_c, _ = get_table_config(type_c)
 
         # 시각적 중복 제거 (폭포수 방식)
         def apply_visual_merge(df, cols):
@@ -326,176 +336,112 @@ def execute_unified_search(base_std, base_ver, base_cat, comp_std, comp_ver, com
                 for col in cols:
                     if col in df.columns:
                         curr = df[col].astype(str).str.strip()
-                        match = (curr == curr.shift(1)) & (~curr.isin(["", "nan", "None"]))
+                        match = (curr == curr.shift(1)) & (~curr.isin(["", "nan", "None", " "]))
                         is_dup = is_dup & match
-                        df.loc[is_dup, col] = ""
+                        df.loc[is_dup, col] = " "
             return df
 
-        # [핵심 추가] Code와 Description 컬럼을 시각적으로 위아래 병합
+        # Code/Description 결합 로직
         def combine_code_desc(df):
             cols = list(df.columns)
             new_cols = []
             processed = set()
-
             for col in cols:
                 if col in processed: continue
-                
-                # _Code 와 _Description 짝꿍 찾기
                 if "_Code" in col:
                     desc_col = col.replace("_Code", "_Description")
                     if desc_col in cols:
                         new_col_name = col.replace("_Code", "")
-                        
                         def combine_cells(row):
-                            c = str(row[col]).strip()
-                            d = str(row[desc_col]).strip()
-                            if c in ["nan", "None", ""]: return d
-                            if d in ["nan", "None", ""]: return f"<span style='font-weight:bold; color:#1a73e8;'>{c}</span>"
-                            
-                            # Code는 파란색 볼드체로, Description은 바로 아랫줄에 출력
+                            c, d = str(row[col]).strip(), str(row[desc_col]).strip()
+                            if c in ["nan", "None", "", "&nbsp;"]: return d
+                            if d in ["nan", "None", "", "&nbsp;"]: return f"<span style='font-weight:bold; color:#1a73e8;'>{c}</span>"
                             return f"<span style='font-weight:bold; color:#1a73e8; display:block; margin-bottom:4px;'>{c}</span>{d}"
-                            
                         df[new_col_name] = df.apply(combine_cells, axis=1)
                         new_cols.append(new_col_name)
-                        processed.add(col)
-                        processed.add(desc_col)
-                    else:
-                        new_cols.append(col)
+                        processed.update([col, desc_col])
+                    else: new_cols.append(col)
                 elif "_Description" in col:
-                    code_col = col.replace("_Description", "_Code")
-                    if code_col not in cols:
-                        new_cols.append(col)
-                else:
-                    new_cols.append(col)
-                    
+                    if col.replace("_Description", "_Code") not in cols: new_cols.append(col)
+                else: new_cols.append(col)
             return df[new_cols]
 
-        # ----------------------------------------
         # 1. 단일 조회
-        # ----------------------------------------
         if base_std and base_ver and base_cat and (not comp_std or not comp_ver or not comp_cat):
-            df, _ = fetch_database_records(base_std, base_ver, base_cat, table_type)
-            if "Error" in df.columns or "Info" in df.columns: return df
-            
-            df = combine_code_desc(df) # 결합 적용
+            df, _ = fetch_database_records(base_std, base_ver, base_cat, type_b)
+            if "Error" in df.columns: return df
+            df = combine_code_desc(df)
             return apply_visual_merge(df, df.columns)
 
-        # ----------------------------------------
-        # 2. 비교 조회 
-        # ----------------------------------------
+        # 2. 비교 조회 (서로 다른 타입 지원)
         if all([base_std, base_ver, base_cat, comp_std, comp_ver, comp_cat]):
-            df_base, real_anchors_b = fetch_database_records(base_std, base_ver, base_cat, table_type)
-            df_comp, real_anchors_c = fetch_database_records(comp_std, comp_ver, comp_cat, table_type)
+            df_base, real_anchors_b = fetch_database_records(base_std, base_ver, base_cat, type_b)
+            df_comp, real_anchors_c = fetch_database_records(comp_std, comp_ver, comp_cat, type_c)
 
             if "Error" in df_base.columns: return df_base
             if "Error" in df_comp.columns: return df_comp
 
-            for ra in real_anchors_b:
-                if ra not in df_base.columns: return pd.DataFrame({"Error": [f"기준 열 '{ra}'이 데이터에 없습니다."]})
-            for ra in real_anchors_c:
-                if ra not in df_comp.columns: return pd.DataFrame({"Error": [f"비교 열 '{ra}'이 데이터에 없습니다."]})
-
+            # 각자의 앵커 리스트를 사용하여 merge_key 생성
             df_base['merge_key'] = df_base[real_anchors_b].apply(lambda row: '-'.join(row.values.astype(str)), axis=1).str.replace(" ", "")
             df_comp['merge_key'] = df_comp[real_anchors_c].apply(lambda row: '-'.join(row.values.astype(str)), axis=1).str.replace(" ", "")
 
+            # 매핑 브릿지 로드
             conn_map = sqlite3.connect(os.path.join(UPLOAD_DIR, "mapping.db"))
-            query_fw = "SELECT Base_section, Comp_section FROM Mapping_table WHERE TRIM(Base_std)=? AND TRIM(Base_ver)=? AND TRIM(Comp_std)=? AND TRIM(Comp_ver)=?"
-            df_fw = pd.read_sql(query_fw, conn_map, params=[base_std.strip(), base_ver.strip(), comp_std.strip(), comp_ver.strip()])
-
-            query_rv = "SELECT Comp_section AS Base_section, Base_section AS Comp_section FROM Mapping_table WHERE TRIM(Comp_std)=? AND TRIM(Comp_ver)=? AND TRIM(Base_std)=? AND TRIM(Base_ver)=?"
-            df_rv = pd.read_sql(query_rv, conn_map, params=[base_std.strip(), base_ver.strip(), comp_std.strip(), comp_ver.strip()])
+            q = "SELECT Base_section, Comp_section FROM Mapping_table WHERE TRIM(Base_std)=? AND TRIM(Base_ver)=? AND TRIM(Comp_std)=? AND TRIM(Comp_ver)=?"
+            df_fw = pd.read_sql(q, conn_map, params=[base_std.strip(), base_ver.strip(), comp_std.strip(), comp_ver.strip()])
+            q_rv = "SELECT Comp_section AS Base_section, Base_section AS Comp_section FROM Mapping_table WHERE TRIM(Comp_std)=? AND TRIM(Comp_ver)=? AND TRIM(Base_std)=? AND TRIM(Base_ver)=?"
+            df_rv = pd.read_sql(q_rv, conn_map, params=[base_std.strip(), base_ver.strip(), comp_std.strip(), comp_ver.strip()])
             conn_map.close()
 
             df_mapping = pd.concat([df_fw, df_rv], ignore_index=True)
-
             if not df_mapping.empty:
-                df_mapping['Base_section'] = df_mapping['Base_section'].astype(str).str.replace('\n', ',').str.replace('\r', '')
-                df_mapping['Comp_section'] = df_mapping['Comp_section'].astype(str).str.replace('\n', ',').str.replace('\r', '')
-                df_mapping['Base_section'] = df_mapping['Base_section'].str.split(',')
-                df_mapping['Comp_section'] = df_mapping['Comp_section'].str.split(',')
+                df_mapping['Base_section'] = df_mapping['Base_section'].astype(str).str.replace('\n', ',').str.split(',')
+                df_mapping['Comp_section'] = df_mapping['Comp_section'].astype(str).str.replace('\n', ',').str.split(',')
                 df_mapping = df_mapping.explode('Base_section').explode('Comp_section')
-                df_mapping['Base_section'] = df_mapping['Base_section'].astype(str).str.strip().str.replace(" ", "")
-                df_mapping['Comp_section'] = df_mapping['Comp_section'].astype(str).str.strip().str.replace(" ", "")
-                df_mapping = df_mapping[(df_mapping['Base_section'] != '') & (df_mapping['Base_section'] != 'nan')]
-                df_mapping = df_mapping[(df_mapping['Comp_section'] != '') & (df_mapping['Comp_section'] != 'nan')]
-                df_mapping = df_mapping.drop_duplicates()
+                df_mapping[['Base_section', 'Comp_section']] = df_mapping[['Base_section', 'Comp_section']].apply(lambda x: x.str.strip().str.replace(" ", ""))
+                df_mapping = df_mapping.dropna().drop_duplicates()
             else:
                 df_mapping = pd.DataFrame(columns=['Base_section', 'Comp_section'])
 
-            explicit_b = set(df_mapping['Base_section'].dropna())
-            explicit_c = set(df_mapping['Comp_section'].dropna())
-
-            unmapped_b = set(df_base['merge_key']) - explicit_b
-            unmapped_c = set(df_comp['merge_key']) - explicit_c
-            implicit_keys = unmapped_b.intersection(unmapped_c)
-
-            df_implicit = pd.DataFrame({'Base_section': list(implicit_keys), 'Comp_section': list(implicit_keys)})
-            bridge = pd.concat([df_mapping, df_implicit], ignore_index=True)
+            # 암시적 매핑 (키가 완전히 똑같은 경우)
+            implicit = pd.DataFrame({'Base_section': list(set(df_base['merge_key']) & set(df_comp['merge_key'])), 
+                                     'Comp_section': list(set(df_base['merge_key']) & set(df_comp['merge_key']))})
+            bridge = pd.concat([df_mapping, implicit], ignore_index=True).drop_duplicates()
 
+            # 컬럼명 정리 및 병합
             rename_b = {c: f"{c}_{base_ver}" for c in df_base.columns if c != 'merge_key'}
             df_base = df_base.rename(columns=rename_b)
-            
             rename_c = {c: f"{c}_{comp_ver}" for c in df_comp.columns if c != 'merge_key'}
             df_comp = df_comp.rename(columns=rename_c)
 
-            df_base['base_idx'] = range(len(df_base))
-            df_comp['comp_idx'] = range(len(df_comp))
-
+            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')
             merged = pd.merge(merged, df_comp, left_on='Comp_section', right_on='merge_key', how='outer')
-
-            merged['base_idx'] = merged['base_idx'].fillna(float('inf'))
-            merged['comp_idx'] = merged['comp_idx'].fillna(float('inf'))
             merged = merged.sort_values(['base_idx', 'comp_idx'])
 
+            # 결과 행 조립 및 Diff
             result_rows = []
-            b_cols_renamed = list(rename_b.values())
-            c_cols_renamed = list(rename_c.values())
-
             for _, row in merged.iterrows():
                 row_dict = {}
-                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 b_cols_renamed:
-                    row_dict[c] = str(row.get(c)) if has_b and not pd.isna(row.get(c)) else ""
-                for c in c_cols_renamed:
-                    row_dict[c] = str(row.get(c)) if has_c and not pd.isna(row.get(c)) else ""
-
-                # Diff 처리 (Description 짝꿍 찾아서 하이라이팅)
+                has_b, has_c = not pd.isna(row.get('base_idx')), not pd.isna(row.get('comp_idx'))
+                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 ""
+                
                 if has_b and has_c:
                     for orig_col in rename_b.keys():
-                        if 'description' in orig_col.lower():
-                            b_col_name = rename_b[orig_col]
-                            c_col_name = rename_c.get(orig_col)
-                            
-                            if c_col_name and c_col_name in row_dict:
-                                b_val, c_val = row_dict[b_col_name], row_dict[c_col_name]
-                                if b_val and c_val and "<img" not in b_val and "<img" not in c_val and b_val != c_val:
-                                    row_dict[b_col_name], row_dict[c_col_name] = generate_html_diff(b_val, c_val)
-
+                        if 'description' in orig_col.lower() 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]]
+                            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)
                 result_rows.append(row_dict)
 
-            final_df = pd.DataFrame(result_rows)
-
-            # [핵심] Diff 처리된 데이터프레임의 Code와 Desc를 한 열로 병합!
-            final_df = combine_code_desc(final_df)
-
-            # 변경된 컬럼명 기준으로 좌/우 시각적 병합(Cascading Blanking) 따로 적용
-            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)
-
-            return final_df
-
-        return pd.DataFrame({"Info": ["조회 조건을 모두 선택해 주세요."] })
+            final_df = combine_code_desc(pd.DataFrame(result_rows))
+            return apply_visual_merge(final_df, final_df.columns)
 
+        return pd.DataFrame({"Info": ["조건을 선택하세요."]})
     except Exception as e:
-        import traceback
         traceback.print_exc()
-        return pd.DataFrame({"Error": [f"비교 조회 중 오류 발생: {str(e)}"]})
+        return pd.DataFrame({"Error": [str(e)]})
 
 
 # ==========================================