kocer 0.1.0__py3-none-any.whl

kocer/__init__.py

@@ -0,0 +1,80 @@
+"""kocer — 한국어 STT를 공정하게 채점하는 CER/WER.
+띄어쓰기·문장부호·숫자 표기·영문 약어 차이를 오류로 세지 않는다."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Sequence, Union
+
+from . import numbers as _numbers
+from .align import Op, align, distance
+from .normalize import normalize as _normalize
+
+__version__ = "0.1.0"
+__all__ = ["cer", "wer", "measure", "Result"]
+
+Text = Union[str, Sequence[str]]
+
+
+@dataclass
+class Result:
+    cer: float            # 정규화 후 오류율 (unit="word"면 WER)
+    raw_cer: float        # 정규화 전 오류율 (jiwer와 같은 값)
+    hits: int
+    substitutions: int
+    deletions: int
+    insertions: int
+    alignment: List[Op] = field(repr=False)
+    chosen_ref: str = ""  # 숫자 후보 중 실제로 채택된 정답
+    chosen_hyp: str = ""
+
+    @property
+    def ops(self):
+        return {"S": self.substitutions, "D": self.deletions, "I": self.insertions}
+
+    @property
+    def errors(self) -> int:
+        return self.substitutions + self.deletions + self.insertions
+
+
+def _units(text: str, unit: str) -> List[str]:
+    return text.split() if unit == "word" else list(text.replace(" ", ""))
+
+
+def measure(reference: str, hypothesis: str, *, unit: str = "char", normalize: bool = True,
+            numbers: bool = True, punct: bool = True, fillers: bool = False, letters: bool = True) -> Result:
+    raw_ref, raw_hyp = (reference.split(), hypothesis.split()) if unit == "word" else (list(reference), list(hypothesis))
+    raw = distance(raw_ref, raw_hyp) / max(len(raw_ref), 1)
+
+    ref, hyp = reference, hypothesis
+    if normalize:
+        ref = _normalize(reference, punct, fillers, letters)
+        hyp = _normalize(hypothesis, punct, fillers, letters)
+        if numbers:
+            # shortcut: hyp 후보를 먼저 ref 원문에 맞춰 고르고, 그다음 ref 후보를 고른 hyp에 맞춤(양쪽 곱집합 아님), 혼합 표기에서 틀리면 곱집합으로 올릴 것
+            hyp = _numbers.best(hyp, lambda c: distance(_units(ref, unit), _units(c, unit)))
+            ref = _numbers.best(ref, lambda c: distance(_units(c, unit), _units(hyp, unit)))
+    r, h = (_units(ref, unit), _units(hyp, unit)) if normalize else (raw_ref, raw_hyp)
+    ops = align(r, h)
+    counts = {k: sum(op == k for op, _, _ in ops) for k in "HSDI"}
+    err = counts["S"] + counts["D"] + counts["I"]
+    return Result(err / max(len(r), 1), raw, counts["H"], counts["S"], counts["D"], counts["I"], ops, ref, hyp)
+
+
+def _rate(reference: Text, hypothesis: Text, unit: str, **opts) -> float:
+    if isinstance(reference, str):
+        reference, hypothesis = [reference], [hypothesis]
+    if len(reference) != len(hypothesis):
+        raise ValueError("reference and hypothesis must have the same length")
+    results = [measure(r, h, unit=unit, **opts) for r, h in zip(reference, hypothesis)]
+    total = sum(x.hits + x.substitutions + x.deletions for x in results)
+    return sum(x.errors for x in results) / max(total, 1)
+
+
+def cer(reference: Text, hypothesis: Text, **opts) -> float:
+    """jiwer.cer 호환. 문자열 하나 또는 리스트."""
+    return _rate(reference, hypothesis, "char", **opts)
+
+
+def wer(reference: Text, hypothesis: Text, **opts) -> float:
+    """jiwer.wer 호환. 띄어쓰기 차이는 오류로 센다 (한국어 WER의 한계)."""
+    return _rate(reference, hypothesis, "word", **opts)

kocer/align.py

@@ -0,0 +1,33 @@
+"""편집거리 + 정렬. 문자 리스트든 단어 리스트든 같은 코드."""
+from typing import List, Sequence, Tuple
+
+Op = Tuple[str, str, str]  # ('H'|'S'|'D'|'I', ref_item, hyp_item)
+
+
+def align(ref: Sequence[str], hyp: Sequence[str]) -> List[Op]:
+    n, m = len(ref), len(hyp)
+    d = [[0] * (m + 1) for _ in range(n + 1)]
+    for i in range(1, n + 1):
+        d[i][0] = i
+    for j in range(1, m + 1):
+        d[0][j] = j
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (ref[i - 1] != hyp[j - 1]))
+    ops: List[Op] = []
+    i, j = n, m
+    while i or j:
+        if i and j and d[i][j] == d[i - 1][j - 1] + (ref[i - 1] != hyp[j - 1]):
+            ops.append(("H" if ref[i - 1] == hyp[j - 1] else "S", ref[i - 1], hyp[j - 1]))
+            i, j = i - 1, j - 1
+        elif i and d[i][j] == d[i - 1][j] + 1:
+            ops.append(("D", ref[i - 1], ""))
+            i -= 1
+        else:
+            ops.append(("I", "", hyp[j - 1]))
+            j -= 1
+    return ops[::-1]
+
+
+def distance(ref: Sequence[str], hyp: Sequence[str]) -> int:
+    return sum(op != "H" for op, _, _ in align(ref, hyp))

kocer/cli.py

@@ -0,0 +1,51 @@
+"""kocer ref.txt hyp.txt [--diff]  — 줄 단위 쌍을 채점."""
+import argparse
+import sys
+
+from . import __version__, measure
+
+RED, GREEN, STRIKE, END = "\x1b[31m", "\x1b[32m", "\x1b[9;31m", "\x1b[0m"
+
+
+def render(alignment) -> str:
+    out = []
+    for op, r, h in alignment:
+        if op == "H":
+            out.append(r)
+        elif op == "S":
+            out.append(f"{RED}{h}{END}")
+        elif op == "D":
+            out.append(f"{STRIKE}{r}{END}")
+        else:
+            out.append(f"{GREEN}{h}{END}")
+    return "".join(out)
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog="kocer", description=__doc__)
+    p.add_argument("ref")
+    p.add_argument("hyp")
+    p.add_argument("--diff", action="store_true", help="틀린 글자를 색으로 표시 (빨강=치환/삭제, 초록=삽입)")
+    p.add_argument("--no-numbers", action="store_true", help="숫자 정규화 끔")
+    p.add_argument("--version", action="version", version=__version__)
+    a = p.parse_args(argv)
+    refs = open(a.ref, encoding="utf-8").read().splitlines()
+    hyps = open(a.hyp, encoding="utf-8").read().splitlines()
+    if len(refs) != len(hyps):
+        sys.exit(f"줄 수가 다릅니다: ref {len(refs)}, hyp {len(hyps)}")
+    err = raw_err = total = 0
+    for i, (r, h) in enumerate(zip(refs, hyps), 1):
+        m = measure(r, h, numbers=not a.no_numbers)
+        n = m.hits + m.substitutions + m.deletions
+        err += m.errors
+        raw_err += round(m.raw_cer * max(len(r), 1))
+        total += n
+        if a.diff and m.errors:
+            print(f"{i}: {render(m.alignment)}  (cer {m.cer:.3f})")
+    print(f"raw CER   {raw_err / max(sum(map(len, refs)), 1):.4f}")
+    print(f"kocer CER {err / max(total, 1):.4f}   ({len(refs)} lines)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

kocer/counters.py

@@ -0,0 +1,30 @@
+"""조수사 사전. 고유어 읽기(세 개) / 한자어 읽기(삼 층) 중 어느 쪽이 쓰이는지.
+사전에 없는 조수사는 두 읽기를 모두 후보로 넣는다 (틀리게 감점하는 것보다 관대한 쪽이 안전)."""
+
+NATIVE = {
+    "개", "명", "시", "시간", "살", "마리", "번", "번째", "잔", "병", "권", "장", "대", "그루",
+    "송이", "사람", "켤레", "벌", "채", "척", "통", "자루", "줄", "곳", "군데", "가지", "달",
+    "끼", "판", "조각", "알", "포기", "다발", "봉지", "상자", "컵", "접시", "쌍", "팀", "배",
+    "편", "곡", "줄기", "개월",  # 개월은 "삼 개월"이 표준이지만 "세 개월"도 흔히 쓰임 → 아래 SINO에도 넣어 둘 다 허용
+}
+SINO = {
+    "층", "원", "년", "월", "일", "호", "초", "세", "도", "퍼센트", "미터", "킬로미터", "킬로그램",
+    "그램", "리터", "번지", "학년", "반", "쪽", "페이지", "교시", "차", "회", "주", "개월", "세기",
+    "등", "위", "점", "인분", "인", "호선", "분기", "단계", "차선", "번길", "동", "급", "차례",
+}
+# 둘 다에 있으면 lookup은 None(둘 다 허용)으로 처리된다
+_BOTH = NATIVE & SINO
+MAX_LEN = max(map(len, NATIVE | SINO))
+
+
+def lookup(following: str):
+    """숫자 뒤에 오는 글자들에서 가장 긴 조수사를 찾아 'native' | 'sino' | None 반환."""
+    for n in range(min(MAX_LEN, len(following)), 0, -1):
+        word = following[:n]
+        if word in _BOTH:
+            return None
+        if word in NATIVE:
+            return "native"
+        if word in SINO:
+            return "sino"
+    return None

kocer/normalize.py

@@ -0,0 +1,48 @@
+"""단계별 정규화. 각 단계는 독립 함수, normalize()가 순서대로 적용."""
+import re
+import unicodedata
+
+# 숫자 사이의 . 과 , (3.5 / 1,000)는 남긴다
+_PUNCT = re.compile(r"(?<!\d)[.,]|[.,](?!\d)|[?!~…·'\"‘’“”()\[\]{}<>:;/\\_\-—–、。，！？「」『』【】]")
+_THOUSANDS = re.compile(r"(?<=\d),(?=\d)")
+_FILLER = re.compile(r"(?<!\S)(?:음+|어+|아+|에+|그+)(?!\S)")
+_LETTERS = dict(zip(
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    "에이 비 시 디 이 에프 지 에이치 아이 제이 케이 엘 엠 엔 오 피 큐 알 에스 티 유 브이 더블유 엑스 와이 지".split(),
+))
+_UNITS = {"%": "퍼센트", "km": "킬로미터", "kg": "킬로그램", "cm": "센티미터", "mm": "밀리미터", "ml": "밀리리터"}
+_UNIT_RE = re.compile(r"(?<=\d)\s*(" + "|".join(map(re.escape, sorted(_UNITS, key=len, reverse=True))) + r")(?![A-Za-z])")
+_CAPS = re.compile(r"[A-Z]+")
+
+
+def nfc(text: str) -> str:
+    return unicodedata.normalize("NFC", text)
+
+
+def strip_punct(text: str) -> str:
+    return _PUNCT.sub(" ", _THOUSANDS.sub("", text))
+
+
+def strip_fillers(text: str) -> str:
+    return _FILLER.sub(" ", text)
+
+
+def spell_letters(text: str) -> str:
+    """AI → 에이아이, 50% → 50퍼센트. 대문자 연속과 단위 기호만 바꾼다."""
+    text = _UNIT_RE.sub(lambda m: _UNITS[m.group(1)], text)
+    return _CAPS.sub(lambda m: "".join(_LETTERS[c] for c in m.group()), text)
+
+
+def squeeze(text: str) -> str:
+    return " ".join(text.split())
+
+
+def normalize(text: str, punct: bool = True, fillers: bool = False, letters: bool = True) -> str:
+    text = nfc(text)
+    if punct:
+        text = strip_punct(text)
+    if fillers:
+        text = strip_fillers(text)
+    if letters:
+        text = spell_letters(text)
+    return squeeze(text)

kocer/numbers.py

@@ -0,0 +1,103 @@
+"""숫자 읽기와 후보 전개."""
+from __future__ import annotations
+
+import re
+from itertools import product
+from typing import Callable, List, Sequence, Tuple
+
+from .counters import lookup
+
+NUMBER = re.compile(r"\d+(?:\.\d+)?")  # 천 단위 콤마는 normalize 단계에서 이미 제거됨
+
+_DIGIT = "영일이삼사오육칠팔구"
+_SMALL = ["", "십", "백", "천"]
+_BIG = ["", "만", "억", "조", "경"]
+_NATIVE_TENS = ["", "열", "스물", "서른", "마흔", "쉰", "예순", "일흔", "여든", "아흔"]
+_NATIVE_ONES = ["", "한", "두", "세", "네", "다섯", "여섯", "일곱", "여덟", "아홉"]
+
+
+def digitwise(s: str) -> str:
+    """010 → 공일공, 1234 → 일이삼사 (전화번호·코드)."""
+    return "".join("공" if c == "0" else _DIGIT[int(c)] for c in s if c.isdigit())
+
+
+def _sino_small(n: int) -> str:
+    out = []
+    for pos in (3, 2, 1, 0):
+        d = n // 10**pos % 10
+        if d == 0:
+            continue
+        out.append(("" if d == 1 and pos else _DIGIT[d]) + _SMALL[pos])
+    return "".join(out)
+
+
+def sino(s: str) -> str:
+    """한자어 읽기. 2024 → 이천이십사, 15000 → 만오천, 3.5 → 삼점오."""
+    if "." in s:
+        whole, frac = s.split(".", 1)
+        return sino(whole) + "점" + digitwise(frac)
+    if s.startswith("0") and len(s) > 1:
+        return digitwise(s)
+    n = int(s)
+    if n == 0:
+        return "영"
+    parts = []
+    i = 0
+    while n:
+        g, n = n % 10000, n // 10000
+        if g:
+            parts.append(("" if g == 1 and i == 1 else _sino_small(g)) + _BIG[i])
+        i += 1
+    return "".join(reversed(parts))
+
+
+def native(s: str):
+    """고유어 관형형 읽기 (3 → 세, 20 → 스무, 21 → 스물한). 1~99만 지원, 그 외 None."""
+    if not s.isdigit() or not 1 <= int(s) <= 99:
+        return None
+    n = int(s)
+    if n == 20:
+        return "스무"
+    return _NATIVE_TENS[n // 10] + _NATIVE_ONES[n % 10]
+
+
+def options(num: str, following: str) -> List[str]:
+    """숫자 하나의 읽기 후보. 원문 숫자는 항상 포함."""
+    kind = lookup(following.lstrip())
+    opts = [num]
+    nat = native(num) if kind != "sino" else None
+    if nat:
+        opts.append(nat)
+    if kind != "native" or not nat:  # 고유어 읽기가 없는 수(100개 → 백 개)는 한자어로
+        opts.append(sino(num))
+    if len(num) >= 2 and num.isdigit() and not num.startswith("0"):
+        opts.append(digitwise(num))  # 2024 → 이공이사, 전화번호 등
+    return list(dict.fromkeys(opts))
+
+
+def _spans(text: str) -> List[Tuple[int, int, List[str]]]:
+    return [(m.start(), m.end(), options(m.group(), text[m.end():m.end() + 6])) for m in NUMBER.finditer(text)]
+
+
+def _build(text: str, spans, choice: Sequence[str]) -> str:
+    for (start, end, _), rep in sorted(zip(spans, choice), reverse=True):
+        text = text[:start] + rep + text[end:]
+    return text
+
+
+def best(text: str, score: Callable[[str], float], limit: int = 1024) -> str:
+    """text의 숫자들을 읽기 후보로 바꿔 본 문자열 중 score가 최소인 것."""
+    spans = _spans(text)
+    if not spans:
+        return text
+    total = 1
+    for _, _, o in spans:
+        total *= len(o)
+    if total <= limit:
+        return min((_build(text, spans, c) for c in product(*(o for _, _, o in spans))), key=score)
+    # shortcut: 후보 조합이 limit 초과면 구간별로 따로 고름(다른 구간은 원문 숫자 유지), 인접 구간 간섭으로 틀리면 묶음 전개로 올릴 것
+    base = [o[0] for _, _, o in spans]
+    choice = []
+    for i, (_, _, o) in enumerate(spans):
+        choice.append(min(o, key=lambda opt: score(_build(text, spans, base[:i] + [opt] + base[i + 1:]))))
+    return _build(text, spans, choice)

kocer-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.5
+Name: kocer
+Version: 0.1.0
+Summary: 한국어 STT를 공정하게 채점하는 CER/WER — 띄어쓰기·숫자·문장부호 차이를 오류로 세지 않음
+Project-URL: Repository, https://github.com/Choi-kwan-u/kocer
+Author: Choi Kwan-u
+License-Expression: MIT
+License-File: LICENSE
+Keywords: asr,cer,evaluation,korean,stt,wer
+Classifier: Natural Language :: Korean
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# kocer
+
+한국어 STT를 공정하게 채점하는 CER — 띄어쓰기·숫자·문장부호·영문 약어 표기 차이를 오류로 세지 않습니다.
+
+*Fair CER/WER for Korean speech recognition. Spacing, punctuation, number notation (3개 ↔ 세 개) and Latin acronyms (AI ↔ 에이아이) are not counted as errors. Pure Python, zero dependencies, `jiwer`-compatible API.*
+
+```
+ref: 사과 세 개 주세요
+hyp: 사과 3개 주세요
+jiwer CER 0.200   nlptutti CER 0.143   kocer CER 0.000
+```
+
+## 설치
+
+```bash
+pip install git+https://github.com/Choi-kwan-u/kocer.git
+```
+
+## 사용
+
+```python
+import kocer
+
+kocer.cer("사과 세 개 주세요", "사과 3개 주세요")   # 0.0
+kocer.cer(refs, hyps)                                # 리스트도 됨 (jiwer와 같은 코퍼스 집계)
+kocer.wer(ref, hyp)
+
+r = kocer.measure("세 시 삼십 분", "3시 30분")
+r.cer         # 0.0  정규화 후
+r.raw_cer     # 0.625  정규화 전 (jiwer와 같은 값). 둘의 차이가 "가짜 오류"의 크기
+r.ops         # {'S': 0, 'D': 0, 'I': 0}
+r.alignment   # [('H', '세', '세'), ...]
+r.chosen_ref  # 숫자 후보 중 실제로 채택된 정답
+r.chosen_hyp  # '세시삼십분'
+```
+
+```bash
+kocer ref.txt hyp.txt          # 줄 단위 쌍, raw CER과 kocer CER을 같이 출력
+kocer ref.txt hyp.txt --diff   # 틀린 글자만 색으로 표시
+```
+
+## 무엇을 무시하고, 무엇을 세는가
+
+정규화는 순서대로 적용되고 각 단계를 끌 수 있습니다.
+
+| 단계 | 기본 | 끄기 | 예 |
+|---|---|---|---|
+| 유니코드 NFC | 켬 | - | 자모 분리 입력 |
+| 문장부호 제거 | 켬 | `punct=False` | `네, 알겠습니다.` = `네 알겠습니다` |
+| 필러 제거 (음, 어, 그) | **끔** | `fillers=True` | 실제 단어 "그"도 지워질 수 있어 기본은 끔 |
+| 영문 약어·단위 | 켬 | `letters=False` | `AI` = `에이아이`, `50%` = `50퍼센트` |
+| 숫자 후보 전개 | 켬 | `numbers=False` | `3개` = `세 개`, `3층` = `삼 층` |
+| 공백 제거 | CER만 | - | WER은 공백 유지 |
+
+`normalize=False`면 jiwer와 같은 순수 CER을 돌려줍니다.
+
+### 숫자: 정답 하나가 아니라 후보 집합
+
+숫자는 조수사에 따라 읽기가 달라서(3개=세 개, 3층=삼 층, 3시 30분=세 시 삼십 분) 규칙 하나로 정답을 만들 수 없습니다. kocer는 숫자마다 `{원문 숫자, 한자어 읽기, 고유어 읽기, 자릿수 읽기}` 후보를 만들고 CER이 최소가 되는 조합을 고릅니다.
+
+- 조수사 사전([counters.py](src/kocer/counters.py))에 있으면 그 읽기만, **없으면 두 읽기 모두 허용**합니다. 틀리게 감점하는 것보다 관대한 쪽이 안전하다는 정책입니다.
+- 반대 방향(ref가 한글 수사, hyp가 숫자)도 처리합니다.
+- 전화번호·연도는 자릿수 읽기(010 = 공일공, 2024 = 이공이사)도 후보에 들어갑니다.
+- 고유어 읽기는 1~99까지. `100개`는 `백 개`만 허용합니다.
+
+### "너무 관대하다"는 비판에 대해
+
+정규화는 실제 오류를 숨길 수 있습니다. 그래서 `raw_cer`를 항상 같이 돌려주고, 모든 단계를 끌 수 있게 했습니다. 두 값을 같이 보고하세요.
+
+## 기존 도구 비교 (2026-10-23 실측)
+
+nlptutti 0.0.0.24, jiwer 4.0.0. [tests/cases.tsv](tests/cases.tsv)의 케이스 일부.
+
+| ref | hyp | jiwer | nlptutti | kocer |
+|---|---|---|---|---|
+| 사과 세 개 주세요 | 사과 3개 주세요 | 0.200 | 0.143 | 0.000 |
+| 삼 층으로 가세요 | 3층으로 가세요 | 0.222 | 0.143 | 0.000 |
+| 세 시 삼십 분 | 3시 30분 | 0.625 | 0.600 | 0.000 |
+| 에이아이 모델 | AI 모델 | 0.571 | 0.667 | 0.000 |
+| 네, 알겠습니다. | 네 알겠습니다 | 0.222 | 0.000 | 0.000 |
+| 오늘날씨가좋다 | 오늘 날씨가 좋다 | 0.286 | 0.000 | 0.000 |
+
+nlptutti는 띄어쓰기·문장부호를 이미 처리하고, CLI·코퍼스 비교 리포트·개체명 평가 등 kocer에 없는 기능이 많습니다. kocer의 차이는 숫자·영문 약어 정규화와 `raw_cer` 대비 표시입니다.
+
+## 한계
+
+- WER은 띄어쓰기 차이를 오류로 셉니다. 한국어 WER의 본질적 한계이고, CER을 권합니다.
+- 조수사 사전은 완전하지 않습니다. 사전에 없는 조수사는 두 읽기를 다 허용합니다. 케이스를 [tests/cases.tsv](tests/cases.tsv)에 추가하는 PR을 환영합니다.
+- 입력은 텍스트 쌍만 받습니다. 음성 파일·모델 실행은 다루지 않습니다.
+
+## 라이선스
+
+MIT

kocer-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+kocer/__init__.py,sha256=V8wQcUkAcSsqpo0Ga201nfFgvUIyXAYsDxVvRk03WYc,3471
+kocer/align.py,sha256=7tifOcYm3FguCxlIwmzQJv0O3peD_9DoruJlT9cEns0,1197
+kocer/cli.py,sha256=ZHDFpjDEYj9MfPBQRN-KzUhCEAAvYDPqXrBrA0tS0U4,1822
+kocer/counters.py,sha256=rXlL65KG1GRE2t37MI1ABwDuLLw_WGX_0HZFLBF1q9Q,1656
+kocer/normalize.py,sha256=TIgdFwg49TAm1C_vubaEZkERMZSc8pp0w_YPiyjMcUc,1800
+kocer/numbers.py,sha256=uBifqSMI8hey3jBXWgZN4En_dB0ti_FmBHx74vPuUNE,3751
+kocer-0.1.0.dist-info/METADATA,sha256=GSdJZCTgDChm1V-05dxWjQ_NQfI288NJA6Do7NA6D38,5162
+kocer-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+kocer-0.1.0.dist-info/entry_points.txt,sha256=YakXBTnGpatVwAOLySzNWTGd2nQJ58qu6oszrVJm1u4,41
+kocer-0.1.0.dist-info/licenses/LICENSE,sha256=GTvv-ikQ5g2GPIGqfUKAoX4CZBcJ-YDYrxrQz8M5Jr8,1068
+kocer-0.1.0.dist-info/RECORD,,

kocer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

kocer-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kocer = kocer.cli:main

kocer-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Choi Kwan-u
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.