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.
- unicode_rbnf/__init__.py +6 -0
- unicode_rbnf/engine.py +505 -0
- unicode_rbnf/py.typed +0 -0
- unicode_rbnf/rbnf/af.xml +109 -0
- unicode_rbnf/rbnf/ak.xml +74 -0
- unicode_rbnf/rbnf/am.xml +64 -0
- unicode_rbnf/rbnf/ar.xml +303 -0
- unicode_rbnf/rbnf/az.xml +113 -0
- unicode_rbnf/rbnf/be.xml +412 -0
- unicode_rbnf/rbnf/bg.xml +511 -0
- unicode_rbnf/rbnf/bs.xml +133 -0
- unicode_rbnf/rbnf/ca.xml +282 -0
- unicode_rbnf/rbnf/ccp.xml +67 -0
- unicode_rbnf/rbnf/chr.xml +69 -0
- unicode_rbnf/rbnf/cs.xml +142 -0
- unicode_rbnf/rbnf/cy.xml +120 -0
- unicode_rbnf/rbnf/da.xml +194 -0
- unicode_rbnf/rbnf/de.xml +237 -0
- unicode_rbnf/rbnf/de_CH.xml +230 -0
- unicode_rbnf/rbnf/ee.xml +109 -0
- unicode_rbnf/rbnf/el.xml +320 -0
- unicode_rbnf/rbnf/en.xml +206 -0
- unicode_rbnf/rbnf/en_001.xml +14 -0
- unicode_rbnf/rbnf/en_IN.xml +200 -0
- unicode_rbnf/rbnf/eo.xml +56 -0
- unicode_rbnf/rbnf/es.xml +323 -0
- unicode_rbnf/rbnf/es_419.xml +50 -0
- unicode_rbnf/rbnf/et.xml +55 -0
- unicode_rbnf/rbnf/fa.xml +70 -0
- unicode_rbnf/rbnf/fa_AF.xml +67 -0
- unicode_rbnf/rbnf/ff.xml +102 -0
- unicode_rbnf/rbnf/fi.xml +1408 -0
- unicode_rbnf/rbnf/fil.xml +74 -0
- unicode_rbnf/rbnf/fo.xml +128 -0
- unicode_rbnf/rbnf/fr.xml +239 -0
- unicode_rbnf/rbnf/fr_BE.xml +211 -0
- unicode_rbnf/rbnf/fr_CH.xml +212 -0
- unicode_rbnf/rbnf/ga.xml +241 -0
- unicode_rbnf/rbnf/he.xml +344 -0
- unicode_rbnf/rbnf/hi.xml +197 -0
- unicode_rbnf/rbnf/hr.xml +223 -0
- unicode_rbnf/rbnf/hu.xml +147 -0
- unicode_rbnf/rbnf/hy.xml +54 -0
- unicode_rbnf/rbnf/id.xml +62 -0
- unicode_rbnf/rbnf/is.xml +128 -0
- unicode_rbnf/rbnf/it.xml +629 -0
- unicode_rbnf/rbnf/ja.xml +98 -0
- unicode_rbnf/rbnf/ka.xml +80 -0
- unicode_rbnf/rbnf/kk.xml +126 -0
- unicode_rbnf/rbnf/kl.xml +86 -0
- unicode_rbnf/rbnf/km.xml +65 -0
- unicode_rbnf/rbnf/ko.xml +276 -0
- unicode_rbnf/rbnf/ky.xml +194 -0
- unicode_rbnf/rbnf/lb.xml +227 -0
- unicode_rbnf/rbnf/lo.xml +61 -0
- unicode_rbnf/rbnf/lrc.xml +70 -0
- unicode_rbnf/rbnf/lt.xml +124 -0
- unicode_rbnf/rbnf/lv.xml +98 -0
- unicode_rbnf/rbnf/mk.xml +109 -0
- unicode_rbnf/rbnf/ms.xml +67 -0
- unicode_rbnf/rbnf/mt.xml +264 -0
- unicode_rbnf/rbnf/my.xml +62 -0
- unicode_rbnf/rbnf/nb.xml +13 -0
- unicode_rbnf/rbnf/ne.xml +188 -0
- unicode_rbnf/rbnf/nl.xml +126 -0
- unicode_rbnf/rbnf/nn.xml +83 -0
- unicode_rbnf/rbnf/no.xml +347 -0
- unicode_rbnf/rbnf/pl.xml +438 -0
- unicode_rbnf/rbnf/pt.xml +212 -0
- unicode_rbnf/rbnf/pt_PT.xml +200 -0
- unicode_rbnf/rbnf/qu.xml +59 -0
- unicode_rbnf/rbnf/ro.xml +105 -0
- unicode_rbnf/rbnf/root.xml +724 -0
- unicode_rbnf/rbnf/ru.xml +1565 -0
- unicode_rbnf/rbnf/se.xml +51 -0
- unicode_rbnf/rbnf/sk.xml +97 -0
- unicode_rbnf/rbnf/sl.xml +145 -0
- unicode_rbnf/rbnf/sq.xml +79 -0
- unicode_rbnf/rbnf/sr.xml +165 -0
- unicode_rbnf/rbnf/sr_Latn.xml +166 -0
- unicode_rbnf/rbnf/su.xml +56 -0
- unicode_rbnf/rbnf/sv.xml +258 -0
- unicode_rbnf/rbnf/sw.xml +64 -0
- unicode_rbnf/rbnf/ta.xml +101 -0
- unicode_rbnf/rbnf/th.xml +61 -0
- unicode_rbnf/rbnf/tr.xml +108 -0
- unicode_rbnf/rbnf/uk.xml +139 -0
- unicode_rbnf/rbnf/vec.xml +423 -0
- unicode_rbnf/rbnf/vi.xml +80 -0
- unicode_rbnf/rbnf/yue.xml +191 -0
- unicode_rbnf/rbnf/yue_Hans.xml +192 -0
- unicode_rbnf/rbnf/zh.xml +286 -0
- unicode_rbnf/rbnf/zh_Hant.xml +252 -0
- unicode_rbnf-1.0.0.dist-info/LICENSE.md +21 -0
- unicode_rbnf-1.0.0.dist-info/METADATA +20 -0
- unicode_rbnf-1.0.0.dist-info/RECORD +98 -0
- unicode_rbnf-1.0.0.dist-info/WHEEL +5 -0
- unicode_rbnf-1.0.0.dist-info/top_level.txt +1 -0
unicode_rbnf/__init__.py
ADDED
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
|
unicode_rbnf/rbnf/af.xml
ADDED
|
@@ -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>
|