voxnorm 0.1.0__py3-none-any.whl

voxnorm/__init__.py

@@ -0,0 +1,145 @@
+"""voxnorm: written forms into spoken forms, so a TTS voice reads them the way a person would.
+
+Language models and databases write for the eye: `12:00`, `NT$1,200`,
+`0912-345-678`. A small TTS frontend handed that text verbatim has to guess,
+and guesses badly -- digits read in the wrong language, a phone number read as
+one enormous quantity. voxnorm rewrites the written forms into what a speaker
+would actually say (`十二點`, `新台幣一千兩百元`, `zero nine one two...`) and
+leaves everything else character-for-character alone.
+
+The shape is two layers, split where languages stop sharing:
+
+- **Detection is language-neutral** (`tokens.py`). `14:30` and `50%` are the
+  same written form in any supported language, so one scanner finds the spans
+  and names their kind.
+- **Verbalisation is per-language** (`zh.py`, `cn.py`, `en.py`, `ja.py`,
+  `ko.py`, one module each, registered in `_VERBALIZERS`). A new language is a new module
+  and one dict entry; the scanner does not change. English, Japanese and
+  Korean ride on num2words for their number words, each adding the local
+  readings the library cannot know (a Japanese year without the era default,
+  Korean native-numeral hours); Chinese is spelled out here, because the
+  兩/二 reading choice (一千兩百, never 一千二百 in zh-TW speech) is exactly
+  what no general-purpose converter gets right, and the Simplified variant
+  (`cn.py`) re-spells that one output vocabulary rather than re-deriving it.
+
+Why not an FST toolkit: the established ones (nemo_text_processing,
+WeTextProcessing) were measured before this package was written. Both depend
+on pynini, which publishes no aarch64 wheel at all -- on an ARM box they need
+OpenFst compiled from source and a permanently vendored `libfst.so` -- and
+both mis-read the very classes this package exists for (phone numbers as
+quantities, room numbers as dates, and in one case force-simplifying every
+Traditional character in the sentence). The classes a spoken product actually
+needs are a bounded set; implementing them directly costs ~3 MB of pure
+Python and stays debuggable.
+
+The charter is **structural only, never guess**. A form whose reading is
+ambiguous does not convert: `1/2` the fraction and `8/17` the date are the
+same slash string, so no slash form converts at all. What is not converted is
+simply spoken as written, which is where it started.
+
+Language is decided per call: an explicit `lang` wins, otherwise script
+evidence decides -- kana anywhere means Japanese, hangul Korean, then one Han
+character means Chinese, else English. Kana is checked before Han because
+Japanese text carries kanji too (which also means one katakana loanword
+inside an otherwise-Chinese sentence flips that sentence to the Japanese
+reading -- pass `lang` where such text is expected); the residual is a Japanese sentence written
+entirely in kanji, indistinguishable from Chinese by script, which lands on
+the Chinese reading. That is as far as auto-detection can honestly go --
+Latin-script languages are indistinguishable without a real detector -- so
+callers that know their conversation language should pass `lang`, and the
+detector stays the no-hint fallback.
+"""
+
+import re
+
+from voxnorm import cn, en, ja, ko, zh
+from voxnorm.tokens import TOKEN_KINDS, TOKEN_PATTERN
+
+__version__ = "0.1.0"
+
+
+def normalize(text: str, lang: str | None = None) -> str:
+    """Return `text` with every recognised written form replaced by its spoken form.
+
+    Args:
+        text: Text bound for a synthesizer. Anything the scanner does not
+            recognise is returned character-for-character.
+        lang: A language tag (`zh`, `zh-TW`, `zh-CN`, `zh-Hans`, `en`, `ja`,
+            `ko`, `en_US`, case-insensitive). A bare `zh` is Traditional
+            (the package's home locale); a `CN`/`Hans`/`SG` subtag selects
+            the Simplified re-spelling. `None` auto-detects on script: kana
+            means Japanese, hangul Korean, a Han character Chinese (with a
+            distinctive-glyph check choosing Simplified when the text shows
+            it), otherwise English.
+
+    Raises:
+        ValueError: If `lang` names a language no verbaliser is registered for.
+    """
+    verbalize = _VERBALIZERS[_resolve_lang(text, lang)]
+    return TOKEN_PATTERN.sub(lambda match: verbalize(_kind_of(match), match), text)
+
+
+_VERBALIZERS = {
+    "zh": zh.verbalize,
+    "zh_cn": cn.verbalize,
+    "en": en.verbalize,
+    "ja": ja.verbalize,
+    "ko": ko.verbalize,
+}
+
+_SIMPLIFIED_SUBTAGS = frozenset({"cn", "hans", "sg"})
+
+_HAN = re.compile(r"[㐀-䶿一-鿿豈-﫿]")
+"""CJK Unified Ideographs (extension A, the base block, and the compatibility
+block) -- one match anywhere is the evidence the text is Chinese, once kana
+and hangul have had their look."""
+
+_KANA = re.compile(r"[ぁ-ゖァ-ヺー]")
+"""Hiragana and katakana (plus the prolonged-sound mark) -- checked before
+`_HAN`, because Japanese text carries kanji too."""
+
+_HANGUL = re.compile(r"[가-힣]")
+"""Precomposed hangul syllables -- Korean shares no script with the others."""
+
+
+_SIMPLIFIED_ONLY = frozenset("万亿点号两说对时会开关议历后发东车长门问间头买卖体见")
+_TRADITIONAL_ONLY = frozenset("萬億點號兩說對時會開關議歷後發東車長門問間頭買賣體見")
+"""Twenty-six high-frequency characters whose glyph differs between the two
+scripts -- a heuristic, not a converter. Text showing Simplified evidence and
+no Traditional evidence reads as zh-CN; anything else Chinese defaults to
+Traditional, the package's home locale."""
+
+
+def _resolve_lang(text: str, lang: str | None) -> str:
+    if lang is None:
+        if _KANA.search(text):
+            return "ja"
+        if _HANGUL.search(text):
+            return "ko"
+        if not _HAN.search(text):
+            return "en"
+        chars = set(text)
+        if chars & _SIMPLIFIED_ONLY and not chars & _TRADITIONAL_ONLY:
+            return "zh_cn"
+        return "zh"
+    parts = re.split(r"[-_]", lang.lower())
+    primary = parts[0]
+    if primary == "zh" and any(subtag in _SIMPLIFIED_SUBTAGS for subtag in parts[1:]):
+        return "zh_cn"
+    if primary not in _VERBALIZERS:
+        known = ", ".join(sorted(_VERBALIZERS))
+        raise ValueError(f"unknown voxnorm language {lang!r}; expected one of {known}")
+    return primary
+
+
+def _kind_of(match: re.Match) -> str:
+    """Name the top-level token class `match` matched.
+
+    Not `match.lastgroup`: with named part-groups nested inside each class
+    (`time_h` inside `time`), `lastgroup` names whichever part matched last,
+    not the class.
+    """
+    for kind in TOKEN_KINDS:
+        if match.group(kind) is not None:
+            return kind
+    raise AssertionError("TOKEN_PATTERN matched outside its own kinds")

voxnorm/cn.py

@@ -0,0 +1,40 @@
+"""The zh-CN verbaliser: the zh-TW readings, re-spelled for the mainland.
+
+The spoken readings are the same language -- 两/二 placement, interior zeros,
+digit-by-digit codes all match -- so this module does not duplicate the
+algorithm: it takes `zh`'s output and re-spells it through one glyph table.
+Two entries are more than glyphs: 兆 becomes 万亿 (the mainland reading of
+10^12), and `¥` means renminbi here, not yen, so the currency rule overrides
+that one symbol before the shared table applies.
+"""
+
+import re
+
+from voxnorm import zh
+
+_TO_SIMPLIFIED = str.maketrans(
+    {
+        "兩": "两",
+        "萬": "万",
+        "億": "亿",
+        "兆": "万亿",
+        "點": "点",
+        "號": "号",
+        "幣": "币",
+        "歐": "欧",
+        "鎊": "镑",
+        "韓": "韩",
+        "圓": "元",
+    }
+)
+"""Every character the zh verbaliser can emit that differs in Simplified
+script. Not a general converter -- the domain is exactly `zh.py`'s own output
+vocabulary, which is what keeps a one-table re-spelling honest."""
+
+
+def verbalize(kind: str, match: re.Match) -> str:
+    """Spell the token `match` of class `kind` the way zh-CN says it."""
+    if kind == "currency" and match["cur_sym"] == "¥":
+        # In the mainland locale ¥ is renminbi (元), not the yen zh-TW reads.
+        return f"{zh.amount_to_zh(match['cur_amt']).translate(_TO_SIMPLIFIED)}元"
+    return zh.verbalize(kind, match).translate(_TO_SIMPLIFIED)

voxnorm/en.py

@@ -0,0 +1,118 @@
+"""The English verbaliser: num2words for the number words, local rules for everything else.
+
+num2words carries the cardinal/ordinal/year word forms (for English and, when
+voxnorm grows, some fifty further languages); what it cannot know is which
+reading a written form takes -- that a clock's `:05` is "oh five", that a
+phone number is digits with pauses, that a room number is never a quantity.
+Those readings live here.
+"""
+
+import re
+
+from num2words import num2words
+
+_DIGIT_WORDS = ("zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine")
+
+_MONTHS = (
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+)
+
+_CURRENCIES = {
+    "NT$": ("NT dollar", "NT dollars"),
+    "NTD": ("NT dollar", "NT dollars"),
+    "US$": ("US dollar", "US dollars"),
+    "USD": ("US dollar", "US dollars"),
+    "$": ("dollar", "dollars"),
+    "€": ("euro", "euros"),
+    "¥": ("yen", "yen"),
+    "₩": ("won", "won"),
+    "£": ("pound", "pounds"),
+}
+"""(singular, plural) spoken after the amount. A bare `$` reads as plain
+dollars; the text saying which kind is the text's job, not a guess."""
+
+
+def verbalize(kind: str, match: re.Match) -> str:
+    """Spell the token `match` of class `kind` the way English says it."""
+    return _RULES[kind](match)
+
+
+def digits_to_en(digits: str) -> str:
+    """`digits` read one at a time, zeros kept: `0912` -> "zero nine one two"."""
+    return " ".join(_DIGIT_WORDS[int(char)] for char in digits if char.isdigit())
+
+
+def _cardinal(value: int) -> str:
+    return num2words(value)
+
+
+def _time(match: re.Match) -> str:
+    hour, minute = int(match["time_h"]), int(match["time_m"])
+    if minute == 0:
+        return f"{_cardinal(hour)} o'clock"
+    if minute < 10:
+        return f"{_cardinal(hour)} oh {_DIGIT_WORDS[minute]}"
+    return f"{_cardinal(hour)} {_cardinal(minute)}"
+
+
+def _iso_date(match: re.Match) -> str:
+    month = _MONTHS[int(match["iso_mo"]) - 1]
+    day = num2words(int(match["iso_d"]), to="ordinal")
+    year = num2words(int(match["iso_y"]), to="year")
+    return f"{month} {day}, {year}"
+
+
+def _phone(match: re.Match) -> str:
+    groups = re.split(r"[-\ ]", match[0])
+    return ", ".join(digits_to_en(group) for group in groups)
+
+
+def _amount_to_en(amount: str) -> str:
+    integer, _, fraction = amount.replace(",", "").partition(".")
+    spoken = _cardinal(int(integer))
+    return f"{spoken} point {digits_to_en(fraction)}" if fraction else spoken
+
+
+def _currency(match: re.Match) -> str:
+    amount = match["cur_amt"]
+    singular, plural = _CURRENCIES[match["cur_sym"]]
+    unit = singular if amount.replace(",", "") == "1" else plural
+    return f"{_amount_to_en(amount)} {unit}"
+
+
+def _bare_int(match: re.Match) -> str:
+    run = match[0]
+    # A leading zero is never a quantity -- it is a code, read digit by digit.
+    if len(run) > 1 and int(run[0]) == 0:
+        return digits_to_en(run)
+    return _cardinal(int(run))
+
+
+_RULES = {
+    "time": _time,
+    "iso_date": _iso_date,
+    "phone": _phone,
+    "currency": _currency,
+    "percent": lambda match: f"{_amount_to_en(match['pct_num'])} percent",
+    "room_en": lambda match: f"{match['room_word']} {digits_to_en(match['room_num'])}",
+    # The zh-anchored kinds (a digit run in front of 號/室/年) stay written
+    # under a forced `lang="en"`: converting the digits while the CJK anchor
+    # character stays behind glues English number words onto raw 年/室
+    # ("twenty twenty-six年") -- worse than the written form it replaced.
+    "room_cjk": lambda match: match[0],
+    "year": lambda match: match[0],
+    "decimal": lambda match: _amount_to_en(match[0]),
+    "comma_int": lambda match: _cardinal(int(match[0].replace(",", ""))),
+    "bare_int": _bare_int,
+}

voxnorm/ja.py

@@ -0,0 +1,89 @@
+"""The Japanese verbaliser: kanji number words via num2words, local readings for the rest.
+
+num2words' `ja` cardinals are solid (cross-checked against kanjize during the
+language survey: byte-identical on every probe), so numbers ride on it. What
+is decided here is which reading each written form takes: a year is a plain
+cardinal with `era=False` (二千二十六年, not the era reading 令和八年 the
+library defaults to), a phone number is digits one at a time with 〇 for
+zero, a room number before 号/室 likewise, and a clock's :30 is 半. The
+kana-vs-kanji pronunciation of what this module emits (四時 read よじ, not
+よんじ) is the TTS frontend's business -- the written spoken-form here is
+standard Japanese that any ja frontend already reads correctly.
+"""
+
+import re
+
+from num2words import num2words
+
+_DIGITS = "〇一二三四五六七八九"
+
+_CURRENCIES = {
+    "NT$": "台湾ドル",
+    "NTD": "台湾ドル",
+    "US$": "米ドル",
+    "USD": "米ドル",
+    "$": "ドル",
+    "€": "ユーロ",
+    "¥": "円",
+    "₩": "ウォン",
+    "£": "ポンド",
+}
+"""Spoken after the amount -- Japanese puts every currency word last."""
+
+
+def verbalize(kind: str, match: re.Match) -> str:
+    """Spell the token `match` of class `kind` the way Japanese says it."""
+    return _RULES[kind](match)
+
+
+def digits_to_ja(digits: str) -> str:
+    """`digits` read one at a time, zeros kept: `0912` -> 〇九一二."""
+    return "".join(_DIGITS[int(char)] for char in digits if char.isdigit())
+
+
+def _cardinal(value: int) -> str:
+    return num2words(value, lang="ja")
+
+
+def _time(match: re.Match) -> str:
+    hour, minute = int(match["time_h"]), int(match["time_m"])
+    if minute == 0:
+        return f"{_cardinal(hour)}時"
+    if minute == 30:
+        return f"{_cardinal(hour)}時半"
+    return f"{_cardinal(hour)}時{_cardinal(minute)}分"
+
+
+def _iso_date(match: re.Match) -> str:
+    # Plain cardinal, not to="year": num2words' year form appends its own 年
+    # (and defaults to the era reading besides).
+    year = _cardinal(int(match["iso_y"]))
+    return f"{year}年{_cardinal(int(match['iso_mo']))}月{_cardinal(int(match['iso_d']))}日"
+
+
+def _spoken_int(digits: str) -> str:
+    # A leading zero is never a quantity -- it is a code, read digit by digit.
+    if len(digits) > 1 and int(digits[0]) == 0:
+        return digits_to_ja(digits)
+    return _cardinal(int(digits))
+
+
+def _amount_to_ja(amount: str) -> str:
+    integer, _, fraction = amount.replace(",", "").partition(".")
+    spoken = _spoken_int(integer)
+    return f"{spoken}点{digits_to_ja(fraction)}" if fraction else spoken
+
+
+_RULES = {
+    "time": _time,
+    "iso_date": _iso_date,
+    "phone": lambda match: digits_to_ja(match[0]),
+    "currency": lambda match: f"{_amount_to_ja(match['cur_amt'])}{_CURRENCIES[match['cur_sym']]}",
+    "percent": lambda match: f"{_amount_to_ja(match['pct_num'])}パーセント",
+    "room_en": lambda match: f"{match['room_word']} {digits_to_ja(match['room_num'])}",
+    "room_cjk": lambda match: digits_to_ja(match[0]),
+    "year": lambda match: _cardinal(int(match[0])),
+    "decimal": lambda match: _amount_to_ja(match[0]),
+    "comma_int": lambda match: _spoken_int(match[0].replace(",", "")),
+    "bare_int": lambda match: _spoken_int(match[0]),
+}

voxnorm/ko.py

@@ -0,0 +1,103 @@
+"""The Korean verbaliser: sino-Korean via num2words, the native numerals written here.
+
+Korean reads numbers in two systems and the choice is grammatical, not
+stylistic: hours take the *native* numerals (한 시, 두 시 -- never 일 시),
+while minutes, dates, money and digit strings take the *sino* numerals
+(이천이십육년, 삼십 분). num2words' `ko` is sino-only, and the language
+survey found no working pure-Python native-numeral library at all -- but the
+attributive native forms an hour clock needs are a closed set of twelve, so
+they live in `_NATIVE_HOURS`. Zero in a digit string is 공 (the phone-number
+reading), not 영.
+"""
+
+import re
+
+from num2words import num2words
+
+_DIGITS = ("공", "일", "이", "삼", "사", "오", "육", "칠", "팔", "구")
+
+_NATIVE_HOURS = ("영", "한", "두", "세", "네", "다섯", "여섯", "일곱", "여덟", "아홉", "열", "열한", "열두")
+"""Attributive native numerals 1-12, the only forms 시 accepts, with 영 at
+index 0 so a loosened hour guard can never emit an empty hour. A 24-hour
+clock past twelve (14시) is read sino (십사 시), matching broadcast usage."""
+
+_MONTHS = ("일월", "이월", "삼월", "사월", "오월", "유월", "칠월", "팔월", "구월", "시월", "십일월", "십이월")
+"""June and October are irregular (유월/시월, not 육월/십월), so the month is a
+lookup, never a composed sino number."""
+
+_CURRENCIES = {
+    "NT$": "대만 달러",
+    "NTD": "대만 달러",
+    "US$": "미국 달러",
+    "USD": "미국 달러",
+    "$": "달러",
+    "€": "유로",
+    "¥": "엔",
+    "₩": "원",
+    "£": "파운드",
+}
+"""Spoken after the amount -- Korean puts every currency word last."""
+
+
+def verbalize(kind: str, match: re.Match) -> str:
+    """Spell the token `match` of class `kind` the way Korean says it."""
+    return _RULES[kind](match)
+
+
+def digits_to_ko(digits: str) -> str:
+    """`digits` read one at a time, zeros kept as 공: `0912` -> 공구일이."""
+    return "".join(_DIGITS[int(char)] for char in digits if char.isdigit())
+
+
+def _sino(value: int) -> str:
+    return num2words(value, lang="ko")
+
+
+def _time(match: re.Match) -> str:
+    hour, minute = int(match["time_h"]), int(match["time_m"])
+    spoken_hour = _NATIVE_HOURS[hour] if 1 <= hour <= 12 else _sino(hour)
+    if minute == 0:
+        return f"{spoken_hour} 시"
+    if minute == 30:
+        return f"{spoken_hour} 시 반"
+    return f"{spoken_hour} 시 {_sino(minute)} 분"
+
+
+def _iso_date(match: re.Match) -> str:
+    year, month, day = int(match["iso_y"]), int(match["iso_mo"]), int(match["iso_d"])
+    return f"{_sino(year)}년 {_MONTHS[month - 1]} {_sino(day)}일"
+
+
+def _spoken_int(digits: str) -> str:
+    # A leading zero is never a quantity -- it is a code, read digit by digit.
+    if len(digits) > 1 and int(digits[0]) == 0:
+        return digits_to_ko(digits)
+    return _sino(int(digits))
+
+
+def _amount_to_ko(amount: str) -> str:
+    integer, _, fraction = amount.replace(",", "").partition(".")
+    spoken = _spoken_int(integer)
+    # Unspaced around 점: the decimal reading is written as one clump
+    # (삼점일사), unlike the counter nouns 시/분/원 that take a space.
+    return f"{spoken}점{digits_to_ko(fraction)}" if fraction else spoken
+
+
+def _phone(match: re.Match) -> str:
+    groups = re.split(r"[-\ ]", match[0])
+    return " ".join(digits_to_ko(group) for group in groups)
+
+
+_RULES = {
+    "time": _time,
+    "iso_date": _iso_date,
+    "phone": _phone,
+    "currency": lambda match: f"{_amount_to_ko(match['cur_amt'])} {_CURRENCIES[match['cur_sym']]}",
+    "percent": lambda match: f"{_amount_to_ko(match['pct_num'])} 퍼센트",
+    "room_en": lambda match: f"{match['room_word']} {digits_to_ko(match['room_num'])}",
+    "room_cjk": lambda match: digits_to_ko(match[0]),
+    "year": lambda match: _sino(int(match[0])),
+    "decimal": lambda match: _amount_to_ko(match[0]),
+    "comma_int": lambda match: _spoken_int(match[0].replace(",", "")),
+    "bare_int": lambda match: _spoken_int(match[0]),
+}

voxnorm/tokens.py

@@ -0,0 +1,91 @@
+"""The language-neutral scanner: one pattern that finds every written form voxnorm speaks.
+
+Each alternative is a named group whose name is the token's kind; the part
+groups inside it (`time_h`, `cur_amt`, ...) are what the verbalisers read.
+Order in the alternation is priority: a clock time must win over the bare
+integers inside it, a phone number over the currency-less digit runs it is
+made of.
+
+The pattern compiles with `re.ASCII`, so `\\d` means `[0-9]` and nothing
+else. Full-width (zenkaku) digits are deliberately NOT scanned: without the
+flag they matched the loose fallback alternatives but never the strict ones
+(the phone lead, the ISO-date years, the literal `%` and `,`), so
+`０９１２-３４５-６７８` half-converted into a chimera of digit-readings and
+stranded hyphens. Under the charter an unrecognised form passes through
+whole -- and TTS frontends in the locales that write zenkaku digits read
+them natively anyway.
+
+Two hard-won rules shape every alternative:
+
+- **No `\\b` against CJK.** Han characters are word characters to `re`, so
+  `\\b` never fires between 是 and 12, and every "boundary" here is written
+  as an explicit digit lookaround instead.
+- **Ambiguous forms are absent, not clever.** No slash form matches at all
+  (`1/2` the fraction and `8/17` the date are the same string); `號` takes a
+  digit-string reading only at three digits and up, because `302號` is a room
+  and `17號` is a day of the month.
+"""
+
+import re
+
+TOKEN_KINDS = (
+    "time",
+    "iso_date",
+    "phone",
+    "currency",
+    "percent",
+    "room_en",
+    "room_cjk",
+    "year",
+    "decimal",
+    "comma_int",
+    "bare_int",
+)
+"""Every top-level group in `TOKEN_PATTERN`, in the pattern's own priority order."""
+
+TOKEN_PATTERN = re.compile(
+    r"""
+      (?P<time>(?<![\d:])(?P<time_h>[01]?\d|2[0-3]):(?P<time_m>[0-5]\d)(?![\d:]))
+    | (?P<iso_date>(?<!\d)(?P<iso_y>(?:19|20)\d\d)-(?P<iso_mo>0?[1-9]|1[0-2])-(?P<iso_d>0?[1-9]|[12]\d|3[01])(?!\d))
+    | (?P<phone>(?<!\d)0\d{1,3}(?:[-\ ]\d{3,4}){2}(?![\d-]))
+    | (?P<currency>(?P<cur_sym>NT\$|US\$|USD|NTD|\$|€|¥|£|₩)\ ?(?P<cur_amt>\d[\d,]*(?:\.\d+)?))
+    | (?P<percent>(?<![\d.])(?P<pct_num>\d[\d,]*(?:\.\d+)?)\ ?%)
+    | (?P<room_en>(?P<room_word>\b[Rr]oom|\b[Ee]xt\.?|房號|分機)\ ?\#?(?P<room_num>\d{2,5})(?!\d))
+    | (?P<room_cjk>(?<!\d)\d{3,10}(?=號|号|室|호))
+    | (?P<year>(?<!\d)(?:19|20)\d\d(?=年|년))
+    | (?P<decimal>(?<![\d./:：])\d+\.\d+(?![\d./:：]))
+    | (?P<comma_int>(?<![\d,/:：])\d{1,3}(?:,\d{3})+(?![\d,/:：]))
+    | (?P<bare_int>(?<![\d./:：])\d+(?![\d./:：]))
+    """,
+    re.VERBOSE | re.ASCII,
+)
+"""Notes per alternative, in order:
+
+- `time` — `HH:MM`, 24-hour, minutes always two digits; the trailing guard
+  keeps `12:00:05` (a duration with seconds, unhandled) from half-matching.
+- `iso_date` — `YYYY-MM-DD` with a plausibility window on every field, so an
+  id-like `1234-56-78` stays text.
+- `phone` — a leading-zero group and exactly two 3-4 digit separator groups:
+  the shapes Taiwanese numbers are actually written in (`0912-345-678`,
+  `02-2345-6789`, `0800-092-000`). A separator-less `0912345678` is caught by
+  `bare_int`'s leading-zero rule instead.
+- `currency` — symbol before amount, the only order this package reads.
+- `room_en` / `room_cjk` — a digit string read digit by digit, licensed by an
+  explicit context word. The CJK suffix (Traditional 號, Japanese 号/室,
+  Korean 호) stays outside the match (lookahead) so `302號房` keeps its 號房;
+  the en prefix is inside and re-emitted, because a variable-width lookbehind
+  is not a thing `re` has.
+- `year` — four digits directly before 年/년 read as a year (二零二六年
+  digit by digit in Chinese, 二千二十六年 / 이천이십육년 as cardinals in
+  Japanese and Korean — the split lives in the verbalisers); without the
+  suffix a four-digit integer is a quantity.
+- `decimal` / `comma_int` / `bare_int` — the residue: point decimals,
+  comma-grouped integers, then any digit run. The lookarounds keep each from
+  matching inside a form a higher alternative half-consumed, keep version-ish
+  strings (`1.2.3`) whole and untouched, and refuse any digit touching a
+  slash or a colon. The `/` guards are the charter's "no slash form converts"
+  applied to the digits inside the form (`1/2` must not become 一/二); the
+  `:`/`：` guards do the same for a colon form the `time` alternative
+  rejected -- an invalid `24:00` must stay written, not half-convert to
+  二十四:零零 around a stranded colon.
+"""

voxnorm/zh.py

@@ -0,0 +1,157 @@
+"""The zh-TW verbaliser: numbers written the way a Taiwanese speaker reads them out.
+
+Chinese is the one language voxnorm spells out itself rather than through a
+number library: num2words has no Chinese at all, and the converters that do
+exist write `一千二百` where a zh-TW speaker says `一千兩百`, in Simplified
+glyphs besides. The 兩/二 choice is positional -- 兩 before a multiplier
+(兩百, 兩千, 兩萬) and for two o'clock (兩點), 二 everywhere else (二十二,
+十二) -- and `_LIANG` is the one rule that encodes it. Output is Traditional
+throughout, 台 not 臺.
+"""
+
+import re
+
+_DIGITS = "零一二三四五六七八九"
+_SECTION_UNITS = ("", "十", "百", "千")
+_GROUP_UNITS = ("", "萬", "億", "兆")
+
+_LIANG_IN_SECTION = re.compile("二(?=[百千])")
+"""兩 replaces 二 where a multiplier follows *within a section* -- 兩百二十二,
+never 兩十. The group units (萬/億/兆) are handled separately in
+`number_to_zh`, and only when the whole section reads 二: adversarial review
+proved a flat rule over the joined string turns 120000 into 十兩萬, because
+the 二 of 十二 happens to sit before the 萬."""
+
+_CURRENCIES = {
+    "NT$": ("新台幣", "元"),
+    "NTD": ("新台幣", "元"),
+    "US$": ("", "美元"),
+    "USD": ("", "美元"),
+    "$": ("", "元"),
+    "€": ("", "歐元"),
+    "¥": ("", "日圓"),
+    "₩": ("", "韓元"),
+    "£": ("", "英鎊"),
+}
+"""(prefix, suffix) around the spoken amount. A bare `$` reads as 元: in this
+package's home locale a bill is in NTD unless the text says otherwise."""
+
+
+def verbalize(kind: str, match: re.Match) -> str:
+    """Spell the token `match` of class `kind` the way zh-TW says it."""
+    return _RULES[kind](match)
+
+
+def number_to_zh(value: int) -> str:
+    """`value` in grouped spoken form: `1200` -> 一千兩百, `100050` -> 十萬零五十.
+
+    Standard positional reading in 4-digit sections (萬/億/兆), interior zeros
+    compressed to one 零, 10-19 and 十萬-class leads dropping the leading 一
+    (十二 and 十萬, but the interior 一十 of 一百一十二 stays).
+
+    Raises:
+        ValueError: At 10^16 and beyond -- 兆 is the largest unit spoken here,
+            and truncating silently was a measured bug, not a feature. Callers
+            with digit runs that long want `digits_to_zh` (`_spoken_int`).
+    """
+    if value >= 10_000_000_000_000_000:
+        raise ValueError(f"{value} is beyond 兆 range; read it digit by digit instead")
+    if value == 0:
+        return _DIGITS[0]
+    sections: list[tuple[int, str]] = []
+    for unit in _GROUP_UNITS:
+        value, section = divmod(value, 10000)
+        sections.append((section, unit))
+        if value == 0:
+            break
+    parts: list[str] = []
+    previous_index: int | None = None
+    for index in range(len(sections) - 1, -1, -1):
+        section, unit = sections[index]
+        if section == 0:
+            continue
+        # A positional gap must be voiced as one 零, or the magnitudes merge:
+        # 100050 is 十萬零五十, not 十萬五十 (which reads as 105,000). A gap is
+        # a section under 1000, or a whole section of zeros skipped between
+        # this one and the last one spoken (一億零兩千).
+        if parts and (section < 1000 or previous_index != index + 1):
+            parts.append(_DIGITS[0])
+        spoken = _LIANG_IN_SECTION.sub("兩", _section_to_zh(section))
+        # A section that is exactly 2 reads 兩 before its group unit (兩萬),
+        # but a section merely *ending* in 2 keeps its 二 (十二萬, 二十二億).
+        if unit and spoken == "二":
+            spoken = "兩"
+        parts.append(spoken + unit)
+        previous_index = index
+    rendered = "".join(parts)
+    if rendered.startswith("一十"):
+        rendered = rendered[1:]
+    return rendered
+
+
+def digits_to_zh(digits: str) -> str:
+    """`digits` read one at a time, zeros kept: `0912` -> 零九一二."""
+    return "".join(_DIGITS[int(char)] for char in digits if char.isdigit())
+
+
+def _section_to_zh(section: int) -> str:
+    rendered = ""
+    for index in (3, 2, 1, 0):
+        digit = section // 10**index % 10
+        rendered += _DIGITS[0] if digit == 0 else _DIGITS[digit] + _SECTION_UNITS[index]
+    rendered = re.sub("零+", "零", rendered).strip("零")
+    return rendered or _DIGITS[0]
+
+
+def _hour_to_zh(hour: int) -> str:
+    return "兩" if hour == 2 else number_to_zh(hour)
+
+
+def _time(match: re.Match) -> str:
+    hour, minute = int(match["time_h"]), int(match["time_m"])
+    if minute == 0:
+        return f"{_hour_to_zh(hour)}點"
+    if minute == 30:
+        return f"{_hour_to_zh(hour)}點半"
+    spoken_minute = f"零{_DIGITS[minute]}" if minute < 10 else number_to_zh(minute)
+    return f"{_hour_to_zh(hour)}點{spoken_minute}分"
+
+
+def _iso_date(match: re.Match) -> str:
+    year, month, day = match["iso_y"], int(match["iso_mo"]), int(match["iso_d"])
+    return f"{digits_to_zh(year)}年{number_to_zh(month)}月{number_to_zh(day)}日"
+
+
+def _spoken_int(digits: str) -> str:
+    """Grouped reading, unless `digits` is a code: a leading zero or a run past
+    兆 range (16 digits) reads digit by digit. The scanner is ASCII-only, so
+    `digits` is always plain 0-9 here."""
+    if (len(digits) > 1 and int(digits[0]) == 0) or len(digits) > 16:
+        return digits_to_zh(digits)
+    return number_to_zh(int(digits))
+
+
+def amount_to_zh(amount: str) -> str:
+    integer, _, fraction = amount.replace(",", "").partition(".")
+    spoken = _spoken_int(integer)
+    return f"{spoken}點{digits_to_zh(fraction)}" if fraction else spoken
+
+
+def _currency(match: re.Match) -> str:
+    prefix, suffix = _CURRENCIES[match["cur_sym"]]
+    return f"{prefix}{amount_to_zh(match['cur_amt'])}{suffix}"
+
+
+_RULES = {
+    "time": _time,
+    "iso_date": _iso_date,
+    "phone": lambda match: digits_to_zh(match[0]),
+    "currency": _currency,
+    "percent": lambda match: f"百分之{amount_to_zh(match['pct_num'])}",
+    "room_en": lambda match: f"{match['room_word']} {digits_to_zh(match['room_num'])}",
+    "room_cjk": lambda match: digits_to_zh(match[0]),
+    "year": lambda match: digits_to_zh(match[0]),
+    "decimal": lambda match: amount_to_zh(match[0]),
+    "comma_int": lambda match: _spoken_int(match[0].replace(",", "")),
+    "bare_int": lambda match: _spoken_int(match[0]),
+}

voxnorm-0.1.0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.5
+Name: voxnorm
+Version: 0.1.0
+Summary: Text normalization for TTS: written forms into spoken forms, multilingual, pure Python
+Project-URL: Repository, https://github.com/allen2c/voxnorm
+Author: Allen Chou
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: speech,spoken-form,text-normalization,tts,verbalization,zh-tw
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Requires-Dist: num2words>=0.5.14
+Description-Content-Type: text/markdown
+
+# voxnorm
+
+Text normalization for TTS: written forms into spoken forms, multilingual,
+pure Python. Currently speaks **Traditional Chinese (zh-TW),
+Simplified Chinese (zh-CN), English, Japanese, and Korean**.
+
+Language models and databases write for the eye — `12:00`, `NT$1,200`,
+`0912-345-678` — and a small TTS frontend handed that text verbatim has to
+guess, and guesses badly. voxnorm rewrites the written forms into what a
+speaker would actually say, and leaves everything else character-for-character
+alone:
+
+```python
+>>> import voxnorm
+>>> voxnorm.normalize("會議在12:00開始")
+'會議在十二點開始'
+>>> voxnorm.normalize("The meeting starts at 12:00")
+"The meeting starts at twelve o'clock"
+>>> voxnorm.normalize("会議は12:00からです")      # kana → Japanese
+'会議は十二時からです'
+>>> voxnorm.normalize("회의는 12:00에 시작합니다")  # hangul → Korean (native-numeral hours)
+'회의는 열두 시에 시작합니다'
+>>> voxnorm.normalize("電話是0912-345-678。")
+'電話是零九一二三四五六七八。'
+>>> voxnorm.normalize("NT$1,200", lang="zh")
+'新台幣一千兩百元'
+>>> voxnorm.normalize("会议在12:00开始")        # simplified glyphs → zh-CN
+'会议在十二点开始'
+```
+
+## Design
+
+Two layers, split where languages stop sharing:
+
+- **Detection is language-neutral** (`voxnorm/tokens.py`): one scanner finds
+  the spans — times, ISO dates, phone numbers, currency, percentages, room
+  numbers, decimals, integers — and names their kind.
+- **Verbalisation is per-language** (`voxnorm/zh.py`, `cn.py`, `en.py`,
+  `ja.py`, `ko.py`): a new language is a new module and one registry entry. English,
+  Japanese and Korean ride on
+  [num2words](https://pypi.org/project/num2words/) for their number words,
+  each adding the readings the library cannot know — a Japanese year without
+  the era default, Korean native-numeral hours (한 시, never 일 시), the
+  irregular Korean months 유월/시월. Chinese is spelled out in-repo,
+  Traditional first, because the 兩/二 reading choice (一千兩百, never
+  一千二百 in zh-TW speech) is exactly what general-purpose converters get
+  wrong; the Simplified variant re-spells that one output vocabulary
+  (`兆` → `万亿`, and `¥` reads as renminbi rather than yen).
+
+Language is decided per call: an explicit hint wins
+(`normalize(text, lang="zh-TW")`), otherwise script evidence decides — kana
+means Japanese, hangul Korean, a Han character Chinese (Simplified when
+distinctive simplified glyphs appear, Traditional otherwise), else English. (A
+Japanese sentence written entirely in kanji is script-identical to Chinese
+and lands on the Chinese reading — pass `lang="ja"` when you know better.)
+
+The charter is **structural only, never guess**: a form whose reading is
+ambiguous does not convert (`1/2` the fraction and `8/17` the date are the
+same slash string, so no slash form converts at all). What is not converted is
+simply spoken as written — which is where it started.
+
+## Why not an FST toolkit
+
+nemo_text_processing and WeTextProcessing were measured before this package
+was written. Both depend on pynini, which publishes no aarch64 wheel — on an
+ARM box they need OpenFst compiled from source and a permanently vendored
+`libfst.so` — and both mis-read the very classes this package exists for:
+phone numbers as quantities, `302號房` as a date, and (WeTextProcessing)
+force-simplifying every Traditional character in the sentence it touches. The
+classes a spoken product needs are a bounded set; implementing them directly
+costs ~3 MB of pure Python and stays debuggable.
+
+## Install
+
+```sh
+uv add voxnorm      # or: pip install voxnorm
+```
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+uv run ruff check .
+```
+
+Apache-2.0.

voxnorm-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+voxnorm/__init__.py,sha256=u-G31qaUUVpCn-_zALxa0ZtQENsxdFIAOG1gLVvpDI8,6760
+voxnorm/cn.py,sha256=m7917eMQw3bAH6XlA7pVUr-vBbMlY3Pqz-oofJp8_9A,1464
+voxnorm/en.py,sha256=8NRmHa4fZXUKWIaynQAtwcnRjAIS6Id_Ws83n-TWpQw,3826
+voxnorm/ja.py,sha256=8eK0A9iknaSw58rIL4qPmcq4ALJYHD4LQS8ktdVFGjg,3293
+voxnorm/ko.py,sha256=vZ68X1z7gKyDAZkwS4KiFHA7NeoA4PAryiermj-U9Go,4028
+voxnorm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+voxnorm/tokens.py,sha256=mEsyblP8MofSJKLKFcXVmwhcVTXUu7hizBYfzYsPtLA,4551
+voxnorm/zh.py,sha256=xjrNnFwASmx-odBHPQshSIL9AzqC8btGOqOLt4M9UsI,6328
+voxnorm-0.1.0.dist-info/METADATA,sha256=xaV0NbQbReN8PwSrJIgySCX20YtptLSsprwOY28z27A,4479
+voxnorm-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+voxnorm-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+voxnorm-0.1.0.dist-info/RECORD,,

voxnorm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

voxnorm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.