anyts 0.1.0__tar.gz

anyts-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+# Python
+__pycache__/
+*.egg-info/
+dist/
+build/
+target/
+
+# Environments
+.venv/
+venv/
+.env
+
+# Tools
+.coverage
+coverage.xml
+.mypy_cache
+.pytest_cache
+.ruff_cache
+.ipynb_checkpoints
+
+# Documentation
+site/
+
+# Editors and OS
+.vscode
+.idea
+.DS_Store

anyts-0.1.0/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2026 Sergey Shkarin
+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.

anyts-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.5
+Name: anyts
+Version: 0.1.0
+Summary: Any Texts Statistics: the language-independent core of text statistics libraries
+Project-URL: Homepage, https://github.com/SergeyShk/anyTS
+Project-URL: Repository, https://github.com/SergeyShk/anyTS
+Project-URL: Documentation, https://sergeyshk.github.io/anyTS/
+Project-URL: Issues, https://github.com/SergeyShk/anyTS/issues
+Author-email: Sergey Shkarin <kouki.sergey@gmail.com>
+Maintainer-email: Sergey Shkarin <kouki.sergey@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: CL,NLP,analytics,computational,language,linguistics,natural,processing,statistics,text
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: pandas>=2.1
+Requires-Dist: scipy>=1.11
+Requires-Dist: spacy>=3.7
+Description-Content-Type: text/markdown
+
+# Any Texts Statistics (anyTS)
+
+[![Version](https://img.shields.io/pypi/v/anyts?logo=pypi&logoColor=FFE873)](https://pypi.org/project/anyts/)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/anyts.svg?logo=python&logoColor=FFE873)](https://pypi.org/project/anyts/)
+[![Build](https://github.com/SergeyShk/anyTS/actions/workflows/ci.yml/badge.svg)](https://github.com/SergeyShk/anyTS/actions/workflows/ci.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/SergeyShk/anyTS/blob/master/LICENSE.txt)
+
+**anyTS** is the language-independent core of the text statistics libraries [ruTS](https://github.com/SergeyShk/ruTS) (Russian) and [esTS](https://github.com/SergeyShk/esTS) (Spanish). It holds the code that does not depend on a language, so that it is written, tested and documented once; a language library adds its tokenizer, lemmatizer, [spaCy](https://github.com/explosion/spaCy) model and rules and re-exports the core under its own names.
+
+[Documentation](https://sergeyshk.github.io/anyTS/) · [PyPI](https://pypi.org/project/anyts/)
+
+## Features
+
+* **[Extraction](https://sergeyshk.github.io/anyTS/extractors/sentences/)** - sentence, word and character N-gram extractors whose tokenizer, lemmatizer and number pattern are hooks a language library overrides
+* **[Lexical diversity](https://sergeyshk.github.io/anyTS/stats/diversity_stats/)** - 32 metrics: TTR and its variants, MATTR, MSTTR, MTLD, MA-MTLD, MTLD-W, HD-D, the indices of Simpson and Yule, entropy, the laws of Zipf and Heaps, over the whole text or over windows with confidence intervals
+* **[Cohesion helpers](https://sergeyshk.github.io/anyTS/stats/cohesion/)** - the overlap of sentences, adjacent and over all pairs, Dice, givenness and repetition
+* **[Dependency tree helpers](https://sergeyshk.github.io/anyTS/stats/syntax/)** - dependency distances, tree depth, valency and coordination chains on the labels shared by Universal Dependencies and ClearNLP
+* **[Corpus measures](https://sergeyshk.github.io/anyTS/corpus/keyness/)** - keywords against a corpus or a frequency dictionary, collocations, the dispersion of a word, Burrows's Delta and its variants, Zeta, Kilgarriff's chi-square, the Mendenhall curve and the comparison of corpora with effect sizes, a bootstrap by texts and the Holm correction
+* **[Exceptions](https://sergeyshk.github.io/anyTS/exceptions/)** - one hierarchy whose classes are also built-in exceptions
+
+The reference of every function is a named section that the libraries include in their own documentation, so a formula is described in one place.
+
+## Installation
+
+Requires Python 3.11 or newer.
+
+```bash
+pip install anyts
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add anyts
+```
+
+The dependencies are numpy, pandas, scipy and spaCy; no trained spaCy model is needed.
+
+## Quick start
+
+```python
+>>> from anyts import DiversityStats, SentsExtractor, WordsExtractor
+
+>>> text = "The cat sat on the mat. The dog sat on the log! The cat and the dog slept."
+
+>>> SentsExtractor().extract(text)
+('The cat sat on the mat.', 'The dog sat on the log!', 'The cat and the dog slept.')
+
+>>> ds = DiversityStats(WordsExtractor(lowercase=True).extract(text))
+>>> ds.ttr, round(ds.entropy, 3)
+(0.5, 2.864)
+```
+
+A language library subclasses the extractors and overrides their hooks:
+
+```python
+>>> class Words(WordsExtractor):
+...     def lemmatize(self, word):
+...         return {"sat": "sit", "slept": "sleep"}.get(word.lower(), word)
+
+>>> Words(lowercase=True, use_lexemes=True).extract("The cat sat. The dog slept.")
+('the', 'cat', 'sit', 'the', 'dog', 'sleep')
+```
+
+The corpus measures take lists of words:
+
+```python
+>>> from anyts.corpus import keyness
+
+>>> cats = WordsExtractor(lowercase=True).extract("The cat sat on the mat. The cat saw a bird. The cat slept.")
+>>> dogs = WordsExtractor(lowercase=True).extract("The dog sat on the log. The dog saw a cat. The dog barked.")
+>>> [(keyword.word, round(keyword.log_ratio, 2)) for keyword in keyness(cats, dogs, min_freq=2)]
+[('cat', 1.58)]
+```
+
+## Development
+
+The project uses [uv](https://docs.astral.sh/uv/) for dependencies and [ruff](https://docs.astral.sh/ruff/) for linting and formatting.
+
+```bash
+git clone https://github.com/SergeyShk/anyTS.git
+cd anyTS
+
+make deps                   # create the environment and install all dependencies
+uv run pre-commit install   # hooks: linters on commit, tests on push
+make lint                   # ruff check, ruff format --check, mypy
+make test-cov               # pytest with doctests and full coverage
+make docs-build             # mkdocs build --strict
+```
+
+The full list of commands is in `make help`. Contribution guidelines are in [CONTRIBUTING.md](https://github.com/SergeyShk/anyTS/blob/master/CONTRIBUTING.md).
+
+## License
+
+[MIT](https://github.com/SergeyShk/anyTS/blob/master/LICENSE.txt)

anyts-0.1.0/README.md

@@ -0,0 +1,96 @@
+# Any Texts Statistics (anyTS)
+
+[![Version](https://img.shields.io/pypi/v/anyts?logo=pypi&logoColor=FFE873)](https://pypi.org/project/anyts/)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/anyts.svg?logo=python&logoColor=FFE873)](https://pypi.org/project/anyts/)
+[![Build](https://github.com/SergeyShk/anyTS/actions/workflows/ci.yml/badge.svg)](https://github.com/SergeyShk/anyTS/actions/workflows/ci.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/SergeyShk/anyTS/blob/master/LICENSE.txt)
+
+**anyTS** is the language-independent core of the text statistics libraries [ruTS](https://github.com/SergeyShk/ruTS) (Russian) and [esTS](https://github.com/SergeyShk/esTS) (Spanish). It holds the code that does not depend on a language, so that it is written, tested and documented once; a language library adds its tokenizer, lemmatizer, [spaCy](https://github.com/explosion/spaCy) model and rules and re-exports the core under its own names.
+
+[Documentation](https://sergeyshk.github.io/anyTS/) · [PyPI](https://pypi.org/project/anyts/)
+
+## Features
+
+* **[Extraction](https://sergeyshk.github.io/anyTS/extractors/sentences/)** - sentence, word and character N-gram extractors whose tokenizer, lemmatizer and number pattern are hooks a language library overrides
+* **[Lexical diversity](https://sergeyshk.github.io/anyTS/stats/diversity_stats/)** - 32 metrics: TTR and its variants, MATTR, MSTTR, MTLD, MA-MTLD, MTLD-W, HD-D, the indices of Simpson and Yule, entropy, the laws of Zipf and Heaps, over the whole text or over windows with confidence intervals
+* **[Cohesion helpers](https://sergeyshk.github.io/anyTS/stats/cohesion/)** - the overlap of sentences, adjacent and over all pairs, Dice, givenness and repetition
+* **[Dependency tree helpers](https://sergeyshk.github.io/anyTS/stats/syntax/)** - dependency distances, tree depth, valency and coordination chains on the labels shared by Universal Dependencies and ClearNLP
+* **[Corpus measures](https://sergeyshk.github.io/anyTS/corpus/keyness/)** - keywords against a corpus or a frequency dictionary, collocations, the dispersion of a word, Burrows's Delta and its variants, Zeta, Kilgarriff's chi-square, the Mendenhall curve and the comparison of corpora with effect sizes, a bootstrap by texts and the Holm correction
+* **[Exceptions](https://sergeyshk.github.io/anyTS/exceptions/)** - one hierarchy whose classes are also built-in exceptions
+
+The reference of every function is a named section that the libraries include in their own documentation, so a formula is described in one place.
+
+## Installation
+
+Requires Python 3.11 or newer.
+
+```bash
+pip install anyts
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add anyts
+```
+
+The dependencies are numpy, pandas, scipy and spaCy; no trained spaCy model is needed.
+
+## Quick start
+
+```python
+>>> from anyts import DiversityStats, SentsExtractor, WordsExtractor
+
+>>> text = "The cat sat on the mat. The dog sat on the log! The cat and the dog slept."
+
+>>> SentsExtractor().extract(text)
+('The cat sat on the mat.', 'The dog sat on the log!', 'The cat and the dog slept.')
+
+>>> ds = DiversityStats(WordsExtractor(lowercase=True).extract(text))
+>>> ds.ttr, round(ds.entropy, 3)
+(0.5, 2.864)
+```
+
+A language library subclasses the extractors and overrides their hooks:
+
+```python
+>>> class Words(WordsExtractor):
+...     def lemmatize(self, word):
+...         return {"sat": "sit", "slept": "sleep"}.get(word.lower(), word)
+
+>>> Words(lowercase=True, use_lexemes=True).extract("The cat sat. The dog slept.")
+('the', 'cat', 'sit', 'the', 'dog', 'sleep')
+```
+
+The corpus measures take lists of words:
+
+```python
+>>> from anyts.corpus import keyness
+
+>>> cats = WordsExtractor(lowercase=True).extract("The cat sat on the mat. The cat saw a bird. The cat slept.")
+>>> dogs = WordsExtractor(lowercase=True).extract("The dog sat on the log. The dog saw a cat. The dog barked.")
+>>> [(keyword.word, round(keyword.log_ratio, 2)) for keyword in keyness(cats, dogs, min_freq=2)]
+[('cat', 1.58)]
+```
+
+## Development
+
+The project uses [uv](https://docs.astral.sh/uv/) for dependencies and [ruff](https://docs.astral.sh/ruff/) for linting and formatting.
+
+```bash
+git clone https://github.com/SergeyShk/anyTS.git
+cd anyTS
+
+make deps                   # create the environment and install all dependencies
+uv run pre-commit install   # hooks: linters on commit, tests on push
+make lint                   # ruff check, ruff format --check, mypy
+make test-cov               # pytest with doctests and full coverage
+make docs-build             # mkdocs build --strict
+```
+
+The full list of commands is in `make help`. Contribution guidelines are in [CONTRIBUTING.md](https://github.com/SergeyShk/anyTS/blob/master/CONTRIBUTING.md).
+
+## License
+
+[MIT](https://github.com/SergeyShk/anyTS/blob/master/LICENSE.txt)

anyts-0.1.0/anyts/__init__.py

@@ -0,0 +1,49 @@
+# Any Texts Statistics (anyTS)
+#
+# Copyright (C) 2026
+# Author: Sergey Shkarin <kouki.sergey@gmail.com>
+# URL: <https://github.com/SergeyShk/anyTS>
+
+import logging
+from importlib.metadata import PackageNotFoundError, version
+
+from .diversity_stats import DiversityStats
+from .exceptions import (
+    AnyTSError,
+    DataFileError,
+    DatasetNotFoundError,
+    DownloadError,
+    ParameterError,
+    SourceError,
+    SourceTypeError,
+    UnknownStatError,
+)
+from .extractors import CharNgramsExtractor, SentsExtractor, WordsExtractor
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+try:
+    __version__ = version("anyts")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+__description__ = (
+    "The language-independent core of text statistics libraries. Requires Python 3.11+"
+)
+__author__ = "Sergey Shkarin"
+__author_email__ = "kouki.sergey@gmail.com"
+
+__all__ = [
+    "AnyTSError",
+    "CharNgramsExtractor",
+    "DataFileError",
+    "DatasetNotFoundError",
+    "DiversityStats",
+    "DownloadError",
+    "ParameterError",
+    "SentsExtractor",
+    "SourceError",
+    "SourceTypeError",
+    "UnknownStatError",
+    "WordsExtractor",
+    "__version__",
+]

anyts-0.1.0/anyts/cohesion.py

@@ -0,0 +1,292 @@
+from collections import Counter
+from collections.abc import Collection, Iterable, Sequence
+from itertools import pairwise
+from math import fsum, nan
+from typing import NamedTuple
+
+import numpy as np
+
+from .utils import check_sequence, check_words, safe_divide
+
+
+def _check_sents(sents: Iterable[Iterable[object]], what: str) -> None:
+    """Checking a list of sentences given as collections of their elements"""
+    check_sequence(sents, "sentences")
+    for sent in sents:
+        check_words(sent, what)
+
+
+class Overlap(NamedTuple):
+    """
+    Overlaps of the sentences of a text
+
+    Attributes:
+        adjacent (float): Share of adjacent pairs of sentences with a shared element
+        all (float): Share of all pairs of sentences with a shared element
+        prop_adjacent (float): Mean share of shared elements in adjacent pairs
+        prop_all (float): Mean share of shared elements in all pairs
+    """
+
+    adjacent: float
+    all: float
+    prop_adjacent: float
+    prop_all: float
+
+
+def calc_overlap(sets: Sequence[Collection[str]], adjacent: bool = True) -> float:
+    """
+    Computing the share of pairs of sentences with a shared element
+
+    Description:
+        The binary overlap of Coh-Metrix (CRFNO1, CRFAO1, CRFSO1 over the
+        adjacent pairs, CRFNOa, CRFAOa, CRFSOa over all): a pair of sentences is
+        cohesive when they share at least one element; all the pairs are counted
+        over bit masks of the sentences, without going through them
+
+    Arguments:
+        sets (list[set[str]]): Elements of every sentence
+        adjacent (bool): Count the adjacent pairs only, otherwise all the pairs
+
+    Returns:
+        float: Share of the pairs with a shared element, nan for a text shorter
+            than two sentences
+
+    Raises:
+        SourceTypeError: If the sentences are a string, a Doc or an iterator, or a sentence
+            is not a list of strings (check_words)
+    """
+    _check_sents(sets, "elements of a sentence")
+    frozen = [frozenset(elements) for elements in sets]
+    n_sents = len(frozen)
+    if n_sents < 2:
+        return nan
+    if adjacent:
+        return sum(1 for first, second in pairwise(frozen) if not first.isdisjoint(second)) / (
+            n_sents - 1
+        )
+    return _count_sharing_pairs(frozen) / (n_sents * (n_sents - 1) // 2)
+
+
+def calc_proportional_overlap(sets: Sequence[Collection[str]], adjacent: bool = True) -> float:
+    """
+    Computing the mean share of shared elements in pairs of sentences
+
+    Description:
+        The proportional overlap of Coh-Metrix (CRFCWO1, CRFCWOa): the Dice
+        coefficient of a pair of sentences (dice) averaged over the pairs; over all
+        the pairs the sum comes from the histograms of the lengths of the sentences
+        holding every element (see calc_overlaps), without going through them
+
+    Arguments:
+        sets (list[set[str]]): Elements of every sentence
+        adjacent (bool): Count the adjacent pairs only, otherwise all the pairs
+
+    Returns:
+        float: Mean share of shared elements, nan for a text shorter than two sentences
+
+    Raises:
+        SourceTypeError: If the sentences are a string, a Doc or an iterator, or a sentence
+            is not a list of strings (check_words)
+    """
+    _check_sents(sets, "elements of a sentence")
+    frozen = [frozenset(elements) for elements in sets]
+    n_sents = len(frozen)
+    if n_sents < 2:
+        return nan
+    if adjacent:
+        return sum(dice(first, second) for first, second in pairwise(frozen)) / (n_sents - 1)
+    return _sum_dice(frozen) / (n_sents * (n_sents - 1) // 2)
+
+
+def dice(first: frozenset[str], second: frozenset[str]) -> float:
+    """
+    Computing the Dice coefficient of two sets
+
+    Arguments:
+        first (frozenset[str]): First set
+        second (frozenset[str]): Second set
+
+    Returns:
+        float: The coefficient 2·|A ∩ B| / (|A| + |B|), 0 for two empty sets
+    """
+    return safe_divide(2 * len(first & second), len(first) + len(second))
+
+
+def calc_overlaps(sets: Sequence[Collection[str]], proportional: bool = True) -> Overlap:
+    """
+    Computing the binary and the proportional overlap over adjacent and all pairs
+
+    Description:
+        Gives the values of calc_overlap and calc_proportional_overlap over the
+        adjacent and all the pairs at once
+
+    Arguments:
+        sets (list[set[str]]): Elements of every sentence
+        proportional (bool): Compute the proportional overlap as well; without it
+            prop_adjacent and prop_all are nan
+
+    Returns:
+        Overlap: Shares of the pairs with a shared element and the mean Dice
+            coefficients, nan for a text shorter than two sentences
+
+    Raises:
+        SourceTypeError: If the sentences are a string, a Doc or an iterator, or a sentence
+            is not a list of strings (check_words)
+    """
+    _check_sents(sets, "elements of a sentence")
+    frozen = [frozenset(elements) for elements in sets]
+    n_sents = len(frozen)
+    if n_sents < 2:
+        return Overlap(nan, nan, nan, nan)
+    n_all = n_sents * (n_sents - 1) // 2
+    return Overlap(
+        sum(1 for first, second in pairwise(frozen) if not first.isdisjoint(second))
+        / (n_sents - 1),
+        _count_sharing_pairs(frozen) / n_all,
+        sum(dice(first, second) for first, second in pairwise(frozen)) / (n_sents - 1)
+        if proportional
+        else nan,
+        _sum_dice(frozen) / n_all if proportional else nan,
+    )
+
+
+def _count_sharing_pairs(sets: Sequence[frozenset[str]], block_size: int = 4096) -> int:
+    """
+    Number of pairs of sentences with a shared element, over bit masks of the occurrences
+
+    Description:
+        Every element gets a mask of the sentences of a block it occurs in; the
+        union of the masks of sentence i gives the sentences it shares an
+        element with, and the bits after i are counted
+    """
+    total = 0
+    for start in range(0, len(sets), block_size):
+        end = min(start + block_size, len(sets))
+        masks: dict[str, int] = {}
+        for j in range(start, end):
+            bit = 1 << (j - start)
+            for element in sets[j]:
+                masks[element] = masks.get(element, 0) | bit
+        for i in range(end):
+            union = 0
+            for element in sets[i]:
+                union |= masks.get(element, 0)
+            if i >= start:
+                union >>= i - start + 1
+            total += union.bit_count()
+    return total
+
+
+def _sum_dice(sets: Sequence[frozenset[str]]) -> float:
+    """
+    Sum of the Dice coefficients over all the pairs, over histograms of the lengths
+
+    Description:
+        A pair of sentences of lengths k and l gives 2/(k + l) for every shared
+        element, so the sum over the pairs holding an element is
+        (h·W·h - h·diag(W)) / 2, where h is the histogram of the lengths of its
+        sentences and W[k, l] = 2/(k + l); the sums of the elements are added
+        by fsum, so the result does not depend on their order
+    """
+    sizes = sorted({len(elements) for elements in sets if elements})
+    columns = {size: column for column, size in enumerate(sizes)}
+    postings: dict[str, list[int]] = {}
+    for elements in sets:
+        if not elements:
+            continue
+        column = columns[len(elements)]
+        for element in elements:
+            postings.setdefault(element, []).append(column)
+    rows = [row for row in postings.values() if len(row) > 1]
+    if not rows:
+        return 0.0
+    histograms = np.zeros((len(rows), len(sizes)))
+    for index, row in enumerate(rows):
+        np.add.at(histograms[index], row, 1)
+    lengths = np.array(sizes, dtype=float)
+    weights = 2 / (lengths[:, None] + lengths[None, :])
+    full = np.einsum("ik,kl,il->i", histograms, weights, histograms)
+    diagonal = (histograms * np.diag(weights)).sum(axis=1)
+    return fsum(full - diagonal) / 2
+
+
+def count_given(sents: Sequence[Sequence[str]]) -> int:
+    """
+    Counting the given elements - the ones used before in the text
+
+    Description:
+        An element is given when the same lemma was used earlier in any sentence,
+        the current one included; the first occurrence is new
+
+    Arguments:
+        sents (list[list[str]]): Lemmas of every sentence in the order of the text
+
+    Returns:
+        int: Number of given elements
+
+    Raises:
+        SourceTypeError: If the sentences are a string, a Doc or an iterator, or a sentence
+            is not a list of strings (check_words)
+    """
+    _check_sents(sents, "lemmas of a sentence")
+    seen: set[str] = set()
+    given = 0
+    for sent in sents:
+        for lemma in sent:
+            if lemma in seen:
+                given += 1
+            seen.add(lemma)
+    return given
+
+
+def dominant(values: Sequence[str]) -> str | None:
+    """
+    Getting the dominant value
+
+    Description:
+        The most frequent value, the first one of the equally frequent
+
+    Arguments:
+        values (list[str]): Values
+
+    Returns:
+        str|None: Dominant value, None for an empty list
+
+    Raises:
+        SourceTypeError: If the values are not a list of strings (check_words)
+    """
+    check_words(values, "values")
+    if not values:
+        return None
+    return Counter(values).most_common(1)[0][0]
+
+
+def calc_repetition(sents: Sequence[Sequence[str]]) -> float:
+    """
+    Computing the share of adjacent pairs of sentences with the same dominant value
+
+    Description:
+        The repetition of the tense and of the mood of Coh-Metrix (SMTEMP): a
+        pair of adjacent sentences is cohesive when the dominant values of the
+        feature of their verbs are equal; a pair where one of the sentences has
+        no verb with the feature is skipped
+
+    Arguments:
+        sents (list[list[str]]): Values of the feature of the verbs of every sentence
+
+    Returns:
+        float: Share of the cohesive pairs, nan without a single pair with the feature
+
+    Raises:
+        SourceTypeError: If the sentences are a string, a Doc or an iterator, or a sentence
+            is not a list of strings (check_words)
+    """
+    _check_sents(sents, "values of a sentence")
+    pairs = [
+        (first, second)
+        for first, second in pairwise(dominant(sent) for sent in sents)
+        if first and second
+    ]
+    if not pairs:
+        return nan
+    return sum(1 for first, second in pairs if first == second) / len(pairs)