messageformat2 1.0.0__tar.gz → 1.1.0__tar.gz

{messageformat2-1.0.0 → messageformat2-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: messageformat2
-Version: 1.0.0
+Version: 1.1.0
 Summary: Python implementation of Unicode MessageFormat 2.0
 Project-URL: Homepage, https://github.com/tomasr8/messageformat2
 Project-URL: Github, https://github.com/tomasr8/messageformat2
@@ -46,11 +46,11 @@ Description-Content-Type: text/markdown
 
 # MessageFormat2 [![Documentation Status](https://readthedocs.org/projects/messageformat2/badge/?version=latest)](https://messageformat2.readthedocs.io/en/latest/?badge=latest) [![CI](https://github.com/tomasr8/messageformat2/workflows/CI/badge.svg)](https://github.com/tomasr8/messageformat2/workflows/CI/badge.svg)
 
-This is a Python implementation of the [Unicode Message Format 2.0
-specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html).
+This is a Python implementation of the [Unicode MessageFormat
+specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html) (LDML 49).
 
-Message Format 2.0 (MF2) is a new iteration of Message Format which aims to be
-more expressive and flexible than both Message Format 1.0 and, in the context of
+Unicode MessageFormat (MessageFormat 2.0, MF2) is a new iteration of MessageFormat which aims to be
+more expressive and flexible than both MessageFormat 1.0 and, in the context of
 Python, gettext.
 
 If you would like to learn more about MF2 itself head over to the [Unicode technical
@@ -60,16 +60,17 @@ specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html).
 
 The library includes:
 
-- A message parser and a formatter
-- Several builtin formatters and selectors described by the
+- A message parser and a formatter, passing the official
+  [test suite](https://github.com/unicode-org/message-format-wg/tree/main/test)
+- All default functions described by the
   [spec](https://github.com/unicode-org/message-format-wg/blob/main/spec/functions/README.md)
+  (`:string`, `:number`, `:integer`, `:offset`, `:percent`, `:currency`, `:date`, `:time`, `:datetime`)
   and the possibility to write custom formatters/selectors
+- Formatting with fallback values and error reporting, optional bidi isolation of placeholders
 - Helper classes to inspect and transform the message [data
   model](https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model/README.md)
 
-## Documentation
-
-Documentation is available here: [https://messageformat2.readthedocs.io/en/latest/](https://messageformat2.readthedocs.io/en/latest/)
+## [Documentation](https://messageformat2.readthedocs.io/en/latest/)
 
 ## Installation
 
@@ -104,15 +105,18 @@ message.format({"name": "Bob"})  # -> "Hello, Bob!"
 There are several builtin locale-aware formatters available.
 
 ```python
-from datetime import datetime
+from datetime import date
 from messageformat2 import Message
 
-message = Message("Today's date is {$now :date}")
-now = datetime.now()
-message.format({"now": now}, locale='en_US')
-# -> Today's date is 5/10/2024
-message.format({"now": now}, locale='en_GB')
-# -> Today's date is 10/05/2024
+message = Message("Today's date is {$today :date}")
+today = date(2024, 5, 10)
+message.format({"today": today}, locale="en_US")
+# -> "Today's date is May 10, 2024"
+message.format({"today": today}, locale="en_GB")
+# -> "Today's date is 10 May 2024"
+
+Message("{$price :currency currency=EUR}").format({"price": 42}, locale="de")
+# -> "42,00\xa0€"
 ```
 
 ### Plural support
@@ -133,4 +137,25 @@ msg.format({"count": 42}, locale='en_US') # -> "You have 42 notifications."
 msg.format({"count": 1}, locale='en_US') # -> "You have 1 notification."
 ```
 
+### Error handling
+
+By default the first error is raised. To get the spec's fallback behaviour instead (`{$name}` for a
+missing variable, etc.) and collect the errors, pass an `on_error` callback:
+
+```python
+errors = []
+Message("Hello, {$name}!").format({}, on_error=errors.append)  # -> "Hello, {$name}!"
+errors  # -> [UnresolvedVariable('Unresolved variable: name')]
+```
+
+### Bidirectional text
+
+The spec's *Default Bidi Strategy* (wrapping placeholders in Unicode isolate controls so that mixed-direction
+text displays correctly) is available with `bidi_isolation=True`:
+
+```python
+Message("Hello, {$name}!").format({"name": "Alice"}, bidi_isolation=True)
+# -> "Hello, \u2068Alice\u2069!"
+```
+
 Complete documentation is available [here](https://messageformat2.readthedocs.io/en/latest/).

{messageformat2-1.0.0 → messageformat2-1.1.0}/README.md

@@ -2,11 +2,11 @@
 
 # MessageFormat2 [![Documentation Status](https://readthedocs.org/projects/messageformat2/badge/?version=latest)](https://messageformat2.readthedocs.io/en/latest/?badge=latest) [![CI](https://github.com/tomasr8/messageformat2/workflows/CI/badge.svg)](https://github.com/tomasr8/messageformat2/workflows/CI/badge.svg)
 
-This is a Python implementation of the [Unicode Message Format 2.0
-specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html).
+This is a Python implementation of the [Unicode MessageFormat
+specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html) (LDML 49).
 
-Message Format 2.0 (MF2) is a new iteration of Message Format which aims to be
-more expressive and flexible than both Message Format 1.0 and, in the context of
+Unicode MessageFormat (MessageFormat 2.0, MF2) is a new iteration of MessageFormat which aims to be
+more expressive and flexible than both MessageFormat 1.0 and, in the context of
 Python, gettext.
 
 If you would like to learn more about MF2 itself head over to the [Unicode technical
@@ -16,16 +16,17 @@ specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html).
 
 The library includes:
 
-- A message parser and a formatter
-- Several builtin formatters and selectors described by the
+- A message parser and a formatter, passing the official
+  [test suite](https://github.com/unicode-org/message-format-wg/tree/main/test)
+- All default functions described by the
   [spec](https://github.com/unicode-org/message-format-wg/blob/main/spec/functions/README.md)
+  (`:string`, `:number`, `:integer`, `:offset`, `:percent`, `:currency`, `:date`, `:time`, `:datetime`)
   and the possibility to write custom formatters/selectors
+- Formatting with fallback values and error reporting, optional bidi isolation of placeholders
 - Helper classes to inspect and transform the message [data
   model](https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model/README.md)
 
-## Documentation
-
-Documentation is available here: [https://messageformat2.readthedocs.io/en/latest/](https://messageformat2.readthedocs.io/en/latest/)
+## [Documentation](https://messageformat2.readthedocs.io/en/latest/)
 
 ## Installation
 
@@ -60,15 +61,18 @@ message.format({"name": "Bob"})  # -> "Hello, Bob!"
 There are several builtin locale-aware formatters available.
 
 ```python
-from datetime import datetime
+from datetime import date
 from messageformat2 import Message
 
-message = Message("Today's date is {$now :date}")
-now = datetime.now()
-message.format({"now": now}, locale='en_US')
-# -> Today's date is 5/10/2024
-message.format({"now": now}, locale='en_GB')
-# -> Today's date is 10/05/2024
+message = Message("Today's date is {$today :date}")
+today = date(2024, 5, 10)
+message.format({"today": today}, locale="en_US")
+# -> "Today's date is May 10, 2024"
+message.format({"today": today}, locale="en_GB")
+# -> "Today's date is 10 May 2024"
+
+Message("{$price :currency currency=EUR}").format({"price": 42}, locale="de")
+# -> "42,00\xa0€"
 ```
 
 ### Plural support
@@ -89,4 +93,25 @@ msg.format({"count": 42}, locale='en_US') # -> "You have 42 notifications."
 msg.format({"count": 1}, locale='en_US') # -> "You have 1 notification."
 ```
 
+### Error handling
+
+By default the first error is raised. To get the spec's fallback behaviour instead (`{$name}` for a
+missing variable, etc.) and collect the errors, pass an `on_error` callback:
+
+```python
+errors = []
+Message("Hello, {$name}!").format({}, on_error=errors.append)  # -> "Hello, {$name}!"
+errors  # -> [UnresolvedVariable('Unresolved variable: name')]
+```
+
+### Bidirectional text
+
+The spec's *Default Bidi Strategy* (wrapping placeholders in Unicode isolate controls so that mixed-direction
+text displays correctly) is available with `bidi_isolation=True`:
+
+```python
+Message("Hello, {$name}!").format({"name": "Alice"}, bidi_isolation=True)
+# -> "Hello, \u2068Alice\u2069!"
+```
+
 Complete documentation is available [here](https://messageformat2.readthedocs.io/en/latest/).

{messageformat2-1.0.0 → messageformat2-1.1.0}/docs/builtins.md

@@ -14,6 +14,8 @@ As a selector, this function selects the exact match among the variant keys
 (after NFC normalization of the value).
 
 ```python
+from messageformat2 import format_message
+
 format_message("""\
 .input {$pet :string}
 .match $pet
@@ -28,8 +30,8 @@ cat {{I have a cat}}
 
 The operand must be an `int`, `float` or `Decimal` (but not a `bool`), or a string matching the
 `number-literal` production of the spec (e.g. `|-1234.5|`, `|1e3|`; `|01|` or `|.5|` are not numbers).
-The resolved value of another numeric function (`:number`, `:integer`, `:offset`) is also accepted, in which
-case its options are inherited, with the options of the expression taking priority.
+The resolved value of another numeric function (`:number`, `:integer`, `:offset`, `:percent`) is also accepted,
+in which case its options are inherited, with the options of the expression taking priority.
 
 #### Formatter
 
@@ -43,16 +45,34 @@ case its options are inherited, with the options of the expression taking priori
     - auto (default)
     - always
     - never
-    - min2 (treated as auto)
+    - min2 (grouping separators only for numbers with at least 5 integer digits)
 - `minimumIntegerDigits`
 - `minimumFractionDigits`
 - `maximumFractionDigits`
 - `minimumSignificantDigits`
 - `maximumSignificantDigits`
-- `numberingSystem` (implementation extension): a Unicode Number System Identifier
+- `roundingMode`
+    - ceil
+    - floor
+    - expand
+    - trunc
+    - halfCeil
+    - halfFloor
+    - halfExpand (default; ties away from zero, like `Intl.NumberFormat` and unlike Python's `round()`)
+    - halfTrunc
+    - halfEven
+- `roundingPriority`: which of the fraction and significant digits options wins when both are given
+    - auto (default; the significant digits options)
+    - morePrecision
+    - lessPrecision
+- `roundingIncrement`: 1 (default), 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000, 2000, 2500 or 5000,
+  in units of the last fraction digit; requires `minimumFractionDigits` and `maximumFractionDigits` to be equal
+- `trailingZeroDisplay`
+    - auto (default)
+    - stripIfInteger (no fraction digits when the rounded value is an integer)
 
 The digit options are *digit size options*: small non-negative integers (`0`-`99`).
-Not implemented: `trailingZeroDisplay`, `roundingPriority`, `roundingIncrement`, `roundingMode` (these are ignored).
+The numbering system is the default one of the locale (e.g. `Locale("ar", "EG")` uses Arabic-Indic digits).
 
 #### Selector
 
@@ -69,14 +89,15 @@ numeric keys (e.g. `1`), then (unless `select=exact`) matches the CLDR plural or
 
 ### `:integer`
 
-Same as `:number`, but the operand is truncated to an integer. The `minimumFractionDigits`, `maximumFractionDigits`
-and `minimumSignificantDigits` options of an annotated operand are discarded.
+Same as `:number`, but the operand is rounded to an integer (`halfExpand`: `1.5` becomes `2`, `-2.5` becomes `-3`).
+The `minimumFractionDigits`, `maximumFractionDigits` and `minimumSignificantDigits` options of an annotated operand
+are discarded.
 
 ### `:offset`
 
 Adds or subtracts a small integer from a numeric operand, e.g. to count "other" users:
 
-```python
+```
 .input {$likes :integer}
 .local $others = {$likes :offset subtract=1}
 ```
@@ -89,6 +110,37 @@ Exactly one of the options must be given:
 The formatting options of an annotated operand (e.g. `signDisplay` of `{$likes :integer signDisplay=always}`)
 are inherited. `:offset` can also be used as a selector, in which case it behaves like `:number`.
 
+### `:percent`
+
+Formats a numeric operand multiplied by 100 as a percentage, e.g. `{0.25 :percent}` → `25%`.
+It takes the same options as `:number` except `select`, `minimumIntegerDigits` and `roundingIncrement`
+(by default no fraction digits are shown). As a selector it always uses the plural rules, on the value
+multiplied by 100. The resolved value of a `:percent` expression keeps the original (unmultiplied) value,
+so `.local $p = {0.25 :percent} {{{$p :number}}}` gives `0.25`.
+
+### `:currency`
+
+Formats a currency amount, e.g. `{42 :currency currency=EUR}` → `€42.00`. The operand is either a numeric
+operand together with the `currency` option, or a currency value: a `messageformat2.builtins.Currency(value, currency)`
+(or any mapping with the keys `value` and `currency`) passed as an input. The currency of a currency value cannot
+be overridden by the `currency` option (`BadOption`). `:currency` does not support selection.
+
+- `currency`: a three-letter currency code (case-insensitive); required for numeric operands
+- `currencySign`
+    - standard (default)
+    - accounting (e.g. `($42.50)`)
+- `currencyDisplay`
+    - symbol (default)
+    - narrowSymbol (treated as symbol)
+    - code (`USD42.00`)
+    - name (`42.00 US dollars`)
+    - never (`42.00`)
+- `useGrouping`, `minimumIntegerDigits`, `minimumSignificantDigits`, `maximumSignificantDigits`, `roundingMode`,
+  `roundingPriority`, `roundingIncrement`, `trailingZeroDisplay`: as for `:number`
+- `fractionDigits`
+    - auto (default): the number of fraction digits of the currency (2 for USD, 0 for JPY, ...)
+    - a *digit size option*: a fixed number of fraction digits
+
 ### `:datetime`, `:date`, `:time`
 
 The operand must be a `datetime` (or a `date`/`time` for `:date`/`:time` respectively) or an ISO 8601 date or
@@ -140,3 +192,13 @@ The option values below must be set by literals (an option set by a variable is
 #### Selector
 
 The date/time functions do not support selection, as it is not required by MF2.
+
+## The `u:` namespace options
+
+These options can be used with any function (including custom ones):
+
+- `u:dir`: `ltr`, `rtl`, `auto` or `inherit` (default). Sets the directionality of the placeholder for the
+  bidi isolation strategy and forces its isolation (except `inherit`). Not allowed on markup.
+- `u:id`: an identifier for the placeholder; accepted (it must be a string) but ignored when formatting to a string.
+
+Both are removed from the options before the function is called.

{messageformat2-1.0.0 → messageformat2-1.1.0}/docs/explanation.md

@@ -5,18 +5,20 @@ If the same variable is referenced more than once, it will also be evaluated mor
 Pay attention when providing custom formatters/selectors with side effects:
 
 ```python
+from messageformat2 import Message
+
 counter = 0
 
 def formatter_with_side_effect(value, locale, options):
-    nonlocal counter
-    counter +=1
+    global counter
+    counter += 1
     return str(value)
 
-msg = Message("\
+msg = Message("""\
 .local $foo = {|foo| :side_effect}
 {{{$foo} {$foo}}}
-")
-msg.format(formatters={'side_effect': formatter_with_side_effect})
+""")
+msg.format(formatters={"side_effect": formatter_with_side_effect})
 print(counter)  # -> 2
 ```
 
@@ -27,6 +29,25 @@ numbers (`int`, `float`, `Decimal`) as if annotated with `:number`, `datetime`,
 `:datetime`, `:date` and `:time`. Anything else is formatted with `str()`.
 Literals are always strings, so `{|1234.5|}` is formatted verbatim.
 
+## Bidirectional text
+
+With `bidi_isolation=True`, placeholders are wrapped in Unicode isolate controls following the spec's
+*Default Bidi Strategy*, so that mixed left-to-right and right-to-left text displays correctly: a value whose
+direction is unknown (strings, literals, the results of custom formatters) is wrapped in U+2068 FIRST STRONG
+ISOLATE … U+2069 POP DIRECTIONAL ISOLATE, a value whose direction differs from the message's (e.g. a number,
+which has the direction of the locale, in a message formatted in an RTL locale) in U+2066 LEFT-TO-RIGHT ISOLATE /
+U+2067 RIGHT-TO-LEFT ISOLATE.
+
+```python
+Message("Hello, {$name}!").format({"name": "Alice"}, bidi_isolation=True)  # -> "Hello, \u2068Alice\u2069!"
+Message("{$n :number} items").format({"n": 3}, bidi_isolation=True)  # -> "3 items" (same direction)
+```
+
+The controls are invisible but do change the string, which is why isolation is off by default.
+The `u:dir` option sets the direction of a placeholder (`ltr`, `rtl` or `auto`) and forces its isolation:
+`{$name :string u:dir=rtl}`. Custom formatters can return a `messageformat2.builtins.FormattedValue(text, direction)`
+to declare the direction of their output.
+
 ## Function composition
 
 A variable which was annotated with a function can be annotated again, for example in a placeholder.
@@ -36,11 +57,12 @@ and decides what to do with it. The built-in numeric functions accept each other
 and inherit their options, with the options of the later expression taking priority:
 
 ```python
-.local $x = {42 :number minimumFractionDigits=2 signDisplay=always}
-{{x = {$x :number minimumFractionDigits=1}}}  # -> "x = +42.0"
+from messageformat2 import format_message
 
-.local $x = {1.25 :integer}
-{{x = {$x :number}}}  # -> "x = 1"
+format_message(".local $x = {42 :number minimumFractionDigits=2 signDisplay=always} {{x = {$x :number minimumFractionDigits=1}}}")
+# -> "x = +42.0"
+format_message(".local $x = {1.25 :integer} {{x = {$x :number}}}")
+# -> "x = 1"
 ```
 
 whereas e.g. `{$x :date}` would raise `BadOperand`. See [Custom formatters](howto/formatter.md) for how to
@@ -54,6 +76,8 @@ Whitespace around a complex message (a message containing declarations and/or a
 so complex messages can be freely indented, e.g. in multiline strings:
 
 ```python
+from messageformat2 import Message
+
 Message("""
     .input {$count :integer}
     .match $count

messageformat2-1.1.0/docs/getting_started.md

@@ -0,0 +1,85 @@
+## Installation
+
+This package is available via `pip` for Python `>= 3.12`:
+
+```sh
+pip install messageformat2
+```
+
+## Simple messages
+
+```python
+from messageformat2 import format_message
+
+format_message("Hello, {$name}!", {"name": "Alice"})  # -> "Hello, Alice!"
+```
+
+Messages can be reused with different inputs.
+
+```python
+from messageformat2 import Message
+
+message = Message("Hello, {$name}!")
+message.format({"name": "Alice"})  # -> "Hello, Alice!"
+message.format({"name": "Bob"})  # -> "Hello, Bob!"
+```
+
+## Built-in formatters
+
+There are several builtin locale-aware [formatters](builtins.md) available.
+
+```python
+from datetime import date
+from messageformat2 import Message
+
+message = Message("Today's date is {$today :date}")
+today = date(2024, 5, 10)
+message.format({"today": today}, locale="en_US")
+# -> "Today's date is May 10, 2024"
+message.format({"today": today}, locale="en_GB")
+# -> "Today's date is 10 May 2024"
+
+Message("{$price :currency currency=EUR}").format({"price": 42}, locale="de")
+# -> "42,00\xa0€"
+```
+
+## Plural support
+
+MF2 supports pluralization using built-in or custom selectors.
+
+```python
+from messageformat2 import Message
+
+msg = Message ("""\
+.input {$count :number}
+.match $count
+one {{You have {$count} notification.}}
+*   {{You have {$count} notifications.}}
+""")
+
+msg.format({"count": 42}, locale='en_US') # -> "You have 42 notifications."
+msg.format({"count": 1}, locale='en_US') # -> "You have 1 notification."
+```
+
+## Error handling
+
+By default the first error is raised. To get the spec's fallback behaviour instead (`{$name}` for a
+missing variable, etc.) and collect the errors, pass an `on_error` callback,
+see [Error handling](howto/errors.md):
+
+```python
+errors = []
+Message("Hello, {$name}!").format({}, on_error=errors.append)  # -> "Hello, {$name}!"
+errors  # -> [UnresolvedVariable('Unresolved variable: name')]
+```
+
+## Bidirectional text
+
+The spec's *Default Bidi Strategy* (wrapping placeholders in Unicode isolate controls so that mixed-direction
+text displays correctly) is available with `bidi_isolation=True`,
+see [Bidirectional text](explanation.md#bidirectional-text):
+
+```python
+Message("Hello, {$name}!").format({"name": "Alice"}, bidi_isolation=True)
+# -> "Hello, \u2068Alice\u2069!"
+```

{messageformat2-1.0.0 → messageformat2-1.1.0}/docs/howto/datamodel.md

@@ -1,7 +1,7 @@
 The `Message` class has a `datamodel` property which gives you access to the
 message data model which is based on the [MF2
 spec](https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model/README.md).
-The data model nodes are documented [here](/datamodel).
+The data model nodes are documented [here](../datamodel.md).
 
 There are two classes to work with the datamodel - `DataModelVisitor` &
 `DataModelTransformer`.

{messageformat2-1.0.0 → messageformat2-1.1.0}/docs/howto/errors.md

@@ -22,7 +22,7 @@ from messageformat2.errors import ParseError, DataModelError
 try:
     Message("}} invalid syntax")
 except ParseError as e:
-    print(e)  # -> Invalid syntax
+    print(e)  # -> Invalid character at the start of a simple message: }
 
 
 try:
@@ -45,7 +45,7 @@ msg = Message("Hello, {$name}!")
 try:
     msg.format()
 except FormatError as e:
-    print(e)  # -> Unresolved variable
+    print(e)  # -> Unresolved variable: name
 ```
 
 ## Formatting with fallback values

{messageformat2-1.0.0 → messageformat2-1.1.0}/docs/howto/formatter.md

@@ -2,6 +2,9 @@ It is possible to write a custom formatter to extend the functionality of the
 library. Here's an example of a simple formatter:
 
 ```python
+from typing import Any
+from messageformat2 import format_message
+
 def capitalize(value: Any, locale, options) -> str:
     return value.capitalize()
 
@@ -41,13 +44,17 @@ and `messageformat2.errors.MessageFunctionError` will be reraised instead.
 ```python
 from messageformat2.errors import MessageFunctionError
 
+def raise_some_error(value, locale, options) -> str:
+    raise ValueError("something went wrong")
+
 try:
     format_message(
         "{foo :raise}",
         formatters={"raise": raise_some_error}
     )
 except MessageFunctionError as e:
-    print(e)
+    print(e)  # -> Exception raised while evaluating formatter :raise
+    print(repr(e.__cause__))  # -> ValueError('something went wrong')
 ```
 
 To signal a specific error, a formatter can raise one of the `MessageFunctionError` subclasses
@@ -94,3 +101,17 @@ format_message(
 )
 # -> "ALICE"
 ```
+
+## Directionality
+
+The result of a custom formatter has an unknown direction and is isolated with U+2068/U+2069 when the message
+is formatted with `bidi_isolation=True` (see [Bidirectional text](../explanation.md#bidirectional-text)).
+Return a `FormattedValue` to declare the direction instead, so that a value in the direction of the message
+is not isolated:
+
+```python
+from messageformat2.builtins import FormattedValue
+
+def shout(value, locale, options) -> FormattedValue:
+    return FormattedValue(str(value).upper(), locale.text_direction)
+```

{messageformat2-1.0.0 → messageformat2-1.1.0}/docs/howto/selector.md

@@ -4,23 +4,27 @@ statement.
 Here's a simple implementation of the `:integer` selector:
 
 ```python
+from typing import Any
+
+from babel import Locale
+
+from messageformat2 import format_message
+
+
 def integer_selector(
     value: Any,  # The value passed to the selector while formatting the message
-    *,
     locale: Locale,  # Babel locale
     options: dict[str, Any],  # Selector options
-    keys: list[str]  # Variant keys to be filtered out
+    keys: list[str],  # Variant keys to be filtered out
 ) -> list[str]:
+    value = int(value)
     select = options.get("select", "plural")
 
-    exact_keys = [value] if value in keys else []
+    exact_keys = [key for key in keys if key == str(value)]
     if select == "exact":
         return exact_keys
-    if select == "plural":
-        form = locale.plural_form(value)
-    if select == "ordinal":
-        form = locale.ordinal_form(value)
-    return exact_keys + keyword_keys
+    form = locale.ordinal_form(value) if select == "ordinal" else locale.plural_form(value)
+    return exact_keys + [key for key in keys if key == form]
 
 
 format_message("""\
@@ -32,19 +36,19 @@ one {{You have {$count} notification.}}
     {"count": 1},
     selectors={"integer": integer_selector}
 )
-# -> You have one notification.
+# -> "You have one notification."
 ```
 
-A selector function must take exactly 3 arguments:
+A selector function must take exactly 4 arguments, which are passed by keyword (so they must have these names):
 
-- `value`: the value passed to the formatter when formatting
+- `value`: the value passed to the selector when formatting
 - `locale`: the current locale as a `babel.Locale` instance
-- `options`: a dictionary containing all the options passed to the formatter.
-- `keys`: The key from each variant of the match statement.
+- `options`: a dictionary containing all the options passed to the selector
+- `keys`: the key from each variant of the match statement (the catch-all `*` is not included)
 
 For example, for this message:
 
-```python
+```
 .input {$count :integer select=plural}
 .match $count
 1   {{You have one notification.}}

{messageformat2-1.0.0 → messageformat2-1.1.0}/docs/index.md

@@ -1,9 +1,9 @@
 This site contains documentation for the `messageformat2`, a Python library
-which implements the [Unicode Message Format 2.0
-specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html).
+which implements the [Unicode MessageFormat
+specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html) (LDML 49).
 
-Message Format 2.0 (MF2) is a new iteration of Message Format which aims to be
-more expressive and flexible than both Message Format 1.0 and, in the context of
+Unicode MessageFormat (MessageFormat 2.0, MF2) is a new iteration of MessageFormat which aims to be
+more expressive and flexible than both MessageFormat 1.0 and, in the context of
 Python, gettext.
 
 If you would like to learn more about MF2 itself head over to the [Unicode technical
@@ -13,10 +13,13 @@ specification](https://www.unicode.org/reports/tr35/tr35-messageFormat.html).
 
 The `messageformat2` library includes:
 
-- A message parser and a formatter
-- Several builtin formatters and selectors described by the
+- A message parser and a formatter, passing the official
+  [test suite](https://github.com/unicode-org/message-format-wg/tree/main/test)
+- All default functions described by the
   [spec](https://github.com/unicode-org/message-format-wg/blob/main/spec/functions/README.md)
+  (`:string`, `:number`, `:integer`, `:offset`, `:percent`, `:currency`, `:date`, `:time`, `:datetime`)
   and the possibility to write custom formatters/selectors
+- Formatting with fallback values and error reporting, optional bidi isolation of placeholders
 - Helper classes to inspect and transform the message [data
   model](https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model/README.md)
 

{messageformat2-1.0.0 → messageformat2-1.1.0}/messageformat2/__init__.py

@@ -1,5 +1,5 @@
 from messageformat2.message import Message, format_message
 
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 __all__ = ["Message", "format_message"]