radixor-c 4.1.3__tar.gz

radixor_c-4.1.3/LICENSE

@@ -0,0 +1,28 @@
+Copyright (C) 2026, Leo Galambos
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

radixor_c-4.1.3/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: radixor-c
+Version: 4.1.3
+Summary: Radixor stemmer — C extension backend
+License-Expression: BSD-3-Clause
+Keywords: stemming,nlp,c-extension
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: radixor-models-standard<2.0,>=1.0
+Dynamic: license-file
+
+# radixor-c — Fast Scalar Stemming for Python
+
+**radixor-c** is the C-backed Python runtime for
+[Radixor](https://github.com/leogalambos/Radixor), a dictionary-trained
+transformation stemmer supporting 20 languages. Its native engine is implemented
+directly against the CPython C API to keep the overhead of stemming individual
+words low.
+
+It uses the same precompiled models and stemming semantics as the Java flagship
+and the Python (PyO3) package, distributed as `radixor`. The distinction is scope: radixor-c focuses
+on basic runtime stemming from prepared models. Text dictionary compilation,
+trie modification and the broader model toolchain belong to Java and, as it
+converges toward Java, the `radixor` Python package.
+
+## Which Radixor package should I use?
+
+| Package | Choose it for | Model operations |
+|---|---|---|
+| **Python-C** (`radixor-c`) | Fast calls for individual Python words; simple deployment | Load standard or [compiled Radixor models](https://leogalambos.github.io/Radixor/data-formats/) |
+| **Python (PyO3)** (`radixor`) | High-throughput batch processing and Python-side compilation | Load compiled models and compile textual dictionaries; broader capabilities are added here first |
+| **Java Radixor** | The complete, flagship API and model development | Full construction, reduction, extension and persistence |
+
+Radixor-c is not a lower-quality stemmer. Given the same compiled trie it
+produces the same results; it currently exposes fewer ways to create or modify
+that trie.
+
+## Installation
+
+```bash
+python -m pip install --only-binary=:all: radixor-c
+```
+
+Published wheels support CPython 3.10–3.14 on Linux, macOS and Windows. The
+installation also resolves `radixor-models-standard`, the shared package of 20
+precompiled standard models.
+
+## Quick start
+
+```python
+from radixor_c import Stemmer
+
+stemmer = Stemmer("en")
+
+stemmer.stem("running")       # "run"
+stemmer.stem("unknown_word")  # None
+```
+
+Construct the stemmer once and reuse it. Scalar calls are the primary reason to
+select radixor-c, but batch and PyStemmer-compatible methods are also available:
+
+```python
+words = ["running", "studies", "cars"]
+
+stemmer.stem_batch(words)
+stemmer.stemWord("running")
+stemmer.stemWords(words)
+```
+
+`stem()` and `stem_batch()` return `None` where no patch applies.
+`stemWord()` and `stemWords()` instead return unmatched input unchanged.
+
+## Custom models
+
+Radixor-c loads [compiled Radixor models](https://leogalambos.github.io/Radixor/data-formats/):
+
+```python
+custom = Stemmer(compiled="models/domain-english.rxc")
+```
+
+It deliberately does not compile a text dictionary. Prepare the interoperable
+`.rxc` file with Java or the `radixor` package:
+
+```python
+import radixor
+
+radixor.compile("domain.tsv.gz", "models/domain-english.rxc", language="en")
+```
+
+The resulting model can be loaded by all three implementations.
+
+## API at a glance
+
+| API | Purpose |
+|---|---|
+| `Stemmer(language)` | Load a bundled model by alias or model ID |
+| `Stemmer(compiled=path)` | Load an application-owned compiled Radixor model |
+| `stem(word)` | Return the dominant stem or `None` |
+| `stem_batch(words)` | Stem a list with positional `None` results |
+| `stemWord(word)` / `stemWords(words)` | PyStemmer-compatible unmatched-word fallback |
+| `stem_all(word)` / `stem_all_batch(words)` | Return ranked alternative stems |
+| `algorithms()` / `version()` | Compatibility and package information |
+
+The default bounded cache holds 10,000 results. Use `cache_size=0` to disable
+it, or configure the PyStemmer-compatible `maxCacheSize` property.
+
+## Documentation
+
+- [Choose a Radixor runtime](https://leogalambos.github.io/Radixor/getting-started/)
+- [Python-C quick start](https://leogalambos.github.io/Radixor/python-c/quick-start/)
+- [Python-C usage and API](https://leogalambos.github.io/Radixor/python-c/usage/)
+- [Shared Python benchmark](https://leogalambos.github.io/Radixor/python/performance/)
+- [Shared data formats](https://leogalambos.github.io/Radixor/data-formats/)
+
+Radixor software is available under the BSD 3-Clause License. Model data keeps
+its separately documented provenance and licensing.

radixor_c-4.1.3/README.md

@@ -0,0 +1,105 @@
+# radixor-c — Fast Scalar Stemming for Python
+
+**radixor-c** is the C-backed Python runtime for
+[Radixor](https://github.com/leogalambos/Radixor), a dictionary-trained
+transformation stemmer supporting 20 languages. Its native engine is implemented
+directly against the CPython C API to keep the overhead of stemming individual
+words low.
+
+It uses the same precompiled models and stemming semantics as the Java flagship
+and the Python (PyO3) package, distributed as `radixor`. The distinction is scope: radixor-c focuses
+on basic runtime stemming from prepared models. Text dictionary compilation,
+trie modification and the broader model toolchain belong to Java and, as it
+converges toward Java, the `radixor` Python package.
+
+## Which Radixor package should I use?
+
+| Package | Choose it for | Model operations |
+|---|---|---|
+| **Python-C** (`radixor-c`) | Fast calls for individual Python words; simple deployment | Load standard or [compiled Radixor models](https://leogalambos.github.io/Radixor/data-formats/) |
+| **Python (PyO3)** (`radixor`) | High-throughput batch processing and Python-side compilation | Load compiled models and compile textual dictionaries; broader capabilities are added here first |
+| **Java Radixor** | The complete, flagship API and model development | Full construction, reduction, extension and persistence |
+
+Radixor-c is not a lower-quality stemmer. Given the same compiled trie it
+produces the same results; it currently exposes fewer ways to create or modify
+that trie.
+
+## Installation
+
+```bash
+python -m pip install --only-binary=:all: radixor-c
+```
+
+Published wheels support CPython 3.10–3.14 on Linux, macOS and Windows. The
+installation also resolves `radixor-models-standard`, the shared package of 20
+precompiled standard models.
+
+## Quick start
+
+```python
+from radixor_c import Stemmer
+
+stemmer = Stemmer("en")
+
+stemmer.stem("running")       # "run"
+stemmer.stem("unknown_word")  # None
+```
+
+Construct the stemmer once and reuse it. Scalar calls are the primary reason to
+select radixor-c, but batch and PyStemmer-compatible methods are also available:
+
+```python
+words = ["running", "studies", "cars"]
+
+stemmer.stem_batch(words)
+stemmer.stemWord("running")
+stemmer.stemWords(words)
+```
+
+`stem()` and `stem_batch()` return `None` where no patch applies.
+`stemWord()` and `stemWords()` instead return unmatched input unchanged.
+
+## Custom models
+
+Radixor-c loads [compiled Radixor models](https://leogalambos.github.io/Radixor/data-formats/):
+
+```python
+custom = Stemmer(compiled="models/domain-english.rxc")
+```
+
+It deliberately does not compile a text dictionary. Prepare the interoperable
+`.rxc` file with Java or the `radixor` package:
+
+```python
+import radixor
+
+radixor.compile("domain.tsv.gz", "models/domain-english.rxc", language="en")
+```
+
+The resulting model can be loaded by all three implementations.
+
+## API at a glance
+
+| API | Purpose |
+|---|---|
+| `Stemmer(language)` | Load a bundled model by alias or model ID |
+| `Stemmer(compiled=path)` | Load an application-owned compiled Radixor model |
+| `stem(word)` | Return the dominant stem or `None` |
+| `stem_batch(words)` | Stem a list with positional `None` results |
+| `stemWord(word)` / `stemWords(words)` | PyStemmer-compatible unmatched-word fallback |
+| `stem_all(word)` / `stem_all_batch(words)` | Return ranked alternative stems |
+| `algorithms()` / `version()` | Compatibility and package information |
+
+The default bounded cache holds 10,000 results. Use `cache_size=0` to disable
+it, or configure the PyStemmer-compatible `maxCacheSize` property.
+
+## Documentation
+
+- [Choose a Radixor runtime](https://leogalambos.github.io/Radixor/getting-started/)
+- [Python-C quick start](https://leogalambos.github.io/Radixor/python-c/quick-start/)
+- [Python-C usage and API](https://leogalambos.github.io/Radixor/python-c/usage/)
+- [Shared Python benchmark](https://leogalambos.github.io/Radixor/python/performance/)
+- [Shared data formats](https://leogalambos.github.io/Radixor/data-formats/)
+
+Radixor software is available under the BSD 3-Clause License. Model data keeps
+its separately documented provenance and licensing.

radixor_c-4.1.3/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "radixor-c"
+version = "4.1.3"
+requires-python = ">=3.10"
+description = "Radixor stemmer — C extension backend"
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+dependencies = ["radixor-models-standard>=1.0,<2.0"]
+keywords = ["stemming", "nlp", "c-extension"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["radixor_c*"]
+
+[tool.setuptools.package-data]
+radixor_c = ["py.typed"]
+
+[tool.cibuildwheel]
+build = "cp310-* cp311-* cp312-* cp313-* cp314-*"
+test-command = 'python -c "import radixor_c, radixor_c._radixor_c"'
+# musllinux is fine — we no longer use towlower (locale-dependent); lowercasing
+# goes through Python's str.lower() which is locale-independent.
+skip = "*-win32"
+
+[tool.cibuildwheel.linux]
+archs = ["x86_64", "aarch64"]
+manylinux-x86_64-image  = "manylinux2014"
+manylinux-aarch64-image = "manylinux2014"
+
+[tool.cibuildwheel.macos]
+archs = ["universal2"]
+
+[tool.cibuildwheel.windows]
+archs = ["AMD64"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"

radixor_c-4.1.3/radixor_c/__init__.py

@@ -0,0 +1,308 @@
+"""Python API for the C-backed Radixor stemmer.
+
+Drop-in replacement for ``radixor`` with identical public interface.
+The underlying trie engine is a pure CPython C extension instead of Rust/PyO3.
+
+Only pre-compiled ``.rxc`` trie files are supported.
+Use ``radixor.compile()`` to compile a TSV dictionary.
+"""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import importlib.resources
+import importlib.metadata as metadata
+import json
+import re
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Iterable, Iterator, Optional, overload
+
+from radixor_c._radixor_c import StemmerCore
+
+_PYSTEMMER_MODEL_MAP: tuple[tuple[str, bool, tuple[str, ...], tuple[str, ...]], ...] = (
+    ("cs-cz-default", True, ("czech", "cs", "ces", "cze"), ()),
+    ("da-dk-default", True, ("danish", "da", "dan"), ()),
+    (
+        "nl-nl-default",
+        True,
+        ("dutch", "nl", "dut", "nld", "kraaij_pohlmann"),
+        ("dutch",),
+    ),
+    ("us-uk-default", True, ("english", "en", "eng"), ()),
+    ("fi-fi-default", True, ("finnish", "fi", "fin"), ()),
+    ("fr-fr-default", True, ("french", "fr", "fre", "fra"), ()),
+    ("de-de-default", True, ("german", "de", "ger", "deu"), ()),
+    ("hu-hu-default", True, ("hungarian", "hu", "hun"), ()),
+    ("it-it-default", True, ("italian", "it", "ita"), ()),
+    ("nb-no-default", True, ("norwegian", "no", "nor"), ("nb",)),
+    ("nn-no-default", False, tuple(), ("nn",)),
+    ("fa-ir-default", True, ("persian", "fa", "fas", "pers"), ()),
+    ("pl-pl-unimorph", True, ("polish", "pl", "pol"), ()),
+    ("pt-pt-default", True, ("portuguese", "pt", "por"), ()),
+    ("ru-ru-default", True, ("russian", "ru", "rus"), ()),
+    ("es-es-default", True, ("spanish", "es", "esl", "spa"), ()),
+    ("sv-se-default", True, ("swedish", "sv", "swe"), ()),
+    ("yi-default", True, ("yiddish", "yi", "yid"), ()),
+    ("he-il-default", False, tuple(), ("he", "hebrew")),
+    ("uk-ua-default", False, tuple(), ("uk", "ukrainian")),
+)
+
+_LANGUAGE_ALIASES: dict[str, str] = {mid: mid for mid, *_ in _PYSTEMMER_MODEL_MAP}
+_SUPPORTED_PYSTEMMER_ALGORITHMS: list[str] = []
+_SUPPORTED_PYSTEMMER_ALIASES: list[str] = []
+for _mid, _supported, _aliases, _native in _PYSTEMMER_MODEL_MAP:
+    for _a in _aliases:
+        _LANGUAGE_ALIASES[_a] = _mid
+    for _a in _native:
+        _LANGUAGE_ALIASES[_a] = _mid
+    if _supported:
+        _SUPPORTED_PYSTEMMER_ALGORITHMS.append(_aliases[0])
+        _SUPPORTED_PYSTEMMER_ALIASES.extend(_aliases)
+
+_SUPPORTED_PYSTEMMER_ALIASES = list(dict.fromkeys(_SUPPORTED_PYSTEMMER_ALIASES))
+_SUPPORTED_PYSTEMMER_MODEL_IDS = frozenset(mid for mid, *_ in _PYSTEMMER_MODEL_MAP)
+_RIGHT_TO_LEFT_MODELS: frozenset[str] = frozenset({"fa-ir-default", "he-il-default", "yi-default"})
+
+_STANDARD_PACKAGE = "radixor_models_standard"
+_STANDARD_CATALOG_VERSION = "2026.1"
+_STANDARD_DISTRIBUTION_VERSION = re.compile(
+    r"(?:0\.0\.0|1\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*))\Z"
+)
+_MODEL_ID = re.compile(r"[a-z0-9]+(?:-[a-z0-9]+)*\Z")
+_SHA256 = re.compile(r"[0-9a-f]{64}\Z")
+_V7_MAGIC = b"EGTR"
+_V7_VERSION = 7
+
+
+def algorithms(aliases: bool = False) -> list[str]:
+    if aliases:
+        return list(_SUPPORTED_PYSTEMMER_ALIASES)
+    return list(_SUPPORTED_PYSTEMMER_ALGORITHMS)
+
+
+def version() -> str:
+    try:
+        return metadata.version("radixor-c")
+    except metadata.PackageNotFoundError:
+        return "0.0.0"
+
+
+def _load_standard_manifest() -> dict[str, Any]:
+    try:
+        ref = importlib.resources.files(_STANDARD_PACKAGE).joinpath("manifest.json")
+    except (ModuleNotFoundError, TypeError) as exc:
+        raise ModuleNotFoundError(
+            "The standard Radixor model package is not installed. "
+            "Install with 'pip install radixor-models-standard>=1.0,<2.0'."
+        ) from exc
+    try:
+        manifest = json.loads(ref.read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise RuntimeError("radixor-models-standard manifest is missing or corrupt.") from exc
+
+    try:
+        models = manifest["models"]
+        format_info = manifest["format"]
+        if manifest["schema_version"] != 1:
+            raise ValueError("unsupported schema_version")
+        if manifest["catalog_version"] != _STANDARD_CATALOG_VERSION:
+            raise ValueError(f"catalog version mismatch")
+        dv = manifest["distribution_version"]
+        if not isinstance(dv, str) or _STANDARD_DISTRIBUTION_VERSION.fullmatch(dv) is None:
+            raise ValueError("incompatible distribution_version")
+        if format_info != {"compression": "gzip", "magic": "EGTR", "version": 7}:
+            raise ValueError("unsupported compiled model format")
+        if not isinstance(models, list) or not models:
+            raise ValueError("models must be a non-empty list")
+        seen: set[str] = set()
+        for model in models:
+            mid = model["id"]
+            if (
+                not isinstance(mid, str)
+                or _MODEL_ID.fullmatch(mid) is None
+                or mid in seen
+                or model["file"] != f"models/{mid}.rxc"
+                or not isinstance(model["version"], str)
+                or _SHA256.fullmatch(model["sha256"]) is None
+            ):
+                raise ValueError("invalid model entry")
+            seen.add(mid)
+    except (KeyError, TypeError, ValueError) as exc:
+        raise RuntimeError(f"radixor-models-standard manifest incompatible: {exc}.") from exc
+    return manifest
+
+
+def _manifest_model(model_id: str) -> dict[str, Any]:
+    if not isinstance(model_id, str) or _MODEL_ID.fullmatch(model_id) is None:
+        raise ValueError(f"Invalid model ID {model_id!r}.")
+    manifest = _load_standard_manifest()
+    for model in manifest["models"]:
+        if model["id"] == model_id:
+            return model
+    raise FileNotFoundError(f"Model '{model_id}' not in standard catalog.")
+
+
+def _validate_standard_model(path: Path, model: dict[str, Any]) -> None:
+    try:
+        digest = hashlib.sha256(path.read_bytes()).hexdigest()
+    except OSError as exc:
+        raise RuntimeError(f"Cannot read standard model '{model['id']}'.") from exc
+    if digest != model["sha256"]:
+        raise RuntimeError(f"Standard model '{model['id']}' failed SHA-256 validation.")
+    try:
+        with gzip.open(path, "rb") as stream:
+            header = stream.read(8)
+    except (OSError, EOFError) as exc:
+        raise RuntimeError(f"Standard model '{model['id']}' is not valid gzip.") from exc
+    if header[:4] != _V7_MAGIC or len(header) != 8:
+        raise RuntimeError(f"Standard model '{model['id']}' missing EGTR marker.")
+    version_int = int.from_bytes(header[4:8], "big", signed=True)
+    if version_int != _V7_VERSION:
+        raise RuntimeError(f"Unsupported model format v{version_int}.")
+
+
+@contextmanager
+def _standard_model_path(model_id: str) -> Iterator[Path]:
+    model = _manifest_model(model_id)
+    ref = (
+        importlib.resources.files(_STANDARD_PACKAGE)
+        .joinpath("models")
+        .joinpath(f"{model_id}.rxc")
+    )
+    try:
+        with importlib.resources.as_file(ref) as path:
+            if not path.is_file():
+                raise FileNotFoundError
+            _validate_standard_model(path, model)
+            yield path
+    except FileNotFoundError as exc:
+        raise FileNotFoundError(
+            f"Standard model '{model_id}' missing; reinstall radixor-models-standard."
+        ) from exc
+
+
+def _is_backward(model_id: str) -> bool:
+    return model_id not in _RIGHT_TO_LEFT_MODELS
+
+
+class Stemmer:
+    """Thread-safe Radixor stemmer backed by the C extension.
+
+    Identical interface to ``radixor.Stemmer``.
+    """
+
+    def __init__(
+        self,
+        language: Optional[str] = None,
+        maxCacheSize: Optional[int] = None,
+        *,
+        path: Optional[str] = None,
+        compiled: Optional[str] = None,
+        backward: Optional[bool] = None,
+        store_original: bool = True,
+        lowercase: bool = True,
+        cache_size: int = 10_000,
+    ) -> None:
+        source = path if path is not None else compiled
+        if maxCacheSize is not None:
+            if not isinstance(maxCacheSize, int):
+                raise TypeError("maxCacheSize must be an int")
+            if maxCacheSize < 0:
+                raise ValueError("maxCacheSize must be non-negative")
+            cache_size = maxCacheSize
+        elif cache_size < 0:
+            raise ValueError("cache_size must be non-negative")
+
+        if source is not None:
+            model_path = source
+            is_backward = True if backward is None else backward
+            model_id_val = None
+        elif language is not None:
+            if language in _LANGUAGE_ALIASES:
+                model_id_val = _LANGUAGE_ALIASES[language]
+            elif language in _SUPPORTED_PYSTEMMER_MODEL_IDS:
+                model_id_val = language
+            elif "-" in language and _MODEL_ID.fullmatch(language) is not None:
+                model_id_val = language
+            elif ".." in language or "/" in language or "\\" in language:
+                raise ValueError(f"Invalid model ID {language!r}.")
+            else:
+                raise KeyError(language)
+            is_backward = _is_backward(model_id_val) if backward is None else backward
+            model_path = None
+        else:
+            raise ValueError("Provide 'language', 'path', or 'compiled'.")
+
+        self._backward = is_backward
+        self._store_original = store_original
+        self._lowercase = lowercase
+        self._cache_size = cache_size
+        self._source_path = model_path
+        self._model_id = model_id_val
+        self._core = self._create_core(cache_size)
+
+    def _create_core(self, cache_size: int) -> StemmerCore:
+        if self._source_path is not None:
+            return StemmerCore(
+                self._source_path,
+                self._backward,
+                self._store_original,
+                self._lowercase,
+                cache_size,
+            )
+        with _standard_model_path(self._model_id or "") as model_path:
+            return StemmerCore(
+                str(model_path),
+                self._backward,
+                self._store_original,
+                self._lowercase,
+                cache_size,
+            )
+
+    @staticmethod
+    def version() -> str:
+        return version()
+
+    @property
+    def maxCacheSize(self) -> int:
+        return self._cache_size
+
+    @maxCacheSize.setter
+    def maxCacheSize(self, size: int) -> None:
+        if not isinstance(size, int):
+            raise TypeError("maxCacheSize must be an int")
+        if size < 0:
+            raise ValueError("maxCacheSize must be non-negative")
+        if size == self._cache_size:
+            return
+        self._cache_size = size
+        self._core = self._create_core(size)
+
+    def stem(self, word: str) -> Optional[str]:
+        return self._core.stem(word)
+
+    def stem_batch(self, words: list[str]) -> list[Optional[str]]:
+        return self._core.stem_batch(words)
+
+    @overload
+    def stemWord(self, word: str) -> str: ...
+
+    @overload
+    def stemWord(self, word: bytes) -> bytes: ...
+
+    def stemWord(self, word: str | bytes) -> str | bytes:
+        return self._core.stemWord(word)
+
+    def stemWords(self, words: Iterable[str | bytes]) -> list[str | bytes]:
+        return self._core.stemWords(words)
+
+    def stem_all(self, word: str) -> list[str]:
+        return self._core.stem_all(word)
+
+    def stem_all_batch(self, words: list[str]) -> list[list[str]]:
+        return self._core.stem_all_batch(words)
+
+
+__all__ = ["Stemmer", "StemmerCore", "algorithms", "version"]