ru-humanizer 3.26.0__py3-none-any.whl

humanizer_metrics/__init__.py

@@ -0,0 +1,100 @@
+"""humanizer_metrics — детерминированные метрики живости текста.
+
+Это грепабельная половина режима «Аудит» из SKILL.md: то, что считается
+машиной, а не LLM. Используется и как локальный буст для Claude Code, и как
+движок eval-харнеса (eval/run_eval.py), и как self-test самого скилла
+(scripts/lint_skill.py).
+
+Семантику (кальки, ирония, translationese, голос) тут не ловим — для этого
+нужен сам скилл. Скрипты не работают в claude.ai web; скилл от них не зависит.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+
+from .burstiness import RhythmStats, rhythm, rhythm_verdict
+from .markers import (
+    MarkerHit,
+    marker_verdict,
+    scan_hard_bans,
+    scan_markers,
+)
+from .morphology import MorphStats, morph_stats, morph_verdict
+from .structure import StructureStats, structure_stats, structure_verdict
+from .score import ScoreResult, cleanliness_score
+
+__all__ = [
+    "Report",
+    "analyze",
+    "RhythmStats",
+    "MorphStats",
+    "StructureStats",
+    "MarkerHit",
+    "ScoreResult",
+    "cleanliness_score",
+    "rhythm",
+    "morph_stats",
+    "structure_stats",
+    "scan_hard_bans",
+    "scan_markers",
+    "mask_foreign",
+    "strip_foreign",
+    "GAP",
+    "QUOTE_MAX_WORDS",
+]
+
+
+@dataclass
+class Report:
+    hard_bans: list[MarkerHit]
+    markers: list[MarkerHit]
+    rhythm: RhythmStats
+    morph: MorphStats
+    structure: StructureStats
+
+    @property
+    def hard_ban_count(self) -> int:
+        return sum(h.count for h in self.hard_bans)
+
+    @property
+    def marker_count(self) -> int:
+        return sum(h.count for h in self.markers)
+
+    def as_dict(self) -> dict:
+        return {
+            "hard_ban_count": self.hard_ban_count,
+            "hard_bans": [(h.marker, h.count) for h in self.hard_bans],
+            "marker_count": self.marker_count,
+            "markers": [(h.category, h.marker, h.count) for h in self.markers],
+            "rhythm": self.rhythm.as_dict(),
+            "morph": self.morph.as_dict(),
+            "structure": self.structure.as_dict(),
+        }
+
+
+# --- Код и цитаты не текст автора ------------------------------------------
+# Разбор границ Markdown живёт в markdown.py (один построчный проход по
+# CommonMark и таблица тестов), здесь только две проекции текста.
+from .markdown import GAP, QUOTE_MAX_WORDS, mask_foreign, strip_foreign  # noqa: E402
+from .facts import Facts, FactsDiff, diff_facts, extract_facts, facts_verdict  # noqa: E402
+
+mask_code_and_quotes = mask_foreign
+strip_code = strip_foreign
+
+
+def analyze(text: str) -> Report:
+    """Полный детерминированный прогон текста."""
+    lexical = mask_code_and_quotes(text)
+    prose = strip_code(text)
+    stats = rhythm(prose)
+    # Тире внутри короткой цитаты («Война — и мир») не типографика автора:
+    # считаем его по заглушенному тексту, ритм по прозе с цитатами.
+    stats = replace(stats, em_dash=lexical.count("—"))
+    return Report(
+        hard_bans=scan_hard_bans(lexical),
+        markers=scan_markers(lexical),
+        rhythm=stats,
+        morph=morph_stats(prose),
+        structure=structure_stats(prose),
+    )

humanizer_metrics/burstiness.py

@@ -0,0 +1,132 @@
+"""Ритм и типографика: то, что скилл велит измерять дисперсией, а не на глаз.
+
+Закрывает пункты чеклиста «вариативность длины предложений — не средняя, а
+ДИСПЕРСИЯ» и «ноль длинных тире». Burstiness тут — статистический прокси, не сам
+детектор: высокий разброс длины предложений коррелирует с человеческим письмом
+(SKILL.md, раздел «Что ловят детекторы»).
+"""
+
+from __future__ import annotations
+
+import re
+import statistics
+from dataclasses import dataclass
+
+from razdel import sentenize, tokenize
+
+
+@dataclass
+class RhythmStats:
+    sentences: int
+    words: int
+    mean_len: float          # средняя длина предложения в словах
+    stdev_len: float         # стандартное отклонение длины
+    cv_len: float            # коэффициент вариации = stdev/mean (главный показатель)
+    min_len: int
+    max_len: int
+    short_share: float       # доля предложений < 5 слов
+    long_share: float        # доля предложений > 25 слов
+    em_dash: int             # длинных тире «—»
+    ellipsis: int            # многоточий
+    parentheses: int         # скобочных ремарок
+    questions: int           # вопросительных предложений
+    staccato_runs: int = 0   # цепочек из 3+ обрывков подряд (каталог #49)
+    staccato_max: int = 0    # длина самой длинной такой цепочки
+
+    def as_dict(self) -> dict:
+        return self.__dict__.copy()
+
+
+_WORD_RE = re.compile(r"[А-Яа-яЁёA-Za-z0-9]")
+
+
+def _word_count(sentence: str) -> int:
+    return sum(1 for t in tokenize(sentence) if _WORD_RE.search(t.text))
+
+
+# Рваная медитативность (каталог #49): «Короткие. Точные. Отдельные.» Цепочка
+# из трёх и более утверждений по 1-3 слова подряд. Не считаются реплики диалога
+# (строка с тире или кавычки в начале), восклицания, вопросы, подводки с
+# двоеточием, пункты списков и заголовки: там обрывки законны. Порог выбран по
+# 400 постам Пикабу: доля обрывков в тексте срабатывала на 5-12% живых текстов
+# и отвергнута, цепочка из трёх подряд даёт 4 из 400 (eval/OVERCORRECTION_CHECK.md).
+STACCATO_MAX_WORDS = 3
+STACCATO_MIN_RUN = 3
+_DIALOG_RE = re.compile(r"^\s*[-–—«\"']")
+_SKIP_LINE_RE = re.compile(r"^\s*(?:(?:[-*•]|\d+[.)])\s+|#)")
+
+
+def staccato_runs(text: str) -> tuple[int, int]:
+    """(число цепочек, длина самой длинной). Цепочка не переходит через строку."""
+    runs: list[int] = []
+    for line in text.replace("\\", "").split("\n"):
+        if not line.strip() or _SKIP_LINE_RE.match(line):
+            continue
+        cur = 0
+        for s in sentenize(line):
+            st = s.text.strip()
+            n = _word_count(st)
+            if not n:
+                continue
+            if n <= STACCATO_MAX_WORDS and not _DIALOG_RE.match(st) and st[-1] not in "?!:;":
+                cur += 1
+            else:
+                if cur >= STACCATO_MIN_RUN:
+                    runs.append(cur)
+                cur = 0
+        if cur >= STACCATO_MIN_RUN:
+            runs.append(cur)
+    return len(runs), max(runs, default=0)
+
+
+def rhythm(text: str) -> RhythmStats:
+    sents = [s.text for s in sentenize(text)]
+    lengths = [_word_count(s) for s in sents]
+    lengths = [n for n in lengths if n > 0]
+    n = len(lengths)
+    total_words = sum(lengths)
+
+    runs, longest = staccato_runs(text)
+    mean = statistics.mean(lengths) if lengths else 0.0
+    stdev = statistics.pstdev(lengths) if n > 1 else 0.0
+    cv = (stdev / mean) if mean else 0.0
+
+    return RhythmStats(
+        sentences=n,
+        words=total_words,
+        mean_len=round(mean, 1),
+        stdev_len=round(stdev, 1),
+        cv_len=round(cv, 3),
+        min_len=min(lengths) if lengths else 0,
+        max_len=max(lengths) if lengths else 0,
+        short_share=round(sum(1 for x in lengths if x < 5) / n, 3) if n else 0.0,
+        long_share=round(sum(1 for x in lengths if x > 25) / n, 3) if n else 0.0,
+        em_dash=text.count("—"),
+        ellipsis=text.count("…") + len(re.findall(r"\.\.\.", text)),
+        parentheses=text.count("("),
+        questions=sum(1 for s in sents if s.rstrip().endswith("?")),
+        staccato_runs=runs,
+        staccato_max=longest,
+    )
+
+
+# Эвристические пороги (откалиброваны под русский грубо, см. eval/RESULTS.md).
+# cv_len < 0.35 — слишком ровный ритм, признак AI. Человеческий текст обычно > 0.45.
+CV_AI_THRESHOLD = 0.35
+CV_HUMAN_TARGET = 0.45
+
+
+def rhythm_verdict(s: RhythmStats, dash_ok: bool = False) -> str:
+    """dash_ok=True для жанров, где длинное тире законно (научный,
+    юридический, художественный): тогда оно показывается фактом, не ⚠."""
+    if s.em_dash > 0 and dash_ok:
+        dash = f"тире: {s.em_dash} (законно для жанра)"
+    elif s.em_dash > 0:
+        dash = f"⚠ {s.em_dash} длинных тире (норма 0)"
+    else:
+        dash = "✓ тире чисто"
+    if s.cv_len < CV_AI_THRESHOLD:
+        rhythm_v = f"⚠ ровный ритм (CV={s.cv_len}, цель ≥{CV_HUMAN_TARGET})"
+    else:
+        rhythm_v = f"✓ ритм рваный (CV={s.cv_len})"
+    return f"{rhythm_v}; {dash}"

humanizer_metrics/facts.py

@@ -0,0 +1,193 @@
+"""Факт-замок как скрипт: что из фактов исходника дожило до результата.
+
+Скилл обещает переносить числа, даты, имена, названия и ссылки без искажений и
+не добавлять новых. Инструкция модели это одно, проверка другое: этот модуль
+вынимает из двух текстов «факты» и сравнивает множества. Не семантика и не
+фактчек: только сохранность того, что уже было, и появление того, чего не было.
+
+Классы фактов:
+- число: любой токен с цифрой (проценты, годы, суммы), нормализован до цифр;
+- число словами: крупные числительные («сорок», «тысяча»), их не пересказывают;
+- месяц: названия месяцев как замена дате;
+- ссылка: URL и адреса вида domain.tld/path;
+- код: содержимое инлайн-кода в бэктиках;
+- имя: слово с заглавной не в начале предложения (с pymorphy3 точнее: теги
+  Name/Surn/Geox/Orgn/Patr и незнакомые словарю слова), плюс любая латиница с
+  заглавной («Excel», «GPT-4»).
+
+Мелкие количества («два», «половина», «вдвое») факты мягкие: в русском они
+идиоматичны («с одной стороны») и обычно пересказывают число исходника. Они
+считаются, но не валят проверку.
+
+Утверждения: слова-кванторы, которые звучат как пафос, а несут факт:
+«первый в России», «единственный», «впервые», «рекордный», «до сих пор».
+Срезать «первый в России сервис» до «сервис» значит исказить исходник, а
+не оживить его. Потерянный квантор попадает в список потерь, появившийся
+выносится отдельным предупреждением: кванторы идиоматичны («первый шаг»,
+«самое время»), поэтому валить проверку автоматически нельзя, но глазами
+такое место обязано проверить.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+try:
+    import pymorphy3
+
+    _MORPH = pymorphy3.MorphAnalyzer()
+except ImportError:  # без словаря сравниваем по основе, грубее, но работает
+    _MORPH = None
+
+PROPER_TAGS = {"Name", "Surn", "Geox", "Orgn", "Patr"}
+
+MONTH_RE = re.compile(
+    r"\b(январ|феврал|март|апрел|июн|июл|август|сентябр|октябр|ноябр|декабр)[а-я]*\b",
+    re.IGNORECASE,
+)
+URL_RE = re.compile(r"https?://[^\s)>\]»]+|\b[a-z0-9-]+\.(?:ru|com|org|net|io|tech|dev|ai|su|рф)(?:/[^\s)>\]»]*)?",
+                    re.IGNORECASE)
+CODE_RE = re.compile(r"`([^`\n]+)`")
+TOKEN_RE = re.compile(r"[A-Za-z][A-Za-z\d\-]*|[А-Яа-яЁё][А-Яа-яЁё\-]*|\d[\d.,:/-]*")
+
+SOFT_QUANTITIES = {
+    "один", "два", "две", "три", "оба", "обе", "пара",
+    "второй", "третий",
+    "вдвое", "втрое", "дважды", "трижды",
+    "половина", "треть", "четверть", "полтора",
+}
+HARD_NUMERALS = {
+    "четыре", "пять", "шесть", "семь", "восемь", "девять", "десять",
+    "одиннадцать", "двенадцать", "пятнадцать", "двадцать", "тридцать",
+    "сорок", "пятьдесят", "шестьдесят", "семьдесят", "восемьдесят",
+    "девяносто", "сто", "двести", "триста", "тысяча", "миллион", "миллиард",
+    "десяток", "сотня", "дюжина",
+}
+# Кванторы-утверждения: громкие слова, за которыми стоит проверяемый факт.
+CLAIM_WORDS = {
+    "первый", "единственный", "впервые", "самый", "рекордный", "крупнейший",
+    "старейший", "никогда", "никто", "навсегда", "беспрецедентный",
+}
+CLAIM_PHRASE_RE = re.compile(r"\bдо сих пор\b|\bв мире\b|\bв россии\b", re.IGNORECASE)
+# Одна сущность под разными именами не считается новым фактом.
+ALIASES = {
+    "ai": ("искусственный", "интеллект", "ии", "нейросеть", "модель"),
+    "ии": ("искусственный", "интеллект", "ai", "нейросеть", "модель"),
+    "llm": ("модель", "нейросеть", "ai", "ии"),
+}
+
+
+@dataclass
+class Facts:
+    hard: set[str] = field(default_factory=set)   # "число:13", "имя:стэнфорд", "ссылка:…"
+    soft: set[str] = field(default_factory=set)   # "два", "половина"
+    words: set[str] = field(default_factory=set)  # все слова в нормальной форме, для алиасов
+    claims: set[str] = field(default_factory=set)  # "утверждение:первый", "утверждение:до сих пор"
+
+
+@dataclass
+class FactsDiff:
+    lost: list[str]      # были в исходнике, пропали
+    added: list[str]     # появились в результате, в исходнике не было
+    kept: int            # жёстких фактов исходника дожило
+    soft_added: list[str]
+    claims_added: list[str] = field(default_factory=list)  # кванторы, которых в исходнике не было
+
+    @property
+    def ok(self) -> bool:
+        return not self.added
+
+    def as_dict(self) -> dict:
+        return {"ok": self.ok, "lost": self.lost, "added": self.added,
+                "kept": self.kept, "soft_added": self.soft_added,
+                "claims_added": self.claims_added}
+
+
+def _norm(word: str) -> str:
+    low = word.lower().replace("ё", "е").strip("-")
+    if _MORPH is None:
+        return low[:5]
+    return _MORPH.parse(low)[0].normal_form.replace("ё", "е")
+
+
+def _sentence_starts(text: str) -> set[int]:
+    starts = {0}
+    for m in re.finditer(r"[.!?…]\s+|^[>\-*]\s+|«|\n", text):
+        starts.add(m.end())
+    return starts
+
+
+def _is_proper(word: str, at_start: bool) -> bool:
+    if not word[:1].isupper():
+        return False
+    if word.isascii():
+        return True
+    if _MORPH is None:
+        return not at_start
+    p = _MORPH.parse(word.lower())[0]
+    if PROPER_TAGS & set(p.tag.grammemes):
+        return True
+    if not p.is_known:
+        return True
+    return not at_start
+
+
+def extract_facts(text: str) -> Facts:
+    f = Facts()
+    for m in URL_RE.finditer(text):
+        url = re.sub(r"^https?://(?:www\.)?", "", m.group(0).rstrip(".,;:").lower()).rstrip("/")
+        f.hard.add("ссылка:" + url)
+    for m in CODE_RE.finditer(text):
+        f.hard.add("код:" + m.group(1).strip())
+    body = CODE_RE.sub(" ", URL_RE.sub(" ", text))
+    for m in MONTH_RE.finditer(body):
+        f.hard.add("месяц:" + m.group(1).lower())
+    for m in CLAIM_PHRASE_RE.finditer(body):
+        f.claims.add("утверждение:" + m.group(0).lower().replace("ё", "е"))
+    starts = _sentence_starts(body)
+    for m in TOKEN_RE.finditer(body):
+        tok = m.group(0)
+        if tok[0].isdigit():
+            digits = re.sub(r"\D", "", tok)
+            if digits:
+                f.hard.add("число:" + (digits.lstrip("0") or "0"))
+            continue
+        norm = _norm(tok)
+        f.words.add(norm)
+        if norm in SOFT_QUANTITIES:
+            f.soft.add(norm)
+        elif norm in CLAIM_WORDS:
+            f.claims.add("утверждение:" + norm)
+        elif norm in HARD_NUMERALS:
+            f.hard.add("число словами:" + norm)
+        elif _is_proper(tok, any(abs(m.start() - s) <= 1 for s in starts)):
+            f.hard.add("имя:" + norm)
+    return f
+
+
+def _alias_covered(fact: str, before_words: set[str]) -> bool:
+    if not fact.startswith("имя:"):
+        return False
+    name = fact[4:]
+    return any(alias in before_words for alias in ALIASES.get(name, ()))
+
+
+def diff_facts(before: str, after: str) -> FactsDiff:
+    b, a = extract_facts(before), extract_facts(after)
+    lost = sorted(b.hard - a.hard) + sorted(b.claims - a.claims)
+    added = sorted(x for x in a.hard - b.hard if not _alias_covered(x, b.words))
+    return FactsDiff(lost=lost, added=added, kept=len(b.hard & a.hard),
+                     soft_added=sorted(a.soft - b.soft),
+                     claims_added=sorted(a.claims - b.claims))
+
+
+def facts_verdict(d: FactsDiff) -> str:
+    if d.added:
+        return f"✗ новых фактов без источника: {len(d.added)} (выдумка хуже канцелярита)"
+    if d.lost:
+        return f"⚠ факты исходника на месте, но {len(d.lost)} потеряно: проверьте, намеренно ли"
+    if d.claims_added:
+        return (f"⚠ факты целы, но появилось утверждений без источника: {len(d.claims_added)} "
+                "(«впервые», «единственный» это факт, а не украшение)")
+    return f"✓ факт-замок цел: {d.kept} фактов исходника перенесено, новых нет"

humanizer_metrics/markdown.py

@@ -0,0 +1,127 @@
+"""Границы чужого текста в Markdown: код, цитаты, короткие «ёлочки».
+
+Сканер измеряет слова автора. Листинг кода, markdown-цитата через «>» и короткая
+цитата в ёлочках это чужие слова, их баны и маркеры не в счёт. Два релиза
+подряд границы чинились регулярками по одному примеру, и каждый раз соседний
+вариант той же ошибки оставался (ограда внутри строки кода, закрытие оградой
+длиннее открывающей, продолжение цитаты без «>»). Здесь один построчный разбор
+состояния по правилам CommonMark и таблица тестов на варианты в
+scripts/test_markers.py.
+
+Две проекции одного текста:
+- lexical: чужое заменено заглушкой GAP посимвольно, переводы строк на месте.
+  Смещения и номера строк совпадают с исходником, фразовые регексы не
+  склеивают слова через заглушку (она не буква).
+- prose: чужое вырезано целиком. Для ритма, морфологии и структуры: заглушки
+  ломали бы длину предложений и подсчёт абзацев.
+
+Правила:
+- Ограда кода: 3+ обратных кавычек или тильд с отступом до 3 пробелов в начале
+  строки. Закрывает ограда того же символа НЕ КОРОЧЕ открывающей. Кавычки внутри
+  строки кода оградой не являются. Незакрытая ограда не маскируется вовсе:
+  для сканера ложное срабатывание дешевле спрятанного абзаца.
+- Цитата: строка с «>» в начале (отступ до 3 пробелов). Ленивое продолжение:
+  следующие непустые строки без «>» остаются цитатой, пока не встретится
+  пустая строка, заголовок, пункт списка или ограда.
+- Инлайн-код: серия обратных кавычек закрывается серией той же длины в
+  пределах строки (`x`, ``a`b``).
+- Короткая цитата в ёлочках (до QUOTE_MAX_WORDS слов) заглушается только в
+  lexical: так цитируют слово или оборот. Длинная остаётся под сканером, это
+  прямая речь или пересказ, её маркеры на совести автора. В prose ёлочки не
+  трогаем, они внутри предложений автора.
+"""
+
+from __future__ import annotations
+
+import re
+
+GAP = "·"
+QUOTE_MAX_WORDS = 12
+
+_FENCE_OPEN = re.compile(r"^ {0,3}(`{3,}|~{3,})(.*)$")
+_FENCE_CLOSE = re.compile(r"^ {0,3}(`{3,}|~{3,})\s*$")
+_QUOTE_LINE = re.compile(r"^ {0,3}>")
+# Строки, которые прерывают ленивое продолжение цитаты (CommonMark 5.1):
+# заголовок, пункт списка, горизонтальная линия, ограда.
+_BLOCK_START = re.compile(r"^ {0,3}(?:#{1,6}\s|[-*+]\s|\d{1,9}[.)]\s|(?:-{3,}|\*{3,}|_{3,})\s*$|`{3,}|~{3,})")
+_INLINE_CODE = re.compile(r"(`+)(?!`)([^`\n]+?)\1(?!`)")
+_QUOTE_MARKS = re.compile(r"«[^«»]*»")
+
+
+def _blank(s: str) -> str:
+    return re.sub(r"[^\n]", GAP, s)
+
+
+def _fence_ranges(lines: list[str]) -> list[tuple[int, int]]:
+    """Пары (первая, последняя) строк закрытых блоков кода, включая ограды."""
+    ranges: list[tuple[int, int]] = []
+    i = 0
+    while i < len(lines):
+        m = _FENCE_OPEN.match(lines[i])
+        # Инфо-строка ограды из кавычек не может содержать кавычки (CommonMark).
+        if not m or (m.group(1)[0] == "`" and "`" in m.group(2)):
+            i += 1
+            continue
+        ch, need = m.group(1)[0], len(m.group(1))
+        j = i + 1
+        while j < len(lines):
+            c = _FENCE_CLOSE.match(lines[j])
+            if c and c.group(1)[0] == ch and len(c.group(1)) >= need:
+                break
+            j += 1
+        if j >= len(lines):
+            i += 1  # незакрытая ограда: обычная строка
+            continue
+        ranges.append((i, j))
+        i = j + 1
+    return ranges
+
+
+def _quote_lines(lines: list[str], in_code: set[int]) -> set[int]:
+    quoted: set[int] = set()
+    inside = False
+    for i, line in enumerate(lines):
+        if i in in_code:
+            inside = False
+            continue
+        if _QUOTE_LINE.match(line):
+            inside = True
+            quoted.add(i)
+        elif inside and line.strip() and not _BLOCK_START.match(line):
+            quoted.add(i)  # ленивое продолжение абзаца цитаты
+        else:
+            inside = False
+    return quoted
+
+
+def _classify(text: str) -> tuple[list[str], set[int], set[int]]:
+    lines = text.split("\n")
+    in_code: set[int] = set()
+    for a, b in _fence_ranges(lines):
+        in_code.update(range(a, b + 1))
+    return lines, in_code, _quote_lines(lines, in_code)
+
+
+def _blank_short_quote(m: re.Match[str]) -> str:
+    inner = m.group(0)[1:-1]
+    return _blank(m.group(0)) if len(inner.split()) <= QUOTE_MAX_WORDS else m.group(0)
+
+
+def mask_foreign(text: str) -> str:
+    """lexical: код, цитаты и короткие ёлочки заглушены, смещения сохранены."""
+    lines, in_code, quoted = _classify(text)
+    out: list[str] = []
+    for i, line in enumerate(lines):
+        if i in in_code or i in quoted:
+            out.append(_blank(line))
+        else:
+            out.append(_INLINE_CODE.sub(lambda m: _blank(m.group(0)), line))
+    return _QUOTE_MARKS.sub(_blank_short_quote, "\n".join(out))
+
+
+def strip_foreign(text: str) -> str:
+    """prose: код и цитаты вырезаны, инлайн-код удалён, ёлочки на месте."""
+    lines, in_code, quoted = _classify(text)
+    kept = [_INLINE_CODE.sub("", line) for i, line in enumerate(lines)
+            if i not in in_code and i not in quoted]
+    return "\n".join(kept)