Drop support for Python < 3.9 (#200)

* style: Apply pyupgrade
* Drop typing-extensions dependency as unnecessary
* Advertise support & add CI tests for Python 3.13 and 3.14

---------

Co-authored-by: Francesco Lodolo <[email protected]>

Author: eemeli

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: astral-sh/setup-uv@v7
         with:
-          python-version: 3.8
+          python-version: 3.9
       - uses: actions/setup-python@v6
       - run: uv sync --dev --all-packages
       - run: uv run python -m flake8
@@ -23,8 +23,8 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-22.04, windows-2022]
-        python-version: [3.8, 3.9, "3.10", 3.11, 3.12, pypy3.9, pypy3.10]
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
       - uses: actions/checkout@v6
       - uses: astral-sh/setup-uv@v7
@@ -48,8 +48,8 @@ jobs:
       - uses: actions/checkout@v6
       - uses: astral-sh/setup-uv@v7
         with:
-          python-version: 3.8
-      - run: uv venv --python 3.8
+          python-version: 3.12
+      - run: uv venv
       - run: uv pip install ${{ matrix.fluent-syntax }}
       - run: uv pip install ./fluent.runtime
       - run: uv run python -m unittest discover -s fluent.runtime

fluent.runtime/fluent/runtime/builtins.py

@@ -1,12 +1,12 @@
-from typing import Callable, Dict
+from typing import Callable
 
 from .types import FluentType, fluent_date, fluent_number
 
 NUMBER = fluent_number
 DATETIME = fluent_date
 
 
-BUILTINS: Dict[str, Callable[..., FluentType]] = {
+BUILTINS: dict[str, Callable[..., FluentType]] = {
     "NUMBER": NUMBER,
     "DATETIME": DATETIME,
 }

fluent.runtime/fluent/runtime/bundle.py

@@ -1,10 +1,9 @@
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Literal, Union, cast
 
 import babel
 import babel.numbers
 import babel.plural
 from fluent.syntax import ast as FTL
-from typing_extensions import Literal
 
 from .builtins import BUILTINS
 from .prepare import Compiler
@@ -34,16 +33,16 @@ class FluentBundle:
 
     def __init__(
         self,
-        locales: List[str],
-        functions: Union[Dict[str, Callable[..., "FluentType"]], None] = None,
+        locales: list[str],
+        functions: Union[dict[str, Callable[..., "FluentType"]], None] = None,
         use_isolating: bool = True,
     ):
         self.locales = locales
         self._functions = {**BUILTINS, **(functions or {})}
         self.use_isolating = use_isolating
-        self._messages: Dict[str, Union[FTL.Message, FTL.Term]] = {}
-        self._terms: Dict[str, Union[FTL.Message, FTL.Term]] = {}
-        self._compiled: Dict[str, Message] = {}
+        self._messages: dict[str, Union[FTL.Message, FTL.Term]] = {}
+        self._terms: dict[str, Union[FTL.Message, FTL.Term]] = {}
+        self._compiled: dict[str, Message] = {}
         # The compiler is not typed, and this cast is only valid for the public API
         self._compiler = cast(
             Callable[[Union[FTL.Message, FTL.Term]], Message], Compiler()
@@ -90,8 +89,8 @@ def _lookup(self, entry_id: str, term: bool = False) -> Message:
         return self._compiled[compiled_id]
 
     def format_pattern(
-        self, pattern: Pattern, args: Union[Dict[str, Any], None] = None
-    ) -> Tuple[Union[str, "FluentNone"], List[Exception]]:
+        self, pattern: Pattern, args: Union[dict[str, Any], None] = None
+    ) -> tuple[Union[str, "FluentNone"], list[Exception]]:
         if args is not None:
             fluent_args = {
                 argname: native_to_fluent(argvalue)
@@ -100,7 +99,7 @@ def format_pattern(
         else:
             fluent_args = {}
 
-        errors: List[Exception] = []
+        errors: list[Exception] = []
         env = ResolverEnvironment(
             context=self, current=CurrentEnvironment(args=fluent_args), errors=errors
         )

fluent.runtime/fluent/runtime/fallback.py

@@ -1,16 +1,7 @@
 import codecs
 import os
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    List,
-    Type,
-    Union,
-    cast,
-)
+from collections.abc import Generator
+from typing import TYPE_CHECKING, Any, Callable, Union, cast
 
 from fluent.syntax import FluentParser
 from typing import NamedTuple
@@ -25,7 +16,7 @@
 
 class FormattedMessage(NamedTuple):
     value: Union[str, None]
-    attributes: Dict[str, str]
+    attributes: dict[str, str]
 
 
 class FluentLocalization:
@@ -38,24 +29,24 @@ class FluentLocalization:
 
     def __init__(
         self,
-        locales: List[str],
-        resource_ids: List[str],
+        locales: list[str],
+        resource_ids: list[str],
         resource_loader: "AbstractResourceLoader",
         use_isolating: bool = False,
-        bundle_class: Type[FluentBundle] = FluentBundle,
-        functions: Union[Dict[str, Callable[[Any], "FluentType"]], None] = None,
+        bundle_class: type[FluentBundle] = FluentBundle,
+        functions: Union[dict[str, Callable[[Any], "FluentType"]], None] = None,
     ):
         self.locales = locales
         self.resource_ids = resource_ids
         self.resource_loader = resource_loader
         self.use_isolating = use_isolating
         self.bundle_class = bundle_class
         self.functions = functions
-        self._bundle_cache: List[FluentBundle] = []
+        self._bundle_cache: list[FluentBundle] = []
         self._bundle_it = self._iterate_bundles()
 
     def format_message(
-        self, msg_id: str, args: Union[Dict[str, Any], None] = None
+        self, msg_id: str, args: Union[dict[str, Any], None] = None
     ) -> FormattedMessage:
         bundle, msg = next((
             (bundle, bundle.get_message(msg_id))
@@ -82,7 +73,7 @@ def format_message(
         )
 
     def format_value(
-        self, msg_id: str, args: Union[Dict[str, Any], None] = None
+        self, msg_id: str, args: Union[dict[str, Any], None] = None
     ) -> str:
         bundle, msg = next((
             (bundle, bundle.get_message(msg_id))
@@ -96,7 +87,7 @@ def format_value(
             str, val
         )  # Never FluentNone when format_pattern called externally
 
-    def _create_bundle(self, locales: List[str]) -> FluentBundle:
+    def _create_bundle(self, locales: list[str]) -> FluentBundle:
         return self.bundle_class(
             locales, functions=self.functions, use_isolating=self.use_isolating
         )
@@ -128,8 +119,8 @@ class AbstractResourceLoader:
     """
 
     def resources(
-        self, locale: str, resource_ids: List[str]
-    ) -> Generator[List["Resource"], None, None]:
+        self, locale: str, resource_ids: list[str]
+    ) -> Generator[list["Resource"], None, None]:
         """
         Yield lists of FluentResource objects, corresponding to
         each of the resource_ids.
@@ -151,18 +142,18 @@ class FluentResourceLoader(AbstractResourceLoader):
     different roots.
     """
 
-    def __init__(self, roots: Union[str, List[str]]):
+    def __init__(self, roots: Union[str, list[str]]):
         """
         Create a resource loader. The roots may be a string for a single
         location on disk, or a list of strings.
         """
         self.roots = [roots] if isinstance(roots, str) else roots
 
     def resources(
-        self, locale: str, resource_ids: List[str]
-    ) -> Generator[List["Resource"], None, None]:
+        self, locale: str, resource_ids: list[str]
+    ) -> Generator[list["Resource"], None, None]:
         for root in self.roots:
-            resources: List[Any] = []
+            resources: list[Any] = []
             for resource_id in resource_ids:
                 path = self.localize_path(os.path.join(root, resource_id), locale)
                 if not os.path.isfile(path):

fluent.runtime/fluent/runtime/prepare.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any
 
 from fluent.syntax import ast as FTL
 
@@ -17,7 +17,7 @@ def compile(self, node: Any) -> Any:
         nodename: str = type(node).__name__
         if not hasattr(resolver, nodename):
             return node
-        kwargs: Dict[str, Any] = vars(node).copy()
+        kwargs: dict[str, Any] = vars(node).copy()
         for propname, propvalue in kwargs.items():
             kwargs[propname] = self(propvalue)
         handler = getattr(self, "compile_" + nodename, self.compile_generic)
@@ -31,7 +31,7 @@ def compile_Placeable(self, _: Any, expression: Any, **kwargs: Any) -> Any:
             return expression
         return resolver.Placeable(expression=expression, **kwargs)
 
-    def compile_Pattern(self, _: Any, elements: List[Any], **kwargs: Any) -> Any:
+    def compile_Pattern(self, _: Any, elements: list[Any], **kwargs: Any) -> Any:
         if len(elements) == 1 and isinstance(elements[0], resolver.Placeable):
             # Don't isolate isolated placeables
             return resolver.NeverIsolatingPlaceable(elements[0].expression)

fluent.runtime/fluent/runtime/resolver.py

@@ -1,5 +1,6 @@
 import contextlib
-from typing import TYPE_CHECKING, Any, Dict, Generator, List, Set, Union, cast
+from collections.abc import Generator
+from typing import TYPE_CHECKING, Any, Union, cast
 
 import attr
 from fluent.syntax import ast as FTL
@@ -42,7 +43,7 @@ class CurrentEnvironment:
     # For Messages, VariableReference nodes are interpreted as external args,
     # but for Terms they are the values explicitly passed using CallExpression
     # syntax. So we have to be able to change 'args' for this purpose.
-    args: Dict[str, Any] = attr.ib(factory=dict)
+    args: dict[str, Any] = attr.ib(factory=dict)
     # This controls whether we need to report an error if a VariableReference
     # refers to an arg that is not present in the args dict.
     error_for_missing_arg: bool = attr.ib(default=True)
@@ -51,9 +52,9 @@ class CurrentEnvironment:
 @attr.s
 class ResolverEnvironment:
     context: "FluentBundle" = attr.ib()
-    errors: List[Exception] = attr.ib()
+    errors: list[Exception] = attr.ib()
     part_count: int = attr.ib(default=0, init=False)
-    active_patterns: Set[FTL.Pattern] = attr.ib(factory=set, init=False)
+    active_patterns: set[FTL.Pattern] = attr.ib(factory=set, init=False)
     current: CurrentEnvironment = attr.ib(factory=CurrentEnvironment)
 
     @contextlib.contextmanager
@@ -72,7 +73,7 @@ def modified(
         self.current = old_current
 
     def modified_for_term_reference(
-        self, args: Union[Dict[str, Any], None] = None
+        self, args: Union[dict[str, Any], None] = None
     ) -> Any:
         return self.modified(
             args=args if args is not None else {}, error_for_missing_arg=False
@@ -100,13 +101,13 @@ class Literal(BaseResolver):
 class Message(FTL.Entry, BaseResolver):
     id: "Identifier"
     value: Union["Pattern", None]
-    attributes: Dict[str, "Pattern"]
+    attributes: dict[str, "Pattern"]
 
     def __init__(
         self,
         id: "Identifier",
         value: Union["Pattern", None] = None,
-        attributes: Union[List["Attribute"], None] = None,
+        attributes: Union[list["Attribute"], None] = None,
         comment: Any = None,
         **kwargs: Any,
     ):
@@ -121,13 +122,13 @@ def __init__(
 class Term(FTL.Entry, BaseResolver):
     id: "Identifier"
     value: "Pattern"
-    attributes: Dict[str, "Pattern"]
+    attributes: dict[str, "Pattern"]
 
     def __init__(
         self,
         id: "Identifier",
         value: "Pattern",
-        attributes: Union[List["Attribute"], None] = None,
+        attributes: Union[list["Attribute"], None] = None,
         comment: Any = None,
         **kwargs: Any,
     ):
@@ -143,7 +144,7 @@ class Pattern(FTL.Pattern, BaseResolver):
     # Prevent messages with too many sub parts, for CPI DOS protection
     MAX_PARTS = 1000
 
-    elements: List[Union["TextElement", "Placeable"]]  # type: ignore
+    elements: list[Union["TextElement", "Placeable"]]  # type: ignore
 
     def __init__(self, *args: Any, **kwargs: Any):
         super().__init__(*args, **kwargs)
@@ -294,7 +295,7 @@ def __call__(self, env: ResolverEnvironment) -> Any:
         if isinstance(arg_val, (FluentType, str)):
             return arg_val
         env.errors.append(
-            TypeError("Unsupported external type: {}, {}".format(name, type(arg_val)))
+            TypeError(f"Unsupported external type: {name}, {type(arg_val)}")
         )
         return FluentNone(name)
 
@@ -306,7 +307,7 @@ class Attribute(FTL.Attribute, BaseResolver):
 
 class SelectExpression(FTL.SelectExpression, BaseResolver):
     selector: "InlineExpression"
-    variants: List["Variant"]  # type: ignore
+    variants: list["Variant"]  # type: ignore
 
     def __call__(self, env: ResolverEnvironment) -> Union[str, FluentNone]:
         key = self.selector(env)
@@ -368,8 +369,8 @@ def __call__(self, env: ResolverEnvironment) -> str:
 
 
 class CallArguments(FTL.CallArguments, BaseResolver):
-    positional: List[Union["InlineExpression", Placeable]]  # type: ignore
-    named: List["NamedArgument"]  # type: ignore
+    positional: list[Union["InlineExpression", Placeable]]  # type: ignore
+    named: list["NamedArgument"]  # type: ignore
 
 
 class FunctionReference(FTL.FunctionReference, BaseResolver):
@@ -384,7 +385,7 @@ def __call__(self, env: ResolverEnvironment) -> Any:
             function = env.context._functions[function_name]
         except LookupError:
             env.errors.append(
-                FluentReferenceError("Unknown function: {}".format(function_name))
+                FluentReferenceError(f"Unknown function: {function_name}")
             )
             return FluentNone(function_name + "()")