hany202507/finance-ai-skills / skills/DSD초안
DSD초안
Verified전기(작년) 감사보고서 · 연결감사보고서 dsd 하나로 당기 초안 dsd 를 만든다. 회사가 준 전기 dsd 든, DSD변환 스킬이 작년 공시 원문으로 만든 dsd 든 그 파일만 있으면 된다. 당기 숫자를 전기 칸으로 옮기고 당기 칸을 비우며, 기수 · 해 +1, 변동표의 새 당기 기초를 작년 기말로 채우고, 원고 엑셀과 초안 검산 · 안내까지 한 번에 낸다. 같은 전기 파일이면 몇 번을 돌려도 바이트까지 같다. "전기 DSD 로 당기 초안", "작년 dsd 로 올해 초안", "다음 기수 초안", "초안 만들어 줘", "롤포워드", "기초 채워서", "당기 초안으로 바꿔 줘", "전기 dsd 있어", "초안 dsd", "이 원고로 dsd 다시 만들어 줘"가 언급되면 트리거. 공시 원문을 dsd 로 바꾸는 것은 DSD변환, 초안 · 회사제시 dsd 의 숫자 검증은 DSD푸팅 스킬이다.
scripts/audit/cli_dsd.py
View on GitHub"""DSD 푸팅 명령줄(2026-10-12). 감사 폴더 없이 dsd 한 파일로 돈다.
python -m audit dsd read <dsd> [--out 폴더]
격자로 읽어 dsd_표.json 을 쓴다
python -m audit dsd foot <dsd> [--links 연결.json [--add]] [--text 문장.json …] [--prev 기존 판] [--prior 작년 보고서] [--wtb 정산표] [--pair 다른 보고서] [--out 폴더] [--defs 파일]
검증 엑셀을 만든다. 오버뷰에 합계 · 레퍼 · 전기 · 버전 네 가지가 신호등으로 보인다.
--links 를 주면 먼저 links --apply 와 같이 연결을 넣고(풀리지 않는 칸이 있으면 엑셀을 만들지 않고 1 로 끝난다), --text 에 여럿을 주면
text --apply 와 같이 합쳐 문장.json 에 쓴 뒤 엑셀까지 한 번에 돈다(2026-10-23 분석 6.7. 모듈 불러오기 약 3초를 한 번만 쓴다).
--prev 를 주면 기존 판 대비 바뀐 곳을, --prior 를 주면 전기 숫자가 작년 보고서와 같은지를 본다.
FALSE 나 풀지 못한 연결이 있으면 1 로 끝난다. 바뀐 곳, 확인, 전기 대사에서 못 찾은 줄은 종료 코드에 넣지 않는다.
--wtb 는 8100B · WTB 양식 · 감사 법인 양식(BS · IS · WBS · WIS · AJE)을 읽는다. 읽지 못하는 양식이면 「이 WTB 양식을 읽지 못함: …」 한 줄로 2 로 끝난다.
python -m audit dsd links <dsd> [--text [--facts 기준사실.json] [--case 감사 폴더] [--split N]] [--out 폴더] [--defs 파일]
AI 가 읽을 자료를 낸다: dsd_읽기자료.md(맨 앞에 연결.json 쓰는 법, 재무제표와 주석 전부, 표마다 줄 · 열 번호), 연결_초안.json(빈 연결.json 과 할 일),
dsd_연결요청.json(아직 주석과 이어지지 않은 과목, 금액 대조가 찾은 참고, 엔진의 연결 후보 proposals). 연결 후보(2026-10-22)는 위치 · 이름 · XBRL 코드로 내고
금액은 보지 않는다. 읽기 자료의 표 아래 「후보 P0001」 줄로도 보인다. --text 면 문장 검토의 문장읽기.md 도 함께 쓴다(dsd text 와 같다)
python -m audit dsd links <dsd> --apply <연결.json> [--add] [--out 폴더] [--defs 파일]
AI 가 적은 연결을 검사해 dsd_연결정의.json 에 넣는다. 이름이 칸으로 풀리지 않는 연결이 하나라도 있으면 아무것도 쓰지 않고 1 로 끝난다.
연결.json 은 AI 연결의 전체 목록이다. 앞서 넣은 AI 연결은 이 목록으로 바뀐다(--add 면 두고 더한다). 넣은 뒤 dsd_연결요청.json 을 다시 쓴다
연결.json 에 proposals(후보 번호의 O · X · 고침)가 있으면 후보 전부에 판정이 있어야 넣는다(--add 면 앞서 판정한 후보는 판정한 것으로 본다)
python -m audit dsd fetch <접수번호 | PDF> [--out 폴더] [--no-prior]
OpenDART 공시서류원본(xml)을 받는다(2026-10-22). PDF 는 DART 에서 받은 「[회사]보고서(접수일).pdf」 꼴이면 그날 그 회사의 공시를 찾는다.
사업 · 반기 · 분기보고서면 <접수번호>_연결.xml · _별도.xml 로 나누고, 작년 비교 보고서(직전 사업보고서, 작년 같은 기간 보고서)도 받아 나눈다.
끝에 foot 명령(--prior · --pair 를 채운 것)을 적어 준다. 인증키는 환경변수 DART_API_KEY 에서만 읽는다. 받지 못하면 한 줄로 2 로 끝난다
python -m audit dsd text <dsd> [--facts 기준사실.json] [--case 감사 폴더] [--prior 작년 보고서] [--split N] [--apply 문장.json …] [--out 폴더]
문장 검토(2026-10-17): 표가 아닌 글과 표 안 글자를 읽어 문장읽기.md(AI 가 읽을 글 전부와 엔진이 찾은 것)와 문장검토.json 을 쓴다.
--split N 이면 문장읽기를 주석 제목에서 끊어 문장읽기_1.md … _N.md 로도 쓴다(2026-10-22, 에이전트 N 명이 동시에 읽는다. 글이 짧으면 덜 나눈다).
--apply 로 AI 가 적은 문장.json 을 넣으면 발췌가 원문에 있는지 본다. 여럿을 주면(문장_1.json 문장_2.json) 하나로 합쳐 문장.json 에 쓴다.
foot 은 폴더의 기준사실.json · 문장.json 을 함께 읽어 「문장 검토」 시트를 만든다
foot 에 --html 을 주면(2026-10-26) 엑셀 옆에 판 비교 · 숫자 검증 HTML(DSD보기_<이름>.html)과 자료 dsd_보기.json 을 쓴다. --prev 와 함께면(2026-11-04)
판 비교 화면은 dsd diff --html 과 같은 셈(추가 · 삭제 · 변경 색과 거르기, 바뀐 곳 목록)이고 판비교_<옛>_<새>.xlsx · .json 도 쓴다. --mask 치환표.json 이면
이름을 바꾼 판(_치환.html)도 쓴다(치환 뒤 check 에 걸리는 글이 남으면 2). 결과 폴더의 확인_*.json(HTML 에서 내려받은 O · X)은 엑셀 확인 칸과 함께 읽는다
python -m audit dsd view <결과 폴더 | dsd_보기.json> [--mask 치환표.json] [--out 폴더]
dsd_보기.json 으로 HTML 을 다시 만든다(템플릿만 고쳤을 때, 이름 치환판이 필요할 때)
python -m audit dsd sheet <dsd | xml> [--roll] [--out 폴더]
DSD → 엑셀(2026-10-26): 원고 엑셀(원고_<이름>.xlsx)을 쓴다. 요소 하나가 원고 줄 하나, 글과 숫자는 원문 그대로, 병합 칸은 회색.
표 오른쪽 「검증」 열에 표 안 합계 수식. --roll 이면 작년 판으로 당기 초안을 만든다(당기 열 → 전기 열, 기수 · 해 +1. 못 한 표는 원고 안내에)
python -m audit dsd build <원고.xlsx> [--out 파일]
엑셀 → DSD: 바탕이 dsd 면 고친 요소의 글자만 바꾸고(고치지 않으면 contents.xml 이 바탕과 바이트까지 같다), 바탕이 공시 xml 이면
엔진 틀에 넣는다. 원고 검사(엑셀 손상 · 옮기지 못한 것 · 롤포워드에서 남은 곳)를 원고검사.json 과 화면에 낸다
foot · links · text · diff 에 dsd 대신 원고 엑셀을 주면 먼저 dsd 로 만들어 돈다. foot 은 「원고 검사」 시트를 더하고 --prev 가 없으면 바탕 판과 견준다
python -m audit dsd diff <옛 판> <새 판> [--html [--mask 치환표.json]] [--out 폴더]
판 비교(2026-10-26): 두 판의 추가 · 삭제 · 변경 · 옮김 · 나뉨 · 합침을 판비교_<옛>_<새>.xlsx(요약 · 바뀐 곳 · 바뀐 부분 시트)와
같은 이름의 .json 으로 낸다. 표지 · 감사보고서 · 재무제표 · 주석 · 외부감사 실시내용을 견준다. 푸팅은 돌리지 않는다.
--html 이면(2026-11-03) 같은 결과를 판비교_<옛>_<새>.html 로도 쓴다. 기존 판 · 새 판을 나란히 두고 추가(연두) · 삭제(분홍) · 변경(하늘색,
칸에 마우스를 올리면 기존 값 · 차이) · 옮김 · 나뉨 · 합침(주황)을 색과 거르기로 나누고, 바뀐 곳 목록에서 누르면 그 칸으로 간다.
--mask 면 이름을 바꾼 판(_치환.html)도 쓴다(치환 뒤 check 에 걸리는 글이 남으면 HTML 을 만들지 않고 2).
바뀐 곳이 있어도 0 으로 끝난다(읽지 못하면 한 줄로 2)
python -m audit dsd quick <dsd> [--wtb …] [--prior …] [--prev …] [--pair …] [--facts …] [--case …] --out <폴더> [--serve [--port 8791]]
빠른 검토(2026-11-04): links --text 와 foot --html 을 한 번에 돈다. AI 연결 정의가 아직 없으면 연결_초안.json 을 넣어 엔진 후보를
판정 없이 건다. AI 없이 첫 HTML 까지 간다(한 회사 vF 14초). --serve 면 끝나고 검토 화면 서버를 띄운다
python -m audit dsd serve <결과 폴더> [--port 8791] [--no-open]
검토 화면 서버(2026-11-04): DSD보기 HTML 을 127.0.0.1 에서 열고, 화면의 「수정」 을 받아 원본은 두고 <이름>_수정판.dsd 에 쓴 뒤
foot 을 다시 돌린다(옵션은 foot --html 이 남긴 dsd_실행.json). 수정 기록은 수정기록.json, 되돌리기는 마지막 묶음을 뺀다
python -m audit dsd fix <dsd> <수정_이름.json> [--out 파일]
서버 없이 연 화면에서 내려받은 수정 목록을 dsd 에 쓴다. 숫자 칸은 값 · 줄 이름으로, 문장은 고칠 글로 원문 요소를 찾고,
쓴 뒤 다시 판독해 다른 숫자 칸이 바뀌었으면 쓰지 않는다. 못 고친 것이 있으면 1
dsd 자리에는 DART 편집기 파일(.dsd)이나 OpenDART 공시서류원본파일(.xml)을 준다.
"""
from __future__ import annotations
import re
from pathlib import Path
def register(sub) -> None:
p = sub.add_parser("dsd", help="회사 제시 dsd 푸팅: 격자 판독과 수식 검증 엑셀")
ps = p.add_subparsers(dest="dcmd", required=True)
r = ps.add_parser("read", help="dsd 를 재무제표와 주석 번호별 격자로 읽는다")
r.add_argument("dsd")
r.add_argument("--out", default=None)
r.set_defaults(func=_read)
f = ps.add_parser("foot", help="수식 검증 엑셀을 만든다")
f.add_argument("dsd")
f.add_argument("--prev", default=None, help="기존 판(dsd · xml). 바뀐 곳을 본다")
f.add_argument("--prior", default=None, nargs="+",
help="작년 보고서(dsd · xml). 전기 숫자가 같은지 본다. 반기 · 분기보고서는 둘을 준다(직전 사업보고서, 작년 같은 기간의 보고서)")
f.add_argument("--wtb", default=None, help="정산표 엑셀(8100B · WTB 양식 · 감사 법인 양식 BS · IS · WBS · WIS · AJE). 본표 과목을 감사한 금액과 견준다. "
"엑셀에서 계산된 값이 저장된 파일이어야 한다. 읽지 못하는 양식이면 한 줄 오류로 2 로 끝난다")
f.add_argument("--pair", default=None, help="함께 낸 다른 보고서(연결이면 별도, 별도면 연결). 자본금처럼 두 보고서에 같은 금액과 「짝:」 으로 적은 연결을 견준다")
f.add_argument("--out", default=None)
f.add_argument("--defs", default=None)
f.add_argument("--amount-links", action="store_true", help="금액이 같은 칸을 엔진이 찾아 함께 건다(기본은 AI 가 정의한 연결만)")
f.add_argument("--facts", default=None, help="문장 검토의 기준 사실 json(없으면 --out 폴더의 기준사실.json)")
f.add_argument("--case", default=None, help="감사 폴더. 회사명 · 결산일과 공시 확인 대상(의사록 · 등기부 판독 사실)을 읽는다")
f.add_argument("--text", default=None, nargs="+", help="AI 가 적은 문장 검토 json(없으면 --out 폴더의 문장.json). 여럿이면(문장_1.json 문장_2.json) 합쳐 문장.json 에 쓴다")
f.add_argument("--links", default=None, nargs="+", help="AI 가 적은 연결.json. 엑셀을 만들기 전에 links --apply 와 같이 넣는다(2026-10-23). "
"여럿이면(몫마다 적은 연결_1.json 연결_2.json) 첫 파일 옆 연결.json 으로 합쳐 넣는다(2026-11-09)")
f.add_argument("--part", type=int, default=0, help="--links 와 함께: 몫 번호. 화면 · 판정자료의 FALSE · 확인을 그 몫 것만 낸다(links --parts 가 쓴 dsd_몫.json)")
f.add_argument("--add", action="store_true", help="--links 와 함께: 앞서 넣은 AI 연결을 두고 더한다")
f.add_argument("--html", action="store_true", help="판 비교 · 숫자 검증 HTML 보기(DSD보기_<이름>.html)와 자료 dsd_보기.json 도 쓴다")
f.add_argument("--stage", choices=("회사제시", "제출"), default=None,
help="문장 검토에서 감사인 절(외부감사 실시내용 · 감사보고서) 빈칸을 셀 방법. 회사제시 초안이면 「감사인 작성 전」 으로 따로 묶는다. "
"없으면 파일 이름(회사제시) · 받은자료 폴더로 정한다(2026-11-04)")
f.add_argument("--mask", default=None, help="이름 치환표 json(subs · check). HTML 을 이름 바꾼 판(_치환)으로 쓴다. 저장소에 넣지 않는다")
vw = ps.add_parser("view", help="dsd_보기.json 으로 HTML 보기를 다시 만든다(템플릿만 고쳤거나 이름 치환판이 필요할 때)")
vw.add_argument("src", help="결과 폴더 또는 dsd_보기.json")
vw.add_argument("--mask", default=None, help="이름 치환표 json")
vw.add_argument("--out", default=None, help="쓸 폴더. 없으면 자료가 있는 폴더")
vw.set_defaults(func=_view)
f.set_defaults(func=_foot)
t = ps.add_parser("text", help="문장 검토: 오타 · 표현 · 사실 불일치(주소 · 대표이사 · 감사기간 · 보고서일) · 공시 누락")
t.add_argument("dsd")
t.add_argument("--facts", default=None)
t.add_argument("--case", default=None)
t.add_argument("--prior", default=None, help="작년 보고서. 같은 문장에 작년 날짜가 남은 곳을 본다")
t.add_argument("--apply", default=None, nargs="+", help="AI 가 적은 문장.json. 폴더에 문장.json 으로 옮겨 둔다. 여럿이면 하나로 합친다")
t.add_argument("--split", type=int, default=0, help="문장읽기를 N 몫으로도 나눠 쓴다(문장읽기_1.md …). 에이전트 N 명이 한 몫씩 읽는다")
t.add_argument("--stage", choices=("회사제시", "제출"), default=None, help="foot 의 --stage 와 같다")
t.add_argument("--out", default=None)
t.set_defaults(func=_text)
k = ps.add_parser("links", help="AI 가 정할 연결의 요청 자료를 내거나(--apply 없이) AI 가 적은 연결을 넣는다(--apply)")
k.add_argument("dsd")
k.add_argument("--apply", default=None, help="AI 가 적은 연결 json. 앞서 넣은 AI 연결은 이 파일의 것으로 바뀐다")
k.add_argument("--add", action="store_true", help="--apply 와 함께: 앞서 넣은 AI 연결을 두고 더한다")
k.add_argument("--carry", default=None, help="--apply 와 함께: --apply 의 연결을 적은 판(dsd · xml). 표 번호와 줄 이름을 이 판에 맞게 옮겨서 넣는다")
k.add_argument("--text", action="store_true", help="--apply 없이: 문장 검토의 문장읽기.md 도 함께 쓴다(dsd text 와 같다)")
k.add_argument("--facts", default=None, help="--text 와 함께: 기준 사실 json(없으면 --out 폴더의 기준사실.json)")
k.add_argument("--case", default=None, help="--text 와 함께: 감사 폴더")
k.add_argument("--prior", default=None, nargs="+", help="--text 와 함께: 작년 보고서(같은 문장에 작년 날짜가 남은 곳을 본다). foot 처럼 둘을 줘도 되고 첫째만 쓴다")
k.add_argument("--split", type=int, default=0, help="--text 와 함께: 문장읽기를 N 몫으로도 나눠 쓴다")
k.add_argument("--parts", type=int, default=0, help="숫자 쪽 읽기 자료 · 연결_초안을 주석 범위 N 몫으로도 나눠 쓴다(dsd_읽기자료_1.md · 연결_초안_1.json …, 2026-11-09)")
# quick 이 --stage 를 links 에 넘긴다. 옵션이 없어 「unrecognized arguments」 로 멈췄다(2026-11-06 실제 회사 시험)
k.add_argument("--stage", choices=("회사제시", "제출"), default=None, help="--text 와 함께: foot 의 --stage 와 같다")
k.add_argument("--out", default=None)
k.add_argument("--defs", default=None)
k.set_defaults(func=_links)
sh = ps.add_parser("sheet", help="DSD → 엑셀: dsd · 공시 xml 을 원고 엑셀로 쓴다")
sh.add_argument("dsd")
sh.add_argument("--roll", action="store_true", help="작년 판으로 당기 초안: 당기 열을 전기 열로 옮기고 당기 칸을 비운다")
sh.add_argument("--out", default=None)
sh.set_defaults(func=_sheet)
bd = ps.add_parser("build", help="엑셀 → DSD: 원고 엑셀로 dsd 를 만든다")
bd.add_argument("xlsx")
bd.add_argument("--out", default=None, help="만들 dsd 경로. 없으면 원고 옆 <이름>_원고판.dsd")
bd.set_defaults(func=_build)
v = ps.add_parser("diff", help="판 비교: 두 판(dsd · xml)의 추가 · 삭제 · 변경을 엑셀로 낸다")
v.add_argument("old", help="옛 판")
v.add_argument("new", help="새 판")
v.add_argument("--out", default=None, help="결과 폴더. 없으면 새 판이 있는 폴더")
v.add_argument("--html", action="store_true", help="판 비교 HTML(판비교_<옛>_<새>.html)도 쓴다. 추가 · 삭제 · 변경을 색으로 나누고 목록에서 그 칸으로 간다")
v.add_argument("--mask", default=None, help="이름 치환표 json. 이름을 바꾼 HTML(_치환.html)도 쓴다(--html 을 뜻한다)")
v.set_defaults(func=_diff)
g = ps.add_parser("fetch", help="OpenDART 원문 xml 을 받아 정기보고서면 연결 · 별도로 나눈다(작년 비교 보고서도)")
g.add_argument("src", help="접수번호(14자리) 또는 DART 에서 받은 PDF")
g.add_argument("--out", default=None, help="받을 폴더. 없으면 PDF 가 있는 폴더(접수번호면 지금 폴더). 그 아래 원문_<접수번호>/ 에 둔다")
g.add_argument("--no-prior", action="store_true", help="작년 비교 보고서를 받지 않는다")
g.set_defaults(func=_fetch)
cv = ps.add_parser("convert", help="DART 공시 원문 → 편집기 dsd: 본문은 원문 그대로 두고 편집기 뼈대(삽입 위치 · 목차 · 안내문 · 머리)만 되살린다")
cv.add_argument("src", help="접수번호(14자리), DART 에서 받은 PDF, 또는 공시 원문 xml(감사보고서 · 연결감사보고서)")
cv.add_argument("--out", default=None, help="결과 폴더. 없으면 원문 xml 이 있는 폴더(접수번호면 지금 폴더)")
cv.add_argument("--roll", action="store_true", help="다음 기수 초안도 만든다: 당기 숫자 → 전기 칸, 기수 · 해 +1, 당기 칸 비움(dsd sheet --roll → build)")
cv.add_argument("--bare", action="store_true", help="뼈대 없이: 머리 감싸개와 meta.xml 만 더한다(편집기 확인용 비교판)")
cv.add_argument("--view", default=None, help="같은 보고서의 DART 공시 화면 HTML. 없으면 원문 옆 <이름>.view.html 을 쓴다. 원문에서 빠진 줄바꿈을 되살린다")
cv.set_defaults(func=_convert)
dr = ps.add_parser("draft", help="전기 dsd → 당기 초안: 당기 숫자를 전기 칸으로, 기수 · 해 +1, 당기 칸 비움, 원고 엑셀 · 초안 검산까지(convert --roll 과 같은 산출물)")
dr.add_argument("dsd", help="전기(작년) 감사보고서 · 연결감사보고서 dsd. 회사가 준 것이든 dsd convert 가 만든 것이든 된다")
dr.add_argument("--out", default=None, help="결과 폴더. 없으면 전기 dsd 가 있는 폴더")
dr.set_defaults(func=_draft)
q = ps.add_parser("quick", help="빠른 검토: links --text 와 foot --html 을 한 번에(엔진 후보는 판정 없이 넣는다). AI 없이 첫 HTML 까지")
q.add_argument("dsd")
for name in ("prev", "wtb", "pair", "facts", "case", "mask"):
q.add_argument(f"--{name}", default=None)
q.add_argument("--prior", default=None, nargs="+")
q.add_argument("--stage", choices=("회사제시", "제출"), default=None)
q.add_argument("--out", default=None)
q.add_argument("--serve", action="store_true", help="끝나면 검토 화면 서버를 띄운다(dsd serve 와 같다)")
q.add_argument("--port", type=int, default=8791)
q.set_defaults(func=_quick)
fx = ps.add_parser("fix", help="수정 목록(HTML 에서 내려받은 수정_<이름>.json)을 dsd 에 써서 수정판을 만든다. 원본은 두고 <이름>_수정판.dsd 에 쓴다")
fx.add_argument("dsd")
fx.add_argument("items", help="수정 목록 json({\"items\": [...]} 또는 목록)")
fx.add_argument("--out", default=None, help="만들 dsd 경로. 없으면 원본 옆 <이름>_수정판.dsd")
fx.set_defaults(func=_fix)
sv = ps.add_parser("serve", help="검토 화면 서버: DSD보기 HTML 을 127.0.0.1 에서 열고 「수정」 을 받아 수정판을 쓰고 다시 검증한다")
sv.add_argument("folder", help="foot --html 결과 폴더(dsd_실행.json 이 있는 곳)")
sv.add_argument("--port", type=int, default=8791)
sv.add_argument("--no-open", action="store_true", help="브라우저를 열지 않는다")
sv.set_defaults(func=_serve)
def _out_dir(a) -> Path:
d = Path(a.out) if a.out else Path(a.dsd).resolve().parent
d.mkdir(parents=True, exist_ok=True)
return d
def _read(a) -> int:
import json
from .report import dsd_grid
doc = dsd_grid.read_grid(Path(a.dsd))
out = _out_dir(a) / "dsd_표.json"
out.write_text(json.dumps(dsd_grid.to_json(doc), ensure_ascii=False, indent=1), encoding="utf-8")
notes = sum(1 for p in doc.parts if p.key.startswith("주석"))
print(f"{doc.source}: 재무제표 {len(doc.parts) - notes}개 · 주석 {notes}개 · 표 {len(doc.tables())}개 → {out}")
return 0
def foot(src: Path, out: Path, prev: Path | None = None, prior: Path | None = None, defs_path: Path | None = None, amount_links: bool = False,
wtb: Path | None = None, pair: Path | None = None, facts: Path | None = None, case: Path | None = None, text: Path | None = None,
draft: list | None = None, html: bool = False, mask: Path | None = None, stage: str | None = None, only=None) -> dict:
"""검증 엑셀을 만들고 요약을 돌려준다. {book, doc, checks, unresolved, changes, consistency, view}
html 이면 같은 결과를 dsd_보기.json 과 DSD보기_<이름>.html 로도 쓴다(2026-10-26). mask 는 이름 치환표 json(HTML 만 치환한다)."""
import json
from .report import dsd_book, dsd_compare, dsd_grid, dsd_links
defs_path = defs_path or out / "dsd_연결정의.json"
book = out / f"DSD푸팅_{src.stem}.xlsx"
defs = json.loads(defs_path.read_text(encoding="utf-8")) if defs_path.exists() else {}
from .report import dsd_view
xlsx_marks = [(old, dsd_book.read_marks(old)) for old in sorted(out.glob("DSD푸팅_*.xlsx"), key=lambda p: p.stat().st_mtime)]
marks, mark_notes = dsd_view.merge_marks(dict(defs.get("marks", {})), out, xlsx_marks) # HTML 에서 내려받은 확인_*.json 도 읽는다
defs["marks"] = marks
cache = dsd_grid.cache_dir() # 넣기마다 foot 을 다시 돌려도 같은 파일은 다시 판독하지 않는다(2026-10-22 P5)
doc = dsd_grid.read_cached(src, cache)
pdoc = dsd_grid.read_cached(prev, cache) if prev else None
priors = [prior] if isinstance(prior, (str, Path)) else list(prior or [])
ydocs = [dsd_grid.read_cached(Path(p), cache) for p in priors]
odoc = dsd_grid.read_cached(Path(pair), cache) if pair else None
checks, new_defs, unresolved = dsd_links.build(doc, defs, amount_links=amount_links, other=odoc)
ydoc = None
prior_matches: list = [] # (작년 문서, 앞머리, 짝) 차이 설명 후보의 「작년 이름」 에 쓴다(11단계)
if ydocs:
ydoc, groups = dsd_links.join_priors(ydocs) # 둘째 보고서의 표는 이름 앞에 ② 를 붙여 한 문서로 잇는다
for y, tag in groups:
ym = dsd_compare.match(doc, y)
prior_matches.append((y, tag, ym))
more, missing = dsd_links.prior_checks(doc, y, ym, tag, defs.get("prior_pairs", []))
dsd_links.apply_marks(more, marks)
dsd_links.apply_prior_verdicts(more, defs.get("prior", []))
notes = dsd_links.by_idk(defs.get("findings", [])) # 전기 대사 차이를 「확인」 으로 판정한 근거도 「볼 것」 시트에 보인다
for c in more:
if not c.finding and dsd_links.idk(c.id) in notes:
dsd_links.apply_finding(c, notes[dsd_links.idk(c.id)])
checks, unresolved = checks + more, unresolved + missing
wdoc = None
if wtb: # 정산표와 본표 과목의 대사
from .report import dsd_wtb
wdoc = dsd_wtb.read_wtb(Path(wtb)) # 읽지 못하면 WtbFormatError(_foot 이 한 줄로 끝낸다)
more, missing = dsd_wtb.checks(doc, wdoc, {(c.table, c.r) for c in checks if c.kind == "세로합"})
dsd_links.apply_marks(more, marks)
notes = dsd_links.by_idk(defs.get("findings", []))
for c in more:
if dsd_links.idk(c.id) in notes:
dsd_links.apply_finding(c, notes[dsd_links.idk(c.id)])
checks, unresolved = checks + more, unresolved + missing
dsd_links.evaluate(doc, checks, ydoc, wdoc, odoc)
from .report import dsd_diff, dsd_verify # 11단계: 고칠 칸 근거 · 독립 검증 · 차이 설명 후보 · 판정자료
dsd_verify.apply_fixes(checks, defs.get("findings", []), doc, ydoc, wdoc, odoc)
review_problems = dsd_verify.apply_review(checks, dsd_verify.load_review(out / dsd_verify.REVIEW), doc, ydoc, wdoc, odoc)
tabs = dsd_diff.tables(doc, ydoc, wdoc, odoc)
dsd_diff.explain(doc, checks, tabs, prior_matches)
mine = [c for c in checks if only(c)] if only else checks # 몫 하나만 판정할 때(--part) 그 몫의 검증만 판정자료에 싣는다
(out / dsd_verify.PACK).write_text(dsd_verify.pack(doc, mine, tabs, dsd_book.causes(doc, checks), dsd_book.last_year(doc, tabs, checks), ydoc), encoding="utf-8")
m = dsd_compare.match(doc, pdoc, fuzzy=True) if pdoc is not None else None
old_checks = None
if pdoc is not None: # 기존 판에도 같은 연결을 걸어 검증 결과가 달라진 것을 본다(고쳐 달라고 한 곳이 고쳐졌는지)
old_checks, _, _ = dsd_links.build(pdoc, dict(defs, marks={}), amount_links=amount_links)
dsd_links.evaluate(pdoc, old_checks)
from .report import dsd_ai
gaps = dsd_ai.request(doc, [c for c in checks if c.group != "전기"], new_defs, with_evidence=False)
same = dsd_ai.consistency(doc)
if wdoc is not None and (wdoc.stats or {}).get("과목에 잇지 못한 수정 계정"):
lost_acc = wdoc.stats["과목에 잇지 못한 수정 계정"]
same.append({"what": "정산표 과목에 잇지 못한 수정 계정", "n": len(lost_acc),
"why": f"{', '.join(lost_acc[:8])}. 감사 법인 WTB 의 계정별 시트에서 수정이 있는 계정을 공시 과목에 잇지 못해 그 과목의 회사제시 금액을 구하지 못했다. "
"수정 후 금액 대사는 그대로 된다."})
if wdoc is not None and dsd_wtb.no_adjustments(wdoc):
same.append({"what": "정산표 수정분개 0건", "n": 0, "why": "정산표의 당기(회사제시)와 당기(최종)이 모든 과목에서 같다. 수정분개를 넣기 전의 정산표라면 "
"정산표 대사는 회사 장부와 맞춘 것일 뿐이다. 수정분개를 다 넣은 정산표로 다시 돌린다."})
for x in mark_notes:
same.append({"what": "엑셀 확인과 HTML 확인이 다름", "n": 1, "why": x})
from .report import dsd_text # 문장 검토(2026-10-17). 기준사실.json · 문장.json 은 폴더에 있으면 읽는다
tres = dsd_text.review(src, dsd_text.load_facts(facts or out / "기준사실.json", case), priors[0] if priors else None,
text or out / "문장.json", case, stage)
dsd_text.mark_stale(tres, out / "문장검토.json") # dsd text 가 AI 에게 준 공시 확인 대상과 지금 대상이 같은지(2026-10-18 B-7)
vres = None
if pdoc is not None: # 판 비교(dsd diff 와 같은 셈). 새 판에서 띄어쓰기가 빠진 낱말은 문장 검토 오타로 넘긴다(2026-11-04)
from .report import dsd_versions
vres = dsd_versions.compare(dsd_versions.read_doc(prev, cache), dsd_versions.read_doc(src, cache))
dsd_text.version_spacing(tres, vres.changes, Path(prev).name)
dsd_book.write(book, doc, checks, unresolved, pdoc, ydoc, m,
{"unlinked": gaps["unlinked"], "unchecked_totals": gaps["unchecked_totals"], "skipped": new_defs.get("skipped", []),
"workpapers": new_defs.get("workpapers", []), "consistency": same, "text": tres, "draft": draft}, wdoc, odoc, old_checks)
defs_path.write_text(json.dumps(new_defs, ensure_ascii=False, indent=1), encoding="utf-8")
changed = dsd_compare.changes(doc, pdoc, m) if pdoc is not None else None
view = None
versions = None
if html and pdoc is not None: # 판 비교 화면은 dsd diff 와 같은 셈(2026-11-04). 판비교 엑셀 · json 도 같이 쓴다
from .report import dsd_versions, dsd_versions_book, dsd_versions_view
vstem = dsd_versions.file_stem(prev, src)
vbook = dsd_versions_book.write(out / f"{vstem}.xlsx", vres, f"python -m audit dsd foot {src.name} --prev {Path(prev).name} --html")
dsd_versions.write_json(out / f"{vstem}.json", vres)
vdata = dsd_versions_view.build(vres)
versions = {"book": vbook, "line": dsd_versions.line(vres), "data": {k: vdata[k] for k in ("parts", "changes", "summary", "leftovers")}}
if html: # 판 비교 · 숫자 검증 HTML 보기(2026-10-26). 엑셀이 정본이고 이 화면은 같은 결과를 그린다
from .report import dsd_links as _dl, dsd_wtb as _dw
data = dsd_view.build(doc, checks, pdoc, m, old_checks,
{"others": {_dl.PRIOR_ID: ydoc, _dw.WTB_ID: wdoc, _dl.PAIR_ID: odoc}, "text": tres,
"prior": " · ".join(Path(p).name for p in priors), "wtb": Path(wtb).name if wtb else "",
"pair": Path(pair).name if pair else "", "diff": versions["data"] if versions else None,
"workpapers": new_defs.get("workpapers", []), "src": src})
view = dsd_view.write(out, data, src.stem)
if mask: # 이름 바꾼 판은 따로 쓴다(_치환). 치환 뒤 이름이 남으면 MaskError
view["masked"] = dsd_view.write(out, data, src.stem, json.loads(Path(mask).read_text(encoding="utf-8")))
return {"book": book, "doc": doc, "checks": checks, "unresolved": unresolved, "changes": changed, "match": m, "consistency": same, "text": tres,
"review_problems": review_problems,
"wtb": wdoc, "view": view, "versions": versions}
SHOW, SHOW_LOST = 40, 10 # foot 화면에 줄마다 적는 수. 넘으면 「외 n건」 과 전체가 있는 엑셀 시트를 적는다(2026-11-04)
def _more(items: list, shown: int, what: str, sheet: str) -> None:
"""화면 목록을 shown 줄에서 끊었으면 남은 수와 전체가 있는 시트를 한 줄로 적는다. 예전에는 알림 없이 끊겨 한 상장사 2026 반기의
FALSE 56건 가운데 40건만 보이고 나머지가 없는 것처럼 읽혔다."""
if len(items) > shown:
print(f" {what} 외 {len(items) - shown}건(엑셀 「{sheet}」)")
def _foot(a) -> int:
from .report import dsd_links
from .report import dsd_view, dsd_wtb
src = Path(a.dsd)
out = _out_dir(a)
src, draft, base = resolve_draft(src, out) # 원고 엑셀이면 dsd 로 만든다(2026-10-26 DSD 네 기능 C)
if draft is not None and not a.prev:
a.prev = str(base)
part = None
if a.links: # 연결.json 을 먼저 넣는다(links --apply 와 같다). 풀리지 않는 칸이 있으면 엑셀을 만들지 않는다
import json
from .report import dsd_ai
links = Path(a.links[0])
if len(a.links) > 1: # 몫마다 적은 연결을 하나로(2026-11-09). 후보 번호 장부는 첫 파일 옆 것을 쓴다
merged = dsd_ai.merge_patches([json.loads(Path(x).read_text(encoding="utf-8")) for x in a.links])
links = links.with_name("연결.json")
links.write_text(json.dumps(merged, ensure_ascii=False, indent=1), encoding="utf-8")
print(f"연결 {len(a.links)}개를 합침: 연결 {len(merged.get('links', []))} · 표 한 줄 {len(merged.get('tables', []))} · 합계 구조 {len(merged.get('sums', []))} · "
f"계산 {len(merged.get('calcs', []))} · 판정 {len(merged.get('findings', []))} · 전기 판정 {len(merged.get('prior', []))} → {links}")
if a.part:
pf = next((x for x in (links.with_name(dsd_ai.PARTS_FILE), out / dsd_ai.PARTS_FILE) if x.exists()), None)
if pf is None:
print(f"--part {a.part}: {dsd_ai.PARTS_FILE} 이 없습니다. links --parts 로 먼저 나눕니다")
return 2
part = (json.loads(pf.read_text(encoding="utf-8")), a.part)
code = apply_links(src, out, Path(a.defs) if a.defs else out / "dsd_연결정의.json", links, add=a.add, pair=Path(a.pair) if a.pair else None, part=part)
if code:
return code
text = None
if a.text and len(a.text) > 1: # 나눈 몫의 문장.json 을 합친다(text --apply 와 같다)
import json
from .report import dsd_text
text = out / "문장.json"
merged = dsd_text.merge_ai([json.loads(Path(x).read_text(encoding="utf-8")) for x in a.text])
text.write_text(json.dumps(merged, ensure_ascii=False, indent=1), encoding="utf-8")
print(f"문장.json {len(a.text)}개를 합침: findings {len(merged['findings'])} · disclosures {len(merged['disclosures'])} → {text}")
elif a.text:
text = Path(a.text[0])
try:
r = foot(src, out, Path(a.prev) if a.prev else None, [Path(p) for p in a.prior] if a.prior else None, Path(a.defs) if a.defs else None, a.amount_links,
Path(a.wtb) if a.wtb else None, Path(a.pair) if a.pair else None, Path(a.facts) if a.facts else None,
Path(a.case) if a.case else None, text, draft, a.html or bool(a.mask), Path(a.mask) if a.mask else None, a.stage,
only=(lambda c: dsd_ai.check_owner(part[0], c) == part[1]) if part else None)
except dsd_wtb.WtbFormatError as e: # 정산표 양식을 못 읽으면 역추적 없이 한 줄(2026-10-18 실제 회사 자료 B-1)
print(f"이 WTB 양식을 읽지 못함: {e}")
return 2
except dsd_view.MaskError as e: # 치환 뒤에도 실제 이름이 남으면 HTML 을 만들지 않는다(설계 4.3)
print(f"HTML 을 만들지 않음: {e}")
return 2
if r.get("view") and draft is None: # 검토 화면 서버가 수정판으로 다시 돌릴 때 쓴다(2026-11-04)
from .report import dsd_serve
dsd_serve.save_run(out, a, src)
doc, checks, unresolved = r["doc"], r["checks"], r["unresolved"]
live = [c for c in checks if not c.excluded and not c.dropped]
n_drop = sum(1 for c in checks if c.dropped)
bad = [c for c in live if dsd_links.failed(c)]
minor = [c for c in live if c.minor]
ask = [c for c in live if dsd_links.asks(c)]
if part: # 몫 하나: 그 몫의 FALSE · 확인만 보인다. 다른 몫의 후보는 판정 없이 들어가 FALSE 가 섞인다
bad = [c for c in bad if dsd_ai.check_owner(part[0], c) == part[1]]
ask = [c for c in ask if dsd_ai.check_owner(part[0], c) == part[1]]
print(f" {part[1]}몫만 보입니다(FALSE · 확인 · 판정자료). 합친 결과는 맡긴 쪽이 foot --links 연결_1.json … 으로 냅니다")
by = {g: sum(1 for c in live if c.group == g) for g in ("합계", "레퍼", "전기")}
n_calc = sum(1 for c in live if c.expr)
lost = [u for u in unresolved if u.get("kind") == "전기"] # 작년 보고서에서 줄을 찾지 못한 전기 금액. 풀지 못한 연결과 따로 센다
nowtb = [u for u in unresolved if u.get("kind") == "조서"] # 정산표에서 과목을 찾지 못한 본표 줄
unresolved = [u for u in unresolved if u.get("kind") not in ("전기", "조서")]
line = (f"{src.name}: 검증 {len(live)}(합계 {by['합계']} · 레퍼 {by['레퍼']}" + (f"(계산 {n_calc})" if n_calc else "") + f" · 전기 {by['전기']}) · FALSE {len(bad)} · 확인 {len(ask)} · 단수 차이 {len(minor)} · "
f"판정으로 뺌 {n_drop} · 제외(X) {len(checks) - len(live) - n_drop} · 풀지 못한 연결 {len(unresolved)}" + (f" · 전기 대사에서 못 찾은 줄 {len(lost)}" if lost else "")
+ (f" · 정산표에서 못 찾은 과목 {len(nowtb)}" if nowtb else ""))
if r["changes"] is not None:
line += f" · 바뀐 곳 {sum(r['changes'].values())}"
kinds = [dsd_links.kind_of(c) for c in live] # 11단계: 숫자 오류(FALSE) · 표시 오류 · 설명 부족 · 독립 검증
if kinds.count("표시 오류") or kinds.count("설명 부족"):
line += f" · 표시 오류 {kinds.count('표시 오류')} · 설명 부족 {kinds.count('설명 부족')}"
judged = [c for c in checks if not c.excluded and c.ok is False and not c.minor and not dsd_links.no_review(c) and (not c.dropped or c.verified)]
# 늘 나는 차이 · 근거 확인 숫자 오류는 독립 검증 대상이 아니다(2026-10-22). 검증 뒤 판정으로 뺀 검증도 센다(10-23 한 상장사: 전기 대사 1건이 「걸지 않음」 으로 바뀌어 9/9 로 보였다)
if any(c.verified for c in judged):
line += f" · 독립 검증 {sum(1 for c in judged if c.verified)}/{len(judged)}(바꿈 {sum(1 for c in judged if c.verified == '바꿈')})"
n_sampled = sum(1 for c in live if dsd_links.sampled(c))
if n_sampled:
line += f" · 늘 나는 차이 {n_sampled}(독립 검증 대신 회계사 표본)"
n_engine = sum(1 for c in live if dsd_links.engine_checked(c))
if n_engine:
line += f" · 엔진이 근거를 확인한 숫자 오류 {n_engine}(독립 검증 안 함)"
print(f"{line} → {r['book']}")
if r.get("view"):
v = r["view"]
print(f" HTML 보기 {v['html'].name}({v['size'] / 1_048_576:.1f}MB) · 자료 {v['json'].name}")
for w in v["warnings"]:
print(f" HTML {w}")
if v.get("masked"):
print(f" 이름 치환한 판 {v['masked']['html'].name}")
if r.get("versions"):
print(f" 판 비교(HTML 판 비교 화면과 같은 셈) {r['versions']['line']} → {r['versions']['book'].name}")
if draft is not None:
print(f" 원고 검사 {len(draft)}건(막음 {sum(1 for x in draft if x['수준'] == '막음')}) · 원고로 만든 dsd {src.name} · 바뀐 곳은 바탕 판과 견줬다")
for p in r.get("review_problems") or []:
print(f" {p}")
if r.get("wtb") is not None:
print(" " + dsd_wtb.describe(r["wtb"]))
for c in bad[:SHOW]:
t = doc.table(c.table)
print(f" FALSE [{c.kind}] {doc.part_of(c.table).key} {dsd_links._labels(t)[c.r]} · {t.header[c.c]}: {c.left:,} ↔ {c.right:,} ({c.label})")
for h in c.hints[:2]:
print(f" 후보 [{h['kind']}] {h['text']}")
_more(bad, SHOW, "FALSE", "볼 것")
for c in ask[:SHOW]:
t = doc.table(c.table)
print(f" 확인 [{c.kind}] {doc.part_of(c.table).key} {dsd_links._labels(t)[c.r]} · {t.header[c.c]}: {c.left:,} ↔ {c.right:,} (차이 {c.left - c.right:,}. 조건: {c.when})")
_more(ask, SHOW, "확인", "볼 것")
for u in unresolved[:SHOW]:
print(f" 풀지 못함 {u['table']}: {u['why']}")
_more(unresolved, SHOW, "풀지 못함", "풀지 못한 연결")
for u in lost[:SHOW_LOST]:
print(f" 전기 대사 {u['table']}: {u['why']}")
_more(lost, SHOW_LOST, "전기 대사", "풀지 못한 연결")
for u in nowtb[:SHOW]:
print(f" 조서 대사 {u['table']}: {u['why']}")
_more(nowtb, SHOW, "조서 대사", "풀지 못한 연결")
for x in r.get("consistency") or []:
print(f" 원문 대조 {x['what']}: {x['why']}")
from .report import dsd_text
print(" " + dsd_text.summary(r["text"]))
for x in (r["text"] or {}).get("invalid", [])[:20]:
print(f" 문장 받지 않음 {x.get('seg') or x.get('item')}: {x['why']}")
if r["changes"]:
for k, n in r["changes"].items():
if n:
print(f" 바뀜 {k}: {n}곳")
for x in r["match"].gone_parts:
print(f" 없어진 시트: {x}")
return 1 if bad or unresolved else 0
def _parse(argv: list[str]):
import argparse
p = argparse.ArgumentParser(prog="audit")
register(p.add_subparsers(dest="cmd"))
return p.parse_args(argv)
def _quick(a) -> int:
"""빠른 검토(2026-11-04): links --text(읽기 자료 · 문장읽기 · 연결_초안) 다음 foot --html. AI 연결 정의가 아직 없으면 연결_초안.json 을
넣어 엔진 후보를 판정 없이 건다. 이미 있으면(두 번째부터) 그 정의를 그대로 쓴다. 끝에 AI 가 볼 곳(FALSE · 할 일 · 문장)을 한 줄씩 적는다."""
import json
import time
t0 = time.time()
out = _out_dir(a)
base = ["dsd", "links", a.dsd, "--text", "--out", str(out)]
for k in ("facts", "case", "stage"):
if getattr(a, k):
base += [f"--{k}", getattr(a, k)]
if a.prior:
base += ["--prior", *a.prior]
code = _links(_parse(base))
if code not in (0, 1):
return code
defs = out / "dsd_연결정의.json"
has_ai = defs.exists() and bool(json.loads(defs.read_text(encoding="utf-8")).get("links"))
argv = ["dsd", "foot", a.dsd, "--out", str(out), "--html"] + ([] if has_ai else ["--links", str(out / "연결_초안.json")])
for k in ("prev", "wtb", "pair", "facts", "case", "stage", "mask"):
if getattr(a, k):
argv += [f"--{k}", getattr(a, k)]
if a.prior:
argv += ["--prior", *a.prior]
code = _foot(_parse(argv))
todo = json.loads((out / "연결_초안.json").read_text(encoding="utf-8")).get("할 일", [])
print(f"빠른 검토 {time.time() - t0:.0f}초 · AI 연결 정의 {'있음(그대로 씀)' if has_ai else '없음(엔진 후보만)'} · 할 일 {len(todo)}건 · "
f"다음: AI 는 dsd_판정자료.md 의 FALSE 와 연결_초안.json 할 일만 보고, 문장은 문장읽기.md 를 다른 에이전트가 본다")
if a.serve:
from .report import dsd_serve
dsd_serve.serve(out, a.port)
return code
def _fix(a) -> int:
import json
from .report import dsd_fix
data = json.loads(Path(a.items).read_text(encoding="utf-8"))
items = data.get("items", []) if isinstance(data, dict) else data
src = Path(a.dsd)
out = Path(a.out) if a.out else src.with_name(dsd_fix.fixed_name(src))
r = dsd_fix.apply(src, items, out)
for x in r["failed"]:
print(f" 못 고침 {x.get('table') or x.get('seg') or ''} {x.get('old', '')}: {x['why']}")
for p in r["problems"]:
print(f" 다시 읽어 보니 {p}")
if r["path"] is None:
print(f"{src.name}: 고친 것 없음(못 고침 {len(r['failed'])})")
return 1 if r["failed"] else 0
print(f"{src.name}: 고침 {len(r['done'])} · 못 고침 {len(r['failed'])}" + (f" · 서식 잃음 {len(r['lost_format'])}" if r["lost_format"] else "")
+ f" → {r['path']}. 원본은 그대로다. 제출 전에 DART 편집기에서 열어 확인한다")
return 1 if r["failed"] else 0
def _serve(a) -> int:
from .report import dsd_serve
try:
dsd_serve.serve(Path(a.folder), a.port, not a.no_open)
except FileNotFoundError as e:
print(e)
return 2
return 0
def _view(a) -> int:
import json
from .report import dsd_view
src = Path(a.src)
js = src / dsd_view.DATA_FILE if src.is_dir() else src
if not js.exists():
print(f"자료가 없습니다: {js} (foot 을 --html 로 먼저 돌린다)")
return 2
data = json.loads(js.read_text(encoding="utf-8"))
out = Path(a.out) if a.out else js.parent
out.mkdir(parents=True, exist_ok=True)
stem = Path(data["meta"]["new"]).stem
try:
v = dsd_view.write(out, data, stem, json.loads(Path(a.mask).read_text(encoding="utf-8")) if a.mask else None)
except dsd_view.MaskError as e:
print(f"HTML 을 만들지 않음: {e}")
return 2
print(f"HTML 보기 {v['html']}({v['size'] / 1_048_576:.1f}MB)")
for w in v["warnings"]:
print(f" {w}")
return 0
def _text(a) -> int:
out = _out_dir(a)
src, _, _ = resolve_draft(Path(a.dsd), out)
return text_run(src, out, Path(a.facts) if a.facts else None, Path(a.case) if a.case else None,
Path(a.prior) if a.prior else None, a.apply, a.split, a.stage)
def text_run(src: Path, out: Path, facts: Path | None = None, case: Path | None = None, prior: Path | None = None,
apply: list | None = None, split: int = 0, stage: str | None = None) -> int:
"""dsd text 의 몸통. links --text 도 이것을 부른다(2026-10-23)."""
import json
import shutil
from .report import dsd_text
dst = out / "문장.json"
if apply and len(apply) > 1: # 나눈 몫마다 적은 문장.json 을 하나로(2026-10-22)
merged = dsd_text.merge_ai([json.loads(Path(x).read_text(encoding="utf-8")) for x in apply])
dst.write_text(json.dumps(merged, ensure_ascii=False, indent=1), encoding="utf-8")
print(f"문장.json {len(apply)}개를 합침: findings {len(merged['findings'])} · disclosures {len(merged['disclosures'])} → {dst}")
elif apply and Path(apply[0]).resolve() != dst.resolve():
shutil.copyfile(apply[0], dst)
facts_ = dsd_text.load_facts(facts or out / "기준사실.json", case)
res = dsd_text.review(src, facts_, prior, dst, case, stage)
(out / "문장읽기.md").write_text(dsd_text.reading(res), encoding="utf-8")
for old in out.glob("문장읽기_*.md"): # 앞서 나눈 몫이 남아 있으면 지운다
old.unlink()
parts = dsd_text.reading_parts(res, split) if split > 1 else []
if len(parts) > 1:
for i, x in enumerate(parts, 1):
(out / f"문장읽기_{i}.md").write_text(x, encoding="utf-8")
(out / "문장검토.json").write_text(json.dumps(dsd_text.to_json(res), ensure_ascii=False, indent=1), encoding="utf-8")
print(f"{src.name}: 글 조각 {len(res['segments'])}개 · {dsd_text.summary(res)} → {out / '문장읽기.md'}")
if len(parts) > 1:
print(f" 나눈 문장읽기 {len(parts)}개: " + ", ".join(f"문장읽기_{i}.md({x.count(chr(10))}줄)" for i, x in enumerate(parts, 1)))
elif split > 1:
print(" 글이 짧아 나누지 않음(문장읽기.md 하나)")
for x in res["engine"][:40]:
print(f" [{x['kind']} · {x['rule']}] {x['seg']} {x['where']}: {x['quote'][:60]} → {x['fix']}")
for x in res["invalid"][:20]:
print(f" 받지 않음 {x.get('seg') or x.get('item')}: {x['why']}")
return 1 if res["invalid"] else 0
def _proposal_line(props: list[dict]) -> str:
from collections import Counter
by = Counter(x["how"] for x in props)
return f"엔진 연결 후보 {len(props)}건" + (f"({' · '.join(f'{k} {v}' for k, v in by.most_common())})" if by else "") \
+ " → dsd_연결요청.json 의 proposals, 읽기 자료의 표 아래 「후보」 줄"
def _links(a) -> int:
import json
from .report import dsd_ai, dsd_grid, dsd_links
src, out = Path(a.dsd), _out_dir(a)
src, _, _ = resolve_draft(src, out)
defs_path = Path(a.defs) if a.defs else out / "dsd_연결정의.json"
if a.apply:
return apply_links(src, out, defs_path, Path(a.apply), add=a.add, carry=Path(a.carry) if a.carry else None)
defs = json.loads(defs_path.read_text(encoding="utf-8")) if defs_path.exists() else {}
doc = dsd_grid.read_cached(src, dsd_grid.cache_dir())
checks, base, _ = dsd_links.build(doc, defs)
dsd_links.evaluate(doc, checks)
p = out / "dsd_연결요청.json"
req = dsd_ai.request(doc, checks, base, with_proposals=True, book=dsd_ai.id_book(p)) # 이 폴더에 앞서 낸 후보 번호를 그대로 쓴다
p.write_text(json.dumps(req, ensure_ascii=False, indent=1), encoding="utf-8")
(out / "dsd_읽기자료.md").write_text(dsd_ai.reading(doc, base, checks, req["proposals"]), encoding="utf-8")
d = dsd_ai.draft(doc, req)
(out / "연결_초안.json").write_text(json.dumps(d, ensure_ascii=False, indent=1), encoding="utf-8")
print(f"{src.name}: {dsd_ai.summary(req)} → {p}")
if a.parts and a.parts > 1: # 숫자 쪽을 주석 범위로 나눈다(2026-11-09). 몫마다 에이전트 하나가 읽고 연결_k.json 을 쓴다
plan = dsd_ai.plan_parts(doc, a.parts, base, checks, req["proposals"])
(out / dsd_ai.PARTS_FILE).write_text(json.dumps(plan, ensure_ascii=False, indent=1), encoding="utf-8")
for k in range(1, plan["n"] + 1):
txt = dsd_ai.part_reading(doc, plan, k, base, checks, req["proposals"])
(out / f"dsd_읽기자료_{k}.md").write_text(txt, encoding="utf-8")
pd = dsd_ai.part_draft(plan, k, d)
(out / f"연결_초안_{k}.json").write_text(json.dumps(pd, ensure_ascii=False, indent=1), encoding="utf-8")
keys = [x for x, v in plan["notes"].items() if v == k]
print(f" 몫 {k}: {keys[0] if keys else '-'} ~ {keys[-1] if keys else '-'} · 읽기 자료 {txt.count(chr(10))}줄 · 할 일 {len(pd['할 일'])}건 → dsd_읽기자료_{k}.md · 연결_초안_{k}.json")
print(" " + _proposal_line(req["proposals"]))
print(f" 연결_초안.json: 할 일 {len(d['할 일'])}건(후보 없는 표 · 합계 구조 없음 · 잇지 못한 과목) → {out / '연결_초안.json'}")
for x in req["unlinked"][:40]:
print(f" {x['table']} {x['row']} (가리킨 주석 {', '.join(x['notes'])})")
if a.text: # 문장읽기도 같은 프로세스에서 쓴다(2026-10-23 분석 6.7)
return text_run(src, out, Path(a.facts) if a.facts else None, Path(a.case) if a.case else None, Path(a.prior[0]) if a.prior else None, None, a.split,
getattr(a, "stage", None))
return 0
def apply_links(src: Path, out: Path, defs_path: Path, patch_path: Path, add: bool = False, carry: Path | None = None, pair: Path | None = None,
part: tuple | None = None) -> int:
"""links --apply 의 몸통. foot --links 도 이것을 부른다(2026-10-23). 넣지 못하면 1."""
import json
from .report import dsd_ai, dsd_grid, dsd_links, dsd_patch
defs = json.loads(defs_path.read_text(encoding="utf-8")) if defs_path.exists() else {}
cache = dsd_grid.cache_dir()
doc = dsd_grid.read_cached(src, cache)
checks, base, _ = dsd_links.build(doc, defs)
patch = json.loads(Path(patch_path).read_text(encoding="utf-8"))
# 후보 번호 장부: AI 가 읽은 dsd_연결요청.json 의 번호. 연결.json 옆에 있으면 그것을, 없으면 결과 폴더의 것을 쓴다(2026-11-09)
book = dsd_ai.id_book(Path(patch_path).with_name("dsd_연결요청.json")) or dsd_ai.id_book(out / "dsd_연결요청.json")
cdoc = dsd_grid.read_cached(carry, cache) if carry else None
odoc = dsd_grid.read_cached(pair, cache) if pair else None
patch, problems, notes = dsd_patch.normalize(cdoc if cdoc is not None else doc, patch, odoc) # 번호 칸 · 표 한 줄은 그 연결을 적은 판의 번호다
if problems:
print(f"연결을 넣지 않았습니다. 고칠 곳 {len(problems)}건")
for x in problems:
print(f" {x}")
return 1
for x in notes:
print(f" {x}")
n_prop = {}
if patch.get("proposals", {}) is not None: # 후보 판정의 건수(넣은 뒤 화면에 보인다). 판정을 적지 않은 후보는 기본으로 들어간다(2026-10-22)
got = patch.get("proposals") or {}
xs = got.get("X") or {}
n_prop = {"O": sum(len(dsd_ai._ids(x)) for x in got.get("O") or []), "X": sum(len(dsd_ai._ids(x)) for x in (xs if isinstance(xs, dict) else [e.get("id") for e in xs])),
"고침": len(got.get("고침") or got.get("edit") or [])}
if carry: # 다른 판에서 적은 연결을 이 판의 표 번호 · 이름으로 옮긴다
if "proposals" in patch: # 후보 번호는 그 판의 것이라 먼저 연결로 풀어 옮긴다
patch, bad, _ = dsd_ai.expand_proposals(cdoc, patch, strict=False)
for x in bad:
print(f" 후보를 풀지 못함 {x}")
patch, lost = dsd_ai.carry(cdoc, doc, patch)
moved = out / "연결_옮김.json"
moved.write_text(json.dumps(patch, ensure_ascii=False, indent=1), encoding="utf-8")
print(f"{Path(carry).name} 의 연결을 옮겼습니다: 연결 {len(patch['links'])} · 합계 구조 {len(patch['sums'])} · 합계 아님 {len(patch['no_sums'])} · 옮기지 못함 {len(lost)} → {moved}")
for x in lost:
print(f" 옮기지 못함 {x}")
new, problems = dsd_ai.apply(doc, base, patch, add=add, book=None if carry else book)
if problems:
print(f"연결을 넣지 않았습니다. 고칠 곳 {len(problems)}건")
for x in problems:
print(f" {x}")
return 1
defs_path.write_text(json.dumps(new, ensure_ascii=False, indent=1), encoding="utf-8")
doc = dsd_grid.read_cached(src, cache) # 단위를 바로잡은 표가 바뀌었을 수 있어 새 사본을 다시 푼다
checks, _, _ = dsd_links.build(doc, new)
dsd_links.evaluate(doc, checks)
ai = [c for c in checks if c.source == "AI" and c.group == "레퍼"]
n = sum(1 for x in new["links"] if x.get("source") == "AI")
same = f" · 규칙이나 합계 구조와 같아 뺀 것 {n - len(ai)}건" if n > len(ai) else ""
print(f"{src.name}: AI 연결 {len(ai)}건을 넣었습니다(맞음 {sum(1 for c in ai if c.ok)} · 단수 차이 {sum(1 for c in ai if c.minor)} · "
f"확인 {sum(1 for c in ai if dsd_links.asks(c))} · 안 맞음 {sum(1 for c in ai if dsd_links.failed(c))}{same}) → {defs_path}")
sm = [c for c in checks if c.source == "AI" and c.group == "합계"]
if new.get("units"):
print(" 단위를 바로잡은 표: " + ", ".join(f"{u['table']} → {u['unit']:,}" for u in new["units"]))
if new.get("sums") or new.get("no_sums"):
print(f" AI 가 정한 합계 구조 {len(new.get('sums', []))}개(검증 칸 {len(sm)} · 맞음 {sum(1 for c in sm if c.ok)} · 단수 차이 {sum(1 for c in sm if c.minor)} · "
f"안 맞음 {sum(1 for c in sm if dsd_links.failed(c))}) · 합계가 아니라고 한 것 {len(new.get('no_sums', []))}개")
eng = [c for c in checks if c.group == "합계" and c.source != "AI" and dsd_links.failed(c)]
if eng: # 엔진이 찾은 구조에서 안 맞는 칸. 구조가 틀렸으면 sums 로 다시 적고, 맞으면 보고서의 차이다
print(f" 엔진 합계 구조에서 안 맞는 칸 {len(eng)}곳")
for c in eng[:20]:
t = doc.table(c.table)
print(f" {c.kind} {c.table} {dsd_links._labels(t)[c.r]} · {t.header[c.c]}: {c.left:,} ↔ {c.right:,} ({c.label})")
for x in dsd_ai.sum_review(doc, base, checks):
why = "걸린 칸이 전부 안 맞습니다. 구조를 잘못 읽었을 수 있으니 표를 다시 읽으십시오" if x["all"] else f"{x['checks']}칸 가운데 {x['false']}칸이 안 맞습니다"
print(f" 합계 안 맞음 {x['table']} {x['kind']} {x['ai']}: {why}" + (f" (엔진이 찾았던 구조: {x['engine']})" if x["engine"] else ""))
req = dsd_ai.request(doc, checks, new, with_proposals=True, book=None if carry else book) # 넣은 뒤의 요청 자료: 아직 이어지지 않은 과목과 금액 대조 참고가 줄어든다
if part: # 몫 하나: 잇지 못한 과목 · 합계 구조 없음 · 금액이 같은 칸 짝도 그 몫 것만
req = dsd_ai.part_request(doc, part[0], part[1], req)
(out / "dsd_연결요청.json").write_text(json.dumps(req, ensure_ascii=False, indent=1), encoding="utf-8")
(out / "dsd_읽기자료.md").write_text(dsd_ai.part_reading(doc, part[0], part[1], new, checks, req["proposals"]) if part
else dsd_ai.reading(doc, new, checks, req["proposals"]), encoding="utf-8")
if n_prop:
vids = {x["id"] for x in new["links"] if x.get("via")}
via = [c for c in ai if c.id in vids or c.id.rsplit("|", 1)[0] in vids]
print(f" 엔진 후보 {len(req['proposals'])}건: 판정 없이 넣음 {sum(1 for x in req['proposals'] if x.get('mark') == '기본')} · O {n_prop['O']} · X {n_prop['X']} · 고침 {n_prop['고침']}"
+ (f" (후보로 넣은 연결 가운데 안 맞음 {sum(1 for c in via if dsd_links.failed(c))})" if via else ""))
else:
print(" " + _proposal_line(req["proposals"]) + '. 연결.json 의 "proposals": null 이라 후보는 넣지 않았습니다')
print(f" {dsd_ai.summary(req)} · 금액이 같은데 아직 연결이 없는 칸 짝 {len(req['amount_evidence'])}건 → dsd_연결요청.json")
for x in dsd_ai.review(doc, [c for c in checks if dsd_ai.check_owner(part[0], c) == part[1]] if part else checks):
print(f" {'단수 차이' if x['minor'] else ('확인' if x['when'] else '안 맞음')} {x['left']}: {x['left_value']:,} ↔ {x['right']} {x['right_value']:,} (차이 {x['diff']:,})")
for y in ([] if x["minor"] else x["same_amount_cells"]):
print(f" 같은 주석에서 그 금액과 같은 칸: {y['table']} {y['row']} · {y['col']}")
return 0
def is_draft(p: Path) -> bool:
return Path(p).suffix.lower() in (".xlsx", ".xlsm")
def resolve_draft(src: Path, out: Path) -> tuple[Path, list | None, Path | None]:
"""원고 엑셀이면 dsd 로 만들어 그 경로를 준다. (dsd 경로, 원고 검사 | None, 바탕 판 경로 | None). 원고가 아니면 그대로."""
import json
if not is_draft(src):
return src, None, None
from .report import dsd_build, dsd_draft_book
d = out / "_원고판"
d.mkdir(parents=True, exist_ok=True)
res = dsd_build.build(src, d / f"{src.stem}.dsd")
r = dsd_draft_book.read(src)
if r.base == "dsd":
base = dsd_build.zip_dsd(d / f"바탕_{src.stem}.dsd", r.contents, r.meta)
else:
base = d / f"바탕_{src.stem}.xml"
base.write_bytes(r.contents)
(out / "원고검사.json").write_text(json.dumps(res["issues"], ensure_ascii=False, indent=1), encoding="utf-8")
return Path(res["path"]), res["issues"], base
def _sheet(a) -> int:
import zipfile
import xml.etree.ElementTree as ET
import xml.parsers.expat
from .report import dsd_draft, dsd_draft_book
src = Path(a.dsd)
out = Path(a.out) if a.out else src.resolve().parent
out.mkdir(parents=True, exist_ok=True)
try:
d = dsd_draft.read(src)
except (zipfile.BadZipFile, ET.ParseError, xml.parsers.expat.ExpatError, ValueError, FileNotFoundError) as e:
print(f"읽지 못함: {type(e).__name__} {e}")
return 2
if a.roll:
dsd_draft.roll(d)
cmd = f"python -m audit dsd sheet {src.name}" + (" --roll" if a.roll else "")
book = dsd_draft_book.write(out / f"원고_{src.stem}.xlsx", d, cmd)
n_line = sum(len(s.lines) for s in d.sheets)
n_tab = sum(1 for s in d.sheets for ln in s.lines if ln.kind in ("표", "글 표"))
rolled = f" · 롤포워드 표 {len(d.info.get('rolled_tables') or [])}" if a.roll else ""
print(f"{src.name}: 시트 {len(d.sheets)}개 · 줄 {n_line} · 표 {n_tab}{rolled} → {book}")
for x in d.notes[:30]:
print(f" {x}")
return 0
def _build(a) -> int:
import json
from .report import dsd_build
src = Path(a.xlsx)
if not src.exists():
print(f"파일이 없습니다: {src}")
return 2
try:
res = dsd_build.build(src, Path(a.out) if a.out else None)
except ValueError as e:
print(f"만들지 못함: {e}")
return 2
path = Path(res["path"])
(path.parent / f"원고검사_{src.stem}.json").write_text(json.dumps(res["issues"], ensure_ascii=False, indent=1), encoding="utf-8")
block = [x for x in res["issues"] if x["수준"] == "막음"]
same = " · 바탕과 바이트까지 같음" if res.get("same_bytes") else ""
print(f"{src.name} → {path.name}({res['mode']}): 고친 요소 {res['changed']} · 더한 것 {res['added']} · 뺀 것 {res['removed']}{same} · "
f"원고 검사 {len(res['issues'])}(막음 {len(block)})")
for x in res["issues"][:40]:
print(f" [{x['수준']} · {x['분류']}] {x['시트']} {x['칸']} {x['내용']}".rstrip())
return 1 if block else 0
def _diff(a) -> int:
import zipfile
import xml.etree.ElementTree as ET
from .report import dsd_grid, dsd_versions, dsd_versions_book
old, new = Path(a.old), Path(a.new)
for p in (old, new):
if not p.exists():
print(f"파일이 없습니다: {p}")
return 2
out = Path(a.out) if a.out else new.resolve().parent
out.mkdir(parents=True, exist_ok=True)
try:
old_d, _, _ = resolve_draft(old, out)
new_d, _, _ = resolve_draft(new, out)
res = dsd_versions.compare_files(old_d, new_d, dsd_grid.cache_dir())
except (zipfile.BadZipFile, ET.ParseError, ValueError) as e:
print(f"판을 읽지 못함: {type(e).__name__} {e}")
return 2
stem = dsd_versions.file_stem(old, new)
cmd = f"python -m audit dsd diff {old.name} {new.name}"
book = dsd_versions_book.write(out / f"{stem}.xlsx", res, cmd)
dsd_versions.write_json(out / f"{stem}.json", res)
print(dsd_versions.line(res))
print(f"→ {book}")
if a.html or a.mask: # 판 비교 HTML(2026-11-03). 엑셀과 같은 셈을 화면으로 그린다
import json
from .report import dsd_versions_view, dsd_view
data = dsd_versions_view.build(res)
try:
views = [dsd_versions_view.write(out, data, stem)]
if a.mask:
views.append(dsd_versions_view.write(out, data, stem, json.loads(Path(a.mask).read_text(encoding="utf-8"))))
except dsd_view.MaskError as e:
print(f"HTML 을 만들지 않음: {e}")
return 2
for v in views:
print(f"→ {v['html']}({v['size'] / 1_048_576:.1f}MB)")
for w in v["warnings"]:
print(f" HTML {w}")
return 0
def _roll_draft(src: Path, out: Path, company: str, year: str, form_name: str, cmd: str) -> dict:
"""전기 dsd 하나로 당기 초안: 당기 숫자 → 전기 칸, 기수 · 해 +1, 당기 칸 비움(dsd_draft.roll) → 원고 엑셀 → dsd build → 초안 검산.
`dsd draft` 와 `dsd convert --roll` 이 같이 쓴다(2026-11-10, 초안 작성을 변환에서 뗌). 산출물은 결과 폴더의
<회사>_<다음 연도>_<보고서>_초안.dsd · 원고_…_초안.xlsx · 원고검사_….json · 초안안내_….txt."""
import json
from .report import dsd_build, dsd_convert as C, dsd_draft, dsd_draft_book
d = dsd_draft.read(src)
dsd_draft.roll(d)
nxt = str(int(year) + 1) if year.isdigit() else "다음"
stem = C.file_stem(company, nxt, form_name)
book = dsd_draft_book.write(out / f"원고_{stem}_초안.xlsx", d, cmd)
res = dsd_build.build(book, out / f"{stem}_초안.dsd")
built = dsd_draft.check_built(d, dsd_draft.read(Path(res["path"]))) # 만든 dsd 를 다시 읽어 원고와 칸마다 견준다(2026-11-10)
res["issues"] += built
(out / f"원고검사_{book.stem}.json").write_text(json.dumps(res["issues"], ensure_ascii=False, indent=1), encoding="utf-8")
rolled = d.info.get("rolled_tables") or []
print(f"다음 기수 초안 → {Path(res['path']).name}: 롤포워드 표 {len(rolled)} · 고친 요소 {res['changed']} · 원고 {book.name}")
print(f" 초안 검산(dsd 를 다시 읽어 원고와 견줌): " + (f"다른 곳 {len(built)}건(막음, 원고 검사에 적었다)" if built else "모든 표 · 줄이 원고와 같다"))
issues = [f"[{x['수준']} · {x['분류']}] {x['시트']} {x['칸']} {x['내용']}".rstrip() for x in res["issues"]]
guide = out / f"초안안내_{book.stem}.txt" # 화면은 앞 몇 줄만, 전체는 파일로(2026-11-06 다른 회사 시험 E6: 말없이 잘렸다)
guide.write_text("\n".join(["[롤포워드 안내]", *d.notes, "", "[원고 검사]", *issues]) + "\n", encoding="utf-8")
for x in d.notes[:30]:
print(f" {x}")
if len(d.notes) > 30:
print(f" … 안내 외 {len(d.notes) - 30}건은 {guide.name}")
for x in issues[:20]:
print(f" {x}")
if len(issues) > 20:
print(f" … 원고 검사 외 {len(issues) - 20}건은 {guide.name}")
print(" 그대로 남은 것: 감사인의 감사보고서 · 외부감사 실시내용 · 문단 속 날짜와 금액은 작년 글이다. 원고 엑셀에서 고쳐 dsd build 로 다시 만든다")
return {"dsd": Path(res["path"]), "book": book, "guide": guide, "issues": res["issues"], "built": built, "draft": d}
def _draft(a) -> int:
"""전기 dsd(회사가 준 것이든 dsd convert 가 만든 것이든) 하나로 당기 초안을 만든다. 회사 · 결산연도 · 보고서 종류는 dsd 안의
COMPANY-NAME · PERIODTO · DOCUMENT-NAME 에서 읽고, 없으면 파일 이름에서 찾는다."""
import zipfile
import xml.etree.ElementTree as ET
import xml.parsers.expat
from .report import dsd_convert as C, dsd_draft
src = Path(a.dsd)
if not src.exists():
print(f"파일이 없습니다: {src}")
return 2
out = Path(a.out) if a.out else src.resolve().parent
out.mkdir(parents=True, exist_ok=True)
try:
d = dsd_draft.read(src)
except (zipfile.BadZipFile, ET.ParseError, xml.parsers.expat.ExpatError, ValueError) as e:
print(f"읽지 못함: {type(e).__name__} {e}")
return 2
info = d.info or {}
company = (info.get("name") or "").strip()
year = (info.get("period_end") or "")[:4]
m = re.match(r"^(.+?)_(\d{4})_(연결감사보고서|감사보고서)", src.stem)
if not company and m:
company = m.group(1)
if not year.isdigit() and m:
year = m.group(2)
doc = info.get("document") or (m.group(3) if m else "")
form_name = "연결감사보고서" if "연결" in doc else "감사보고서"
if not year.isdigit():
print(f"결산연도를 알지 못함: {src.name}. dsd 의 PERIODTO 나 파일 이름 <회사>_<연도>_<보고서> 에서 읽는다")
return 2
print(f"{src.name}: {company or '회사 이름 없음'} · 결산 {info.get('period_end') or year} · {form_name} · 시트 {len(d.sheets)}개")
_roll_draft(src, out, company, year, form_name, f"python -m audit dsd draft {src.name}")
return 0
def _convert(a) -> int:
import json
from xml.parsers.expat import ExpatError
from .report import dart_fetch as F, dsd_convert as C
src = a.src.strip()
try:
if re.fullmatch(r"\d{14}", src) or (src.lower().endswith(".pdf") and Path(src).exists()):
rcept = src if re.fullmatch(r"\d{14}", src) else F.from_pdf(Path(src))[0]
base = Path(a.out) if a.out else (Path.cwd() if re.fullmatch(r"\d{14}", src) else Path(src).resolve().parent)
xp = Path(F.fetch_one(rcept, base)["main"])
elif src.lower().endswith(".xml") and Path(src).exists():
xp = Path(src)
else:
print(f"바꿀 것을 알지 못함: {src}. 접수번호(14자리), DART 에서 받은 PDF, 공시 원문 xml 중 하나를 주십시오")
return 2
except F.FetchError as e: # 오류 글에는 인증키가 없다
print(f"원문을 받지 못함: {e}")
return 2
out = Path(a.out) if a.out else xp.resolve().parent
out.mkdir(parents=True, exist_ok=True)
raw = xp.read_bytes()
from .report import dsd_breaks
vp = Path(a.view) if a.view else dsd_breaks.view_for(xp)
view = vp.read_text(encoding="utf-8", errors="replace") if vp and vp.exists() else None
try:
r = C.convert(raw, bare=a.bare, view=view)
except (ValueError, ExpatError) as e:
print(f"바꾸지 못함: {e}")
return 2
year = r.period_end[:4]
stem = C.file_stem(r.company, year, C.FORMS[r.form])
path = C.write(out / f"{stem}_변환{'_뼈대없음' if a.bare else ''}.dsd", r, C.sha(raw))
same = C.same_body(raw, r.contents)
print(f"{xp.name} → {path.name}: {C.FORMS[r.form]}({r.form}) · {r.company} · 결산 {r.period_end or '?'} · "
f"삽입 위치 {r.counts.get('삽입 위치', 0)}(넣은 LIBRARY {r.counts.get('넣은 LIBRARY', 0)}) · ENG 뺌 {r.counts.get('ENG 뺌', 0)} · "
f"본문 원문과 {'같음' if same else '다름'} · 줄바꿈 "
+ (f"{r.counts.get('줄바꿈 되살림', 0)}곳 · 빈칸 {r.counts.get('빈칸 되살림', 0)}곳 되살림(공시 화면 {vp.name})" if r.breaks == "화면" else "없음(공시 화면 없음)"))
for x in r.notes:
print(f" {x}")
print(" 편집기에서: 재무제표마다 [재무제표 > 재무제표 검사] 를 돌린 뒤 파일형식 검사를 한다(공시 원문에는 그 검사 기록이 없다)")
code = 0 if same else 1
if a.roll:
_roll_draft(path, out, r.company, year, C.FORMS[r.form], f"python -m audit dsd convert {xp.name} --roll")
return code
def _fetch(a) -> int:
from .report import dart_fetch as F
src = a.src.strip()
try:
if re.fullmatch(r"\d{14}", src):
rcept, how, base = src, "접수번호", Path(a.out) if a.out else Path.cwd()
elif src.lower().endswith(".pdf") and Path(src).exists():
rcept, how = F.from_pdf(Path(src))
base = Path(a.out) if a.out else Path(src).resolve().parent
else:
print(f"받을 것을 알지 못함: {src}. 접수번호(14자리)나 DART 에서 받은 PDF 를 주십시오")
return 2
r = F.fetch(rcept, base, with_prior=not a.no_prior)
except F.FetchError as e: # 오류 글에는 인증키가 없다
print(f"원문을 받지 못함: {e}")
return 2
def line(x, what):
kinds = " · ".join(["본문"] + list(x["split"])) if x["split"] else x["main"].name
return f"{what} {x['rcept_no']} {x.get('report_nm') or x['name']} ({kinds}) → {x['main'].parent}"
print(line(r["main"], f"원문 받음({how}):"))
for x in r["priors"]:
print(" " + line(x, "작년 비교:"))
m, ps = r["main"], r["priors"]
kinds = list(m["split"]) or [""]
print("foot 명령:")
for kind in kinds:
me = m["split"].get(kind, m["main"]) if kind else m["main"]
prior = [str(p["split"].get(kind, p["main"]) if kind else p["main"]) for p in ps if not kind or kind in p["split"]]
other = [m["split"][k] for k in m["split"] if k != kind]
cmd = f'python -m audit dsd foot "{me}"' + ("" if not prior else " --prior " + " ".join(f'"{p}"' for p in prior)) \
+ (f' --pair "{other[0]}"' if other else "") + f' --out "{base / ("푸팅결과_" + kind if kind else "푸팅결과")}"'
print(" " + cmd)
return 0
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |