words2num2 0.3.2__tar.gz → 0.3.3__tar.gz

{words2num2-0.3.2 → words2num2-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: words2num2
-Version: 0.3.2
+Version: 0.3.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{words2num2-0.3.2 → words2num2-0.3.3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "maturin"
 name = "words2num2"
 # Static base version. The release CI overrides it from the pushed git tag
 # (see .github/workflows/release.yml); bump here for local source builds.
-version = "0.3.2"
+version = "0.3.3"
 license = "LGPL-2.1-only"
 license-files = ["COPYING"]
 description = "Rust-powered inverse of num2words2: parse spoken-form numbers back to numeric values across 100+ languages, optimized for ASR/LLM/speech."

{words2num2-0.3.2 → words2num2-0.3.3}/rust/Cargo.lock

@@ -21,27 +21,12 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "cfg-if"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
-
 [[package]]
 name = "heck"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "indoc"
-version = "2.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "libc"
 version = "0.2.186"
@@ -54,15 +39,6 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
-[[package]]
-name = "memoffset"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "num-bigint"
 version = "0.4.8"
@@ -105,7 +81,7 @@ dependencies = [
 
 [[package]]
 name = "num2words2-core"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "bigdecimal",
  "num-bigint",
@@ -136,38 +112,34 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
 dependencies = [
- "cfg-if",
- "indoc",
  "libc",
- "memoffset",
  "num-bigint",
+ "num-traits",
  "once_cell",
  "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
- "unindent",
 ]
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+checksum = "f41027e41b4bd03f6e60f9f417fe24a6341a6bb744edd62b6f709f2a52ea30e9"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+checksum = "e591a95526fead067432c3b3a33fc74770b87b1e04e73671090d9c2055a2b327"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -175,9 +147,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+checksum = "73225868fc1cd84eef2c3c230ddb91273bf1de46aeb8a4248da76d32a0924a1c"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -187,13 +159,12 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+checksum = "571575aa3749fa6216757dd47d2a3e7ef360f329a40f0666a9fbd14889024952"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
  "syn",
 ]
@@ -207,12 +178,6 @@ dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "rustversion"
-version = "1.0.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
-
 [[package]]
 name = "syn"
 version = "2.0.119"
@@ -226,9 +191,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tinyvec"
@@ -260,15 +225,9 @@ dependencies = [
  "tinyvec",
 ]
 
-[[package]]
-name = "unindent"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
-
 [[package]]
 name = "words2num2-core"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "bigdecimal",
  "num-bigint",
@@ -278,7 +237,7 @@ dependencies = [
 
 [[package]]
 name = "words2num2-py"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "bigdecimal",
  "num-bigint",

{words2num2-0.3.2 → words2num2-0.3.3}/rust/Cargo.toml

@@ -3,7 +3,7 @@ members = ["words2num2-core", "words2num2-py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 license = "LGPL-2.1-only"
 repository = "https://github.com/gladiaio/words2num2"

{words2num2-0.3.2 → words2num2-0.3.3}/rust/words2num2-core/src/lib.rs

@@ -422,6 +422,59 @@ fn hundred_word(lang: &str) -> Option<String> {
     out
 }
 
+/// Cache of the derived bare hundred prefix per language (es "ciento").
+fn hundred_prefix_cache() -> &'static RwLock<HashMap<String, Option<String>>> {
+    static P: OnceLock<RwLock<HashMap<String, Option<String>>>> = OnceLock::new();
+    P.get_or_init(|| RwLock::new(HashMap::new()))
+}
+
+/// The hundred word num2words never renders on its own, only as the head of
+/// a composed hundred: es "ciento" (100 is "cien", 101 is "ciento uno"),
+/// pt "cento" (100 is "cem"). The reverse table has no entry for it, so the
+/// sentence walker never opened a run on it and "ciento cincuenta y cuatro"
+/// came out as "ciento 54". Derived by rendering 101..=109 and keeping the
+/// head token when it is not a table word by itself while the rest is the
+/// unit. `None` where the hundred is a table word already (fr "cent") or is
+/// glued to its unit (de "hunderteins", it "centouno").
+fn hundred_prefix(lang: &str) -> Option<String> {
+    if let Some(v) = hundred_prefix_cache().read().unwrap().get(lang) {
+        return v.clone();
+    }
+    let out = (|| {
+        let l = num2words2_core::get_lang_by_key(lang)?;
+        let conns = connector_words(lang);
+        for n in 101i64..=109 {
+            let words = l.to_cardinal(&BigInt::from(n)).ok()?;
+            let norm = normalize(&words);
+            let toks: Vec<&str> = norm.split_whitespace().collect();
+            if toks.len() < 2 || lookup_plain(lang, toks[0]).is_some() {
+                continue;
+            }
+            let rest = trim_connectors(&toks[1..].join(" "), conns);
+            if lookup_plain(lang, &rest) == Some(n - 100) {
+                return Some(toks[0].to_string());
+            }
+        }
+        None
+    })();
+    hundred_prefix_cache()
+        .write()
+        .unwrap()
+        .insert(lang.to_string(), out.clone());
+    out
+}
+
+/// The bare hundred prefix on its own ("ciento") reads as 100. A run head in
+/// the sentence walker must be a number word by itself, and this is the one
+/// hundred word the reverse table cannot vouch for.
+pub fn lookup_hundred_prefix(lang: &str, text: &str) -> Option<i64> {
+    if !supported_langs().contains(&lang) {
+        return None;
+    }
+    let prefix = hundred_prefix(lang)?;
+    (normalize(text) == prefix).then_some(100)
+}
+
 /// Recover a spoken "year" reading that is not num2words' canonical spelling:
 /// `L <hundred> R` (explicit or glued) → `L*100 + R`, or two 2-digit groups
 /// `a b` → `a*100 + b`. All parts are resolved through the reverse table, so no

{words2num2-0.3.2 → words2num2-0.3.3}/rust/words2num2-core/src/w2n_lang_en.rs

@@ -634,6 +634,18 @@ const TENS: [(&str, i64); 8] = [
     ("ninety", 90),
 ];
 
+/// Value of a unit or teen word (`_UNITS`: "zero".."nineteen", "oh"), for
+/// the sentence walker's digit-string and spoken-year readings.
+pub(crate) fn unit_value(word: &str) -> Option<i64> {
+    UNITS.iter().find(|(w, _)| *w == word).map(|&(_, v)| v)
+}
+
+/// Value of a tens word (`_TENS`: "twenty".."ninety"), for the sentence
+/// walker's spoken-year reading.
+pub(crate) fn tens_value(word: &str) -> Option<i64> {
+    TENS.iter().find(|(w, _)| *w == word).map(|&(_, v)| v)
+}
+
 /// `_SCALES`, as (word, power-of-ten). "hundred" is 100 = 10^2.
 ///
 /// Note "hundred" is a member here *and* is special-cased ahead of the
@@ -886,19 +898,56 @@ impl W2nLangEn {
         let mut total = BigInt::from(0);
         let mut current = BigInt::from(0);
         let mut seen_any = false;
+        // What the sub-hundred slot of `current` already holds.
+        //
+        // English composes a tens word with a *following* unit ("sixty
+        // three" = 63), never with a preceding one, and a unit closes the
+        // slot. "three sixty" is two numbers read in sequence, not 3 + 60;
+        // "twenty twenty" is two twenties, not 40; "four five six seven" is
+        // four digits read out, not 22; "twenty nineteen" is a year, not 39.
+        // Rejecting a word the slot cannot take is what makes them come out
+        // as separate runs — or a digit string, or a year — in a sentence.
+        //
+        // "hundred" and the scale words close the slot, so "one hundred
+        // sixty" (160) and "two thousand sixty" (2060) are unaffected.
+        #[derive(PartialEq)]
+        enum Slot {
+            Empty,
+            /// A tens word; a single digit (0-9) may still follow.
+            Tens,
+            /// A unit, or a tens word plus its unit; nothing may follow.
+            Full,
+        }
+        let mut slot = Slot::Empty;
+        let cannot_follow = |tok: &str| {
+            W2nError::new(format!(
+                "{} cannot follow a smaller number in {}",
+                py_repr(tok),
+                py_repr(&toks.join(" "))
+            ))
+        };
         for tok in toks {
             if let Some(&v) = self.units.get(*tok) {
+                if slot == Slot::Full || (slot == Slot::Tens && v >= 10) {
+                    return Err(cannot_follow(tok));
+                }
                 current += v;
                 seen_any = true;
+                slot = Slot::Full;
             } else if let Some(&v) = self.tens.get(*tok) {
+                if slot != Slot::Empty {
+                    return Err(cannot_follow(tok));
+                }
                 current += v;
                 seen_any = true;
+                slot = Slot::Tens;
             } else if *tok == "hundred" {
                 if current.sign() == Sign::NoSign {
                     current = BigInt::from(1);
                 }
                 current *= 100;
                 seen_any = true;
+                slot = Slot::Empty;
             } else if let Some(scale) = self.scales.get(*tok) {
                 if current.sign() == Sign::NoSign {
                     current = BigInt::from(1);
@@ -906,6 +955,7 @@ impl W2nLangEn {
                 total += &current * scale;
                 current = BigInt::from(0);
                 seen_any = true;
+                slot = Slot::Empty;
             } else if is_digits(tok) {
                 // Allow embedded digit groups, e.g. "two thousand 24".
                 match BigInt::from_str(&nd_to_ascii(tok)) {
@@ -971,8 +1021,9 @@ impl W2nLangEn {
     ///
     /// Tries every split point and takes the first where the high half is a
     /// 2-digit number and the low half is at most 99. When nothing matches it
-    /// falls back to plain cardinal addition, which is why "nine eleven" is
-    /// 20 rather than 911.
+    /// falls back to the plain cardinal reading — which, since a unit may
+    /// not follow a unit, now rejects "nine eleven" rather than summing it
+    /// to 20.
     fn year_value(&self, toks: &[&str]) -> W2nResult<BigInt> {
         if toks.len() < 2 {
             return self.cardinal_value(toks);

{words2num2-0.3.2 → words2num2-0.3.3}/rust/words2num2-core/src/w2n_sentence.rs

@@ -16,8 +16,12 @@
 //! Verified against the live interpreter. These all look wrong and are all
 //! correct ports:
 //!
-//! * `words2num_sentence("nineteen ninety nine")` → `"118"`, **not** `"1999"`.
-//!   The sentence walker calls `to_cardinal` (19 + 99), never `to_year`.
+//! * `words2num_sentence("nineteen ninety nine")` used to be `"118"` (the
+//!   walker calls `to_cardinal`, 19 + 99). Since a tens word may no longer
+//!   follow a smaller number, and the walker now reads a spoken year that
+//!   outgrows the cardinal ([`en_year_run`]) and a digit string read one
+//!   digit at a time ([`en_digit_run`]), it is `"1999"` — and "four five six
+//!   seven" is `"4567"` rather than `"22"`.
 //! * `words2num_sentence("minus forty two")` → `"minus 42"`. A run may not
 //!   *start* with a connector, and `to_cardinal("minus")` raises, so "minus"
 //!   is not a run head. Same for `"a hundred and one dogs"` → `"a 101 dogs"`.
@@ -717,6 +721,12 @@ fn base_convert(lang: &str, text: &str, ordinal: bool) -> Result<W2nValue, W2nEr
         // Composition multi-échelle pour les valeurs hors table (> 10001) :
         // « soixante-neuf mille huit » → 69008. Uniquement en cardinal.
         if !ordinal {
+            // The bare hundred prefix num2words never renders alone (es
+            // "ciento"): 100, so the walker can open a run on it and grow it
+            // into the table hit "ciento cincuenta y cuatro".
+            if let Some(v) = crate::lookup_hundred_prefix(lang, text) {
+                return Ok(W2nValue::Int(BigInt::from(v)));
+            }
             if let Some(v) = crate::parse_scaled(lang, text) {
                 return Ok(W2nValue::Int(BigInt::from(v)));
             }
@@ -955,6 +965,129 @@ fn is_candidate(converter: &Converter, token: &str, includable: &[&str]) -> bool
         .any(|sub| converter.is_number_word(sub))
 }
 
+/// One word of an English number run: the word itself (lowercased, hyphens
+/// split), the index of the sentence part it came from, and whether it is the
+/// last word of that part — a reading may only stop on a part boundary, never
+/// halfway through "ninety-nine".
+struct EnWord {
+    word: String,
+    part: usize,
+    last: bool,
+}
+
+/// The consecutive English number words starting at part `i`: units, teens,
+/// tens and "oh"/"o", each part split on hyphens. Stops at the first part
+/// that is not wholly made of such words, and after one that ends in
+/// terminal punctuation — the same run boundaries the cardinal walk uses.
+fn en_number_words(parts: &[String], i: usize) -> Vec<EnWord> {
+    use crate::w2n_lang_en::{tens_value, unit_value};
+    let mut words = Vec::new();
+    let mut j = i;
+    while j < parts.len() {
+        let tok = &parts[j];
+        if py_str_isspace(tok) {
+            j += 1;
+            continue;
+        }
+        let clean = rstrip_punct(tok).to_lowercase().replace('-', " ");
+        let subs = py_split_whitespace(&clean);
+        if subs.is_empty()
+            || !subs
+                .iter()
+                .all(|w| *w == "o" || unit_value(w).is_some() || tens_value(w).is_some())
+        {
+            break;
+        }
+        let n = subs.len();
+        for (k, w) in subs.iter().enumerate() {
+            words.push(EnWord {
+                word: w.to_string(),
+                part: j,
+                last: k + 1 == n,
+            });
+        }
+        if ends_with_terminal_punct(tok) {
+            break;
+        }
+        j += 1;
+    }
+    words
+}
+
+/// A digit string read one digit at a time — an account number, ZIP code or
+/// phone number: "four five six seven" -> "4567", "zero six one two" ->
+/// "0612". Two or more consecutive single-digit words (zero, one..nine), no
+/// tens or scale word among them; "oh"/"o" count as 0 only *inside* such a
+/// run, never as its first word. A lone digit word ("press one") is left to
+/// the cardinal grammar, as is "twenty five". The digits are concatenated,
+/// never summed, and a leading zero is kept — which is why this returns the
+/// string rather than a value. Also returns the last part index covered.
+fn en_digit_run(parts: &[String], i: usize) -> Option<(String, usize)> {
+    use crate::w2n_lang_en::unit_value;
+    let mut digits = String::new();
+    let mut end: Option<(usize, usize)> = None;
+    for (k, w) in en_number_words(parts, i).iter().enumerate() {
+        let d = match w.word.as_str() {
+            "oh" | "o" if k > 0 => 0,
+            "oh" | "o" | "nought" | "naught" => break,
+            other => match unit_value(other) {
+                Some(v) if v <= 9 => v,
+                _ => break,
+            },
+        };
+        digits.push(char::from(b'0' + d as u8));
+        if w.last {
+            end = Some((digits.len(), w.part));
+        }
+    }
+    let (len, part) = end?;
+    if len < 2 {
+        return None;
+    }
+    digits.truncate(len);
+    Some((digits, part))
+}
+
+/// A spoken year that is not one English cardinal: "nineteen" or "twenty"
+/// followed by "oh" + digit ("twenty oh five" = 2005), a teen ("twenty
+/// nineteen" = 2019), or a tens word with an optional unit ("nineteen ninety
+/// nine" = 1999, "twenty twenty" = 2020). This is the pair reading of
+/// `to="year"`, applied by the cardinal walk only when it reaches further
+/// than the cardinal did — so "twenty five" stays 25, and "two thousand
+/// twenty five" never comes here. Returns the year and the last part index.
+fn en_year_run(parts: &[String], i: usize) -> Option<(i64, usize)> {
+    use crate::w2n_lang_en::{tens_value, unit_value};
+    let words = en_number_words(parts, i);
+    let word = |k: usize| words.get(k).map(|w| w.word.as_str());
+    let century = match word(0)? {
+        "nineteen" => 1900,
+        "twenty" => 2000,
+        _ => return None,
+    };
+    let digit = |k: usize| unit_value(word(k)?).filter(|v| (1..=9).contains(v));
+    // Candidate readings as (word count, value); the longest one that ends
+    // on a part boundary wins.
+    let mut readings: Vec<(usize, i64)> = Vec::new();
+    let second = word(1)?;
+    if second == "oh" || second == "o" {
+        if let Some(u) = digit(2) {
+            readings.push((3, century + u));
+        }
+    } else if let Some(t) = unit_value(second).filter(|v| (10..=19).contains(v)) {
+        readings.push((2, century + t));
+    } else if let Some(t) = tens_value(second) {
+        readings.push((2, century + t));
+        if let Some(u) = digit(2) {
+            readings.push((3, century + t + u));
+        }
+    }
+    readings
+        .into_iter()
+        .rev()
+        .find(|&(n, _)| words[n - 1].last)
+        .map(|(n, year)| (year, words[n - 1].part))
+}
+
 /// `SentenceConverter.INCLUDABLE` — tokens allowed *inside* a run though they
 /// are not numbers. Keyed by the **resolved** code, so only exactly `"en"`
 /// gets them: `words2num_sentence(..., lang="en_IN")` resolves to `"en_IN"`
@@ -1004,6 +1137,11 @@ pub fn words2num_sentence(
         includable_for(&resolved)
     };
 
+    // The digit-string and spoken-year readings are English-only and belong
+    // to the cardinal walk: `to="year"` keeps its own pair reading, and any
+    // extra keyword argument fails every conversion (see `has_kwargs`).
+    let en_cardinal = matches!(converter, Converter::En) && to == "cardinal" && !has_kwargs;
+
     let parts = tokenize(sentence);
     let n = parts.len();
     let mut out = String::new();
@@ -1024,6 +1162,18 @@ pub fn words2num_sentence(
             continue;
         }
 
+        // A digit string read one digit at a time is concatenated, not
+        // summed: "four five six seven" is 4567, never 22.
+        if en_cardinal {
+            if let Some((digits, end)) = en_digit_run(&parts, i) {
+                let run = parts[i..=end].concat();
+                out.push_str(&digits);
+                out.push_str(trailing_punct(&run));
+                i = end + 1;
+                continue;
+            }
+        }
+
         // Grow a number run starting at i.
         let mut best_value: Option<W2nValue> = None;
         let mut best_end = i;
@@ -1055,6 +1205,18 @@ pub fn words2num_sentence(
             j += 1;
         }
 
+        // A spoken year outgrows the cardinal reading: "twenty twenty five"
+        // is the cardinal "twenty" and then a dangling "twenty five", but the
+        // year 2025.
+        if en_cardinal {
+            if let Some((year, end)) = en_year_run(&parts, i) {
+                if best_value.is_none() || end > best_end {
+                    best_value = Some(W2nValue::Int(BigInt::from(year)));
+                    best_end = end;
+                }
+            }
+        }
+
         if let Some(v) = best_value {
             // Preserve trailing punctuation that was stripped during parse.
             let run = parts[i..=best_end].concat();
@@ -2453,7 +2615,39 @@ mod digits_tests {
             s("sixty-one hundred Main Street", "en", "digits", false).unwrap(),
             "sixty-one hundred Main Street"
         );
-        // The old cardinal behaviour that motivated this: "two seven five" -> 14.
-        assert_eq!(s("Two seven five", "en", "cardinal", false).unwrap(), "14");
+        // The old cardinal behaviour that motivated this was "two seven five"
+        // -> 14; the cardinal walk now reads the digit string itself.
+        assert_eq!(s("Two seven five", "en", "cardinal", false).unwrap(), "275");
+    }
+
+    #[test]
+    fn cardinal_walk_reads_years_and_digit_strings() {
+        // Spoken years outgrow the cardinal reading.
+        assert_eq!(s("twenty twenty five", "en", "cardinal", false).unwrap(), "2025");
+        assert_eq!(s("nineteen ninety-nine", "en", "cardinal", false).unwrap(), "1999");
+        assert_eq!(s("twenty oh five", "en", "cardinal", false).unwrap(), "2005");
+        assert_eq!(
+            s("december one twenty twenty five.", "en", "cardinal", false).unwrap(),
+            "december 1 2025."
+        );
+        // Digit strings concatenate and keep a leading zero.
+        assert_eq!(
+            s("account ending in four five six seven", "en", "cardinal", false).unwrap(),
+            "account ending in 4567"
+        );
+        assert_eq!(s("zero six one two", "en", "cardinal", false).unwrap(), "0612");
+        // Valid cardinals and lone digits are untouched.
+        assert_eq!(s("twenty five people", "en", "cardinal", false).unwrap(), "25 people");
+        assert_eq!(s("press one", "en", "cardinal", false).unwrap(), "press 1");
+        assert_eq!(s("five twenty", "en", "cardinal", false).unwrap(), "5 20");
+        assert_eq!(s("two thousand twenty five", "en", "cardinal", false).unwrap(), "2025");
+        // `to="year"` keeps its own pair reading.
+        assert_eq!(s("twenty twenty five", "en", "year", false).unwrap(), "2025");
+        // es: the bare hundred prefix opens the run.
+        assert_eq!(
+            s("ciento cincuenta y cuatro dólares", "es", "cardinal", false).unwrap(),
+            "154 dólares"
+        );
+        assert_eq!(s("ciento uno", "es", "cardinal", false).unwrap(), "101");
     }
 }

{words2num2-0.3.2 → words2num2-0.3.3}/rust/words2num2-py/Cargo.toml

@@ -11,4 +11,4 @@ crate-type = ["cdylib"]
 words2num2-core = { path = "../words2num2-core" }
 num-bigint = "0.4"
 bigdecimal = "0.4"
-pyo3 = { version = "0.23", features = ["extension-module", "abi3-py38", "num-bigint"] }
+pyo3 = { version = "0.29", features = ["extension-module", "abi3-py38", "num-bigint"] }

{words2num2-0.3.2 → words2num2-0.3.3}/rust/words2num2-py/src/lib.rs

@@ -50,7 +50,7 @@ fn w2n_error_to_pyerr(py: Python<'_>, e: w2n_sentence::W2nError) -> PyErr {
 }
 
 /// `decimal.Decimal(s)` — rebuilds an exact `Decimal` from its `str()` form.
-fn make_decimal(py: Python<'_>, s: String) -> PyResult<PyObject> {
+fn make_decimal(py: Python<'_>, s: String) -> PyResult<Py<PyAny>> {
     let decimal = py.import("decimal")?.getattr("Decimal")?;
     Ok(decimal.call1((s,))?.unbind())
 }
@@ -58,7 +58,7 @@ fn make_decimal(py: Python<'_>, s: String) -> PyResult<PyObject> {
 /// Convert a `w2n_lang_en::W2nValue` (`int` / `float` / `Decimal`) to Python.
 /// `PyDec`'s `Display` is Python's `str(Decimal)`, so `Decimal(pydec.to_string())`
 /// reproduces the value (including a signed zero) exactly.
-fn en_value_to_py(py: Python<'_>, v: w2n_lang_en::W2nValue) -> PyResult<PyObject> {
+fn en_value_to_py(py: Python<'_>, v: w2n_lang_en::W2nValue) -> PyResult<Py<PyAny>> {
     use w2n_lang_en::W2nValue;
     match v {
         W2nValue::Int(i) => i.into_py_any(py),
@@ -69,7 +69,7 @@ fn en_value_to_py(py: Python<'_>, v: w2n_lang_en::W2nValue) -> PyResult<PyObject
 
 /// Convert a `w2n_formats::W2nValue` to Python. `parse_number_string` only ever
 /// yields `int` / `float`; the `Decimal` arm is here for completeness.
-fn formats_value_to_py(py: Python<'_>, v: w2n_formats::W2nValue) -> PyResult<PyObject> {
+fn formats_value_to_py(py: Python<'_>, v: w2n_formats::W2nValue) -> PyResult<Py<PyAny>> {
     use w2n_formats::W2nValue;
     match v {
         W2nValue::Int(i) => i.into_py_any(py),
@@ -79,7 +79,7 @@ fn formats_value_to_py(py: Python<'_>, v: w2n_formats::W2nValue) -> PyResult<PyO
 }
 
 /// Convert a `w2n_sentence::W2nValue` (`int` / `float` / `Decimal`) to Python.
-fn sentence_value_to_py(py: Python<'_>, v: &w2n_sentence::W2nValue) -> PyResult<PyObject> {
+fn sentence_value_to_py(py: Python<'_>, v: &w2n_sentence::W2nValue) -> PyResult<Py<PyAny>> {
     use w2n_sentence::W2nValue;
     match v {
         W2nValue::Int(i) => i.clone().into_py_any(py),
@@ -109,7 +109,7 @@ fn w2nvalue_from_py(obj: &Bound<'_, PyAny>) -> PyResult<w2n_sentence::W2nValue>
 /// Build a `words2num2.converters.auto.Quantity` from the core struct. The
 /// dataclass stays defined in Python (it is a public API type users import);
 /// only the parsing logic lives in the core.
-fn quantity_to_py(py: Python<'_>, q: w2n_sentence::Quantity) -> PyResult<PyObject> {
+fn quantity_to_py(py: Python<'_>, q: w2n_sentence::Quantity) -> PyResult<Py<PyAny>> {
     let value = sentence_value_to_py(py, &q.value)?;
     let cls = py
         .import("words2num2.converters.auto")?
@@ -164,7 +164,7 @@ fn parse_int(s: &str) -> PyResult<i64> {
 
 /// `_rust.en_to_cardinal(text)`.
 #[pyfunction]
-fn en_to_cardinal(py: Python<'_>, text: &str) -> PyResult<PyObject> {
+fn en_to_cardinal(py: Python<'_>, text: &str) -> PyResult<Py<PyAny>> {
     match words2num2_core::en_to_cardinal(text) {
         Ok(v) => en_value_to_py(py, v),
         Err(e) => Err(words2num_error(py, e.msg)),
@@ -173,7 +173,7 @@ fn en_to_cardinal(py: Python<'_>, text: &str) -> PyResult<PyObject> {
 
 /// `_rust.en_to_ordinal(text)`.
 #[pyfunction]
-fn en_to_ordinal(py: Python<'_>, text: &str) -> PyResult<PyObject> {
+fn en_to_ordinal(py: Python<'_>, text: &str) -> PyResult<Py<PyAny>> {
     match words2num2_core::en_to_ordinal(text) {
         Ok(v) => en_value_to_py(py, v),
         Err(e) => Err(words2num_error(py, e.msg)),
@@ -182,7 +182,7 @@ fn en_to_ordinal(py: Python<'_>, text: &str) -> PyResult<PyObject> {
 
 /// `_rust.en_to_year(text)`.
 #[pyfunction]
-fn en_to_year(py: Python<'_>, text: &str) -> PyResult<PyObject> {
+fn en_to_year(py: Python<'_>, text: &str) -> PyResult<Py<PyAny>> {
     match words2num2_core::en_to_year(text) {
         Ok(v) => en_value_to_py(py, v),
         Err(e) => Err(words2num_error(py, e.msg)),
@@ -198,7 +198,7 @@ fn parse_number_string(
     thousands_sep: Option<&str>,
     decimal_sep: Option<&str>,
     lang: Option<&str>,
-) -> PyResult<PyObject> {
+) -> PyResult<Py<PyAny>> {
     match w2n_formats::parse_number_string(s, thousands_sep, decimal_sep, lang) {
         Ok(v) => formats_value_to_py(py, v),
         Err(e) => Err(words2num_error(py, e.0)),
@@ -220,7 +220,7 @@ fn words2num(
     lang: &str,
     to: &str,
     kwargs: Option<Bound<'_, PyDict>>,
-) -> PyResult<PyObject> {
+) -> PyResult<Py<PyAny>> {
     if kwargs.as_ref().is_some_and(|d| !d.is_empty()) {
         return Err(PyTypeError::new_err(
             "words2num() got an unexpected keyword argument",
@@ -267,7 +267,7 @@ fn auto_parse(
     prefer: Option<HashMap<String, String>>,
     thousands_sep: Option<&str>,
     decimal_sep: Option<&str>,
-) -> PyResult<PyObject> {
+) -> PyResult<Py<PyAny>> {
     let prefer = prefer.unwrap_or_default();
     match w2n_sentence::auto_parse(text, lang, &prefer, thousands_sep, decimal_sep) {
         Ok(q) => quantity_to_py(py, q),

{words2num2-0.3.2 → words2num2-0.3.3}/words2num2/_version.py

@@ -1,5 +1,5 @@
 # Static version file. maturin (unlike setuptools_scm) does not regenerate
 # this; the release CI sets pyproject's version from the git tag, and this is
 # bumped alongside it so `words2num2.__version__` matches the wheel.
-__version__ = "0.3.0"
-__version_tuple__ = (0, 3, 0)
+__version__ = "0.3.3"
+__version_tuple__ = (0, 3, 3)