normalize-uk 0.4.2__cp315-cp315-win_amd64.whl

normalize_uk/__init__.py

@@ -0,0 +1,273 @@
+"""Ukrainian text normalization and tokenization."""
+
+from __future__ import annotations
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_13_1():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'normalize_uk.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_1()
+del _delvewheel_patch_1_13_1
+# end delvewheel patch
+
+import warnings as _warnings
+from collections.abc import Iterable
+
+from ._normalize_uk import (
+    ColonStyle,
+    CurrencySymbolPolicy,
+    DateStyle,
+    NormalizeOptions,
+    NormalizePreset,
+    NumericDateOrder,
+    PhoneStyle,
+    QuoteStyle,
+    RangeStyle,
+    Substring,
+    SymbolStyle,
+    UncertainSpan,
+    UncertaintyCategory,
+    UncertaintySeverity,
+    expand_abbreviations,
+    normalize_abbreviations,
+    options_for_preset,
+    split_sentences,
+    tokenize,
+    transliterate_to_cyrillic,
+)
+from ._normalize_uk import (
+    cyrilize as _native_cyrilize,
+)
+from ._normalize_uk import (
+    cyrrilize as _native_cyrrilize,
+)
+from ._normalize_uk import (
+    flag_uncertain as _native_flag_uncertain,
+)
+from ._normalize_uk import (
+    normalize_ukrainian as _native_normalize_ukrainian,
+)
+from ._normalize_uk import (
+    normalize_ukrainian_many as _native_normalize_ukrainian_many,
+)
+from ._normalize_uk import (
+    number_to_ordinal_words as _native_number_to_ordinal_words,
+)
+from ._normalize_uk import (
+    number_to_words as _native_number_to_words,
+)
+from ._normalize_uk import (
+    number_to_words_case as _native_number_to_words_case,
+)
+from ._normalize_uk import (
+    number_to_words_digit_by_digit as _native_number_to_words_digit_by_digit,
+)
+from ._normalize_uk import (
+    sentenize as _native_sentenize,
+)
+
+__all__ = (
+    "ColonStyle",
+    "CurrencySymbolPolicy",
+    "DateStyle",
+    "NormalizeOptions",
+    "NormalizePreset",
+    "NumericDateOrder",
+    "PhoneStyle",
+    "QuoteStyle",
+    "RangeStyle",
+    "Substring",
+    "SymbolStyle",
+    "UncertainSpan",
+    "UncertaintyCategory",
+    "UncertaintySeverity",
+    "cyrilize",
+    "cyrrilize",
+    "expand_abbreviations",
+    "flag_uncertain",
+    "normalize_abbreviations",
+    "normalize_ukrainian",
+    "normalize_ukrainian_many",
+    "normalize_ukrainian_with_preset",
+    "number_to_ordinal_words",
+    "number_to_words",
+    "number_to_words_case",
+    "number_to_words_digit_by_digit",
+    "options_for_preset",
+    "sentenize",
+    "split_sentences",
+    "tokenize",
+    "transliterate_to_cyrillic",
+)
+
+_MAX_SPOKEN_NUMBER = 10**18 - 1
+_ORDINAL_FORMS = frozenset(
+    (
+        "nom_m",
+        "nom_n",
+        "nom_f",
+        "nom_pl",
+        "gen",
+        "dat",
+        "prep",
+        "loc",
+        "pl",
+        "loc_pl",
+        "acc_f",
+        "gen_f",
+        "ins",
+        "ins_f",
+        "ins_pl",
+        "loc_f",
+    )
+)
+_CARDINAL_CASES = frozenset(("gen", "dat", "instr", "prep"))
+
+
+def _spoken_number(n: int) -> int:
+    if isinstance(n, bool) or not isinstance(n, int):
+        raise TypeError("n must be an integer")
+    if not 0 <= n <= _MAX_SPOKEN_NUMBER:
+        raise ValueError(f"n must be between 0 and {_MAX_SPOKEN_NUMBER}")
+    return n
+
+
+def number_to_words(n: int) -> str:
+    """Spell a nonnegative integer smaller than 10**18 in Ukrainian."""
+    return _native_number_to_words(_spoken_number(n))
+
+
+def number_to_words_digit_by_digit(digits: str) -> str:
+    """Spell each ASCII digit, preserving leading zeroes."""
+    if not isinstance(digits, str):
+        raise TypeError("digits must be a string")
+    if not digits or any(ch < "0" or ch > "9" for ch in digits):
+        raise ValueError("digits must contain one or more ASCII digits only")
+    return _native_number_to_words_digit_by_digit(digits)
+
+
+def number_to_ordinal_words(n: int, form: str = "nom_m") -> str:
+    """Spell an ordinal using one of the supported grammatical forms."""
+    if not isinstance(form, str):
+        raise TypeError("form must be a string")
+    if form not in _ORDINAL_FORMS:
+        raise ValueError(
+            f"unknown ordinal form {form!r}; expected one of {', '.join(sorted(_ORDINAL_FORMS))}"
+        )
+    return _native_number_to_ordinal_words(_spoken_number(n), form)
+
+
+def number_to_words_case(n: int, grammatical_case: str) -> str:
+    """Spell a cardinal in the genitive, dative, instrumental, or prepositional case."""
+    if not isinstance(grammatical_case, str):
+        raise TypeError("grammatical_case must be a string")
+    if grammatical_case not in _CARDINAL_CASES:
+        raise ValueError(
+            f"unknown grammatical case {grammatical_case!r}; expected one of "
+            f"{', '.join(sorted(_CARDINAL_CASES))}"
+        )
+    return _native_number_to_words_case(_spoken_number(n), grammatical_case)
+
+
+def _selection(
+    options: NormalizeOptions | NormalizePreset | None,
+    preset: NormalizePreset | None,
+) -> NormalizeOptions | NormalizePreset | None:
+    if isinstance(options, NormalizePreset):
+        if preset is not None:
+            raise ValueError("provide either options or preset, not both")
+        preset, options = options, None
+    if options is not None and preset is not None:
+        raise ValueError("provide either options or preset, not both")
+    if options is not None:
+        if not isinstance(options, NormalizeOptions):
+            raise TypeError("options must be a NormalizeOptions instance")
+        return options
+    if preset is not None:
+        if not isinstance(preset, NormalizePreset):
+            raise TypeError("preset must be a NormalizePreset value")
+        return preset
+    return None
+
+
+def normalize_ukrainian(
+    text: str,
+    options: NormalizeOptions | NormalizePreset | None = None,
+    *,
+    preset: NormalizePreset | None = None,
+) -> str:
+    """Normalize text with either an options object or a preset."""
+    selected = _selection(options, preset)
+    if selected is None:
+        return _native_normalize_ukrainian(text)
+    if isinstance(selected, NormalizePreset):
+        return _native_normalize_ukrainian(text, selected)
+    return _native_normalize_ukrainian(text, selected)
+
+
+def normalize_ukrainian_many(
+    texts: Iterable[str],
+    options: NormalizeOptions | NormalizePreset | None = None,
+    *,
+    preset: NormalizePreset | None = None,
+) -> list[str]:
+    """Normalize an iterable of strings using one options snapshot for the batch."""
+    selected = _selection(options, preset)
+    if selected is None:
+        return _native_normalize_ukrainian_many(texts)
+    if isinstance(selected, NormalizePreset):
+        return _native_normalize_ukrainian_many(texts, selected)
+    return _native_normalize_ukrainian_many(texts, selected)
+
+
+def flag_uncertain(
+    text: str,
+    options: NormalizeOptions | NormalizePreset | None = None,
+    *,
+    preset: NormalizePreset | None = None,
+) -> list[UncertainSpan]:
+    """Find uncertain spans; explicit options suppress resolved ambiguity warnings."""
+    selected = _selection(options, preset)
+    if selected is None:
+        return _native_flag_uncertain(text)
+    if isinstance(selected, NormalizePreset):
+        return _native_flag_uncertain(text, selected)
+    return _native_flag_uncertain(text, selected)
+
+
+def normalize_ukrainian_with_preset(
+    text: str, preset: NormalizePreset = NormalizePreset.Default
+) -> str:
+    """Compatibility alias for normalize_ukrainian(text, preset=preset)."""
+    return normalize_ukrainian(text, preset=preset)
+
+
+def sentenize(text: str) -> list[Substring]:
+    _warnings.warn(
+        "sentenize() is deprecated; use split_sentences()",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return _native_sentenize(text)
+
+
+def cyrilize(text: str) -> str:
+    _warnings.warn(
+        "cyrilize() is deprecated; use transliterate_to_cyrillic()",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return _native_cyrilize(text)
+
+
+def cyrrilize(text: str) -> str:
+    _warnings.warn(
+        "cyrrilize() is deprecated; use transliterate_to_cyrillic()",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return _native_cyrrilize(text)

normalize_uk/__init__.pyi

@@ -0,0 +1,135 @@
+from collections.abc import Iterable
+from typing import Literal, overload
+
+from ._normalize_uk import (
+    ColonStyle as ColonStyle,
+)
+from ._normalize_uk import (
+    CurrencySymbolPolicy as CurrencySymbolPolicy,
+)
+from ._normalize_uk import (
+    DateStyle as DateStyle,
+)
+from ._normalize_uk import (
+    NormalizeOptions as NormalizeOptions,
+)
+from ._normalize_uk import (
+    NormalizePreset as NormalizePreset,
+)
+from ._normalize_uk import (
+    NumericDateOrder as NumericDateOrder,
+)
+from ._normalize_uk import (
+    PhoneStyle as PhoneStyle,
+)
+from ._normalize_uk import (
+    QuoteStyle as QuoteStyle,
+)
+from ._normalize_uk import (
+    RangeStyle as RangeStyle,
+)
+from ._normalize_uk import (
+    Substring as Substring,
+)
+from ._normalize_uk import (
+    SymbolStyle as SymbolStyle,
+)
+from ._normalize_uk import (
+    UncertainSpan as UncertainSpan,
+)
+from ._normalize_uk import (
+    UncertaintyCategory as UncertaintyCategory,
+)
+from ._normalize_uk import (
+    UncertaintySeverity as UncertaintySeverity,
+)
+from ._normalize_uk import (
+    expand_abbreviations as expand_abbreviations,
+)
+from ._normalize_uk import (
+    normalize_abbreviations as normalize_abbreviations,
+)
+from ._normalize_uk import (
+    options_for_preset as options_for_preset,
+)
+from ._normalize_uk import (
+    split_sentences as split_sentences,
+)
+from ._normalize_uk import (
+    tokenize as tokenize,
+)
+from ._normalize_uk import (
+    transliterate_to_cyrillic as transliterate_to_cyrillic,
+)
+
+def number_to_words(n: int) -> str: ...
+def number_to_words_digit_by_digit(digits: str) -> str: ...
+def number_to_ordinal_words(
+    n: int,
+    form: Literal[
+        "nom_m",
+        "nom_n",
+        "nom_f",
+        "nom_pl",
+        "gen",
+        "dat",
+        "prep",
+        "loc",
+        "pl",
+        "loc_pl",
+        "acc_f",
+        "gen_f",
+        "ins",
+        "ins_f",
+        "ins_pl",
+        "loc_f",
+    ] = "nom_m",
+) -> str: ...
+def number_to_words_case(
+    n: int, grammatical_case: Literal["gen", "dat", "instr", "prep"]
+) -> str: ...
+def cyrilize(text: str) -> str: ...
+def cyrrilize(text: str) -> str: ...
+@overload
+def normalize_ukrainian(
+    text: str, options: NormalizeOptions | None = None, *, preset: None = None
+) -> str: ...
+@overload
+def normalize_ukrainian(
+    text: str, options: NormalizePreset, *, preset: None = None
+) -> str: ...
+@overload
+def normalize_ukrainian(
+    text: str, options: None = None, *, preset: NormalizePreset
+) -> str: ...
+def normalize_ukrainian_with_preset(
+    text: str, preset: NormalizePreset = NormalizePreset.Default
+) -> str: ...
+@overload
+def normalize_ukrainian_many(
+    texts: Iterable[str],
+    options: NormalizeOptions | None = None,
+    *,
+    preset: None = None,
+) -> list[str]: ...
+@overload
+def normalize_ukrainian_many(
+    texts: Iterable[str], options: NormalizePreset, *, preset: None = None
+) -> list[str]: ...
+@overload
+def normalize_ukrainian_many(
+    texts: Iterable[str], options: None = None, *, preset: NormalizePreset
+) -> list[str]: ...
+@overload
+def flag_uncertain(
+    text: str, options: NormalizeOptions | None = None, *, preset: None = None
+) -> list[UncertainSpan]: ...
+@overload
+def flag_uncertain(
+    text: str, options: NormalizePreset, *, preset: None = None
+) -> list[UncertainSpan]: ...
+@overload
+def flag_uncertain(
+    text: str, options: None = None, *, preset: NormalizePreset
+) -> list[UncertainSpan]: ...
+def sentenize(text: str) -> list[Substring]: ...

normalize_uk/_normalize_uk.pyi

@@ -0,0 +1,181 @@
+from collections.abc import Iterable
+from enum import Enum
+from typing import overload
+
+class UncertaintyCategory(Enum):
+    AmbiguousAbbreviation: UncertaintyCategory
+    BareNumber: UncertaintyCategory
+    Currency: UncertaintyCategory
+    Date: UncertaintyCategory
+    Identifier: UncertaintyCategory
+    ForeignWord: UncertaintyCategory
+    MixedScript: UncertaintyCategory
+    RomanNumeral: UncertaintyCategory
+    Unit: UncertaintyCategory
+    Web: UncertaintyCategory
+    InvalidDate: UncertaintyCategory
+    AmbiguousNumberGrouping: UncertaintyCategory
+    Agreement: UncertaintyCategory
+    Time: UncertaintyCategory
+    Fraction: UncertaintyCategory
+    Network: UncertaintyCategory
+    Scientific: UncertaintyCategory
+    Coordinate: UncertaintyCategory
+
+class UncertaintySeverity(Enum):
+    Info: UncertaintySeverity
+    Warning: UncertaintySeverity
+    Error: UncertaintySeverity
+
+class RangeStyle(Enum):
+    Compact: RangeStyle
+    FromTo: RangeStyle
+
+class PhoneStyle(Enum):
+    Grouped: PhoneStyle
+    DigitByDigit: PhoneStyle
+
+class SymbolStyle(Enum):
+    Expand: SymbolStyle
+    Preserve: SymbolStyle
+
+class DateStyle(Enum):
+    Formal: DateStyle
+    Spoken: DateStyle
+
+class ColonStyle(Enum):
+    Contextual: ColonStyle
+    Clock: ColonStyle
+    Ratio: ColonStyle
+
+class NumericDateOrder(Enum):
+    DayMonthYear: NumericDateOrder
+    MonthDayYear: NumericDateOrder
+    PreserveAmbiguous: NumericDateOrder
+
+class CurrencySymbolPolicy(Enum):
+    AssumeCommon: CurrencySymbolPolicy
+    PreserveAmbiguous: CurrencySymbolPolicy
+
+class QuoteStyle(Enum):
+    Keep: QuoteStyle
+    Guillemets: QuoteStyle
+    Straight: QuoteStyle
+    Strip: QuoteStyle
+
+class NormalizePreset(Enum):
+    Default: NormalizePreset
+    TtsFriendly: NormalizePreset
+    Conservative: NormalizePreset
+    SearchIndexing: NormalizePreset
+
+class UncertainSpan:
+    @property
+    def start(self) -> int: ...
+    @property
+    def stop(self) -> int: ...
+    @property
+    def text(self) -> str: ...
+    @property
+    def reason(self) -> str: ...
+    @property
+    def category(self) -> UncertaintyCategory: ...
+    @property
+    def severity(self) -> UncertaintySeverity: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __copy__(self) -> UncertainSpan: ...
+    def __deepcopy__(self, memo: dict[object, object]) -> UncertainSpan: ...
+
+class NormalizeOptions:
+    expand_known_acronyms: bool
+    spell_unknown_acronyms: bool
+    normalize_english_words: bool
+    transliterate_latin: bool
+    range_style: RangeStyle
+    phone_style: PhoneStyle
+    symbol_style: SymbolStyle
+    date_style: DateStyle
+    colon_style: ColonStyle
+    numeric_date_order: NumericDateOrder
+    currency_symbol_policy: CurrencySymbolPolicy
+    repair_homoglyphs: bool
+    validate_dates: bool
+    parse_thousand_separators: bool
+    normalize_network_addresses: bool
+    quote_style: QuoteStyle
+
+    def __init__(
+        self,
+        preset: NormalizePreset = NormalizePreset.Default,
+        *,
+        expand_known_acronyms: bool = ...,
+        spell_unknown_acronyms: bool = ...,
+        normalize_english_words: bool = ...,
+        transliterate_latin: bool = ...,
+        repair_homoglyphs: bool = ...,
+        validate_dates: bool = ...,
+        parse_thousand_separators: bool = ...,
+        normalize_network_addresses: bool = ...,
+        range_style: RangeStyle = ...,
+        phone_style: PhoneStyle = ...,
+        symbol_style: SymbolStyle = ...,
+        date_style: DateStyle = ...,
+        colon_style: ColonStyle = ...,
+        numeric_date_order: NumericDateOrder = ...,
+        currency_symbol_policy: CurrencySymbolPolicy = ...,
+        quote_style: QuoteStyle = ...,
+    ) -> None: ...
+    def __copy__(self) -> NormalizeOptions: ...
+    def __deepcopy__(self, memo: dict[object, object]) -> NormalizeOptions: ...
+
+class Substring:
+    @property
+    def start(self) -> int: ...
+    @property
+    def stop(self) -> int: ...
+    @property
+    def text(self) -> str: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __copy__(self) -> Substring: ...
+    def __deepcopy__(self, memo: dict[object, object]) -> Substring: ...
+
+def options_for_preset(preset: NormalizePreset) -> NormalizeOptions: ...
+def number_to_words(n: int) -> str: ...
+def number_to_words_digit_by_digit(digits: str) -> str: ...
+def number_to_ordinal_words(n: int, form: str = "nom_m") -> str: ...
+def number_to_words_case(n: int, grammatical_case: str) -> str: ...
+def normalize_abbreviations(text: str) -> str: ...
+def expand_abbreviations(text: str) -> str: ...
+def transliterate_to_cyrillic(text: str) -> str: ...
+def cyrilize(text: str) -> str: ...
+def cyrrilize(text: str) -> str: ...
+@overload
+def normalize_ukrainian(text: str) -> str: ...
+@overload
+def normalize_ukrainian(text: str, options: NormalizeOptions) -> str: ...
+@overload
+def normalize_ukrainian(text: str, preset: NormalizePreset) -> str: ...
+@overload
+def normalize_ukrainian_many(texts: Iterable[str]) -> list[str]: ...
+@overload
+def normalize_ukrainian_many(
+    texts: Iterable[str], options: NormalizeOptions
+) -> list[str]: ...
+@overload
+def normalize_ukrainian_many(
+    texts: Iterable[str], preset: NormalizePreset
+) -> list[str]: ...
+def normalize_ukrainian_with_preset(
+    text: str, preset: NormalizePreset = NormalizePreset.Default
+) -> str: ...
+@overload
+def flag_uncertain(text: str) -> list[UncertainSpan]: ...
+@overload
+def flag_uncertain(text: str, options: NormalizeOptions) -> list[UncertainSpan]: ...
+@overload
+def flag_uncertain(text: str, preset: NormalizePreset) -> list[UncertainSpan]: ...
+def split_sentences(text: str) -> list[Substring]: ...
+def sentenize(text: str) -> list[Substring]: ...
+def tokenize(text: str) -> list[Substring]: ...

normalize_uk/py.typed

@@ -0,0 +1 @@
+

normalize_uk-0.4.2.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.1
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-3cq3h79w\\cp315-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-3cq3h79w\\cp315-win_amd64\\repaired_wheel', '-v', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-3cq3h79w\\cp315-win_amd64\\built_wheel\\normalize_uk-0.4.2-cp315-cp315-win_amd64.whl']

normalize_uk-0.4.2.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: normalize-uk
+Version: 0.4.2
+Summary: Python bindings for Ukrainian text normalization and tokenization utilities
+License-Expression: MIT
+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
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: C++
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# normalize-uk-cpp
+
+[![CI](https://github.com/ThirdLetterC/normalize_uk-cpp/actions/workflows/ci.yml/badge.svg)](https://github.com/ThirdLetterC/normalize_uk-cpp/actions/workflows/ci.yml)
+[![Release](https://github.com/ThirdLetterC/normalize_uk-cpp/actions/workflows/release.yml/badge.svg)](https://github.com/ThirdLetterC/normalize_uk-cpp/actions/workflows/release.yml)
+
+C++23 Ukrainian text normalization and tokenization utilities with optional Python 3.10+ bindings.
+
+## CMake
+
+```sh
+cmake -S . -B build
+cmake --build build
+ctest --test-dir build
+```
+
+Enable Python bindings explicitly when building with CMake:
+
+```sh
+cmake -S . -B build-python -DNORMALIZE_UK_CPP_BUILD_PYTHON=ON
+cmake --build build-python
+```
+
+A regular CMake install includes the C++ library, headers, and CMake package.
+Python wheels contain only the Python package and compiled extension.
+
+## Python
+
+```sh
+python -m pip install .
+```
+
+```python
+import normalize_uk as nuk
+
+print(nuk.number_to_words(123))
+print(nuk.normalize_ukrainian("01.05.2024"))
+print(nuk.normalize_ukrainian("01.05.2024", preset=nuk.NormalizePreset.TtsFriendly))
+print(nuk.normalize_ukrainian_many(["01.05.2024", "5 кг"]))
+print([sentence.text for sentence in nuk.split_sentences("П'ять зв'язків. Два.")])
+print([token.text for token in nuk.tokenize("П'ять зв'язків.")])
+```
+
+More examples live in `examples/python/`.
+
+Tags matching the version in `pyproject.toml` (for example, `v0.4.2`) trigger
+wheel builds for supported Python versions. The workflow uploads the wheels to
+GitHub Release Assets, then downloads those Assets and publishes them to PyPI.
+To enable PyPI Trusted Publishing, register `ThirdLetterC/normalize_uk-cpp` as
+a publisher for `normalize-uk` with workflow `release.yml` and environment
+`pypi`. For a new PyPI project, register a
+[pending publisher](https://docs.pypi.org/trusted-publishers/creating-a-project-through-oidc/)
+first. No PyPI API token is needed.
+
+`NormalizeOptions` accepts a preset and named overrides at construction time:
+
+```python
+options = nuk.NormalizeOptions(
+    preset=nuk.NormalizePreset.TtsFriendly,
+    range_style=nuk.RangeStyle.Compact,
+    numeric_date_order=nuk.NumericDateOrder.DayMonthYear,
+)
+result = nuk.normalize_ukrainian("5–7 кг", options=options)
+spans = nuk.flag_uncertain("10:30, $12", options=options)
+```
+
+Pass either `options=` or `preset=` to `normalize_ukrainian` and `flag_uncertain`.
+`normalize_ukrainian_many()` accepts any iterable of Python strings and applies one
+options snapshot to the entire batch. It returns a list in input order and raises
+`TypeError` if an item is not a string. It accepts the same `options=` and `preset=`
+selection as `normalize_ukrainian`. Identical strings within one batch are
+normalized once and their result is reused.
+The older positional options/preset calls and `normalize_ukrainian_with_preset()` remain available.
+Without options, `flag_uncertain()` reports all ambiguity candidates. With explicit options
+or a preset, it omits warnings for ambiguous dates, colon pairs, and currency symbols
+when the selected policy resolves them; invalid-value diagnostics remain.
+
+`Substring.start`/`stop` and `UncertainSpan.start`/`stop` are Python `str` indexes,
+with `stop` exclusive: `span.text == source[span.start:span.stop]`. They count Unicode
+code points, matching Python slicing, rather than UTF-8 bytes.
+
+`number_to_words()`, `number_to_ordinal_words()`, and `number_to_words_case()` accept
+integers from 0 through `999999999999999999`. Values outside that range raise
+`ValueError`; non-integers raise `TypeError`. `number_to_words_digit_by_digit()` accepts
+a nonempty string of ASCII digits only and preserves leading zeroes. Its invalid input
+raises `ValueError`. Ordinal forms are `nom_m`, `nom_n`, `nom_f`, `nom_pl`, `gen`, `dat`,
+`prep`, `loc`, `pl`, `loc_pl`, `acc_f`, `gen_f`, `ins`, `ins_f`, `ins_pl`, and `loc_f`.
+Cardinal cases are `gen`, `dat`, `instr`, and `prep`. Unknown forms raise `ValueError`.
+
+The legacy spellings `sentenize()`, `cyrilize()`, and `cyrrilize()` remain available
+but issue `DeprecationWarning`; use `split_sentences()` and
+`transliterate_to_cyrillic()` in new code.
+
+`NormalizeOptions`, `Substring`, and `UncertainSpan` support `copy.copy()`,
+`copy.deepcopy()`, and `pickle` serialization. Copies are independent value objects.
+
+## Currency and cryptocurrency coverage
+
+Normalization covers all 178 active ISO 4217 List One codes, including their
+0-, 2-, 3-, or 4-digit minor-unit rules. More than 70 common cryptocurrency and
+finance tickers have natural Ukrainian readings. Other 2–10 character uppercase
+alphanumeric tickers are spelled out after amounts and when paired with a known
+asset, so newly introduced assets do not require an immediate library release.
+Prefix and suffix
+amounts, localized thousands separators, signs, decimals, and the `₿` symbol
+are supported.
+
+## Ambiguity controls
+
+`NormalizeOptions` keeps backward-compatible defaults while allowing callers to resolve ambiguous input explicitly:
+
+- `colon_style`: contextual clock/ratio detection, forced clock, or forced ratio.
+- `numeric_date_order`: day-month-year, month-day-year, or preservation of dates where both fields are at most 12.
+- `currency_symbol_policy`: assume the common currency for `$` and `¥`, or preserve those ambiguous symbols.
+
+The CLI exposes the same controls through `--colon-style`, `--date-order`, and
+`--preserve-ambiguous-currency`.
+
+## Benchmarks and fuzzing
+
+Build and run the benchmark explicitly:
+
+```sh
+cmake --build build --target uktextnorm_benchmark
+./build/uktextnorm_benchmark .
+```
+
+For Python binding timings, install the package and run
+`python benchmarks/python_binding_benchmark.py`. It compares scalar and batched
+normalization, including unique inputs, and span-returning calls.
+
+With Clang and libFuzzer support, build the normalization harness with sanitizers:
+
+```sh
+cmake -S . -B build-fuzz -DCMAKE_CXX_COMPILER=clang++ -DNORMALIZE_UK_CPP_BUILD_FUZZER=ON
+cmake --build build-fuzz --target uktextnorm_fuzzer
+./build-fuzz/uktextnorm_fuzzer -max_total_time=60 tests/data
+```
+
+## Development
+
+Install `uv` and `just` for development. Run `just` to see all recipes. `just format` applies Ruff fixes and Python formatting; `just lint` runs the Python static checks; `just check` also runs Python and C++ tests.
+
+```sh
+just setup
+just format
+just lint
+just check
+just wheel 3.15
+```
+
+The project includes a `.clang-format` file and a CMake formatting target. Install `clang-format`, then run:
+
+```sh
+cmake --build build --target format
+```

normalize_uk-0.4.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+normalize_uk/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+normalize_uk/_normalize_uk.cp315-win_amd64.pyd,sha256=qv34QHoSAaISipbxyrrlUIilM_ZaRF5CyzxEBlE8tPo,3089408
+normalize_uk/_normalize_uk.pyi,sha256=5h1sHW7-FJeskuuant4AoMfJSNAJxvgaGvunyw6pXzY,5961
+normalize_uk/__init__.py,sha256=-zN5qc6V28A7mZCKcsqWWHfV48a4fS0J344J9x8oCbQ,8367
+normalize_uk/__init__.pyi,sha256=UrTlJAckVhsfHykAJbCoi_BKarv2FC0o9Bu0m6qUmQA,3598
+normalize_uk-0.4.2.dist-info/DELVEWHEEL,sha256=IK6a-eKDrniSWv60rLdIEX6_LO6e6-4E6Mt-RA57Xi4,411
+normalize_uk-0.4.2.dist-info/METADATA,sha256=TCRiWCKAJmJuCcg_81Trh5U7lrpJV8eKmk388Ivd47o,7208
+normalize_uk-0.4.2.dist-info/RECORD,,
+normalize_uk-0.4.2.dist-info/WHEEL,sha256=zRSxk0lFSz9yrcoNCqCgDrmWhvhsSyignczP3ORAtmA,105
+normalize_uk-0.4.2.dist-info/licenses/LICENSE,sha256=H74gUlraCIIvf60AlpOT_K4KB_BN_sH9_zhIwYkT4VU,1093
+normalize_uk.libs/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056

normalize_uk-0.4.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.0.3
+Root-Is-Purelib: false
+Tag: cp315-cp315-win_amd64
+

normalize_uk-0.4.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yehor Smoliakov
+
+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.