jayron 0.1.0__tar.gz

jayron-0.1.0/LICENSE

@@ -0,0 +1,71 @@
+jayron License (Non-Commercial, No Derivatives)
+
+Copyright (c) 2026 Rakhimberdi Rakhmonberdiev. All rights reserved.
+
+The jayron software, including its source code, word lists, rules, regular
+expressions and documentation (the "Software"), is source-available but is
+NOT open source. You may read the source code, but you may use it only as
+described below.
+
+1. FREE NON-COMMERCIAL USE
+
+   You may download, install and run the unmodified Software, and use the
+   text it produces (the "Output"), free of charge, for non-commercial
+   purposes only. Non-commercial purposes are:
+     (a) personal projects that earn no money;
+     (b) study and teaching;
+     (c) research at universities, schools or non-profit research
+         organizations, including research published in papers.
+
+   If you publish work that uses the Software, please credit
+   "jayron by Rakhimberdi Rakhmonberdiev".
+
+2. COMMERCIAL USE REQUIRES A PAID LICENSE
+
+   Any commercial use requires a separate written license from the
+   copyright holder. Commercial use includes, for example:
+     (a) any use by or for a company or other for-profit organization;
+     (b) use in, or to build, a product or service that is sold, licensed,
+         offered for a fee or funded by advertising;
+     (c) use to prepare, normalize, train, evaluate or improve data or
+         models (for example speech recognition models) that are used
+         commercially;
+     (d) use in paid consulting, freelance or contract work.
+
+   To get a commercial license, contact Rakhimberdi Rakhmonberdiev at
+   r.raxmonberdiyev10@gmail.com.
+
+3. WHAT YOU MAY NOT DO
+
+   Unless the copyright holder has given you written permission, you may not:
+     (a) modify, translate, adapt or create derivative works of the
+         Software;
+     (b) copy the Software or any part of its source code (including its
+         rules, word lists and regular expressions) into other software,
+         documents or datasets, or re-create it from the source code;
+     (c) sell, rent, sublicense or distribute the Software, except that it
+         may be distributed unmodified, exactly as published by the
+         copyright holder, through the Python Package Index (PyPI) and its
+         mirrors;
+     (d) remove or change this license or any copyright notice.
+
+   Copies made automatically when you install or run the Software as
+   allowed in section 1 or under a commercial license are permitted.
+
+4. TERMINATION
+
+   If you break any of these terms, your permission to use the Software
+   ends automatically, and you must stop using it and delete all copies.
+
+5. NO WARRANTY
+
+   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 COPYRIGHT HOLDER 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.
+
+All rights not expressly granted in this license are reserved by the
+copyright holder.

jayron-0.1.0/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: jayron
+Version: 0.1.0
+Summary: Uzbek text normalizer for speech recognition (ASR): numbers, dates, Cyrillic, apostrophes, new 2026 alphabet.
+Author: Rakhimberdi Rakhmonberdiev
+License-Expression: LicenseRef-jayron-NonCommercial
+Keywords: uzbek,asr,speech-recognition,text-normalization,wer,transliteration,nlp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# jayron
+
+Tools for Uzbek speech recognition. The first module is a text normalizer that
+turns written Uzbek into the form a speaker says it, for ASR training targets
+and for scoring (WER/CER). No dependencies, Python 3.9+.
+
+> Free for non-commercial use. Commercial use requires a license, see [License](#license).
+
+```bash
+pip install jayron
+```
+
+```python
+from jayron.normalizers import uz_normilizer
+
+uz_normilizer("2024-yil 15-mart kuni soat 14:30 da 1,5 mln so'm to'landi.")
+# 'ikki ming yigirma toʻrtinchi yil oʻn beshinchi mart kuni soat oʻn toʻrt oʻttizda
+#  bir butun oʻndan besh million soʻm toʻlandi'
+
+uz_normilizer(["Ўзбекистон", "5 ta kitob"])   # lists work too
+# ['oʻzbekiston', 'beshta kitob']
+```
+
+`uz_normalizer` is the same object under the standard spelling.
+
+## What it does
+
+| Input | Output |
+|---|---|
+| `O‘zbekiston`, `O'zbekiston`, `O`zbekiston` | `oʻzbekiston` (one apostrophe character) |
+| `Ўзбекистон Республикаси` | `oʻzbekiston respublikasi` |
+| `Toshkеnt` (Cyrillic `е` inside) | `toshkent` |
+| `137`, `1 000 000`, `1,000,000` | `bir yuz oʻttiz yetti`, `bir million` |
+| `2024-yil`, `5-sinf`, `2024 yil`, `1991 y.` | `ikki ming yigirma toʻrtinchi yil`, `beshinchi sinf`, ... |
+| `5ta`, `5 ta`, `40ga`, `10dan` | `beshta`, `beshta`, `qirqqa`, `oʻndan` |
+| `3-xonali`, `30-yillik` | `uch xonali`, `oʻttiz yillik` (cardinal, not ordinal) |
+| `3,5`, `2.75` | `uch butun oʻndan besh`, `ikki butun yuzdan yetmish besh` |
+| `1/2`, `½`, `2½` | `ikkidan bir`, `ikkidan bir`, `ikki butun ikkidan bir` |
+| `25%`, `12,5%ga` | `yigirma besh foiz`, `oʻn ikki butun oʻndan besh foizga` |
+| `$100`, `50 €`, `100 USD`, `$1,5 mln` | `bir yuz dollar`, `ellik yevro`, ..., `bir butun oʻndan besh million dollar` |
+| `5 kg`, `50 m²`, `-5°C` | `besh kilogramm`, `ellik kvadrat metr`, `minus besh gradus` |
+| `14:30`, `soat 9:05da` | `oʻn toʻrt oʻttiz`, `soat toʻqqiz nol beshda` |
+| `12.05.2024`, `2024-05-12`, `15 mart` | `oʻn ikkinchi may ikki ming yigirma toʻrtinchi yil`, ..., `oʻn beshinchi mart` |
+| `5-10 kishi`, `1990-2000-yillar` | `besh oʻn kishi`, `... toʻqsoninchi ikki minginchi yillar` |
+| `XXI asr`, `IV bob` | `yigirma birinchi asr`, `toʻrtinchi bob` |
+| `+998 90 123 45 67` | read group by group |
+| `va h.k.`, `Toshkent sh.`, `№5`, `&` | `va hokazo`, `toshkent shahri`, `raqam besh`, `va` |
+| `[noise]`, `<unk>`, `[1]` | removed |
+| `Café`, `«Salom!»` | `cafe`, `salom` |
+
+With the defaults, output contains only `a-z`, `ʻ` and single spaces.
+
+## New alphabet (2026 reform)
+
+The reform law (signed 21 Oct 2026, in force from 22 Apr 2027) replaces
+`Oʻ Gʻ Sh Ch` with `Ö Ğ Ş Ç` and drops `Ng` as a separate letter (it stays
+written as n + g). The apostrophe is kept.
+
+```python
+from jayron.normalizers import converter
+
+converter("Bog'chaga bordingmi?")          # 'Boğçaga bordingmi?'
+converter("Ўзбекистон шаҳри")              # 'Özbekiston şahri'   (Cyrillic works too)
+converter.to_old("Boğçaga bordingmi?")     # 'Bogʻchaga bordingmi?'
+```
+
+Only those four letters change; case, punctuation, digits, `ng`, the tutuq
+(`maʼno`) and `s'h` (`Is'hoq`) are left as they are, and so are links and
+e-mail addresses.
+
+To get normalized ASR text in the new alphabet, use `UzbekNormalizer(alphabet="new")`:
+
+```python
+UzbekNormalizer(alphabet="new")("Bog'chaga 5 ta o'quvchi bordi.")
+# 'boğçaga beşta öquvçi bordi'
+```
+
+The normalizer reads either alphabet as input, so a corpus that mixes old
+and new spellings comes out consistent.
+
+## Options
+
+```python
+from jayron.normalizers import UzbekNormalizer
+
+norm = UzbekNormalizer(
+    alphabet="old",              # "new" -> ö ğ ş ç
+    apostrophe="'",              # default ʻ (U+02BB); "'" if your tokenizer prefers ASCII
+    lowercase=True,
+    remove_punctuation=True,     # False keeps punctuation (for punctuation-aware models)
+    transliterate=True,          # Cyrillic -> Latin
+    expand_numbers=True,
+    expand_abbreviations=True,   # mln, h.k., sh., %, №, &
+    strip_accents=True,          # é -> e
+    drop_annotations=True,       # [noise], <unk>
+    custom_rules=[(r"\bAI\b", "sun'iy intellekt")],  # your own regex rules, applied first
+)
+```
+
+Use the same settings for training transcripts and for scoring (both references
+and model output), or WER will count formatting differences as errors.
+
+Lower-level helpers live in `jayron.normalizers.uz`: `number_to_words`,
+`number_to_ordinal`, `cyrillic_to_latin`, `expand_numbers`.
+
+## Command line
+
+```bash
+jayron-uz-norm "2024-yil 5 ta kitob"
+jayron-uz-norm -i corpus.txt -o corpus.norm.txt
+jayron-uz-norm -i train.jsonl -o train.norm.jsonl --jsonl --field text   # NeMo manifest
+jayron-uz-norm --help
+```
+
+## Conventions and known ambiguities
+
+- Hundreds and thousands keep `bir` (`100` → `bir yuz`, `1000` → `bir ming`),
+  except when multiplying a larger scale (`100 000` → `yuz ming`) or in ordinals
+  (`100-yil` → `yuzinchi yil`).
+- `ʻ` is used for oʻ, gʻ and the tutuq belgisi alike, so the model has one
+  apostrophe token.
+- Space-grouped thousands are joined: `5 100` → `besh ming bir yuz`. In plain
+  text this is right almost always, but a list such as "5 100" would be merged.
+- A single dot group is a decimal: `1.500` → `bir butun mingdan besh yuz`;
+  a single comma group of three digits is thousands: `1,500` → `bir ming besh yuz`.
+- Times are read digit-pair by digit-pair: `14:00` → `oʻn toʻrt nol nol`.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest
+```
+
+## License
+
+Copyright (c) 2026 Rakhimberdi Rakhmonberdiev. All rights reserved.
+
+jayron is **free for non-commercial use**: personal projects, study, teaching
+and non-profit research. **Commercial use** (companies, paid products or
+services, commercial ASR models or datasets, paid contract work) **needs a
+paid license**. Contact r.raxmonberdiyev10@gmail.com.
+
+The source code may not be modified, copied into other projects, or
+redistributed. See [LICENSE](LICENSE) for the full terms.

jayron-0.1.0/README.md

@@ -0,0 +1,145 @@
+# jayron
+
+Tools for Uzbek speech recognition. The first module is a text normalizer that
+turns written Uzbek into the form a speaker says it, for ASR training targets
+and for scoring (WER/CER). No dependencies, Python 3.9+.
+
+> Free for non-commercial use. Commercial use requires a license, see [License](#license).
+
+```bash
+pip install jayron
+```
+
+```python
+from jayron.normalizers import uz_normilizer
+
+uz_normilizer("2024-yil 15-mart kuni soat 14:30 da 1,5 mln so'm to'landi.")
+# 'ikki ming yigirma toʻrtinchi yil oʻn beshinchi mart kuni soat oʻn toʻrt oʻttizda
+#  bir butun oʻndan besh million soʻm toʻlandi'
+
+uz_normilizer(["Ўзбекистон", "5 ta kitob"])   # lists work too
+# ['oʻzbekiston', 'beshta kitob']
+```
+
+`uz_normalizer` is the same object under the standard spelling.
+
+## What it does
+
+| Input | Output |
+|---|---|
+| `O‘zbekiston`, `O'zbekiston`, `O`zbekiston` | `oʻzbekiston` (one apostrophe character) |
+| `Ўзбекистон Республикаси` | `oʻzbekiston respublikasi` |
+| `Toshkеnt` (Cyrillic `е` inside) | `toshkent` |
+| `137`, `1 000 000`, `1,000,000` | `bir yuz oʻttiz yetti`, `bir million` |
+| `2024-yil`, `5-sinf`, `2024 yil`, `1991 y.` | `ikki ming yigirma toʻrtinchi yil`, `beshinchi sinf`, ... |
+| `5ta`, `5 ta`, `40ga`, `10dan` | `beshta`, `beshta`, `qirqqa`, `oʻndan` |
+| `3-xonali`, `30-yillik` | `uch xonali`, `oʻttiz yillik` (cardinal, not ordinal) |
+| `3,5`, `2.75` | `uch butun oʻndan besh`, `ikki butun yuzdan yetmish besh` |
+| `1/2`, `½`, `2½` | `ikkidan bir`, `ikkidan bir`, `ikki butun ikkidan bir` |
+| `25%`, `12,5%ga` | `yigirma besh foiz`, `oʻn ikki butun oʻndan besh foizga` |
+| `$100`, `50 €`, `100 USD`, `$1,5 mln` | `bir yuz dollar`, `ellik yevro`, ..., `bir butun oʻndan besh million dollar` |
+| `5 kg`, `50 m²`, `-5°C` | `besh kilogramm`, `ellik kvadrat metr`, `minus besh gradus` |
+| `14:30`, `soat 9:05da` | `oʻn toʻrt oʻttiz`, `soat toʻqqiz nol beshda` |
+| `12.05.2024`, `2024-05-12`, `15 mart` | `oʻn ikkinchi may ikki ming yigirma toʻrtinchi yil`, ..., `oʻn beshinchi mart` |
+| `5-10 kishi`, `1990-2000-yillar` | `besh oʻn kishi`, `... toʻqsoninchi ikki minginchi yillar` |
+| `XXI asr`, `IV bob` | `yigirma birinchi asr`, `toʻrtinchi bob` |
+| `+998 90 123 45 67` | read group by group |
+| `va h.k.`, `Toshkent sh.`, `№5`, `&` | `va hokazo`, `toshkent shahri`, `raqam besh`, `va` |
+| `[noise]`, `<unk>`, `[1]` | removed |
+| `Café`, `«Salom!»` | `cafe`, `salom` |
+
+With the defaults, output contains only `a-z`, `ʻ` and single spaces.
+
+## New alphabet (2026 reform)
+
+The reform law (signed 21 Oct 2026, in force from 22 Apr 2027) replaces
+`Oʻ Gʻ Sh Ch` with `Ö Ğ Ş Ç` and drops `Ng` as a separate letter (it stays
+written as n + g). The apostrophe is kept.
+
+```python
+from jayron.normalizers import converter
+
+converter("Bog'chaga bordingmi?")          # 'Boğçaga bordingmi?'
+converter("Ўзбекистон шаҳри")              # 'Özbekiston şahri'   (Cyrillic works too)
+converter.to_old("Boğçaga bordingmi?")     # 'Bogʻchaga bordingmi?'
+```
+
+Only those four letters change; case, punctuation, digits, `ng`, the tutuq
+(`maʼno`) and `s'h` (`Is'hoq`) are left as they are, and so are links and
+e-mail addresses.
+
+To get normalized ASR text in the new alphabet, use `UzbekNormalizer(alphabet="new")`:
+
+```python
+UzbekNormalizer(alphabet="new")("Bog'chaga 5 ta o'quvchi bordi.")
+# 'boğçaga beşta öquvçi bordi'
+```
+
+The normalizer reads either alphabet as input, so a corpus that mixes old
+and new spellings comes out consistent.
+
+## Options
+
+```python
+from jayron.normalizers import UzbekNormalizer
+
+norm = UzbekNormalizer(
+    alphabet="old",              # "new" -> ö ğ ş ç
+    apostrophe="'",              # default ʻ (U+02BB); "'" if your tokenizer prefers ASCII
+    lowercase=True,
+    remove_punctuation=True,     # False keeps punctuation (for punctuation-aware models)
+    transliterate=True,          # Cyrillic -> Latin
+    expand_numbers=True,
+    expand_abbreviations=True,   # mln, h.k., sh., %, №, &
+    strip_accents=True,          # é -> e
+    drop_annotations=True,       # [noise], <unk>
+    custom_rules=[(r"\bAI\b", "sun'iy intellekt")],  # your own regex rules, applied first
+)
+```
+
+Use the same settings for training transcripts and for scoring (both references
+and model output), or WER will count formatting differences as errors.
+
+Lower-level helpers live in `jayron.normalizers.uz`: `number_to_words`,
+`number_to_ordinal`, `cyrillic_to_latin`, `expand_numbers`.
+
+## Command line
+
+```bash
+jayron-uz-norm "2024-yil 5 ta kitob"
+jayron-uz-norm -i corpus.txt -o corpus.norm.txt
+jayron-uz-norm -i train.jsonl -o train.norm.jsonl --jsonl --field text   # NeMo manifest
+jayron-uz-norm --help
+```
+
+## Conventions and known ambiguities
+
+- Hundreds and thousands keep `bir` (`100` → `bir yuz`, `1000` → `bir ming`),
+  except when multiplying a larger scale (`100 000` → `yuz ming`) or in ordinals
+  (`100-yil` → `yuzinchi yil`).
+- `ʻ` is used for oʻ, gʻ and the tutuq belgisi alike, so the model has one
+  apostrophe token.
+- Space-grouped thousands are joined: `5 100` → `besh ming bir yuz`. In plain
+  text this is right almost always, but a list such as "5 100" would be merged.
+- A single dot group is a decimal: `1.500` → `bir butun mingdan besh yuz`;
+  a single comma group of three digits is thousands: `1,500` → `bir ming besh yuz`.
+- Times are read digit-pair by digit-pair: `14:00` → `oʻn toʻrt nol nol`.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest
+```
+
+## License
+
+Copyright (c) 2026 Rakhimberdi Rakhmonberdiev. All rights reserved.
+
+jayron is **free for non-commercial use**: personal projects, study, teaching
+and non-profit research. **Commercial use** (companies, paid products or
+services, commercial ASR models or datasets, paid contract work) **needs a
+paid license**. Contact r.raxmonberdiyev10@gmail.com.
+
+The source code may not be modified, copied into other projects, or
+redistributed. See [LICENSE](LICENSE) for the full terms.

jayron-0.1.0/jayron/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2026 Rakhimberdi Rakhmonberdiev. All rights reserved.
+# Free for non-commercial use only; modification and redistribution are not allowed.
+# Commercial use requires a license. See the LICENSE file or contact r.raxmonberdiyev10@gmail.com.
+
+"""jayron — tools for Uzbek speech recognition."""
+
+__version__ = "0.1.0"

jayron-0.1.0/jayron/normalizers/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2026 Rakhimberdi Rakhmonberdiev. All rights reserved.
+# Free for non-commercial use only; modification and redistribution are not allowed.
+# Commercial use requires a license. See the LICENSE file or contact r.raxmonberdiyev10@gmail.com.
+
+"""Text normalizers.
+
+    from jayron.normalizers import uz_normilizer, converter
+    uz_normilizer("2024-yil 5 ta kitob")   # 'ikki ming yigirma toʻrtinchi yil beshta kitob'
+    converter("Bog'chaga bordingmi?")      # 'Boğçaga bordingmi?'  (new 2026 alphabet)
+"""
+
+from .uz import AlphabetConverter, UzbekNormalizer, converter, uz_normalizer, uz_normilizer
+
+__all__ = ["AlphabetConverter", "UzbekNormalizer", "converter", "uz_normalizer", "uz_normilizer"]

jayron-0.1.0/jayron/normalizers/uz/__init__.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2026 Rakhimberdi Rakhmonberdiev. All rights reserved.
+# Free for non-commercial use only; modification and redistribution are not allowed.
+# Commercial use requires a license. See the LICENSE file or contact r.raxmonberdiyev10@gmail.com.
+
+"""Uzbek text normalization for ASR."""
+
+from .converter import AlphabetConverter, converter, to_new, to_old
+from .normalizer import OKINA, UzbekNormalizer, expand_numbers
+from .numbers import number_to_ordinal, number_to_words
+from .transliterate import cyrillic_to_latin
+
+uz_normalizer = UzbekNormalizer()
+uz_normilizer = uz_normalizer  # same object, under the spelling used in the project
+
+__all__ = [
+    "OKINA",
+    "AlphabetConverter",
+    "UzbekNormalizer",
+    "converter",
+    "cyrillic_to_latin",
+    "to_new",
+    "to_old",
+    "expand_numbers",
+    "number_to_ordinal",
+    "number_to_words",
+    "uz_normalizer",
+    "uz_normilizer",
+]

jayron-0.1.0/jayron/normalizers/uz/__main__.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2026 Rakhimberdi Rakhmonberdiev. All rights reserved.
+# Free for non-commercial use only; modification and redistribution are not allowed.
+# Commercial use requires a license. See the LICENSE file or contact r.raxmonberdiyev10@gmail.com.
+
+"""Command line: normalize text, text files, or JSONL manifests.
+
+    python -m jayron.normalizers.uz "2024-yil 5 ta kitob"
+    python -m jayron.normalizers.uz -i corpus.txt -o corpus.norm.txt
+    python -m jayron.normalizers.uz -i train.jsonl -o train.norm.jsonl --jsonl --field text
+    cat corpus.txt | python -m jayron.normalizers.uz
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import List, Optional
+
+from .normalizer import OKINA, UzbekNormalizer
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    p = argparse.ArgumentParser(prog="jayron-uz-norm", description="Uzbek text normalizer for ASR")
+    p.add_argument("text", nargs="*", help="text to normalize (otherwise reads --input or stdin)")
+    p.add_argument("-i", "--input", help="input file (one sentence per line, or JSONL with --jsonl)")
+    p.add_argument("-o", "--output", help="output file (default: stdout)")
+    p.add_argument("--jsonl", action="store_true", help="input is JSON lines (e.g. a NeMo manifest)")
+    p.add_argument("--field", default="text", help="JSONL field to normalize (default: text)")
+    p.add_argument("--out-field", help="write the result to this field instead of overwriting --field")
+    p.add_argument("--alphabet", choices=("old", "new"), default="old",
+                   help="old: oʻ gʻ sh ch (default); new: ö ğ ş ç (2026 reform)")
+    p.add_argument("--apostrophe", default=OKINA, help="character for oʻ/gʻ/tutuq (default: ʻ U+02BB)")
+    p.add_argument("--keep-case", action="store_true")
+    p.add_argument("--keep-punctuation", action="store_true")
+    p.add_argument("--no-transliterate", action="store_true", help="leave Cyrillic text as is")
+    p.add_argument("--no-numbers", action="store_true", help="leave digits as is")
+    args = p.parse_args(argv)
+
+    norm = UzbekNormalizer(
+        alphabet=args.alphabet,
+        apostrophe=args.apostrophe,
+        lowercase=not args.keep_case,
+        remove_punctuation=not args.keep_punctuation,
+        transliterate=not args.no_transliterate,
+        expand_numbers=not args.no_numbers,
+    )
+
+    if args.text:
+        print(norm(" ".join(args.text)))
+        return 0
+
+    src = open(args.input, encoding="utf-8") if args.input else sys.stdin
+    dst = open(args.output, "w", encoding="utf-8") if args.output else sys.stdout
+    try:
+        for line in src:
+            line = line.rstrip("\n")
+            if args.jsonl:
+                if not line.strip():
+                    continue
+                record = json.loads(line)
+                record[args.out_field or args.field] = norm(record.get(args.field) or "")
+                dst.write(json.dumps(record, ensure_ascii=False) + "\n")
+            else:
+                dst.write(norm(line) + "\n")
+    finally:
+        if src is not sys.stdin:
+            src.close()
+        if dst is not sys.stdout:
+            dst.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

jayron-0.1.0/jayron/normalizers/uz/converter.py

@@ -0,0 +1,139 @@
+# Copyright (c) 2026 Rakhimberdi Rakhmonberdiev. All rights reserved.
+# Free for non-commercial use only; modification and redistribution are not allowed.
+# Commercial use requires a license. See the LICENSE file or contact r.raxmonberdiyev10@gmail.com.
+
+"""Convert Uzbek text between the 1995 Latin alphabet and the 2026 reform.
+
+The reform (law signed 21 Oct 2026, in force from 22 Apr 2027) replaces four
+letters and drops Ng as a separate letter:
+
+    Oʻ -> Ö    Gʻ -> Ğ    Sh -> Ş    Ch -> Ç    (ng stays written as n + g)
+
+The apostrophe (tutuq belgisi, as in maʼno) is kept, and so is the s'h spelling
+of a separate s + h (Is'hoq stays Is'hoq).
+
+    >>> from jayron.normalizers import converter
+    >>> converter("Bog'chaga bordingmi?")
+    'Boğçaga bordingmi?'
+    >>> converter.to_old("Boğçaga bordingmi?")
+    'Bogʻchaga bordingmi?'
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+from .numbers import OKINA
+from .transliterate import cyrillic_to_latin
+
+__all__ = ["APOSTROPHES", "AlphabetConverter", "NEW_LETTERS", "converter", "to_new", "to_old"]
+
+# ' ` ´ ʹ ʻ ʼ ʽ ‘ ’ ‛ ′  — all the ways people type the oʻ / gʻ mark
+APOSTROPHES = "['`´ʹʻʼʽ‘’‛′]"
+NEW_LETTERS = "öğşçÖĞŞÇ"
+
+_OG = re.compile("([oOgG])" + APOSTROPHES)
+_DIGRAPH = re.compile("([sScC])[hH]")
+_TO_NEW = {"o": "ö", "O": "Ö", "g": "ğ", "G": "Ğ", "s": "ş", "S": "Ş", "c": "ç", "C": "Ç"}
+
+# New letters, plus look-alikes from drafts and other keyboards (ō from the 2021 draft, ḡ, ș, ǧ ...).
+_OLD_OG = {"ö": "o", "ō": "o", "ğ": "g", "ḡ": "g", "ǵ": "g", "ǧ": "g"}
+_OLD_OG.update({k.upper(): v.upper() for k, v in list(_OLD_OG.items())})
+_OLD_DIGRAPH = {"ş": "s", "ș": "s", "ç": "c"}
+_OLD_DIGRAPH.update({k.upper(): v.upper() for k, v in list(_OLD_DIGRAPH.items())})
+_NEW_LETTER = re.compile("[" + "".join(_OLD_OG) + "".join(_OLD_DIGRAPH) + "]")
+
+# Links and e-mail addresses are left untouched.
+_PROTECTED = re.compile(r"(?:https?://|www\.)\S+|[\w.+-]+@[\w-]+(?:\.[\w-]+)+")
+
+
+def _letters_to_old(text: str, apostrophe: str = OKINA) -> str:
+    """ö -> oʻ, ğ -> gʻ, ş -> sh, ç -> ch (also accepts ō, ḡ, ș, ...)."""
+    if text.isascii():
+        return text
+
+    def repl(m: "re.Match[str]") -> str:
+        ch = m.group()
+        if ch in _OLD_OG:
+            return _OLD_OG[ch] + apostrophe
+        base = _OLD_DIGRAPH[ch]
+        if base.islower():
+            return base + "h"
+        i, s = m.start(), m.string
+        prev = s[i - 1] if i else ""
+        nxt = s[i + 1] if i + 1 < len(s) else ""
+        all_caps = nxt.isupper() or (prev.isupper() and not nxt.isalpha())
+        return base + ("H" if all_caps else "h")
+
+    return _NEW_LETTER.sub(repl, text)
+
+
+def _letters_to_new(text: str) -> str:
+    text = _OG.sub(lambda m: _TO_NEW[m.group(1)], text)
+    return _DIGRAPH.sub(lambda m: _TO_NEW[m.group(1)], text)
+
+
+def _outside_links(text: str, fn) -> str:
+    parts, last = [], 0
+    for m in _PROTECTED.finditer(text):
+        parts.append(fn(text[last:m.start()]))
+        parts.append(m.group())
+        last = m.end()
+    parts.append(fn(text[last:]))
+    return "".join(parts)
+
+
+def to_new(text: str, *, transliterate: bool = True) -> str:
+    """Convert to the new alphabet: "Bog'chaga" -> "Boğçaga".
+
+    Accepts the old Latin alphabet (any apostrophe variant), Cyrillic (when
+    ``transliterate`` is on), or text already partly in the new alphabet.
+    Everything else (case, punctuation, digits, ng, tutuq) is kept as is.
+    """
+    if not text:
+        return text
+    text = unicodedata.normalize("NFC", text)
+    if transliterate:
+        text = cyrillic_to_latin(text)
+    return _outside_links(text, lambda part: _letters_to_new(_letters_to_old(part)))
+
+
+def to_old(text: str, *, apostrophe: str = OKINA, transliterate: bool = True) -> str:
+    """Convert to the 1995 alphabet: "Boğçaga" -> "Bogʻchaga" (``apostrophe`` marks oʻ/gʻ)."""
+    if not text:
+        return text
+    text = unicodedata.normalize("NFC", text)
+    if transliterate:
+        text = cyrillic_to_latin(text)
+    return _letters_to_old(text, apostrophe)
+
+
+class AlphabetConverter:
+    """Old (1995) <-> new (2026) Uzbek Latin alphabet. Calling it converts to the new one.
+
+    Args:
+        transliterate: also accept Uzbek Cyrillic input.
+        apostrophe: character for oʻ/gʻ when converting back to the old alphabet.
+    """
+
+    def __init__(self, *, transliterate: bool = True, apostrophe: str = OKINA) -> None:
+        self.transliterate = transliterate
+        self.apostrophe = apostrophe
+
+    def to_new(self, text: str) -> str:
+        return to_new(text, transliterate=self.transliterate)
+
+    def to_old(self, text: str) -> str:
+        return to_old(text, apostrophe=self.apostrophe, transliterate=self.transliterate)
+
+    def __call__(self, text):
+        if isinstance(text, str):
+            return self.to_new(text)
+        return [self.to_new(t) for t in text]
+
+    def __repr__(self) -> str:
+        return f"AlphabetConverter(transliterate={self.transliterate!r}, apostrophe={self.apostrophe!r})"
+
+
+converter = AlphabetConverter()