messageformat2 0.1.0__py3-none-any.whl

messageformat2/runtime.py

@@ -0,0 +1,301 @@
+from dataclasses import dataclass
+from typing import Any
+
+from babel import Locale
+
+from messageformat2.builtins import Registry
+from messageformat2.errors import (
+    InvalidExpression,
+    SelectionError,
+    UnknownFunction,
+    UnresolvedVariable,
+    UnsupportedExpression,
+    UnsupportedStatement,
+)
+from messageformat2.parser import (
+    CatchallKey,
+    Expression,
+    FunctionAnnotation,
+    FunctionExpression,
+    InputDeclaration,
+    Literal,
+    LiteralExpression,
+    Markup,
+    Message,
+    Option,
+    Pattern,
+    PatternMessage,
+    SelectMessage,
+    UnsupportedAnnotation,
+    VariableExpression,
+    VariableRef,
+    Variant,
+)
+from messageformat2.parser import (
+    UnsupportedExpression as _UnsupportedExpression,
+)
+from messageformat2.parser import UnsupportedStatement as _UnsupportedStatement
+
+
+@dataclass
+class FormattingContext:
+    locale: Locale
+    inputs: dict[str, Any]
+    registry: Registry
+    declarations: dict[str, Any]
+    strict: bool = True
+
+
+class LazyValue:
+    def __init__(self, *, fn_name: str, value: Any = None, options: dict[str, Any] | None = None):
+        self.fn_name = fn_name
+        self.value = value
+        self.options = options or {}
+
+    def format(self, ctx: FormattingContext) -> str:
+        if annotation := ctx.registry.formatters.get(self.fn_name):
+            try:
+                return str(annotation(value=self.value, locale=ctx.locale, options=self.options))
+            except InvalidExpression:
+                raise
+            except Exception as e:
+                msg = "Exception raised while evaluating formatter"
+                raise InvalidExpression(msg) from e
+        msg = f"Unknown function: {self.fn_name}"
+        raise UnknownFunction(msg)
+
+    def select(self, ctx: FormattingContext, *, keys: list[str]) -> list[str]:
+        if selector := ctx.registry.selectors.get(self.fn_name):
+            try:
+                return selector(value=self.value, locale=ctx.locale, options=self.options, keys=keys)
+            except SelectionError:
+                raise
+            except Exception as e:
+                msg = "Exception raised while evaluating selector"
+                raise SelectionError(msg) from e
+        msg = f"Unknown selector: {self.fn_name}"
+        raise UnknownFunction(msg)
+
+    def __repr__(self):
+        return f"LazyValue({self.fn_name}({self.value}, {self.options}))"
+
+
+def format_message(message: Message, locale: Locale, inputs: dict[str, Any], registry: Registry) -> str:
+    ctx = FormattingContext(
+        locale=locale,
+        inputs=inputs,
+        registry=registry,
+        declarations={},
+    )
+    match message:
+        case PatternMessage():
+            return format_pattern_message(message, ctx)
+        case _:
+            return format_select_message(message, ctx)
+
+
+def format_pattern_message(message: PatternMessage, ctx: FormattingContext) -> str:
+    for decl in message.declarations:
+        match decl:
+            case _UnsupportedStatement():
+                msg = "Unsupported statement"
+                raise UnsupportedStatement(msg)
+            case _:
+                ctx.declarations[decl.name] = decl
+    return format_pattern(message.pattern, ctx)
+
+
+def format_pattern(pattern: Pattern, ctx: FormattingContext) -> str:
+    output = ""
+    for part in pattern:
+        match part:
+            case str():
+                output += part
+            case LiteralExpression() | VariableExpression() | FunctionExpression() | _UnsupportedExpression():
+                output += format_expression(part, ctx)
+            case Markup():
+                output += format_markup(part, ctx)
+    return output
+
+
+def format_select_message(message: SelectMessage, ctx: FormattingContext) -> str:
+    for decl in message.declarations:
+        match decl:
+            case _UnsupportedStatement():
+                msg = "Unsupported statement"
+                raise UnsupportedStatement(msg)
+            case _:
+                ctx.declarations[decl.name] = decl
+
+    selectors = [resolve_selector(selector, ctx) for selector in message.selectors]
+
+    pref = []
+    for i, selector in enumerate(selectors):
+        keys = [key.value for v in message.variants if isinstance(key := v.keys[i], Literal)]
+        pref.append(selector.select(ctx, keys=keys))
+
+    variants = filter_variants(pref, message.variants)
+    pattern = sort_variants(pref, variants)
+    return format_pattern(pattern, ctx)
+
+
+def filter_variants(pref: list, variants: list[Variant]) -> list[Variant]:
+    filtered = []
+    for v in variants:
+        include = True
+        for i, matches in enumerate(pref):
+            key = v.keys[i]
+            if isinstance(key, CatchallKey):
+                continue
+            assert isinstance(key, Literal)
+            ks = key.value
+            if ks not in matches:
+                include = False
+        if include:
+            filtered.append(v)
+    return filtered
+
+
+def sort_variants(pref: list, variants: list[Variant]) -> Pattern:
+    sortable = [[-1, v] for v in variants]
+
+    i = len(pref) - 1
+    while i >= 0:
+        matches = pref[i]
+        minpref = len(matches)
+        for s in sortable:
+            matchpref = minpref
+            key = s[1].keys[i]
+            if not isinstance(key, CatchallKey):
+                assert isinstance(key, Literal)
+                ks = key.value
+                matchpref = matches.index(ks)
+            s[0] = matchpref
+        sortable.sort(key=lambda x: x[0])
+        i = i - 1
+    return sortable[0][1].value
+
+
+def resolve_selector(selector: Expression, ctx: FormattingContext) -> Any | LazyValue:
+    return resolve_expression(selector, ctx)
+
+
+def format_expression(expression: Expression, ctx: FormattingContext) -> str:
+    resolved = resolve_expression(expression, ctx)
+    match resolved:
+        case LazyValue() as lazy_value:
+            return lazy_value.format(ctx)
+        case _:
+            return str(resolved)
+
+
+def format_markup(markup: Markup, ctx: FormattingContext) -> str:
+    options = format_options(markup.options, ctx)
+    options = f" {options}" if options else ""
+
+    if markup.kind == "standalone":
+        return f"<{markup.name}{options}/>"
+    if markup.kind == "open":
+        return f"<{markup.name}{options}>"
+    return f"</{markup.name}{options}>"
+
+
+def format_options(options: list[Option], ctx: FormattingContext) -> str:
+    return " ".join(format_option(opt, ctx) for opt in options)
+
+
+def format_option(option: Option, ctx: FormattingContext) -> str:
+    value = resolve_option(option, ctx)
+    return f"{option.name}={value}"
+
+
+def resolve_options(options: list[Option], ctx: FormattingContext) -> dict[str, Any]:
+    return {opt.name: resolve_option(opt, ctx) for opt in options}
+
+
+def resolve_option(option: Option, ctx: FormattingContext) -> Any:
+    match option.value:
+        case Literal(value=value):
+            return value
+        case VariableRef(name=name):
+            resolved = resolve_variable(name, ctx)
+            match resolved:
+                case LazyValue() as lazy_value:
+                    return lazy_value.format(ctx)
+                case _:
+                    return resolved
+
+
+def resolve_expression(expression: Expression, ctx: FormattingContext) -> Any | LazyValue:
+    match expression:
+        case LiteralExpression(arg=Literal(value), annotation=annotation):
+            if not annotation:
+                return value
+            match annotation:
+                case FunctionAnnotation(name=name, options=options):
+                    options = resolve_options(options, ctx)
+                    return LazyValue(fn_name=name, value=value, options=options)
+                case UnsupportedAnnotation():
+                    msg = "Unsupported expression"
+                    raise UnsupportedExpression(msg)
+        case VariableExpression(arg=VariableRef(ref), annotation=annotation):
+            if not annotation:
+                return resolve_variable(ref, ctx)
+            match annotation:
+                case FunctionAnnotation(name=name, options=options):
+                    resolved = resolve_variable(ref, ctx)
+                    options = resolve_options(options, ctx)
+                    match resolved:
+                        case LazyValue(fn_name=lazy_function, value=lazy_value, options=lazy_options):
+                            if lazy_function and lazy_function != name:
+                                msg = f"Function mismatch: {lazy_function} != {name}"
+                                raise ValueError(msg)
+                            return LazyValue(fn_name=name, value=lazy_value, options=(lazy_options or {}) | options)
+                        case _:
+                            return LazyValue(fn_name=name, value=resolved, options=options)
+                case UnsupportedAnnotation():
+                    msg = "Unsupported expression"
+                    raise UnsupportedExpression(msg)
+        case FunctionExpression(annotation=FunctionAnnotation(name=name, options=options)):
+            options = resolve_options(options, ctx)
+            return LazyValue(fn_name=name, value=None, options=options)
+        case _UnsupportedExpression(annotation=annotation):
+            msg = f"Unsupported expression: {annotation}"
+            raise UnsupportedExpression(msg)
+
+
+def resolve_variable(name: str, ctx: FormattingContext) -> Any:
+    if name in ctx.declarations:
+        decl = ctx.declarations[name]
+        match decl:
+            case InputDeclaration(value=VariableExpression(annotation=annotation)):
+                if not annotation:
+                    return resolve_global(name, ctx)
+                match annotation:
+                    case FunctionAnnotation(name=fn_name, options=options):
+                        resolved = resolve_global(name, ctx)
+                        options = resolve_options(options, ctx)
+                        match resolved:
+                            case LazyValue(fn_name=lazy_fn_name, value=lazy_value, options=lazy_options):
+                                if lazy_fn_name and lazy_fn_name != fn_name:
+                                    msg = f"Function mismatch: {lazy_fn_name} != {fn_name}"
+                                    raise ValueError(msg)
+                                return LazyValue(
+                                    fn_name=fn_name, value=lazy_value, options=(lazy_options or {}) | options
+                                )
+                            case _:
+                                return LazyValue(fn_name=fn_name, value=resolved, options=options)
+                    case UnsupportedAnnotation(annotation=annotation):
+                        msg = f"Unsupported expression: {annotation}"
+                        raise UnsupportedExpression(msg)
+            case _:
+                expression = decl.value
+                return resolve_expression(expression, ctx)
+    return resolve_global(name, ctx)
+
+
+def resolve_global(name: str, ctx: FormattingContext) -> Any:
+    if name in ctx.inputs:
+        return ctx.inputs[name]
+    msg = f"Unresolved variable: {name}"
+    raise UnresolvedVariable(msg)

messageformat2-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) European Organization for Nuclear Research (CERN)
+
+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.

messageformat2-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.1
+Name: messageformat2
+Version: 0.1.0
+Summary: Python implementation of Unicode MessageFormat 2.0
+Author-email: Tomas Roun <tomas.roun8@gmail.com>
+License: MIT License
+        
+        Copyright (c) European Organization for Nuclear Research (CERN)
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/tomasr8/messageformat2
+Project-URL: Github, https://github.com/tomasr8/messageformat2
+Keywords: i18n,internationalization,localization,messageformat,messageformat 2,cldr,gettext
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Internationalization
+Classifier: Topic :: Software Development :: Localization
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Babel
+Requires-Dist: click
+Provides-Extra: dev
+Requires-Dist: build ; extra == 'dev'
+Requires-Dist: twine ; extra == 'dev'
+Requires-Dist: uv ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: pytest-snapshot ; extra == 'dev'
+Requires-Dist: pytest-cov ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
+Requires-Dist: pyright ; extra == 'dev'
+Requires-Dist: mkdocs ; extra == 'dev'
+Requires-Dist: mkdocstrings[python] ; extra == 'dev'
+Requires-Dist: mkdocs-material ; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs ; extra == 'docs'
+Requires-Dist: mkdocstrings[python] ; extra == 'docs'
+Requires-Dist: mkdocs-material ; extra == 'docs'
+
+
+
+# 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) [![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
+
+This is a Python implementation of the [Unicode Message Format 2.0
+specification](https://www.unicode.org/reports/tr35/tr35-72/tr35-messageFormat.html).
+
+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
+Python, gettext.
+
+If you would like to learn more about MF2 itself head over to the [Unicode technical
+specification](https://www.unicode.org/reports/tr35/tr35-72/tr35-messageFormat.html).
+
+## Features
+
+The library includes:
+
+- A message parser and a formatter
+- Several builtin formatters and selectors described by the
+  [spec](https://www.unicode.org/reports/tr35/tr35-72/tr35-messageFormat.html#function-registry)
+  and the possibility to write custom formatters/selectors
+- Helper classes to inspect and transform the message [data
+  model](https://www.unicode.org/reports/tr35/tr35-72/tr35-messageFormat.html#interchange-data-model)
+
+## [Documentation](https://messageformat2.readthedocs.io/en/latest/)
+
+## Installation
+
+Via pip for Python `>= 3.12`
+
+```sh
+pip install messageformat2
+```
+
+## Examples
+
+### 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 available.
+
+```python
+from datetime import datetime
+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
+```
+
+### Plural support
+
+MF2 supports pluralization using built-in or custom selectors.
+
+```python
+from messageformat2 import Message
+
+msg = Message ("""\
+.match {$count :number}
+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."
+```
+
+Complete documentation is available [here](https://messageformat2.readthedocs.io/en/latest/).

messageformat2-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+messageformat2/__init__.py,sha256=1A2OfD38uErtOd27xMUDA1BoRAMuvDj95QVPTQuMexI,123
+messageformat2/builtins.py,sha256=lJV-ibYu0kk1TwJxkA4NK_mJjdSV6UnLq6CgldZ0DAg,10612
+messageformat2/cli.py,sha256=n_cR9jOYg9aoC3VZ6_sReZ7UM-i8iTtiMWvI5mqEJyU,1421
+messageformat2/datamodel.py,sha256=3MRPau_An48cxOoPAW2JJCornFbLzj823bXyxLxVUI0,15486
+messageformat2/errors.py,sha256=Tli-83XlHhG1ia5fbLcFLnZUISyWSJ79yHsJNaKlt98,4447
+messageformat2/message.py,sha256=iLwKjzkrfN_8-oVFL8-sPeAoHKh9vwhHZP96ZXhv5YM,4159
+messageformat2/parser.py,sha256=6TxFQma0pODuBCz7ArHpKvh53GfvnK8rLDleqiHupK8,17023
+messageformat2/runtime.py,sha256=Ml9EsmLiAExAN8l8H8EzsMXHHlq7kBWSBYKH-o1uzi0,11123
+messageformat2-0.1.0.dist-info/LICENSE,sha256=yPtRmLQVOw1jZIJ9HeJ6Su2-NA_RAXG53XdfeQ7Vyvk,1101
+messageformat2-0.1.0.dist-info/METADATA,sha256=hzsAE8JBrjPsK3cV0wN4FYRUzS2a3tzd3MlxFzzwE3c,5665
+messageformat2-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+messageformat2-0.1.0.dist-info/entry_points.txt,sha256=yQ3aIPQ4zPI188NgLN6F49a7kspObfZFuDBkNpVT0NU,47
+messageformat2-0.1.0.dist-info/top_level.txt,sha256=XlAc7JtB9R1O9vO7viztX1fWAkiucBMmwNY8oG_7poA,15
+messageformat2-0.1.0.dist-info/RECORD,,

messageformat2-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

messageformat2-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mf2 = messageformat2.cli:cli

messageformat2-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+messageformat2