wordsnum 0.2.0__tar.gz

wordsnum-0.2.0/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

wordsnum-0.2.0/.github/FUNDING.yml

@@ -0,0 +1 @@
+buy_me_a_coffee: jlianesglrs

wordsnum-0.2.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/

wordsnum-0.2.0/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0]
+
+- Replace the word-summing parser with a real grammar. Behaviour change: malformed
+  input that 0.1.0 summed into a number is now rejected with `MisplacedWordError`, for
+  example "one two" (was 3), "one, two" (was 3), "and one" (was 1), "one and" (was 1)
+  and "thousand million".
+- Scales up to vigintillion (10**63), with ordinal forms.
+- Fractions ("three quarters", "a half", "seven hundredths", "three thirty-seconds")
+  and mixed numbers ("two and three quarters").
+- Decimals with a final scale word ("two point five million") and "oh" after "point".
+- Digit groups mixed with words ("3 million", "2,500", "1.5 billion", "21st", "-5").
+- `parse` returns a `ParsedNumber` with the exact value, kind and source span.
+- `words_to_fraction` and `words_to_decimal` return exact results.
+- `find_numbers` finds every number inside free text.
+- `num_to_words` spells integers in the canonical form, round-tripping with the parser.
+- `strict=True` accepts only the canonical spelling.
+- Typed errors `UnknownWordError` and `MisplacedWordError` carry `word`, `start` and `end`.
+- The `wordsnum` command line tool: `parse`, `find` and `say`.
+- GUIDE.md documents the full grammar and the unsupported forms.
+
+## [0.1.0]
+
+- First release.
+- `words_to_num` parses spelled-out English numbers into `int` or `float`.
+- Handles units, teens, tens, hundreds, and scales up to trillion.
+- Accepts "and", hyphenated words, articles ("a hundred"), ordinals, negatives, and decimals.
+- Raises `WordsNumError` with a clear message on unparseable input.

wordsnum-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing
+
+Thanks for taking the time. This project keeps a small, predictable shape.
+
+## Setup
+
+```
+pip install -r requirements-dev.txt
+```
+
+## Before you open a pull request
+
+- Keep public API in `src/wordsnum/__init__.py`; internals live in `_`-prefixed modules.
+- Add a test for the behaviour you change. Tests inject time, disk and network; they
+  never touch the real thing.
+- Run `scripts/check.ps1` (format, lint, types, tests) and make sure it passes.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

wordsnum-0.2.0/GUIDE.md

@@ -0,0 +1,141 @@
+# wordsnum guide
+
+This guide describes exactly what `wordsnum` accepts, how each form is read, and what
+it does not support.
+
+## Public API
+
+| Name | Returns | Purpose |
+| --- | --- | --- |
+| `words_to_num(text, *, strict=False)` | `int` or `float` | Quick conversion |
+| `parse(text, *, strict=False)` | `ParsedNumber` | Exact value, kind and span |
+| `words_to_fraction(text, *, strict=False)` | `Fraction` | Exact rational value |
+| `words_to_decimal(text, *, strict=False)` | `Decimal` | Exact decimal value |
+| `find_numbers(text)` | `list[ParsedNumber]` | Every number inside free text |
+| `num_to_words(n, *, ordinal=False, british=False)` | `str` | Spell an integer |
+| `ParsedNumber` | dataclass | `value`, `kind`, `text`, `start`, `end`, `number`, `to_decimal()` |
+| `Kind` | `Literal` | `"cardinal"`, `"ordinal"`, `"decimal"`, `"fraction"` |
+| `WordsNumError` | exception | Base error, a `ValueError` |
+| `UnknownWordError` | exception | A word that is not a number word |
+| `MisplacedWordError` | exception | A number word in a position the grammar rejects |
+
+Every error carries `word`, `start` and `end`, with `text[start:end] == word`, or
+`None` for all three when no single word is at fault (empty input).
+
+## Cardinals
+
+A cardinal is a sequence of groups, each below one thousand, joined by scale words in
+strictly decreasing order:
+
+- Units and teens: `zero` to `nineteen`. `zero` must stand alone.
+- Tens: `twenty` to `ninety`, optionally followed by a unit: `twenty-one`, `forty two`.
+- Hundreds: `one hundred`, `nine hundred ninety-nine`, `a hundred`.
+- Scales, short scale: `thousand` (10**3), `million`, `billion`, `trillion`,
+  `quadrillion`, `quintillion`, `sextillion`, `septillion`, `octillion`, `nonillion`,
+  `decillion` (10**33), `undecillion`, `duodecillion`, `tredecillion`,
+  `quattuordecillion`, `quindecillion`, `sexdecillion`, `septendecillion`,
+  `octodecillion`, `novemdecillion` and `vigintillion` (10**63).
+- A leading scale may drop its `one`: `hundred`, `thousand two hundred`.
+- `a`/`an` stands for one before `hundred` or a scale: `a thousand and one`.
+- Year style: a teen or tens word before `hundred` (`nineteen hundred eighty four`,
+  `twenty-five hundred`) is accepted when no other scale word appears.
+- British `and` is accepted after `hundred` (`one hundred and one`) and after a scale
+  before a final group below one hundred (`one thousand and five`). Anywhere else it is
+  an error.
+
+Rejected examples: `one two`, `thousand million`, `one thousand one million`,
+`zero hundred`, `one hundred hundred`, `one and two`.
+
+## Ordinals
+
+The last word may be an ordinal: `first`, `twelfth`, `twentieth`, `twenty-first`,
+`one hundred and third`, `hundredth`, `one millionth`, `decillionth`. Digit ordinals
+such as `21st`, `2nd`, `103rd` and `111th` work when the suffix is correct. Ordinals
+are never negative.
+
+## Decimals
+
+`point` is followed by one-digit words (`zero` to `nine`, or `oh`):
+`three point one four`, `point five`, `one point oh five`. One final scale word may
+follow the digits when the whole part is below a thousand: `two point five million`.
+Digit decimals also work: `3.14`, `1,234.5`, `1.5 billion`.
+
+## Fractions
+
+A numerator followed by a denominator word:
+
+- `half`/`halves`, `quarter`/`quarters`, and ordinal denominators such as `thirds`,
+  `fourths`, `hundredths`, `millionths`. A hyphenated compound also works:
+  `three thirty-seconds`, `a twenty-first`.
+- A numerator of one takes the singular (`a third`, `one half`); any other numerator
+  takes the plural (`two thirds`, `zero halves`).
+- `one` followed by a scale ordinal reads as an ordinal (`one hundredth` is the 100th);
+  use `a hundredth` for the fraction 1/100.
+- Mixed numbers: `one and a half`, `two and three quarters`. The reading after the last
+  `and` is used as a mixed number only when that fraction is proper, so
+  `one hundred and one third` is 100 1/3 while `two hundred and fifty thirds` is 250/3.
+- `first` and `second` are not denominators on their own (`two seconds` is not 2/2).
+- Scale denominators read greedily as one numerator: `three hundred thousandths` is
+  300/1000 and `three hundred and fifty thousandths` is 300 and 50/1000. Compound scale
+  denominators are not supported: `three hundred-thousandths` is also read as
+  300/1000, so write 3/100000 as a decimal (`zero point zero zero zero zero three`).
+
+## Signs and digits
+
+`minus` or `negative` may lead any cardinal, decimal or fraction, and a `-` written
+directly before leading digits is a sign too (`-5`, `-1.5 million`). Digit groups mix with
+words: `3 million`, `5 hundred`, `2,500`, `1 million two hundred`. A digit group after
+a scale must be below a thousand, and a digit decimal (`1.5`) may only start the
+number. Digits cannot follow a word inside a group (`twenty 5` and `one hundred 5` are
+rejected). Only ASCII digits are read, and runs longer than 1000 characters are not
+treated as numbers.
+
+## Strict and lenient
+
+Both modes accept the same grammar; they differ only in how the words may be written.
+Lenient mode, the default, ignores case, collapses whitespace and accepts hyphens and
+commas between words. Strict mode checks the written form: lowercase words, exactly
+one space between words, a hyphen exactly between a tens word and a unit word
+(`twenty-one`, `thirty-second`), no commas between words, no surrounding whitespace,
+and the article that matches the sound of the next word (`a hundred`, `an eighth`).
+Everything `num_to_words` writes passes strict mode. Grammatical variants such as
+`negative five`, `hundred`, `point five`, `2,500` or `twenty-five hundred` are valid in
+both modes. Neither mode corrects spelling.
+
+Spacing matters for compound denominators: `twenty-ninths` is a plural of 1/29 while
+`twenty ninths` is 20/9, and `three thirty-seconds` (3/32) needs its hyphen in both
+modes.
+
+## Finding numbers in text
+
+`find_numbers` scans free text, case-insensitively, and returns the longest valid
+reading at each position. Words that are also everyday words are reported as numbers:
+`no one` contains 1 and `just a second` contains the ordinal 2. A comma-separated list
+can merge when the words also form one number (`sixty, five, four` gives 65 and 4), and
+dotted strings such as version numbers are read as decimals. Filter by `kind` or by
+context when that matters. A decimal or fraction too large for a `float` makes
+`number` raise `WordsNumError`; `value` always holds the exact result.
+
+## Unsupported forms
+
+These are rejected rather than guessed:
+
+- `dozen`, `score`, `gross`, `half a million`, `one and a half million`.
+- Year style without `hundred`: `nineteen eighty four` (write `nineteen hundred eighty
+  four`); `find_numbers` reports it as 19 and 84.
+- Long-scale meanings (British `billion` as 10**12) and scales above vigintillion.
+- Spelling-error correction of any kind.
+- Roman numerals and other languages.
+- Spelling non-integers with `num_to_words`.
+
+## Command line
+
+```
+wordsnum parse WORDS... [--strict] [--exact] [--json]
+wordsnum find [--text TEXT] [--exact] [--json]     # reads stdin without --text
+wordsnum say NUMBER [--ordinal] [--british]
+```
+
+Without words, `parse` reads one number per non-empty stdin line. `--exact` prints
+`3/4` and `1.1` instead of floats. Errors are printed to stderr and the exit status
+is 1.

wordsnum-0.2.0/IMPROVEMENTS-round.md

@@ -0,0 +1,42 @@
+# Improvement round: ranked plan
+
+Ranked by value to users. Every item keeps the existing API working; new names are added
+alongside `words_to_num` and `WordsNumError`.
+
+1. **A real grammar instead of a running sum.** The 0.1 parser added words together, so
+   `"one two"` gave 3 and `"hundred thousand hundred"` gave a number. Replace it with a
+   grammar that checks word order: groups below a thousand, scales in strictly
+   decreasing order, `"and"` only where British usage puts it, `"zero"` only on its own.
+2. **Scales to vigintillion.** Short scale from thousand up to vigintillion (10**63),
+   with ordinal forms (`"millionth"`, `"decillionth"`). Covers "at least decillion".
+3. **Fractions.** `"three quarters"`, `"a half"`, `"two thirds"`, `"seven hundredths"`,
+   `"three thirty-seconds"`, and mixed numbers (`"two and three quarters"`).
+4. **Exact results.** `words_to_fraction` and `words_to_decimal` return `Fraction` and
+   `Decimal`, so `"one point one"` is exactly 11/10 and never a binary float.
+5. **Typed errors that point at the bad word.** `UnknownWordError` (not a number word)
+   and `MisplacedWordError` (a number word in the wrong place), both carrying `word`,
+   `start` and `end` offsets into the original text.
+6. **Strict and lenient modes.** Lenient (default) tolerates case, extra spacing,
+   hyphens and commas. Strict accepts only the canonical lowercase spelling. Neither
+   mode guesses typos.
+7. **Mixed digits and words.** `"3 million"`, `"1.5 billion"`, `"2,500"`, `"21st"`.
+8. **Decimals with a scale.** `"two point five million"`, and `"oh"` as a digit after
+   the point (`"one point oh five"`).
+9. **Finding numbers inside text.** `find_numbers` returns every number phrase in free
+   text with its span, value and kind, using the longest valid reading.
+10. **A structured result.** `parse` returns a `ParsedNumber` with the exact value, the
+    kind (`cardinal`, `ordinal`, `decimal`, `fraction`) and the source span.
+11. **The inverse for integers.** `num_to_words` spells an int (cardinal or ordinal,
+    American or British) in exactly the canonical form strict mode accepts, so the two
+    directions round-trip.
+12. **A command line tool.** `wordsnum parse`, `wordsnum find` (reads stdin) and
+    `wordsnum say`, with JSON output and errors on stderr.
+13. **Documentation.** Docstrings on every public name and a GUIDE covering the grammar,
+    the modes, the supported and unsupported forms.
+14. **Tests as contracts.** A contract test over every public promise, a seeded
+    round-trip against an independent spelling generator on thousands of numbers, and
+    an end-to-end test that builds the wheel, installs it into a fresh virtual
+    environment and drives the installed command.
+
+Out of scope, documented as unsupported: "dozen", "score", "half a million", long-scale
+billions, Roman numerals, spelling of non-integers, and guessing misspelled words.

wordsnum-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Lianes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wordsnum-0.2.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.5
+Name: wordsnum
+Version: 0.2.0
+Summary: Parse spelled-out English numbers into int or float, fully typed and dependency-free
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/wordsnum
+Project-URL: Issues, https://github.com/JaviLianes8/wordsnum/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/wordsnum/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# wordsnum
+
+Parse spelled-out English numbers into int or float, fully typed and dependency-free.
+
+## Install
+
+```
+pip install wordsnum
+```
+
+## Usage
+
+```python
+from wordsnum import words_to_num
+
+words_to_num("two hundred fifty")  # 250
+words_to_num("two thousand and twenty-one")  # 2021
+words_to_num("nineteen hundred eighty four")  # 1984
+words_to_num("a hundred")  # 100
+words_to_num("minus forty two")  # -42
+words_to_num("twenty-first")  # 21 (ordinals)
+words_to_num("three point one four")  # 3.14
+words_to_num("two point five million")  # 2500000.0
+words_to_num("two and three quarters")  # 2.75
+words_to_num("3 million")  # 3000000
+words_to_num("one decillion")  # 10**33
+```
+
+Cardinals and ordinals come back as `int`; decimals and fractions as `float`.
+
+### Exact values, kinds and spans
+
+```python
+from wordsnum import parse, words_to_decimal, words_to_fraction
+
+words_to_fraction("two thirds")  # Fraction(2, 3)
+words_to_decimal("one point one")  # Decimal('1.1')
+
+result = parse("  Seven Hundredths ")
+result.value  # Fraction(7, 100)
+result.kind  # 'fraction'  (also 'cardinal', 'ordinal', 'decimal')
+result.text, result.start, result.end  # ('Seven Hundredths', 2, 18)
+```
+
+### Numbers inside text
+
+```python
+from wordsnum import find_numbers
+
+for match in find_numbers("We sold twenty-one boxes, then 3 million more."):
+    print(match.start, match.end, match.number, match.text)
+# 8 18 21 twenty-one
+# 31 40 3000000 3 million
+```
+
+### Spelling integers
+
+```python
+from wordsnum import num_to_words
+
+num_to_words(1234)  # 'one thousand two hundred thirty-four'
+num_to_words(1005, british=True)  # 'one thousand and five'
+num_to_words(21, ordinal=True)  # 'twenty-first'
+```
+
+`num_to_words` writes exactly the canonical form that strict parsing accepts, so the
+two directions round-trip.
+
+### Strict and lenient
+
+By default case, extra spaces, hyphens and commas are tolerated. `strict=True` accepts
+only the canonical spelling (lowercase, single spaces, `twenty-one` hyphenated, no
+commas). Neither mode guesses typos: `"fourty"` is always an error.
+
+### Errors that point at the problem
+
+```python
+from wordsnum import MisplacedWordError, UnknownWordError, words_to_num
+
+try:
+    words_to_num("two hundred banana")
+except UnknownWordError as error:
+    print(error.word, error.start, error.end)  # banana 12 18
+
+try:
+    words_to_num("one thousand one million")
+except MisplacedWordError as error:
+    print(error)  # scale words must get smaller from left to right: 'million' at position 17
+```
+
+Both subclass `WordsNumError`, which subclasses `ValueError`.
+
+## Command line
+
+```
+wordsnum parse two thousand and twenty-one        # 2021
+wordsnum parse three quarters --exact             # 3/4
+echo "minus forty two" | wordsnum parse           # -42
+echo "I owe you twenty-one pounds" | wordsnum find
+wordsnum say 21 --ordinal                         # twenty-first
+```
+
+Run `wordsnum --help` for every option. Errors go to stderr with exit status 1.
+
+See [GUIDE.md](GUIDE.md) for the full grammar and the list of unsupported forms.
+
+## Why
+
+Turning words back into numbers is the reverse of spelling them out, and the existing
+options are thin. `word2number` has not seen a release since 2017, ships no type hints,
+and mishandles several common phrasings. `numerizer` is a port of a Ruby gem, is
+untyped, and returns strings rather than numbers. `text2num` is maintained but builds
+on a Rust extension, which is a heavy dependency for a small parsing job.
+
+`wordsnum` is a small, pure-Python parser with zero runtime dependencies, a `py.typed`
+marker, a clean `mypy --strict` build, a real grammar that rejects malformed input
+instead of summing words, and exact results when you need them.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

wordsnum-0.2.0/README.md

@@ -0,0 +1,127 @@
+# wordsnum
+
+Parse spelled-out English numbers into int or float, fully typed and dependency-free.
+
+## Install
+
+```
+pip install wordsnum
+```
+
+## Usage
+
+```python
+from wordsnum import words_to_num
+
+words_to_num("two hundred fifty")  # 250
+words_to_num("two thousand and twenty-one")  # 2021
+words_to_num("nineteen hundred eighty four")  # 1984
+words_to_num("a hundred")  # 100
+words_to_num("minus forty two")  # -42
+words_to_num("twenty-first")  # 21 (ordinals)
+words_to_num("three point one four")  # 3.14
+words_to_num("two point five million")  # 2500000.0
+words_to_num("two and three quarters")  # 2.75
+words_to_num("3 million")  # 3000000
+words_to_num("one decillion")  # 10**33
+```
+
+Cardinals and ordinals come back as `int`; decimals and fractions as `float`.
+
+### Exact values, kinds and spans
+
+```python
+from wordsnum import parse, words_to_decimal, words_to_fraction
+
+words_to_fraction("two thirds")  # Fraction(2, 3)
+words_to_decimal("one point one")  # Decimal('1.1')
+
+result = parse("  Seven Hundredths ")
+result.value  # Fraction(7, 100)
+result.kind  # 'fraction'  (also 'cardinal', 'ordinal', 'decimal')
+result.text, result.start, result.end  # ('Seven Hundredths', 2, 18)
+```
+
+### Numbers inside text
+
+```python
+from wordsnum import find_numbers
+
+for match in find_numbers("We sold twenty-one boxes, then 3 million more."):
+    print(match.start, match.end, match.number, match.text)
+# 8 18 21 twenty-one
+# 31 40 3000000 3 million
+```
+
+### Spelling integers
+
+```python
+from wordsnum import num_to_words
+
+num_to_words(1234)  # 'one thousand two hundred thirty-four'
+num_to_words(1005, british=True)  # 'one thousand and five'
+num_to_words(21, ordinal=True)  # 'twenty-first'
+```
+
+`num_to_words` writes exactly the canonical form that strict parsing accepts, so the
+two directions round-trip.
+
+### Strict and lenient
+
+By default case, extra spaces, hyphens and commas are tolerated. `strict=True` accepts
+only the canonical spelling (lowercase, single spaces, `twenty-one` hyphenated, no
+commas). Neither mode guesses typos: `"fourty"` is always an error.
+
+### Errors that point at the problem
+
+```python
+from wordsnum import MisplacedWordError, UnknownWordError, words_to_num
+
+try:
+    words_to_num("two hundred banana")
+except UnknownWordError as error:
+    print(error.word, error.start, error.end)  # banana 12 18
+
+try:
+    words_to_num("one thousand one million")
+except MisplacedWordError as error:
+    print(error)  # scale words must get smaller from left to right: 'million' at position 17
+```
+
+Both subclass `WordsNumError`, which subclasses `ValueError`.
+
+## Command line
+
+```
+wordsnum parse two thousand and twenty-one        # 2021
+wordsnum parse three quarters --exact             # 3/4
+echo "minus forty two" | wordsnum parse           # -42
+echo "I owe you twenty-one pounds" | wordsnum find
+wordsnum say 21 --ordinal                         # twenty-first
+```
+
+Run `wordsnum --help` for every option. Errors go to stderr with exit status 1.
+
+See [GUIDE.md](GUIDE.md) for the full grammar and the list of unsupported forms.
+
+## Why
+
+Turning words back into numbers is the reverse of spelling them out, and the existing
+options are thin. `word2number` has not seen a release since 2017, ships no type hints,
+and mishandles several common phrasings. `numerizer` is a port of a Ruby gem, is
+untyped, and returns strings rather than numbers. `text2num` is maintained but builds
+on a Rust extension, which is a heavy dependency for a small parsing job.
+
+`wordsnum` is a small, pure-Python parser with zero runtime dependencies, a `py.typed`
+marker, a clean `mypy --strict` build, a real grammar that rejects malformed input
+instead of summing words, and exact results when you need them.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

wordsnum-0.2.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "wordsnum"
+version = "0.2.0"
+description = "Parse spelled-out English numbers into int or float, fully typed and dependency-free"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Javier Lianes", email = "javier@lianes8studio.com" }]
+keywords = []
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["ruff", "mypy", "pytest", "build", "twine"]
+
+[project.scripts]
+wordsnum = "wordsnum._cli:main"
+
+[project.urls]
+Homepage = "https://lianes8studio.com"
+Repository = "https://github.com/JaviLianes8/wordsnum"
+Issues = "https://github.com/JaviLianes8/wordsnum/issues"
+Changelog = "https://github.com/JaviLianes8/wordsnum/blob/main/CHANGELOG.md"
+LinkedIn = "https://www.linkedin.com/in/jlianes/"
+Funding = "https://buymeacoffee.com/jlianesglrs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/wordsnum"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-q"

wordsnum-0.2.0/requirements-dev.txt

@@ -0,0 +1,3 @@
+# Development dependencies: the package in editable mode plus its dev extras
+# (ruff, mypy, pytest, build, twine). Install with:  pip install -r requirements-dev.txt
+-e .[dev]

wordsnum-0.2.0/scripts/check.ps1

@@ -0,0 +1,11 @@
+# Local quality gate. Run before every commit. No CI runs in the cloud.
+$ErrorActionPreference = "Stop"
+
+ruff format --check .
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+ruff check .
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+mypy --strict src
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+pytest
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }

wordsnum-0.2.0/scripts/release.ps1

@@ -0,0 +1,28 @@
+# Build and upload to PyPI. Run scripts/check.ps1 first.
+# The name must not already exist on PyPI; the token is read from a secret store, never git.
+$ErrorActionPreference = "Stop"
+
+# Works on both Windows PowerShell 5.1 and pwsh 7 (generic catch, no PS7-only types).
+$taken = $true
+try {
+    Invoke-WebRequest -UseBasicParsing "https://pypi.org/pypi/wordsnum/json" | Out-Null
+} catch {
+    if ($_.Exception.Response.StatusCode.value__ -eq 404) { $taken = $false } else { throw }
+}
+if ($taken) { throw "The name 'wordsnum' already exists on PyPI. Choose another before publishing." }
+
+$token = $env:PYPI_TOKEN
+if (-not $token -and (Test-Path "C:\secrets\pypi-token.txt")) {
+    $token = (Get-Content "C:\secrets\pypi-token.txt" -Raw).Trim()
+}
+if (-not $token) {
+    throw "No PyPI token. Set `$env:PYPI_TOKEN or save it to C:\secrets\pypi-token.txt (never commit it)."
+}
+
+Remove-Item -Recurse -Force dist -ErrorAction SilentlyContinue
+python -m build
+python -m twine check dist/*
+
+$env:TWINE_USERNAME = "__token__"
+$env:TWINE_PASSWORD = $token
+try { python -m twine upload dist/* } finally { Remove-Item Env:\TWINE_PASSWORD -ErrorAction SilentlyContinue }