ru-stylometry 0.1.1__py3-none-any.whl

ru_stylometry/__init__.py

@@ -0,0 +1,34 @@
+"""ru-stylometry — interpretable stylometric features for Russian text.
+
+Public API:
+    - :func:`extract_features` — named stylometric features of one text.
+    - :func:`feature_names` and :func:`describe_features` — the feature catalogue.
+    - :class:`StylometricVectorizer` — scikit-learn transformer: texts -> feature matrix.
+    - :class:`StylometricClassifier` — classifier over those features with explanations.
+
+Features are grouped by the level of analysis (characters, typography, vocabulary, syntax,
+readability, repetition, morphology); see :data:`ALL_GROUPS` and :data:`DEFAULT_GROUPS`.
+The submodules ``evaluation``, ``explain`` and ``perturb`` hold the quality criteria, the
+explanations and the text transformations used in robustness checks.
+"""
+
+from ru_stylometry.features import (
+    ALL_GROUPS,
+    DEFAULT_GROUPS,
+    describe_features,
+    extract_features,
+    feature_names,
+)
+from ru_stylometry.model import StylometricClassifier
+from ru_stylometry.vectorizer import StylometricVectorizer
+
+__all__ = [
+    "ALL_GROUPS",
+    "DEFAULT_GROUPS",
+    "StylometricClassifier",
+    "StylometricVectorizer",
+    "describe_features",
+    "extract_features",
+    "feature_names",
+]
+__version__ = "0.1.1"

ru_stylometry/__main__.py

@@ -0,0 +1,5 @@
+"""Allow ``python -m ru_stylometry``."""
+
+from ru_stylometry.cli import main
+
+raise SystemExit(main())

ru_stylometry/_lexicons.py

@@ -0,0 +1,76 @@
+"""Small hand-made lexicons for lexicon-based features (lowercase, 'ё' folded into 'е')."""
+
+from __future__ import annotations
+
+from typing import FrozenSet, Tuple
+
+# Prepositions, conjunctions, particles, pronouns and forms of "быть". Stylometry has long used
+# such function words as topic-independent markers of style (Mosteller & Wallace, 1964).
+_FUNCTION_WORDS = """
+    в во на с со к ко по из изо от ото до за у о об обо для при про над надо под подо перед передо
+    между через без безо около после среди ради сквозь против кроме вместо внутри вне возле вокруг
+    мимо
+    и а но да или либо ни что чтобы чтоб как если когда пока потому поэтому так также тоже зато
+    однако хотя будто словно ведь
+    не бы же ли вот вон даже только лишь уже еще именно просто ну разве неужели почти пусть пускай
+    я ты он она оно мы вы они мой моя мое мои твой твоя твое твои его ее их наш наша наше наши
+    ваш ваша ваше ваши свой своя свое свои себя себе собой этот эта это эти тот та то те такой
+    такая такое такие весь вся все сам сама сами кто какой какая какое какие который которая
+    которое которые чей где куда откуда почему зачем чем чего чему кому кого ему ей им них ним нем
+    ней мне меня тебе тебя нас нам вас вам нами вами мной
+    быть был была было были буду будешь будет будем будете будут есть суть
+"""
+
+_NEGATIONS = """
+    не ни нет нельзя никогда никто ничто ничего никак нигде никуда никакой никакая никакое никакие
+    нисколько ничей
+"""
+
+FUNCTION_WORDS: FrozenSet[str] = frozenset(_FUNCTION_WORDS.split())
+NEGATIONS: FrozenSet[str] = frozenset(_NEGATIONS.split())
+
+# Coordinating conjunctions that often open sentences in informal writing.
+CONJUNCTION_STARTERS: FrozenSet[str] = frozenset("и а но да или либо зато ни".split())
+
+# Connectives and stock phrases typical of formal prose and of machine-generated Russian text.
+DISCOURSE_MARKERS: Tuple[str, ...] = (
+    "кроме того",
+    "более того",
+    "таким образом",
+    "в целом",
+    "в заключение",
+    "подводя итог",
+    "тем не менее",
+    "в связи с этим",
+    "в частности",
+    "стоит отметить",
+    "следует отметить",
+    "важно отметить",
+    "необходимо отметить",
+    "важно подчеркнуть",
+    "следует подчеркнуть",
+    "иными словами",
+    "в первую очередь",
+    "в свою очередь",
+    "в то же время",
+    "наряду с этим",
+    "помимо этого",
+    "кроме этого",
+    "с одной стороны",
+    "с другой стороны",
+    "в результате",
+    "как правило",
+    "в конечном счете",
+    "в итоге",
+    "во-первых",
+    "во-вторых",
+    "в-третьих",
+    "однако",
+    "следовательно",
+    "соответственно",
+    "играет важную роль",
+    "играет ключевую роль",
+    "играет значительную роль",
+    "в современном мире",
+    "в наши дни",
+)

ru_stylometry/_morph.py

@@ -0,0 +1,41 @@
+"""Cached morphological analysis on top of pymorphy3."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Any, NamedTuple, Optional
+
+_analyzer: Any = None
+
+
+class WordInfo(NamedTuple):
+    """The grammatical facts about one word that the morphological features need."""
+
+    pos: Optional[str]
+    case: Optional[str]
+    tense: Optional[str]
+    person: Optional[str]
+    lemma: str
+    is_known: bool
+
+
+def get_analyzer() -> Any:
+    """Return a shared ``pymorphy3.MorphAnalyzer``; dictionaries are loaded on first use."""
+    global _analyzer
+    if _analyzer is None:
+        import pymorphy3
+
+        _analyzer = pymorphy3.MorphAnalyzer()
+    return _analyzer
+
+
+@lru_cache(maxsize=100_000)
+def analyze_word(word: str) -> WordInfo:
+    """Analyse a lowercase word and keep its most probable parse.
+
+    Results are cached per process: word frequencies follow Zipf's law, so a few thousand
+    entries cover most of the running text and pymorphy3 parses each of them only once.
+    """
+    parse = get_analyzer().parse(word)[0]
+    tag = parse.tag
+    return WordInfo(tag.POS, tag.case, tag.tense, tag.person, parse.normal_form, parse.is_known)

ru_stylometry/_stats.py

@@ -0,0 +1,91 @@
+"""Small numeric helpers shared by feature groups."""
+
+from __future__ import annotations
+
+from collections import Counter
+from typing import Hashable, Sequence
+
+
+def safe_div(numerator: float, denominator: float, default: float = 0.0) -> float:
+    """Divide, returning ``default`` when the denominator is zero."""
+    return numerator / denominator if denominator else default
+
+
+def mean(values: Sequence[float]) -> float:
+    """Arithmetic mean; 0.0 for an empty sequence."""
+    return sum(values) / len(values) if values else 0.0
+
+
+def pstdev(values: Sequence[float]) -> float:
+    """Population standard deviation; 0.0 for an empty sequence."""
+    if not values:
+        return 0.0
+    mu = mean(values)
+    return (sum((v - mu) ** 2 for v in values) / len(values)) ** 0.5
+
+
+def mattr(tokens: Sequence[Hashable], window: int = 50) -> float:
+    """Moving-average type-token ratio (Covington & McFall, 2010).
+
+    Mean share of distinct tokens over all windows of ``window`` consecutive tokens. Unlike the
+    plain type-token ratio it does not fall as the text gets longer. Texts shorter than the window
+    fall back to the plain type-token ratio.
+    """
+    n = len(tokens)
+    if n == 0:
+        return 0.0
+    if n <= window:
+        return len(set(tokens)) / n
+    counts = Counter(tokens[:window])
+    unique = len(counts)
+    total = unique
+    for i in range(window, n):
+        leaving = tokens[i - window]
+        counts[leaving] -= 1
+        if counts[leaving] == 0:
+            unique -= 1
+        if counts[tokens[i]] == 0:
+            unique += 1
+        counts[tokens[i]] += 1
+        total += unique
+    return total / ((n - window + 1) * window)
+
+
+def _mtld_pass(tokens: Sequence[Hashable], threshold: float) -> float:
+    factors = 0.0
+    types: set = set()
+    count = 0
+    for token in tokens:
+        types.add(token)
+        count += 1
+        if len(types) / count <= threshold:
+            factors += 1.0
+            types = set()
+            count = 0
+    if count:
+        factors += (1.0 - len(types) / count) / (1.0 - threshold)
+    return len(tokens) / factors if factors else float(len(tokens))
+
+
+def mtld(tokens: Sequence[Hashable], threshold: float = 0.72) -> float:
+    """Measure of textual lexical diversity (McCarthy & Jarvis, 2010).
+
+    Average length of a token run over which the type-token ratio stays above ``threshold``,
+    computed forwards and backwards. A text in which no run ever drops to the threshold gets a value
+    equal to its length.
+    """
+    if not tokens:
+        return 0.0
+    forward = _mtld_pass(tokens, threshold)
+    backward = _mtld_pass(tokens[::-1], threshold)
+    return (forward + backward) / 2.0
+
+
+def yule_k(tokens: Sequence[Hashable]) -> float:
+    """Yule's K characteristic (Yule, 1944): higher values mean more repetitive vocabulary."""
+    n = len(tokens)
+    if n == 0:
+        return 0.0
+    spectrum = Counter(Counter(tokens).values())
+    s2 = sum(m * m * v for m, v in spectrum.items())
+    return 1e4 * (s2 - n) / (n * n)

ru_stylometry/_text.py

@@ -0,0 +1,99 @@
+"""Low-level text helpers: tokenisation, sentence splitting and syllable counting."""
+
+from __future__ import annotations
+
+import re
+from typing import List
+
+# A word is a run of letters, optionally joined by hyphens or apostrophes ("кто-то", "don't").
+WORD_RE = re.compile(r"[^\W\d_]+(?:[-’'][^\W\d_]+)*")
+CYRILLIC_RE = re.compile(r"[А-Яа-яЁё]")
+
+# Words *longer* than this many letters are "long" (Björnsson's definition used by LIX).
+LONG_WORD_LETTERS = 6
+
+# Paragraph break, or a line break in front of a list item / heading marker.
+_BLOCK_RE = re.compile(r"\n\s*\n|\n(?=[ \t]*(?:[-*•–—#]+|\d+[.)])[ \t]+)")
+# Sentence terminator, optional closing quotes/brackets (captured) and the whitespace after them.
+_BOUNDARY_RE = re.compile(r"(?<=[.!?…])([\"»”’)\]]*)\s+")
+_INITIALS_RE = re.compile(r"^(?:[А-ЯЁA-Z]\.){1,3}$")
+
+# Abbreviations after which a full stop does not end the sentence (lowercase, one token each).
+_ABBREVIATION_LIST = """
+    т.д. т.п. т.е. т.к. т.н. т.о. т.ч. и.о. н.э. г. гг. в. вв. ул. им. пр. др. см. рис. табл. стр.
+    с. т. тт. тыс. млн. млрд. руб. коп. проф. доц. акад. канд. докт. напр. англ. лат. нем. франц.
+    ок. ср. изд. вып. гл. п. пп. ч. ст. обл. пос. д. кв. корп. оф. тел. тов.
+"""
+_ABBREVIATIONS = frozenset(_ABBREVIATION_LIST.split())
+
+_VOWELS = frozenset("аеёиоуыэюяaeiouy")
+
+
+def word_length(word: str) -> int:
+    """Number of letters in a word (hyphens and apostrophes are not counted)."""
+    return sum(1 for char in word if char.isalpha())
+
+
+def count_syllables(word: str) -> int:
+    """Count syllables as vowel letters (Cyrillic and basic Latin vowels)."""
+    return sum(1 for char in word.lower() if char in _VOWELS)
+
+
+def truncate_words(text: str, max_words: int) -> str:
+    """Keep the beginning of the text up to the end of its ``max_words``-th word.
+
+    Texts with at most ``max_words`` words are returned unchanged. Cutting before analysis bounds
+    the cost of long documents and puts texts of very different lengths on the same footing.
+    """
+    end = 0
+    for count, match in enumerate(WORD_RE.finditer(text), start=1):
+        if count > max_words:
+            return text[:end]
+        end = match.end()
+    return text
+
+
+def _ends_with_abbreviation(chunk: str) -> bool:
+    last = chunk.rsplit(None, 1)[-1]
+    return last.lower() in _ABBREVIATIONS or bool(_INITIALS_RE.match(last))
+
+
+def _continues_after_ellipsis(previous: str, following: str) -> bool:
+    return previous.endswith(("…", "...")) and following[:1].islower()
+
+
+def _split_block(block: str) -> List[str]:
+    parts = _BOUNDARY_RE.split(block)
+    # parts = [sentence, closers, sentence, closers, ..., sentence]; glue closers back on.
+    chunks = [parts[i] + parts[i + 1] for i in range(0, len(parts) - 1, 2)] + [parts[-1]]
+    merged: List[str] = []
+    for chunk in chunks:
+        if merged and (
+            _ends_with_abbreviation(merged[-1]) or _continues_after_ellipsis(merged[-1], chunk)
+        ):
+            merged[-1] = f"{merged[-1]} {chunk}"
+        else:
+            merged.append(chunk)
+    return merged
+
+
+def split_sentences(text: str) -> List[str]:
+    """Split Russian text into sentences with a rule-based splitter.
+
+    Boundaries are paragraph breaks, line breaks before list items, and sentence-final
+    punctuation followed by whitespace. A full stop after a known abbreviation ("т.д.", "г.") or
+    after initials ("А. С.") does not end a sentence, nor does an ellipsis followed by a lowercase
+    letter. Single line breaks inside a paragraph are treated as spaces.
+
+    Args:
+        text: Input text.
+
+    Returns:
+        Non-empty sentences in order of appearance.
+    """
+    sentences: List[str] = []
+    for block in _BLOCK_RE.split(text):
+        block = " ".join(block.split())
+        if block:
+            sentences.extend(_split_block(block))
+    return sentences

ru_stylometry/cli.py

@@ -0,0 +1,269 @@
+"""Command-line interface of ``ru-stylometry``.
+
+Commands: ``features`` and ``list-features`` work with the feature extractor; ``train``,
+``evaluate``, ``predict`` and ``explain`` work with a classifier trained on a labelled table.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+from ru_stylometry import __version__
+from ru_stylometry.evaluation import evaluate_classification, format_report
+from ru_stylometry.features import (
+    ALL_GROUPS,
+    DEFAULT_GROUPS,
+    describe_features,
+    extract_features,
+    group_description,
+)
+from ru_stylometry.model import ESTIMATORS, StylometricClassifier
+
+Row = Tuple[str, str, str]
+
+
+def _read_text(args: argparse.Namespace) -> str:
+    if args.file is not None:
+        return args.file.read_text(encoding="utf-8")
+    if args.text is not None:
+        return args.text
+    return sys.stdin.read()
+
+
+def _read_table(path: Path, text_column: str, label_column: str) -> Tuple[List[str], List[str]]:
+    """Read texts and labels from a ``.csv``, ``.jsonl`` or ``.parquet`` file."""
+    suffix = path.suffix.lower()
+    if suffix == ".csv":
+        csv.field_size_limit(sys.maxsize)
+        with path.open(encoding="utf-8", newline="") as handle:
+            records: List[Dict[str, Any]] = list(csv.DictReader(handle))
+    elif suffix in (".jsonl", ".ndjson"):
+        lines = path.read_text(encoding="utf-8").splitlines()
+        records = [json.loads(line) for line in lines if line.strip()]
+    elif suffix == ".parquet":
+        try:
+            import pandas as pd
+        except ImportError as error:
+            raise ValueError(
+                "Reading Parquet needs pandas and pyarrow: pip install ru-stylometry[experiments]"
+            ) from error
+        records = pd.read_parquet(path, columns=[text_column, label_column]).to_dict("records")
+    else:
+        raise ValueError(f"Unsupported file type {suffix!r}; use .csv, .jsonl or .parquet.")
+    for column in (text_column, label_column):
+        if not records or column not in records[0]:
+            available = sorted(records[0]) if records else []
+            raise ValueError(f"Column {column!r} not found in {path}; available: {available}.")
+    return [str(r[text_column]) for r in records], [str(r[label_column]) for r in records]
+
+
+def _markdown_catalogue(rows: Sequence[Row]) -> str:
+    by_group: Dict[str, List[Tuple[str, str]]] = {}
+    for group, name, description in rows:
+        by_group.setdefault(group, []).append((name, description))
+    default_count = sum(1 for group, _, _ in rows if group in DEFAULT_GROUPS)
+    lines = [
+        "# Feature catalogue",
+        "",
+        f"{len(rows)} features in {len(by_group)} groups. The {default_count} features of the "
+        "default groups form the default feature vector; groups marked *opt-in* are excluded "
+        "from it.",
+    ]
+    for group, items in by_group.items():
+        status = "default" if group in DEFAULT_GROUPS else "opt-in"
+        lines += [
+            "",
+            f"## `{group}` ({status}, {len(items)} features)",
+            "",
+            group_description(group),
+            "",
+            "| Feature | Description |",
+            "|---|---|",
+        ]
+        lines += [f"| `{name}` | {description} |" for name, description in items]
+    return "\n".join(lines)
+
+
+def _dump(data: Any) -> None:
+    print(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+def _cmd_features(args: argparse.Namespace) -> int:
+    _dump(extract_features(_read_text(args), groups=args.groups, max_words=args.max_words))
+    return 0
+
+
+def _cmd_list_features(args: argparse.Namespace) -> int:
+    rows = describe_features(args.groups or ALL_GROUPS)
+    if args.format == "json":
+        _dump([{"group": g, "name": n, "description": d} for g, n, d in rows])
+    elif args.format == "markdown":
+        print(_markdown_catalogue(rows))
+    else:
+        width = max(len(name) for _, name, _ in rows)
+        for group, name, description in rows:
+            print(f"{group:<12} {name:<{width}}  {description}")
+    return 0
+
+
+def _cmd_train(args: argparse.Namespace) -> int:
+    texts, labels = _read_table(args.data, args.text_column, args.label_column)
+    model = StylometricClassifier(
+        estimator=args.estimator,
+        groups=args.groups,
+        max_words=args.max_words,
+        class_weight="balanced" if args.balanced else None,
+        n_jobs=args.n_jobs,
+    )
+    started = time.perf_counter()
+    model.fit(texts, labels)
+    summary: Dict[str, Any] = {
+        "model": str(args.out),
+        "classes": [str(c) for c in model.classes_],
+        "texts": len(texts),
+        "features": len(model.feature_names_),
+        "seconds": round(time.perf_counter() - started, 1),
+    }
+    model.save(str(args.out))
+    if args.valid is not None:
+        valid_texts, valid_labels = _read_table(args.valid, args.text_column, args.label_column)
+        report = evaluate_classification(valid_labels, model.predict(valid_texts), model.classes_)
+        summary["valid"] = {k: report[k] for k in ("n", "accuracy", "macro_f1")}
+    _dump(summary)
+    return 0
+
+
+def _cmd_evaluate(args: argparse.Namespace) -> int:
+    model = StylometricClassifier.load(str(args.model))
+    texts, labels = _read_table(args.data, args.text_column, args.label_column)
+    started = time.perf_counter()
+    predicted = model.predict(texts)
+    seconds = time.perf_counter() - started
+    report = evaluate_classification(labels, predicted, labels=[str(c) for c in model.classes_])
+    report["ms_per_document"] = 1000.0 * seconds / max(len(texts), 1)
+    if args.format == "json":
+        _dump(report)
+    else:
+        print(format_report(report))
+        print(f"\nTime per document: {report['ms_per_document']:.1f} ms")
+    return 0
+
+
+def _cmd_predict(args: argparse.Namespace) -> int:
+    model = StylometricClassifier.load(str(args.model))
+    text = _read_text(args)
+    probabilities = model.predict_proba([text])[0]
+    best = int(probabilities.argmax())
+    _dump(
+        {
+            "label": str(model.classes_[best]),
+            "probability": float(probabilities[best]),
+            "probabilities": {str(c): float(p) for c, p in zip(model.classes_, probabilities)},
+        }
+    )
+    return 0
+
+
+def _cmd_explain(args: argparse.Namespace) -> int:
+    model = StylometricClassifier.load(str(args.model))
+    explanation = model.explain(_read_text(args), target=args.target, top_k=args.top)
+    if args.format == "json":
+        _dump(explanation)
+        return 0
+    print(f"label: {explanation['label']} (probability {explanation['probability']:.3f})")
+    print(f"effect on the log-odds of class '{explanation['target']}' (positive: towards it):")
+    for item in explanation["features"]:
+        print(
+            f"  {item['feature']:<26} {item['effect']:+.2f}   value {item['value']:.3f}, "
+            f"typical {item['typical']:.3f}   [{item['group']}]"
+        )
+    print(
+        "by group: "
+        + ", ".join(f"{g} {v['effect']:+.2f}" for g, v in explanation["groups"].items())
+    )
+    return 0
+
+
+def _add_text_input(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("text", nargs="?", help="text to analyse (default: read from stdin)")
+    parser.add_argument("-f", "--file", type=Path, help="read the text from a UTF-8 file")
+
+
+def _add_table_columns(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--text-column", default="text", help="column with the texts")
+    parser.add_argument("--label-column", default="label", help="column with the class labels")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ru-stylometry",
+        description="Interpretable stylometric features and classifiers for Russian text.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    features = commands.add_parser("features", help="extract features from a text as JSON")
+    _add_text_input(features)
+    features.add_argument("-g", "--groups", nargs="+", metavar="GROUP", help="feature groups")
+    features.add_argument(
+        "--max-words", type=int, metavar="N", help="analyse only the first N words"
+    )
+    features.set_defaults(handler=_cmd_features)
+
+    catalogue = commands.add_parser("list-features", help="print the feature catalogue")
+    catalogue.add_argument("-g", "--groups", nargs="+", metavar="GROUP", help="feature groups")
+    catalogue.add_argument("--format", choices=["text", "markdown", "json"], default="text")
+    catalogue.set_defaults(handler=_cmd_list_features)
+
+    train = commands.add_parser("train", help="train a classifier on a labelled table")
+    train.add_argument(
+        "data", type=Path, help=".csv, .jsonl or .parquet file with texts and labels"
+    )
+    train.add_argument("-o", "--out", type=Path, required=True, help="where to save the model")
+    _add_table_columns(train)
+    train.add_argument("--estimator", choices=ESTIMATORS, default="hgb")
+    train.add_argument("-g", "--groups", nargs="+", metavar="GROUP", help="feature groups")
+    train.add_argument("--max-words", type=int, default=500, metavar="N")
+    train.add_argument("--balanced", action="store_true", help="weight classes equally")
+    train.add_argument("--n-jobs", type=int, help="worker processes for feature extraction")
+    train.add_argument("--valid", type=Path, help="labelled file to score the model on")
+    train.set_defaults(handler=_cmd_train)
+
+    evaluate = commands.add_parser("evaluate", help="score a saved model on a labelled table")
+    evaluate.add_argument("data", type=Path, help=".csv, .jsonl or .parquet file")
+    evaluate.add_argument("-m", "--model", type=Path, required=True)
+    _add_table_columns(evaluate)
+    evaluate.add_argument("--format", choices=["markdown", "json"], default="markdown")
+    evaluate.set_defaults(handler=_cmd_evaluate)
+
+    predict = commands.add_parser("predict", help="classify one text")
+    _add_text_input(predict)
+    predict.add_argument("-m", "--model", type=Path, required=True)
+    predict.set_defaults(handler=_cmd_predict)
+
+    explain = commands.add_parser("explain", help="explain the decision for one text")
+    _add_text_input(explain)
+    explain.add_argument("-m", "--model", type=Path, required=True)
+    explain.add_argument("--target", help="class to explain (default: the predicted class)")
+    explain.add_argument("--top", type=int, default=10, help="number of features to list")
+    explain.add_argument("--format", choices=["text", "json"], default="text")
+    explain.set_defaults(handler=_cmd_explain)
+
+    parser.epilog = f"feature groups: {', '.join(ALL_GROUPS)}"
+    return parser
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    """Entry point of the ``ru-stylometry`` command."""
+    args = _build_parser().parse_args(argv)
+    try:
+        return args.handler(args)
+    except (ValueError, TypeError, OSError) as error:
+        print(f"ru-stylometry: error: {error}", file=sys.stderr)
+        return 2