lawdangle-kr 0.1.0__py3-none-any.whl

lawdangle/__init__.py

@@ -0,0 +1,51 @@
+"""lawdangle — Dead Cross-Reference Detector for Korean Statutes.
+
+현행 법령이 인용하는 대상 법령의 폐지·개명·이관·사문화를 탐지하고 5분류로 태깅한다.
+배포명 `lawdangle-kr` / import명 `lawdangle` (DESIGN.md 네이밍).
+"""
+
+from __future__ import annotations
+
+from .classifier import classify
+from .cli import run, run_law
+from .mapper import (
+    MappingSuggestion,
+    discover_successors,
+    rank_correspondence,
+    suggest_mapping,
+    suggest_mapping_auto,
+)
+from .models import (
+    Category,
+    Citation,
+    Confidence,
+    HistoryInfo,
+    LawStatus,
+    Result,
+)
+from .parser import parse_citations
+from .resolver import FixtureResolver, LawGoKrResolver, Resolver
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Category",
+    "Citation",
+    "Confidence",
+    "HistoryInfo",
+    "LawStatus",
+    "Result",
+    "classify",
+    "run",
+    "run_law",
+    "parse_citations",
+    "Resolver",
+    "FixtureResolver",
+    "LawGoKrResolver",
+    "suggest_mapping",
+    "suggest_mapping_auto",
+    "discover_successors",
+    "rank_correspondence",
+    "MappingSuggestion",
+    "__version__",
+]

lawdangle/classifier.py

@@ -0,0 +1,202 @@
+"""③ Classifier — 5분류 (도구의 심장).
+
+DESIGN.md §3 ③ 의사결정 트리 구현.
+핵심 원칙: C/D/E는 자동 단정 금지 — 플래그만 달고 사람이 본다.
+"""
+
+from __future__ import annotations
+
+import re
+
+from .models import Category, Citation, Confidence, HistoryInfo, LawStatus, Result
+
+_ART_KEY_RE = re.compile(r"(제\d+조(?:의\d+)?)")
+
+
+def _article_key(article: str | None) -> str | None:
+    """'제17조제2항' → 조(條) 단위 키 '제17조'."""
+    if not article:
+        return None
+    m = _ART_KEY_RE.match(article)
+    return m.group(1) if m else None
+
+
+def _normalize_name(name: str) -> str:
+    """법명 정규화 — 약칭/표기차(가운뎃점ㆍ, 띄어쓰기)를 개명으로 오판 방지.
+
+    DESIGN.md §6 함정 1.
+    """
+    return name.replace("ㆍ", "").replace("·", "").replace(" ", "").strip()
+
+
+def classify(citation: Citation, history: HistoryInfo) -> Result:
+    """인용 레코드 + 연혁 → 5분류 판정.
+
+    의사결정 트리(DESIGN.md §3 ③):
+      1. 현행 유지? → 법명 동일? → 정상 / 개명(A)
+      2. 폐지 → 후속법 수로 B / C / D·E 분기
+    """
+    cited_name = citation.cited_law_name
+    status = history.status
+
+    # --- 1. 현행 유지 ---------------------------------------------------- #
+    if status == LawStatus.CURRENT:
+        current = history.current_name or cited_name
+        if _normalize_name(cited_name) == _normalize_name(current):
+            # 정상 — 분류 대상 아님. category=None.
+            return Result(
+                citation=citation,
+                history=history,
+                category=None,
+                confidence=Confidence.HIGH,
+                note="현행 유지·법명 일치 (정상)",
+            )
+        # 현행이지만 인용 법명이 현행명과 다름 → 약칭/부분명/표기차 = A(법명만 교체)
+        cause = {
+            "alias": "약칭",
+            "partial": "부분명(앞부분 생략)",
+        }.get(history.name_form, "표기차/개명")
+        return Result(
+            citation=citation,
+            history=history,
+            category=Category.A,
+            confidence=Confidence.HIGH,
+            successor_suggestion=current,
+            note=f"{cause}: 「{cited_name}」 → 현행 「{current}」 (풀네임 표기 권장)",
+        )
+
+    # --- 2. 개명(법인격 동일) → 조문 보존 여부로 A vs B 분기 ------------- #
+    if status == LawStatus.RENAMED:
+        current = history.current_name
+        art_key = _article_key(citation.cited_article)
+
+        # 인용 조문이 현행본에 살아있으면 깨끗한 개명(A: 법명만 교체).
+        if art_key is None or not history.alive_articles or art_key in history.alive_articles:
+            return Result(
+                citation=citation,
+                history=history,
+                category=Category.A,
+                confidence=Confidence.HIGH,
+                successor_suggestion=current,
+                note=f"단순 개명: 「{cited_name}」 → 「{current}」 (법명만 교체)",
+            )
+
+        # 법은 개명됐으나 인용 조문이 현행본에 없음(삭제/전부개정 재번호) → B.
+        return Result(
+            citation=citation,
+            history=history,
+            category=Category.B,
+            confidence=Confidence.MEDIUM,
+            successor_suggestion=current,
+            flag=True,
+            note=(
+                f"개명+조문 이동: 「{cited_name}」→「{current}」(법인격 동일)이나 "
+                f"인용 {art_key}이 현행본에 없음(삭제/재번호). 법명+조문 교체 필요 — "
+                "--map 으로 대응 조문 확인 [수동]"
+            ),
+        )
+
+    # --- 3. 폐지 → 후속법 분석 ------------------------------------------ #
+    if status == LawStatus.REPEALED:
+        n = len(history.successors)
+
+        if n == 1:
+            # 후속법 단일. 조문 대응이 깨질 수 있으므로(함정 2) 조문 교체 플래그.
+            # 단정 자동: B. 단, 조문번호 변경 가능성은 note로 경고.
+            return Result(
+                citation=citation,
+                history=history,
+                category=Category.B,
+                confidence=Confidence.MEDIUM,
+                successor_suggestion=history.successors[0],
+                flag=True,
+                note=(
+                    f"전부개정·이관: 제도가 「{history.successors[0]}」(으)로 승계. "
+                    "법명+조문 교체 필요 — 조문번호 대응 확인할 것"
+                ),
+            )
+
+        if n >= 2:
+            # 후속법 여럿 → 분할 승계 C. 호 단위 수동 매핑 필수.
+            return Result(
+                citation=citation,
+                history=history,
+                category=Category.C,
+                confidence=Confidence.MANUAL,
+                successor_suggestion=", ".join(history.successors),
+                flag=True,
+                note=(
+                    "분할 승계(1:N): 내용이 여러 법으로 분산. "
+                    "호 단위 수동 매핑 필요 [수동]"
+                ),
+            )
+
+        # n == 0: 확정 후속법 없음 → 폐지법 상세 산문 신호로 보강.
+        # 자동으로 D/E를 단정하지 않는다 — 모두 manual_required(오탐 차단, §3③).
+
+        if history.absorbed:
+            # "일반회계로 통합/흡수" 등 → 후속'법'이 없고 자체 흡수 → D 강신호.
+            note = "폐지·흡수통합: " + (history.repeal_reason or "타 회계/제도로 흡수")
+            return Result(
+                citation=citation,
+                history=history,
+                category=Category.D,
+                confidence=Confidence.MANUAL,
+                successor_suggestion=None,
+                flag=True,
+                note=note + " — 자체 완결(D) 유력, 수동 확인 [수동]",
+            )
+
+        if history.successor_candidates:
+            # 후속법 후보(타법폐지 역추적/제개정이유) — 개수로 B(이관)/C(분할) 구분.
+            cands = history.successor_candidates
+            joined = ", ".join(cands)
+            if len(cands) == 1:
+                return Result(
+                    citation=citation,
+                    history=history,
+                    category=Category.B,
+                    confidence=Confidence.MEDIUM,
+                    successor_suggestion=cands[0],
+                    flag=True,
+                    note=(
+                        f"폐지·이관 후보: 「{cands[0]}」(으)로 이관 추정. "
+                        "법명+조문 교체 — --map 으로 대응 조문 확인 [수동]"
+                    ),
+                )
+            return Result(
+                citation=citation,
+                history=history,
+                category=Category.C,
+                confidence=Confidence.MANUAL,
+                successor_suggestion=joined,
+                flag=True,
+                note=(
+                    f"폐지·분할 승계 후보: 「{joined}」 — 내용이 여러 법으로 분산. "
+                    "호 단위 수동 매핑 필요 [수동]"
+                ),
+            )
+
+        # 신호 없음 → D(자체 완결) / E(효과 마비) 갈림. 기본 후보 D, 최종은 사람이.
+        return Result(
+            citation=citation,
+            history=history,
+            category=Category.D,
+            confidence=Confidence.MANUAL,
+            successor_suggestion=None,
+            flag=True,
+            note=(
+                "폐지·후속법 없음: 자체 완결(D)인지 효과 마비(E)인지 수동 확인 필요. "
+                "E일 경우 최우선 검토 [수동]"
+            ),
+        )
+
+    # --- status UNKNOWN: 조회 실패 -------------------------------------- #
+    return Result(
+        citation=citation,
+        history=history,
+        category=None,
+        confidence=Confidence.LOW,
+        flag=True,
+        note="연혁 조회 실패 — 대상 법령 상태 미확인 [수동]",
+    )

lawdangle/cli.py

@@ -0,0 +1,196 @@
+"""`lawdangle <법령ID 또는 파일>` — 한 줄 실행.
+
+DESIGN.md §3 ④ / §4.
+파이프라인: parse → resolve → classify → report.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from . import report
+from .classifier import classify
+from .mapper import enrich_result, suggest_mapping, suggest_mapping_auto
+from .parser import parse_citations
+from .resolver import FixtureResolver, LawGoKrResolver, Resolver
+from .models import Result
+
+
+def _build_resolver(args) -> Resolver:
+    """--fixture 우선, 없으면 OC(법제처 API 키)로 라이브 resolver."""
+    if args.fixture:
+        return FixtureResolver.from_files(*args.fixture)
+    oc = args.oc or os.environ.get("LAW_OC")
+    if not oc:
+        sys.exit(
+            "법제처 API 키(OC)가 없습니다. --oc 또는 LAW_OC 환경변수, "
+            "또는 오프라인이면 --fixture <연혁.json> 을 지정하세요."
+        )
+    return LawGoKrResolver(oc)
+
+
+def run(
+    text: str, resolver: Resolver, *, citing_law: str = "", deep: bool = False
+) -> list[Result]:
+    """파이프라인 한 번: 텍스트 → 판정 결과 리스트.
+
+    deep=True 면 B/이관·개명+조문이동 건에 구체 대응 조문 제안까지 붙인다
+    (라이브 resolver 필요 — 조문 매핑은 네트워크 조회).
+    """
+    citations = parse_citations(text, citing_law=citing_law)
+    results = [classify(c, resolver.resolve(c.cited_law_name)) for c in citations]
+    if deep and isinstance(resolver, LawGoKrResolver):
+        results = [enrich_result(r, resolver) for r in results]
+    return results
+
+
+def run_law(law_name: str, resolver: LawGoKrResolver, *, deep: bool = False) -> list[Result]:
+    """법령명으로 현행 본문을 직접 가져와 조 단위로 죽은 인용을 분석한다.
+
+    텍스트 붙여넣기의 약점(판례 혼입·표기깨짐·citing_article 미상)을 피하는
+    권장 입력 경로. 각 조문에서 인용을 추출하고 citing_article을 채운다.
+    """
+    arts = resolver.current_articles(law_name)
+    if not arts:
+        raise ValueError(f"현행 법령 「{law_name}」을(를) 찾지 못했습니다(법령명 확인).")
+    results: list[Result] = []
+    for art_key, body in arts.items():
+        for c in parse_citations(body, citing_law=law_name, citing_article=art_key):
+            r = classify(c, resolver.resolve(c.cited_law_name))
+            if deep:
+                r = enrich_result(r, resolver)
+            results.append(r)
+    return results
+
+
+def _run_map(args) -> int:
+    """--map: '옛법령 조문 [후속법령]' → 조문 대응 순위 제안(라이브 전용).
+
+    후속법령 생략 시 본문 기반으로 후속법을 자동 발견(분할 이관 포함).
+    """
+    oc = args.oc or os.environ.get("LAW_OC")
+    if not oc:
+        sys.exit("조문 대응 제안은 법제처 API 키(--oc 또는 LAW_OC)가 필요합니다.")
+    if len(args.map) not in (2, 3):
+        sys.exit("--map 는 '옛법령 조문' 또는 '옛법령 조문 후속법령' 형식입니다.")
+    resolver = LawGoKrResolver(oc)
+
+    if len(args.map) == 3:
+        old_law, article, successor = args.map
+        s = suggest_mapping(resolver, old_law, article, successor)
+    else:
+        old_law, article = args.map
+        print("후속법 자동 발견 중… (본문 기반)")
+        s = suggest_mapping_auto(resolver, old_law, article)
+        if s is None:
+            print(f"옛 법 「{old_law}」 {article}의 후속법을 찾지 못했습니다.")
+            return 0
+
+    print(f"옛 법령 : 「{s.old_law}」 {s.old_article}"
+          + (f"  (실본문 {s.old_article_version} 시행본)" if s.old_article_version else ""))
+    if s.old_snippet:
+        print(f"옛 조문 : {s.old_snippet}…")
+    print(f"후속법령: 「{s.successor_law}」" + (" (자동발견)" if len(args.map) == 2 else ""))
+    print(f"판정    : {'유력' if s.confident else '수동확인'} — {s.note}")
+    if s.candidates:
+        print("후보(유사도순):")
+        for i, c in enumerate(s.candidates, 1):
+            print(f"  {i}. {c.article}  (유사도 {c.score})  {c.snippet}…")
+    else:
+        print("후보: 없음")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(
+        prog="lawdangle",
+        description="현행 법령의 죽은 참조(폐지·개명·이관·사문화)를 탐지·5분류.",
+    )
+    p.add_argument(
+        "input",
+        nargs="?",
+        help="법령 본문 텍스트 파일 경로 (- 는 표준입력). --law/--map 모드에선 생략",
+    )
+    p.add_argument(
+        "--law",
+        metavar="법령명",
+        help="법령명으로 현행 본문을 가져와 조 단위로 분석(권장 입력, 라이브)",
+    )
+    p.add_argument(
+        "--map",
+        nargs="+",
+        metavar="옛법령 조문 [후속법령]",
+        help="조문 대응 제안: '옛법령 조문' (후속법 자동발견) 또는 '옛법령 조문 후속법령' (직접 지정)",
+    )
+    p.add_argument("--citing-law", default="", help="인용하는 쪽 법령명(리포트용)")
+    p.add_argument("--oc", help="법제처 OPEN API 인증키(OC). 없으면 LAW_OC 환경변수")
+    p.add_argument(
+        "--fixture",
+        nargs="+",
+        help="오프라인 연혁 fixture JSON (지정 시 API 미사용)",
+    )
+    p.add_argument(
+        "--format",
+        choices=("csv", "json", "summary"),
+        default="summary",
+        help="출력 형식 (기본 summary)",
+    )
+    p.add_argument(
+        "--deep",
+        action="store_true",
+        help="B/개명+조문이동 건에 구체 대응 조문까지 매핑(라이브, 느림)",
+    )
+    p.add_argument("-o", "--output", help="출력 파일 (미지정 시 표준출력)")
+
+    # Windows 콘솔(cp949) 등에서 한글/em-dash 출력 깨짐·크래시 방지.
+    # parse_args() 전에 재설정해야 --help·인자 오류 메시지도 깨지지 않음.
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+
+    args = p.parse_args(argv)
+
+    # --- 조문 대응 제안 모드 -------------------------------------------- #
+    if args.map:
+        return _run_map(args)
+
+    # --- 법령명 분석 모드(권장) ----------------------------------------- #
+    if args.law:
+        oc = args.oc or os.environ.get("LAW_OC")
+        if not oc:
+            sys.exit("--law 모드는 법제처 API 키(--oc 또는 LAW_OC)가 필요합니다.")
+        try:
+            results = run_law(args.law, LawGoKrResolver(oc), deep=args.deep)
+        except ValueError as e:
+            sys.exit(str(e))
+    else:
+        if not args.input:
+            p.error("input 파일이 필요합니다 (또는 --law / --map 모드를 쓰세요)")
+        if args.input == "-":
+            text = sys.stdin.read()
+        else:
+            text = Path(args.input).read_text(encoding="utf-8")
+        resolver = _build_resolver(args)
+        results = run(text, resolver, citing_law=args.citing_law, deep=args.deep)
+
+    if args.format == "csv":
+        out = report.to_csv(results)
+    elif args.format == "json":
+        out = report.to_json(results)
+    else:
+        out = report.format_summary(results)
+
+    if args.output:
+        Path(args.output).write_text(out, encoding="utf-8")
+        # 요약은 콘솔에도 한 번 보여준다.
+        print(report.format_summary(results), file=sys.stderr)
+    else:
+        print(out)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())