Update app.py

app.py

@@ -3,18 +3,16 @@ import pandas as pd
 import io, zipfile, re, html, json
 from typing import Dict, Tuple
 
-st.set_page_config(page_title="📦 박스라벨(HWPX) — 완전 치환", layout="wide")
-st.title("📦 박스라벨 자동 생성기 — HWPX 필드·토큰·텍스트 자리표시자 완전 치환")
+st.set_page_config(page_title="📦 박스라벨(HWPX) — 문단 단위 완전 치환", layout="wide")
+st.title("📦 박스라벨 자동 생성기 — HWPX 필드·토큰·텍스트 완전 치환(문단 단위)")
 
-# ================== 데이터 유틸 ==================
+# -------------------- 데이터 유틸 --------------------
 def _year_range(series: pd.Series) -> str:
     s = series.astype(str).fillna("")
     v = s[~s.isin(["", "0", "0000"])]
-    if v.empty:
-        return "0000-0000"
+    if v.empty: return "0000-0000"
     nums = pd.to_numeric(v, errors="coerce").dropna().astype(int)
-    if nums.empty:
-        return "0000-0000"
+    if nums.empty: return "0000-0000"
     return f"{nums.min():04d}-{nums.max():04d}"
 
 def build_rows(df: pd.DataFrame) -> pd.DataFrame:
@@ -34,68 +32,89 @@ def build_rows(df: pd.DataFrame) -> pd.DataFrame:
     has_mgmt = "관리번호" in df.columns
     lists = []
     for b, g in df.groupby("박스번호"):
-        lines = [
-            f"- {r['관리번호']} {r.get('제목','')}" if has_mgmt else f"- {r.get('제목','')}"
-            for _, r in g.iterrows()
-        ]
+        lines = [f"- {r['관리번호']} {r.get('제목','')}" if has_mgmt else f"- {r.get('제목','')}"
+                 for _, r in g.iterrows()]
         lists.append({"박스번호": b, "목록": "\r\n".join(lines)})
     list_df = pd.DataFrame(lists)
 
     # 대표 메타
-    meta_cols = ["박스번호", "종료연도", "보존기간", "단위업무", "기록물철", "제목"]
+    meta_cols = ["박스번호","종료연도","보존기간","단위업무","기록물철","제목"]
     meta_exist = [c for c in meta_cols if c in df.columns]
-    meta = (
-        df.groupby("박스번호", as_index=False).first()[meta_exist]
-        if meta_exist
-        else pd.DataFrame({"박스번호": df["박스번호"].unique()})
-    )
+    meta = df.groupby("박스번호", as_index=False).first()[meta_exist] if meta_exist \
+          else pd.DataFrame({"박스번호": df["박스번호"].unique()})
 
     merged = meta.merge(list_df, on="박스번호", how="left").merge(yr, on="박스번호", how="left")
     return merged
 
-# ================== 치환 유틸 ==================
-# 1) 접두어 와일드카드: <hp:..> 뿐 아니라 <hwp:..>, <h:..> 등 모두 허용
+# -------------------- 치환 유틸 --------------------
 FIELD_PAIR_RE_TMPL = (
-    r'<(?P<prefix>[a-zA-Z0-9_]+):fieldBegin\b[^>]*\bname="{name}"[^>]*/>'
+    r'<(?P<fprefix>[a-zA-Z0-9_]+):fieldBegin\b[^>]*\bname="{name}"[^>]*/>'
     r'(.*?)'
-    r'<(?P=prefix):fieldEnd\b[^>]*/>'
+    r'<(?P=fprefix):fieldEnd\b[^>]*/>'
 )
-
-# 2) 토큰(백업 경로)
 TOKEN_FMT = "{{{{{key}}}}}"
 
-# 3) 순수 텍스트 자리표시자: <hp:run>…<hp:t>키</hp:t>…</hp:run> 전체를 값 run들로 교체
-TEXT_RUN_RE_TMPL = (
-    r'(<(?P<prefix>[a-zA-Z0-9_]+):run\b[^>]*>\s*'
-    r'(?:<(?P=prefix):t[^>]*>)\s*)'
-    r'{name}'
-    r'(\s*(?:</(?P=prefix):t>)\s*</(?P=prefix):run>)'
+# 문단(<*:p>) 탐색 패턴
+PARA_RE = re.compile(
+    r'<(?P<pprefix>[a-zA-Z0-9_]+):p(?P<pattrs>[^>]*)>(?P<pbody>.*?)</(?P=pprefix):p>',
+    re.DOTALL
 )
 
-def _runs_plain(text: str) -> str:
-    return f"<hp:run><hp:t>{html.escape('' if text is None else str(text))}</hp:t></hp:run>"
+# 문단 하나를 같은 스타일로 복제해주는 헬퍼
+def _make_para(pprefix: str, pattrs: str, text: str) -> str:
+    esc = html.escape("" if text is None else str(text))
+    return f'<{pprefix}:p{pattrs}><{pprefix}:run><{pprefix}:t>{esc}</{pprefix}:t></{pprefix}:run></{pprefix}:p>'
+
+def _split_lines(val) -> list:
+    if val is None: return [""]
+    return str(val).replace("\r\n","\n").split("\n")
 
-def _runs_multiline(text: str) -> str:
+def _replace_para_multiline(xml: str, key: str, value: str, dbg: dict) -> str:
     """
-    다중 줄 텍스트를 안전하게 표시:
-      - 각 줄을 아예 독립 <hp:p> 문단으로 생성
+    key가 포함된 '부모 문단 전체'를, 값의 각 줄을 담은 여러 문단으로 교체.
+    - fieldBegin/End, <*:t>키</*:t>, {{키}} 모두 감지
     """
-    if text is None:
-        return ""
-    lines = str(text).replace("\r\n", "\n").split("\n")
-    parts = []
-    for ln in lines:
-        escaped = html.escape(ln)
-        parts.append(f"<hp:p><hp:run><hp:t>{escaped}</hp:t></hp:run></hp:p>")
-    return "".join(parts)
+    pair_pat = re.compile(FIELD_PAIR_RE_TMPL.format(name=re.escape(key)), re.DOTALL)
+    tnode_pat = re.compile(rf'<(?P<p>[a-zA-Z0-9_]+):t[^>]*>[^<]*{re.escape(key)}[^<]*</(?P=p):t>', re.DOTALL)
+    token_str = TOKEN_FMT.format(key=key)
+
+    def para_repl(m):
+        body = m.group("pbody")
+        if not (pair_pat.search(body) or tnode_pat.search(body) or (token_str in body)):
+            return m.group(0)
+
+        lines = _split_lines(value)
+        pprefix = m.group("pprefix")
+        pattrs  = m.group("pattrs")
+        new_paras = "".join(_make_para(pprefix, pattrs, ln) for ln in lines)
+        dbg["para_hits"][key] = dbg["para_hits"].get(key, 0) + 1
+        return new_paras
+
+    xml2 = PARA_RE.sub(para_repl, xml)
+    if xml2 != xml:
+        dbg["touched"] = True
+    return xml2
+
+def _runs_plain(text: str) -> str:
+    return f"<hp:run><hp:t>{html.escape('' if text is None else str(text))}</hp:t></hp:run>"
 
 def _apply_to_xml(xml: str, mapping: Dict[str, str], dbg: dict) -> str:
     changed_any = False
 
-    # 1) 필드쌍 완전 치환
+    # 0) 다중줄 키는 먼저 "부모 문단 교체"로 처리
+    multi_key = re.compile(r"^(목록|list|제목|업무명)\d+$", re.IGNORECASE)
+    for k, v in mapping.items():
+        if multi_key.match(k):
+            xml_new = _replace_para_multiline(xml, k, v, dbg)
+            if xml_new != xml:
+                xml = xml_new
+                changed_any = True
+
+    # 1) 필드쌍(인라인) 치환 — 단일줄 키만
     for k, v in mapping.items():
-        is_multiline = bool(re.match(r"^(목록|list|제목|업무명)\d+$", k, re.IGNORECASE))
-        replacement = _runs_multiline(v) if is_multiline else _runs_plain(v)
+        if multi_key.match(k):
+            continue
+        replacement = _runs_plain(v)
         pat = re.compile(FIELD_PAIR_RE_TMPL.format(name=re.escape(k)), re.DOTALL)
         xml_new, n = pat.subn(replacement, xml)
         if n:
@@ -103,54 +122,42 @@ def _apply_to_xml(xml: str, mapping: Dict[str, str], dbg: dict) -> str:
             xml = xml_new
             changed_any = True
 
-    # 2) 순수 텍스트 자리표시자 치환
+    # 2) 순수 텍스트 자리표시자(<*:t>키</*:t>) 부분치환 — 단일줄 키만
+    tnode_all = re.compile(
+        r'(<(?P<prefix>[a-zA-Z0-9_]+):t[^>]*>)([^<]*?)</(?P=prefix):t>',
+        re.DOTALL
+    )
     for k, v in mapping.items():
-        is_multiline = bool(re.match(r"^(목록|list|제목|업무명)\d+$", k, re.IGNORECASE))
-        replacement = _runs_multiline(v) if is_multiline else _runs_plain(v)
-
-        # 정확 일치: run 안의 텍스트가 키만 있는 경우
-        pat_text = re.compile(TEXT_RUN_RE_TMPL.format(name=re.escape(k)), re.DOTALL)
-        xml_new, n = pat_text.subn(replacement, xml)
-        if n:
-            dbg["text_hits"][k] = dbg["text_hits"].get(k, 0) + n
-            xml = xml_new
+        if multi_key.match(k):
+            continue
+        def repl_tnode(m):
+            text_node = m.group(3)
+            if k not in text_node:
+                return m.group(0)
+            new_text = html.escape(text_node.replace(k, "" if v is None else str(v)))
+            return f"{m.group(1)}{new_text}</{m.group('prefix')}:t>"
+        xml2 = tnode_all.sub(repl_tnode, xml)
+        if xml2 != xml:
+            dbg["text_hits"][k] = dbg["text_hits"].get(k, 0) + 1
+            xml = xml2
             changed_any = True
-        else:
-            # 부분 일치: 같은 <t> 안에 다른 문자와 섞여 있을 때
-            pat_tnode = re.compile(
-                r'(<(?P<prefix>[a-zA-Z0-9_]+):t[^>]*>)([^<]*?)</(?P=prefix):t>',
-                re.DOTALL
-            )
-            def repl_tnode(m):
-                text_node = m.group(3)
-                if k not in text_node:
-                    return m.group(0)
-                val = "" if v is None else str(v)
-                # 부분 치환은 문단 구조를 건드리지 않고 문자열만 교체
-                new_text = html.escape(text_node.replace(k, val))
-                return f"{m.group(1)}{new_text}</{m.group('prefix')}:t>"
-
-            xml2 = pat_tnode.sub(repl_tnode, xml)
-            if xml2 != xml:
-                dbg["text_hits"][k] = dbg["text_hits"].get(k, 0) + 1
-                xml = xml2
-                changed_any = True
 
-    # 3) 토큰 치환
+    # 3) 토큰 치환 — 단일줄 키만
     for k, v in mapping.items():
+        if multi_key.match(k):
+            continue
         tok = TOKEN_FMT.format(key=k)
         if tok in xml:
-            rep = _runs_multiline(v) if re.match(r"^(목록|list|제목|업무명)\d+$", k, re.IGNORECASE) else html.escape("" if v is None else str(v))
-            xml = xml.replace(tok, rep)
+            xml = xml.replace(tok, html.escape("" if v is None else str(v)))
             dbg["token_hits"][k] = dbg["token_hits"].get(k, 0) + 1
             changed_any = True
 
     if changed_any:
-        dbg["touched"] = True
+        dbg["files_touched"] = True
     return xml
 
 def replace_in_hwpx(hwpx_bytes: bytes, mapping: Dict[str,str]) -> Tuple[bytes, dict]:
-    dbg = {"field_hits":{}, "text_hits":{}, "token_hits":{}, "touched_files": []}
+    dbg = {"para_hits":{}, "field_hits":{}, "text_hits":{}, "token_hits":{}, "touched_files": []}
     zin = zipfile.ZipFile(io.BytesIO(hwpx_bytes), "r")
     out_buf = io.BytesIO()
     zout = zipfile.ZipFile(out_buf, "w")
@@ -158,8 +165,7 @@ def replace_in_hwpx(hwpx_bytes: bytes, mapping: Dict[str,str]) -> Tuple[bytes, d
     # mimetype 무압축 + 맨앞
     names = zin.namelist()
     if "mimetype" in names:
-        zi = zipfile.ZipInfo("mimetype")
-        zi.compress_type = zipfile.ZIP_STORED
+        zi = zipfile.ZipInfo("mimetype"); zi.compress_type = zipfile.ZIP_STORED
         zout.writestr(zi, zin.read("mimetype"))
 
     for e in zin.infolist():
@@ -170,33 +176,25 @@ def replace_in_hwpx(hwpx_bytes: bytes, mapping: Dict[str,str]) -> Tuple[bytes, d
             try:
                 s = data.decode("utf-8", errors="ignore")
                 before = s
-                local_dbg = {
-                    "field_hits": dbg["field_hits"],
-                    "text_hits": dbg["text_hits"],
-                    "token_hits": dbg["token_hits"],
-                    "touched": False
-                }
-                s = _apply_to_xml(s, mapping, local_dbg)
+                s = _apply_to_xml(s, mapping, {"para_hits":dbg["para_hits"], "field_hits":dbg["field_hits"],
+                                               "text_hits":dbg["text_hits"], "token_hits":dbg["token_hits"],
+                                               "files_touched":False})
                 if s != before:
                     dbg["touched_files"].append(e.filename)
                 data = s.encode("utf-8")
             except Exception:
                 pass
-        zi = zipfile.ZipInfo(e.filename)
-        zi.compress_type = zipfile.ZIP_DEFLATED
+        zi = zipfile.ZipInfo(e.filename); zi.compress_type = zipfile.ZIP_DEFLATED
         zout.writestr(zi, data)
 
     zout.close(); out_buf.seek(0); zin.close()
     return out_buf.getvalue(), dbg
 
-# ================== UI ==================
+# -------------------- UI --------------------
 with st.expander("사용법", expanded=True):
     st.markdown("""
-- HWPX ZIP 내부 **모든 XML**에서 아래 순서로 치환합니다.
-  1) `fieldBegin(name=키)`~`fieldEnd` **필드쌍** 통째 교체  
-  2) `<*:t>키</*:t>` 같은 **순수 텍스트 자리표시자** run 교체  
-  3) `{{키}}` **토큰** 교체  
-- ‘목록/제목/업무명’ 같이 여러 줄이 들어갈 수 있는 값은 **각 줄을 독립 run + `lineBreak`**로 넣어 겹침을 방지합니다.
+- **다중 줄(목록/제목/업무명)은 부모 문단을 여러 문단으로 교체**하여 겹침 없이 표시합니다.
+- 나머지 키는 필드쌍/텍스트/토큰을 인라인 치환합니다.
 """)
 
 tpl = st.file_uploader("📄 HWPX 템플릿 업로드", type=["hwpx"])
@@ -208,8 +206,7 @@ if tpl and data:
     df = pd.read_csv(data) if data.name.lower().endswith(".csv") else pd.read_excel(data)
 
     if "박스번호" not in df.columns:
-        st.error("❌ 필수 컬럼 '박스번호'가 없습니다.")
-        st.stop()
+        st.error("❌ 필수 컬럼 '박스번호'가 없습니다."); st.stop()
 
     st.success("✅ 위치 매핑 완료 (엑셀 측)")
     st.dataframe(df.head(10), use_container_width=True)
@@ -227,60 +224,55 @@ if tpl and data:
 
     # 1페이지 매핑 프리뷰
     st.subheader("🧪 1페이지 매핑 프리뷰")
-    keys = ["박스번호", "종료연도", "보존기간", "단위업무", "기록물철", "목록", "제목", "업무명"]
+    keys = ["박스번호","종료연도","보존기간","단위업무","기록물철","목록","제목","업무명"]
     mapping_preview = {}
     for i in range(int(n_per_page)):
         if i < len(records):
             r = records[i]
-            for k in keys:
-                val = r.get("생산연도","") if k=="종료연도" else r.get("제목","") if k=="업무명" else r.get(k,"")
-                mapping_preview[f"{k}{i+1}"] = val
+            mapping_preview.update({
+                f"박스번호{i+1}": r.get("박스번호",""),
+                f"종료연도{i+1}": r.get("생산연도",""),
+                f"보존기간{i+1}": r.get("보존기간",""),
+                f"단위업무{i+1}": r.get("단위업무",""),
+                f"기록물철{i+1}": r.get("기록물철",""),
+                f"목록{i+1}": r.get("목록",""),
+                f"제목{i+1}": r.get("제목",""),
+                f"업무명{i+1}": r.get("제목",""),  # 템플릿이 '업무명1'을 쓰는 경우 대응
+            })
         else:
-            for k in keys:
-                mapping_preview[f"{k}{i+1}"] = ""
-    st.dataframe(
-        pd.DataFrame([{"키": k, "값 앞부분": str(v)[:120]} for k, v in sorted(mapping_preview.items())]),
-        use_container_width=True,
-        height=320,
-    )
+            for k in keys: mapping_preview[f"{k}{i+1}"] = ""
+    st.dataframe(pd.DataFrame([{"키":k, "값 앞부분":str(v)[:120]} for k,v in sorted(mapping_preview.items())]),
+                 use_container_width=True, height=320)
 
     if st.button("🚀 라벨 생성 (페이지별 HWPX ZIP)"):
-        mem = io.BytesIO()
-        zout = zipfile.ZipFile(mem, "w", zipfile.ZIP_DEFLATED)
+        mem = io.BytesIO(); zout = zipfile.ZipFile(mem, "w", zipfile.ZIP_DEFLATED)
         pages = (len(records) + int(n_per_page) - 1) // int(n_per_page)
         debug_all = []
 
         for p in range(pages):
-            chunk = records[p * int(n_per_page) : (p + 1) * int(n_per_page)]
-            # 매핑 구축 (제목 == 업무명 동치)
+            chunk = records[p*int(n_per_page):(p+1)*int(n_per_page)]
             mapping = {}
             for i in range(int(n_per_page)):
                 if i < len(chunk):
                     r = chunk[i]
-                    mapping[f"박스번호{i+1}"] = r.get("박스번호", "")
-                    mapping[f"종료연도{i+1}"] = r.get("생산연도", "")
-                    mapping[f"보존기간{i+1}"] = r.get("보존기간", "")
-                    mapping[f"단위업무{i+1}"] = r.get("단위업무", "")
-                    mapping[f"기록물철{i+1}"] = r.get("기록물철", "")
-                    mapping[f"목록{i+1}"]   = r.get("목록", "")
-                    title_val = r.get("제목", "")
+                    mapping[f"박스번호{i+1}"] = r.get("박스번호","")
+                    mapping[f"종료연도{i+1}"] = r.get("생산연도","")
+                    mapping[f"보존기간{i+1}"] = r.get("보존기간","")
+                    mapping[f"단위업무{i+1}"] = r.get("단위업무","")
+                    mapping[f"기록물철{i+1}"] = r.get("기록물철","")
+                    mapping[f"목록{i+1}"]   = r.get("목록","")
+                    title_val = r.get("제목","")
                     mapping[f"제목{i+1}"]   = title_val
-                    mapping[f"업무명{i+1}"] = title_val  # 템플릿이 '업무명1' 같은 키를 쓸 수 있음
+                    mapping[f"업무명{i+1}"] = title_val
                 else:
-                    for k in keys:
-                        mapping[f"{k}{i+1}"] = ""
+                    for k in keys: mapping[f"{k}{i+1}"] = ""
 
             out_hwpx, dbg = replace_in_hwpx(tpl_bytes, mapping)
-            debug_all.append({"page": p + 1, "stats": dbg})
-            name = "_".join([r.get("박스번호", "") for r in chunk]) if chunk else f"empty_{p+1}"
+            debug_all.append({"page": p+1, "stats": dbg})
+            name = "_".join([r.get("박스번호","") for r in chunk]) if chunk else f"empty_{p+1}"
             zout.writestr(f"label_{name}.hwpx", out_hwpx)
 
-        zout.close()
-        mem.seek(0)
+        zout.close(); mem.seek(0)
         st.download_button("⬇️ ZIP 다운로드", data=mem, file_name="labels_by_page.zip", mime="application/zip")
-        st.download_button(
-            "⬇️ 디버그(JSON)",
-            data=json.dumps(debug_all, ensure_ascii=False, indent=2),
-            file_name="debug.json",
-            mime="application/json",
-        )
+        st.download_button("⬇️ 디버그(JSON)", data=json.dumps(debug_all, ensure_ascii=False, indent=2),
+                           file_name="debug.json", mime="application/json")