unicode-rbnf 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (98) hide show
  1. unicode_rbnf/__init__.py +6 -0
  2. unicode_rbnf/engine.py +505 -0
  3. unicode_rbnf/py.typed +0 -0
  4. unicode_rbnf/rbnf/af.xml +109 -0
  5. unicode_rbnf/rbnf/ak.xml +74 -0
  6. unicode_rbnf/rbnf/am.xml +64 -0
  7. unicode_rbnf/rbnf/ar.xml +303 -0
  8. unicode_rbnf/rbnf/az.xml +113 -0
  9. unicode_rbnf/rbnf/be.xml +412 -0
  10. unicode_rbnf/rbnf/bg.xml +511 -0
  11. unicode_rbnf/rbnf/bs.xml +133 -0
  12. unicode_rbnf/rbnf/ca.xml +282 -0
  13. unicode_rbnf/rbnf/ccp.xml +67 -0
  14. unicode_rbnf/rbnf/chr.xml +69 -0
  15. unicode_rbnf/rbnf/cs.xml +142 -0
  16. unicode_rbnf/rbnf/cy.xml +120 -0
  17. unicode_rbnf/rbnf/da.xml +194 -0
  18. unicode_rbnf/rbnf/de.xml +237 -0
  19. unicode_rbnf/rbnf/de_CH.xml +230 -0
  20. unicode_rbnf/rbnf/ee.xml +109 -0
  21. unicode_rbnf/rbnf/el.xml +320 -0
  22. unicode_rbnf/rbnf/en.xml +206 -0
  23. unicode_rbnf/rbnf/en_001.xml +14 -0
  24. unicode_rbnf/rbnf/en_IN.xml +200 -0
  25. unicode_rbnf/rbnf/eo.xml +56 -0
  26. unicode_rbnf/rbnf/es.xml +323 -0
  27. unicode_rbnf/rbnf/es_419.xml +50 -0
  28. unicode_rbnf/rbnf/et.xml +55 -0
  29. unicode_rbnf/rbnf/fa.xml +70 -0
  30. unicode_rbnf/rbnf/fa_AF.xml +67 -0
  31. unicode_rbnf/rbnf/ff.xml +102 -0
  32. unicode_rbnf/rbnf/fi.xml +1408 -0
  33. unicode_rbnf/rbnf/fil.xml +74 -0
  34. unicode_rbnf/rbnf/fo.xml +128 -0
  35. unicode_rbnf/rbnf/fr.xml +239 -0
  36. unicode_rbnf/rbnf/fr_BE.xml +211 -0
  37. unicode_rbnf/rbnf/fr_CH.xml +212 -0
  38. unicode_rbnf/rbnf/ga.xml +241 -0
  39. unicode_rbnf/rbnf/he.xml +344 -0
  40. unicode_rbnf/rbnf/hi.xml +197 -0
  41. unicode_rbnf/rbnf/hr.xml +223 -0
  42. unicode_rbnf/rbnf/hu.xml +147 -0
  43. unicode_rbnf/rbnf/hy.xml +54 -0
  44. unicode_rbnf/rbnf/id.xml +62 -0
  45. unicode_rbnf/rbnf/is.xml +128 -0
  46. unicode_rbnf/rbnf/it.xml +629 -0
  47. unicode_rbnf/rbnf/ja.xml +98 -0
  48. unicode_rbnf/rbnf/ka.xml +80 -0
  49. unicode_rbnf/rbnf/kk.xml +126 -0
  50. unicode_rbnf/rbnf/kl.xml +86 -0
  51. unicode_rbnf/rbnf/km.xml +65 -0
  52. unicode_rbnf/rbnf/ko.xml +276 -0
  53. unicode_rbnf/rbnf/ky.xml +194 -0
  54. unicode_rbnf/rbnf/lb.xml +227 -0
  55. unicode_rbnf/rbnf/lo.xml +61 -0
  56. unicode_rbnf/rbnf/lrc.xml +70 -0
  57. unicode_rbnf/rbnf/lt.xml +124 -0
  58. unicode_rbnf/rbnf/lv.xml +98 -0
  59. unicode_rbnf/rbnf/mk.xml +109 -0
  60. unicode_rbnf/rbnf/ms.xml +67 -0
  61. unicode_rbnf/rbnf/mt.xml +264 -0
  62. unicode_rbnf/rbnf/my.xml +62 -0
  63. unicode_rbnf/rbnf/nb.xml +13 -0
  64. unicode_rbnf/rbnf/ne.xml +188 -0
  65. unicode_rbnf/rbnf/nl.xml +126 -0
  66. unicode_rbnf/rbnf/nn.xml +83 -0
  67. unicode_rbnf/rbnf/no.xml +347 -0
  68. unicode_rbnf/rbnf/pl.xml +438 -0
  69. unicode_rbnf/rbnf/pt.xml +212 -0
  70. unicode_rbnf/rbnf/pt_PT.xml +200 -0
  71. unicode_rbnf/rbnf/qu.xml +59 -0
  72. unicode_rbnf/rbnf/ro.xml +105 -0
  73. unicode_rbnf/rbnf/root.xml +724 -0
  74. unicode_rbnf/rbnf/ru.xml +1565 -0
  75. unicode_rbnf/rbnf/se.xml +51 -0
  76. unicode_rbnf/rbnf/sk.xml +97 -0
  77. unicode_rbnf/rbnf/sl.xml +145 -0
  78. unicode_rbnf/rbnf/sq.xml +79 -0
  79. unicode_rbnf/rbnf/sr.xml +165 -0
  80. unicode_rbnf/rbnf/sr_Latn.xml +166 -0
  81. unicode_rbnf/rbnf/su.xml +56 -0
  82. unicode_rbnf/rbnf/sv.xml +258 -0
  83. unicode_rbnf/rbnf/sw.xml +64 -0
  84. unicode_rbnf/rbnf/ta.xml +101 -0
  85. unicode_rbnf/rbnf/th.xml +61 -0
  86. unicode_rbnf/rbnf/tr.xml +108 -0
  87. unicode_rbnf/rbnf/uk.xml +139 -0
  88. unicode_rbnf/rbnf/vec.xml +423 -0
  89. unicode_rbnf/rbnf/vi.xml +80 -0
  90. unicode_rbnf/rbnf/yue.xml +191 -0
  91. unicode_rbnf/rbnf/yue_Hans.xml +192 -0
  92. unicode_rbnf/rbnf/zh.xml +286 -0
  93. unicode_rbnf/rbnf/zh_Hant.xml +252 -0
  94. unicode_rbnf-1.0.0.dist-info/LICENSE.md +21 -0
  95. unicode_rbnf-1.0.0.dist-info/METADATA +20 -0
  96. unicode_rbnf-1.0.0.dist-info/RECORD +98 -0
  97. unicode_rbnf-1.0.0.dist-info/WHEEL +5 -0
  98. unicode_rbnf-1.0.0.dist-info/top_level.txt +1 -0
@@ -0,0 +1,6 @@
1
+ from .engine import RbnfEngine, RulesetName
2
+
3
+ __all__ = [
4
+ "RbnfEngine",
5
+ "RulesetName",
6
+ ]
unicode_rbnf/engine.py ADDED
@@ -0,0 +1,505 @@
1
+ import logging
2
+ from abc import ABC
3
+ from bisect import bisect_left
4
+ from collections import defaultdict
5
+ from dataclasses import dataclass, field
6
+ from enum import Enum
7
+ from math import ceil, floor, isinf, isnan, log, modf
8
+ from pathlib import Path
9
+ from typing import Dict, Final, Iterable, List, Optional, Union
10
+ from xml.etree import ElementTree as et
11
+
12
+
13
+ class RulesetName(str, Enum):
14
+ """Names of common rulesets."""
15
+
16
+ DEFAULT = "spellout-numbering"
17
+ VERBOSE = "spellout-numbering-verbose"
18
+ CARDINAL = "spellout-cardinal"
19
+ CARDINAL_VERBOSE = "spellout-cardinal-verbose"
20
+ ORDINAL = "spellout-ordinal"
21
+ ORDINAL_VERBOSE = "spellout-ordinal-verbose"
22
+ YEAR = "spellout-numbering-year"
23
+
24
+
25
+ DEFAULT_LANGUAGE: Final = "en"
26
+ DEFAULT_TOLERANCE: Final = 1e-8
27
+ SKIP_RULESETS: Final = {"lenient-parse"}
28
+
29
+ _LANG_DIR = Path(__file__).parent / "rbnf"
30
+ _LOGGER = logging.getLogger()
31
+
32
+
33
+ class RbnfRulePart(ABC):
34
+ """Abstract base class for rule parts."""
35
+
36
+
37
+ @dataclass
38
+ class TextRulePart(RbnfRulePart):
39
+ """Literal text rule part."""
40
+
41
+ text: str
42
+ """Literal text to insert."""
43
+
44
+
45
+ class SubType(str, Enum):
46
+ """Type of substitution."""
47
+
48
+ REMAINER = "remainder"
49
+ """Use remainder for rule value."""
50
+
51
+ QUOTIENT = "quotient"
52
+ """Use quotient for rule value."""
53
+
54
+
55
+ @dataclass
56
+ class SubRulePart(RbnfRulePart):
57
+ """Substitution rule part."""
58
+
59
+ type: SubType
60
+ """Type of substitution."""
61
+
62
+ is_optional: bool = False
63
+ """True if substitution is optional."""
64
+
65
+ text_before: str = ""
66
+ """Text to insert before substitution."""
67
+
68
+ text_after: str = ""
69
+ """Text to insert after substitution."""
70
+
71
+ ruleset_name: Optional[str] = None
72
+ """Ruleset name to use during substitution (None for current ruleset name)."""
73
+
74
+
75
+ @dataclass
76
+ class ReplaceRulePart(RbnfRulePart):
77
+ """Replace with other ruleset (keep value)."""
78
+
79
+ ruleset_name: str
80
+ """Name of ruleset to use."""
81
+
82
+
83
+ class ParseState(str, Enum):
84
+ """Set of rbnf parser."""
85
+
86
+ TEXT = "text"
87
+ SUB_OPTIONAL_BEFORE = "optional_before"
88
+ SUB_OPTIONAL_AFTER = "optional_after"
89
+ SUB_REMAINER = "remainder"
90
+ SUB_QUOTIENT = "quotient"
91
+ SUB_RULESET_NAME = "sub_ruleset_name"
92
+ REPLACE_RULESET_NAME = "replace_ruleset_name"
93
+
94
+
95
+ class RbnfSpecialRule(str, Enum):
96
+ """Special rule types"""
97
+
98
+ NEGATIVE_NUMBER = "negative_number"
99
+ """The rule is a negative-number rule (-x)."""
100
+
101
+ NOT_A_NUMBER = "not_a_number"
102
+ """The rule for an IEEE 754 NaN (NaN)."""
103
+
104
+ INFINITY = "infinity"
105
+ """The rule for infinity (Inf)."""
106
+
107
+ IMPROPER_FRACTION = "improper_fraction"
108
+ """The rule for improper fractions (x.x)"""
109
+
110
+
111
+ @dataclass
112
+ class RbnfRule:
113
+ """Parsed rbnf rule."""
114
+
115
+ value: Union[int, RbnfSpecialRule]
116
+ """Numeric lookup value for rule."""
117
+
118
+ parts: List[RbnfRulePart] = field(default_factory=list)
119
+ """Parts of rule in order to be processed."""
120
+
121
+ radix: int = 10
122
+ """Radix used when calculating divisor."""
123
+
124
+ @staticmethod
125
+ def parse(value_str: str, text: str, radix: int = 10) -> "Optional[RbnfRule]":
126
+ """Parse RBNF rule for a value."""
127
+ # Handle special rules
128
+ if value_str == "-x":
129
+ rule = RbnfRule(value=RbnfSpecialRule.NEGATIVE_NUMBER)
130
+ elif value_str == "x.x":
131
+ rule = RbnfRule(value=RbnfSpecialRule.IMPROPER_FRACTION)
132
+ elif value_str == "NaN":
133
+ rule = RbnfRule(value=RbnfSpecialRule.NOT_A_NUMBER)
134
+ elif value_str == "Inf":
135
+ rule = RbnfRule(value=RbnfSpecialRule.INFINITY)
136
+ else:
137
+ try:
138
+ rule = RbnfRule(value=int(value_str), radix=radix)
139
+ except ValueError:
140
+ _LOGGER.error(
141
+ "Unrecognized special rule: value=%s, text=%s", value_str, text
142
+ )
143
+ return None
144
+
145
+ state = ParseState.TEXT
146
+ part: Optional[RbnfRulePart] = None
147
+ is_sub_optional = False
148
+ sub_text_before = ""
149
+
150
+ for c in text:
151
+ if c == ";":
152
+ # End of rule text
153
+ break
154
+
155
+ if c == "'":
156
+ # Placeholder
157
+ continue
158
+
159
+ if c in (">", "→"):
160
+ # Divide the number by the rule's divisor and format the remainder
161
+ if state in {ParseState.TEXT, ParseState.SUB_OPTIONAL_BEFORE}:
162
+ state = ParseState.SUB_REMAINER
163
+ part = SubRulePart(
164
+ SubType.REMAINER,
165
+ is_optional=is_sub_optional,
166
+ text_before=sub_text_before,
167
+ )
168
+ rule.parts.append(part)
169
+ sub_text_before = ""
170
+ elif state in {ParseState.SUB_REMAINER, ParseState.SUB_RULESET_NAME}:
171
+ if is_sub_optional:
172
+ state = ParseState.SUB_OPTIONAL_AFTER
173
+ else:
174
+ state = ParseState.TEXT
175
+ part = None
176
+ else:
177
+ raise ValueError(f"Got {c} in {state}")
178
+ elif c in ("<", "←"):
179
+ # Divide the number by the rule's divisor and format the quotient
180
+ if state in {ParseState.TEXT, ParseState.SUB_OPTIONAL_BEFORE}:
181
+ state = ParseState.SUB_QUOTIENT
182
+ part = SubRulePart(SubType.QUOTIENT, is_optional=is_sub_optional)
183
+ rule.parts.append(part)
184
+ elif state in {ParseState.SUB_QUOTIENT, ParseState.SUB_RULESET_NAME}:
185
+ if is_sub_optional:
186
+ state = ParseState.SUB_OPTIONAL_AFTER
187
+ else:
188
+ state = ParseState.TEXT
189
+ part = None
190
+ else:
191
+ raise ValueError(f"Got {c} in {state}")
192
+ elif c == "%":
193
+ # =%rule_name= replacement
194
+ if state in {ParseState.SUB_QUOTIENT, ParseState.SUB_REMAINER}:
195
+ assert isinstance(part, SubRulePart)
196
+ state = ParseState.SUB_RULESET_NAME
197
+ part.ruleset_name = ""
198
+ elif state in {
199
+ ParseState.REPLACE_RULESET_NAME,
200
+ ParseState.SUB_RULESET_NAME,
201
+ }:
202
+ pass
203
+ else:
204
+ raise ValueError(f"Got {c} in {state}")
205
+ elif c == "[":
206
+ # [optional] (start)
207
+ if state == ParseState.TEXT:
208
+ is_sub_optional = True
209
+ state = ParseState.SUB_OPTIONAL_BEFORE
210
+ sub_text_before = ""
211
+ else:
212
+ raise ValueError(f"Got {c} in {state}")
213
+ elif c == "]":
214
+ # [optional] (end)
215
+ if state == ParseState.SUB_OPTIONAL_AFTER:
216
+ is_sub_optional = False
217
+ state = ParseState.TEXT
218
+ part = None
219
+ else:
220
+ raise ValueError(f"Got {c} in {state}")
221
+ elif c == "=":
222
+ # =%rule_name= replacement
223
+ if state == ParseState.TEXT:
224
+ part = ReplaceRulePart("")
225
+ rule.parts.append(part)
226
+ state = ParseState.REPLACE_RULESET_NAME
227
+ elif state == ParseState.REPLACE_RULESET_NAME:
228
+ part = None
229
+ state = ParseState.TEXT
230
+ else:
231
+ raise ValueError(f"Got {c} in {state}")
232
+ elif state == ParseState.SUB_OPTIONAL_BEFORE:
233
+ # [before ...]
234
+ sub_text_before += c
235
+ elif state == ParseState.SUB_OPTIONAL_AFTER:
236
+ # [... after]
237
+ assert isinstance(part, SubRulePart)
238
+ part.text_after += c
239
+ elif state == ParseState.SUB_RULESET_NAME:
240
+ # %ruleset_name in << or >>
241
+ assert isinstance(part, SubRulePart)
242
+ assert part.ruleset_name is not None
243
+ part.ruleset_name += c
244
+ elif state == ParseState.REPLACE_RULESET_NAME:
245
+ # =%ruleset_name=
246
+ assert isinstance(part, ReplaceRulePart)
247
+ part.ruleset_name += c
248
+ elif state == ParseState.TEXT:
249
+ # literal text
250
+ if part is None:
251
+ part = TextRulePart("")
252
+ rule.parts.append(part)
253
+
254
+ assert isinstance(part, TextRulePart)
255
+ part.text += c
256
+ else:
257
+ raise ValueError(f"Got {c} in {state}")
258
+
259
+ return rule
260
+
261
+
262
+ @dataclass
263
+ class RbnfRuleSet:
264
+ """Named collection of rbnf rules."""
265
+
266
+ name: str
267
+ """Name of ruleset."""
268
+
269
+ numeric_rules: Dict[int, RbnfRule] = field(default_factory=dict)
270
+ """Rules keyed by lookup number."""
271
+
272
+ special_rules: Dict[RbnfSpecialRule, RbnfRule] = field(default_factory=dict)
273
+ """Rules keyed by special rule type."""
274
+
275
+ _sorted_numbers: Optional[List[int]] = field(default=None)
276
+ """Sorted list of numeric_rules keys (updated on demand)."""
277
+
278
+ def update(self) -> None:
279
+ """Force update to sorted key list."""
280
+ self._sorted_numbers = sorted(self.numeric_rules.keys())
281
+
282
+ def find_rule(
283
+ self, number: float, tolerance: float = DEFAULT_TOLERANCE
284
+ ) -> Optional[RbnfRule]:
285
+ """Look up closest rule by number."""
286
+
287
+ # Special rules
288
+ if number < 0:
289
+ return self.special_rules.get(RbnfSpecialRule.NEGATIVE_NUMBER)
290
+
291
+ if isnan(number):
292
+ return self.special_rules.get(RbnfSpecialRule.NOT_A_NUMBER)
293
+
294
+ if isinf(number):
295
+ return self.special_rules.get(RbnfSpecialRule.INFINITY)
296
+
297
+ if (number - int(number)) > DEFAULT_TOLERANCE:
298
+ return self.special_rules.get(RbnfSpecialRule.IMPROPER_FRACTION)
299
+
300
+ # Numeric rules
301
+ number_int = int(number)
302
+ if (self._sorted_numbers is None) or (
303
+ len(self._sorted_numbers) != len(self.numeric_rules)
304
+ ):
305
+ self.update()
306
+
307
+ assert self._sorted_numbers is not None
308
+
309
+ # Find index of place where number would be inserted
310
+ index = bisect_left(self._sorted_numbers, number_int)
311
+ num_rules = len(self._sorted_numbers)
312
+
313
+ if index >= num_rules:
314
+ # Last rule
315
+ index = num_rules - 1
316
+ elif index < 0:
317
+ # First rule
318
+ index = 0
319
+
320
+ rule_number = self._sorted_numbers[index]
321
+ if number_int < rule_number:
322
+ # Not an exact match, use one rule down
323
+ index = max(0, index - 1)
324
+ rule_number = self._sorted_numbers[index]
325
+
326
+ return self.numeric_rules.get(rule_number)
327
+
328
+
329
+ class RbnfEngine:
330
+ """Formatting engine using rbnf."""
331
+
332
+ def __init__(self, language: Optional[str] = None) -> None:
333
+ # Default language
334
+ self.language = language
335
+
336
+ # lang -> ruleset name -> ruleset
337
+ self.rulesets: Dict[str, Dict[str, RbnfRuleSet]] = defaultdict(dict)
338
+
339
+ @staticmethod
340
+ def for_language(language: str) -> "RbnfEngine":
341
+ """Load XML rules for a language and construct an engine."""
342
+ xml_path = _LANG_DIR / f"{language}.xml"
343
+ if not xml_path.is_file():
344
+ raise ValueError(f"{language} is not supported")
345
+
346
+ engine = RbnfEngine(language=language)
347
+ with open(xml_path, "r", encoding="utf-8") as xml_file:
348
+ root = et.fromstring(xml_file.read())
349
+ engine.load_xml(root)
350
+
351
+ return engine
352
+
353
+ def add_rule(
354
+ self,
355
+ value_str: str,
356
+ rule_text: str,
357
+ radix: int = 10,
358
+ ruleset_name: Optional[str] = None,
359
+ language: Optional[str] = None,
360
+ ) -> Optional[RbnfRule]:
361
+ """Manually add a rule to the engine."""
362
+ language = language or self.language or DEFAULT_LANGUAGE
363
+ ruleset_name = ruleset_name or RulesetName.DEFAULT
364
+
365
+ ruleset = self.rulesets[language].get(ruleset_name)
366
+ if ruleset is None:
367
+ ruleset = RbnfRuleSet(name=ruleset_name)
368
+ self.rulesets[language][ruleset_name] = ruleset
369
+
370
+ rule = RbnfRule.parse(value_str, rule_text, radix=radix)
371
+ if rule is None:
372
+ return rule
373
+
374
+ if isinstance(rule.value, RbnfSpecialRule):
375
+ # Special rule
376
+ ruleset.special_rules[rule.value] = rule
377
+ else:
378
+ # Numeric rule
379
+ ruleset.numeric_rules[rule.value] = rule
380
+
381
+ return rule
382
+
383
+ def load_xml(self, root: et.Element, language: Optional[str] = None) -> None:
384
+ """Load an XML file with rbnf rules."""
385
+ if language is None:
386
+ lang_elem = root.find("identity/language")
387
+ language = (
388
+ lang_elem.attrib["type"] if lang_elem is not None else DEFAULT_LANGUAGE
389
+ )
390
+
391
+ for group_elem in root.findall("rbnf//ruleset"):
392
+ ruleset_name = group_elem.attrib["type"]
393
+ if ruleset_name in SKIP_RULESETS:
394
+ _LOGGER.debug("Skipping ruleset: %s", ruleset_name)
395
+ continue
396
+
397
+ for rule_elem in group_elem.findall("rbnfrule"):
398
+ if not rule_elem.text:
399
+ continue
400
+
401
+ value_str = rule_elem.attrib["value"]
402
+ radix = int(rule_elem.attrib.get("radix", 10))
403
+
404
+ self.add_rule(
405
+ value_str,
406
+ rule_elem.text,
407
+ radix=radix,
408
+ ruleset_name=ruleset_name,
409
+ language=language,
410
+ )
411
+
412
+ def format_number(
413
+ self,
414
+ number: float,
415
+ ruleset_name: Optional[str] = None,
416
+ radix: Optional[int] = None,
417
+ language: Optional[str] = None,
418
+ tolerance: float = DEFAULT_TOLERANCE,
419
+ ) -> str:
420
+ """Format a number using loaded rulesets."""
421
+ return "".join(
422
+ self.iter_format_number(
423
+ number,
424
+ ruleset_name=ruleset_name,
425
+ language=language,
426
+ tolerance=tolerance,
427
+ )
428
+ )
429
+
430
+ def iter_format_number(
431
+ self,
432
+ number: float,
433
+ ruleset_name: Optional[str] = None,
434
+ radix: Optional[int] = None,
435
+ language: Optional[str] = None,
436
+ tolerance: float = DEFAULT_TOLERANCE,
437
+ ) -> Iterable[str]:
438
+ """Format a number using loaded rulesets (generator)."""
439
+ language = language or self.language or DEFAULT_LANGUAGE
440
+ ruleset_name = ruleset_name or RulesetName.DEFAULT
441
+
442
+ ruleset = self.rulesets[language].get(ruleset_name)
443
+ if ruleset is None:
444
+ raise ValueError(f"No ruleset: {ruleset_name}")
445
+
446
+ rule = ruleset.find_rule(number, tolerance=tolerance)
447
+ if rule is None:
448
+ raise ValueError(f"No rule for {number} in {ruleset_name}")
449
+
450
+ q: int = 0
451
+ r: int = 0
452
+
453
+ if isinstance(rule.value, RbnfSpecialRule):
454
+ if rule.value == RbnfSpecialRule.NEGATIVE_NUMBER:
455
+ r = int(-number)
456
+ elif rule.value == RbnfSpecialRule.IMPROPER_FRACTION:
457
+ frac_part, int_part = modf(number)
458
+ q = int(int_part)
459
+ r = fractional_to_int(frac_part * 10, tolerance=tolerance)
460
+ elif rule.value in {RbnfSpecialRule.NOT_A_NUMBER, RbnfSpecialRule.INFINITY}:
461
+ # Should just be text substitutions
462
+ pass
463
+ else:
464
+ _LOGGER.warning("Unhandled special rule: %s", rule.value)
465
+ elif rule.value > 0:
466
+ power_below = rule.radix ** int(floor(log(rule.value, rule.radix)))
467
+ power_above = rule.radix ** int(ceil(log(rule.value, rule.radix)))
468
+ divisor = power_above if (number >= power_above) else power_below
469
+ q, r = divmod(number, divisor)
470
+
471
+ for part in rule.parts:
472
+ if isinstance(part, TextRulePart):
473
+ if part.text:
474
+ yield part.text
475
+ elif isinstance(part, SubRulePart):
476
+ if (part.type == SubType.QUOTIENT) and (q > 0):
477
+ if part.text_before:
478
+ yield part.text_before
479
+ yield from self.iter_format_number(
480
+ q, ruleset_name=part.ruleset_name or ruleset_name
481
+ )
482
+ if part.text_after:
483
+ yield part.text_after
484
+ elif (part.type == SubType.REMAINER) and (r > 0):
485
+ if part.text_before:
486
+ yield part.text_before
487
+ yield from self.iter_format_number(
488
+ r, ruleset_name=part.ruleset_name or ruleset_name
489
+ )
490
+ if part.text_after:
491
+ yield part.text_after
492
+ elif isinstance(part, ReplaceRulePart):
493
+ yield from self.iter_format_number(
494
+ number, ruleset_name=part.ruleset_name
495
+ )
496
+
497
+
498
+ def fractional_to_int(frac_part: float, tolerance: float = DEFAULT_TOLERANCE) -> int:
499
+ """Convert fractional part to int like 0.14000000000000012 -> 14"""
500
+ frac_int = int(frac_part)
501
+
502
+ if (frac_part - frac_int) > tolerance:
503
+ return fractional_to_int(frac_part * 10, tolerance=tolerance)
504
+
505
+ return frac_int
unicode_rbnf/py.typed ADDED
File without changes
@@ -0,0 +1,109 @@
1
+ <?xml version="1.0" encoding="UTF-8" ?>
2
+ <!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
3
+ <!--
4
+ Copyright © 1991-2013 Unicode, Inc.
5
+ CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
6
+ For terms of use, see http://www.unicode.org/copyright.html
7
+ -->
8
+ <ldml>
9
+ <identity>
10
+ <version number="$Revision$"/>
11
+ <language type="af"/>
12
+ </identity>
13
+ <rbnf>
14
+ <rulesetGrouping type="SpelloutRules">
15
+ <ruleset type="2d-year" access="private">
16
+ <rbnfrule value="0">honderd[ →%spellout-numbering→];</rbnfrule>
17
+ <rbnfrule value="1">nul =%spellout-numbering=;</rbnfrule>
18
+ <rbnfrule value="10">=%spellout-numbering=;</rbnfrule>
19
+ </ruleset>
20
+ <ruleset type="spellout-numbering-year">
21
+ <rbnfrule value="-x">min →→;</rbnfrule>
22
+ <rbnfrule value="x.x">=0.0=;</rbnfrule>
23
+ <rbnfrule value="0">=%spellout-numbering=;</rbnfrule>
24
+ <rbnfrule value="1100" radix="100">←← →%%2d-year→;</rbnfrule>
25
+ <rbnfrule value="10000">=%spellout-numbering=;</rbnfrule>
26
+ </ruleset>
27
+ <ruleset type="spellout-numbering">
28
+ <rbnfrule value="0">=%spellout-cardinal=;</rbnfrule>
29
+ </ruleset>
30
+ <ruleset type="spellout-cardinal">
31
+ <rbnfrule value="-x">min →→;</rbnfrule>
32
+ <rbnfrule value="x.x">←← komma →→;</rbnfrule>
33
+ <rbnfrule value="0">nul;</rbnfrule>
34
+ <rbnfrule value="1">een;</rbnfrule>
35
+ <rbnfrule value="2">twee;</rbnfrule>
36
+ <rbnfrule value="3">drie;</rbnfrule>
37
+ <rbnfrule value="4">vier;</rbnfrule>
38
+ <rbnfrule value="5">vyf;</rbnfrule>
39
+ <rbnfrule value="6">ses;</rbnfrule>
40
+ <rbnfrule value="7">sewe;</rbnfrule>
41
+ <rbnfrule value="8">agt;</rbnfrule>
42
+ <rbnfrule value="9">nege;</rbnfrule>
43
+ <rbnfrule value="10">tien;</rbnfrule>
44
+ <rbnfrule value="11">elf;</rbnfrule>
45
+ <rbnfrule value="12">twaalf;</rbnfrule>
46
+ <rbnfrule value="13">dertien;</rbnfrule>
47
+ <rbnfrule value="14">veertien;</rbnfrule>
48
+ <rbnfrule value="15">vyftien;</rbnfrule>
49
+ <rbnfrule value="16">sestien;</rbnfrule>
50
+ <rbnfrule value="17">sewentien;</rbnfrule>
51
+ <rbnfrule value="18">agttien;</rbnfrule>
52
+ <rbnfrule value="19">negentien;</rbnfrule>
53
+ <rbnfrule value="20">[→→-en-]twintig;</rbnfrule>
54
+ <rbnfrule value="30">[→→-en-]dertig;</rbnfrule>
55
+ <rbnfrule value="40">[→→-en-]veertig;</rbnfrule>
56
+ <rbnfrule value="50">[→→-en-]vyftig;</rbnfrule>
57
+ <rbnfrule value="60">[→→-en-]sestig;</rbnfrule>
58
+ <rbnfrule value="70">[→→-en-]sewentig;</rbnfrule>
59
+ <rbnfrule value="80">[→→-en-]tagtig;</rbnfrule>
60
+ <rbnfrule value="90">[→→-en-]negentig;</rbnfrule>
61
+ <rbnfrule value="100">honderd[ →→];</rbnfrule>
62
+ <rbnfrule value="200">←←honderd[ →→];</rbnfrule>
63
+ <rbnfrule value="1000">duisend[ →→];</rbnfrule>
64
+ <rbnfrule value="2000">←←­duisend[ →→];</rbnfrule>
65
+ <rbnfrule value="21000" radix="1000">←← duisend[ →→];</rbnfrule>
66
+ <rbnfrule value="1000000">←← miljoen[ →→];</rbnfrule>
67
+ <rbnfrule value="1000000000">←← miljard[ →→];</rbnfrule>
68
+ <rbnfrule value="1000000000000">←← biljoen[ →→];</rbnfrule>
69
+ <rbnfrule value="1000000000000000">←← biljard[ →→];</rbnfrule>
70
+ <rbnfrule value="1000000000000000000">=#,##0=;</rbnfrule>
71
+ </ruleset>
72
+ <ruleset type="ord-ste" access="private">
73
+ <rbnfrule value="0">ste;</rbnfrule>
74
+ <rbnfrule value="1">' en =%spellout-ordinal=;</rbnfrule>
75
+ <rbnfrule value="2">' =%spellout-ordinal=;</rbnfrule>
76
+ </ruleset>
77
+ <ruleset type="spellout-ordinal">
78
+ <rbnfrule value="-x">min →→;</rbnfrule>
79
+ <rbnfrule value="x.x">=#,##0.#=;</rbnfrule>
80
+ <rbnfrule value="0">nulste;</rbnfrule>
81
+ <rbnfrule value="1">eerste;</rbnfrule>
82
+ <rbnfrule value="2">tweede;</rbnfrule>
83
+ <rbnfrule value="3">derde;</rbnfrule>
84
+ <rbnfrule value="4">=%spellout-numbering=de;</rbnfrule>
85
+ <rbnfrule value="20">=%spellout-numbering=ste;</rbnfrule>
86
+ <rbnfrule value="102">←%spellout-numbering← honderd→%%ord-ste→;</rbnfrule>
87
+ <rbnfrule value="1000">←%spellout-numbering← duisend→%%ord-ste→;</rbnfrule>
88
+ <rbnfrule value="1000000">←%spellout-numbering← miljoen→%%ord-ste→;</rbnfrule>
89
+ <rbnfrule value="1000000000">←%spellout-numbering← miljard→%%ord-ste→;</rbnfrule>
90
+ <rbnfrule value="1000000000000">←%spellout-numbering← biljoen→%%ord-ste→;</rbnfrule>
91
+ <rbnfrule value="1000000000000000">←%spellout-numbering← biljard→%%ord-ste→;</rbnfrule>
92
+ <rbnfrule value="1000000000000000000">=#,##0=.;</rbnfrule>
93
+ </ruleset>
94
+ </rulesetGrouping>
95
+ <rulesetGrouping type="OrdinalRules">
96
+ <ruleset type="digits-ordinal-indicator" access="private">
97
+ <rbnfrule value="0">ste;</rbnfrule>
98
+ <rbnfrule value="1">ste;</rbnfrule>
99
+ <rbnfrule value="2">de;</rbnfrule>
100
+ <rbnfrule value="20">ste;</rbnfrule>
101
+ <rbnfrule value="100">→→;</rbnfrule>
102
+ </ruleset>
103
+ <ruleset type="digits-ordinal">
104
+ <rbnfrule value="-x">−→→;</rbnfrule>
105
+ <rbnfrule value="0">=#,##0==%%digits-ordinal-indicator=;</rbnfrule>
106
+ </ruleset>
107
+ </rulesetGrouping>
108
+ </rbnf>
109
+ </ldml>