python3.14 compat (#5859)

* Include python3.14 in unit-tests and integration-tests

* bypass PyO3 abi check

* handle lazy annotations in py3.14

* [sqlmodel] fix get_annotations for python3.14 compat

Guard sqlmodel import with find_spec

* update deprecation versions to 0.8.15

* Add LOAD_FAST_BORROW opcode to dep_tracking

Ensure that computed var dependencies can be determined on python3.14

* Monkeypatch rx.Base for python3.14 compatible annotations

* remove pyO3 ABI workaround

* Use 3.14 in app-harness, reflex-web, perf tests, and unit_tests for mac

* pyi_generator: remove get_type_hints, wasn't doing the right thing

* reflex-web is not compatible with 3.14 yet because replicate pkg still uses pydantic v1

* Consolidate implementation around annotationlib

* add python3.14 classifier to pyproject

* remove deprecated asyncio.iscoroutine* usage

* update sqlmodel to 0.0.27 and remove compat hacks

* bump granian min dep to 2.5.5

Author: masenf

.github/workflows/integration_app_harness.yml

@@ -26,7 +26,7 @@ jobs:
     strategy:
       matrix:
         state_manager: ["redis", "memory"]
-        python-version: ["3.11", "3.12", "3.13"]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
         split_index: [1, 2]
       fail-fast: false
     runs-on: ubuntu-22.04

.github/workflows/integration_tests.yml

@@ -148,7 +148,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: ./.github/actions/setup_build_env
         with:
-          python-version: 3.13
+          python-version: 3.14
           run-uv-sync: true
 
       - name: Create app directory

.github/workflows/performance.yml

@@ -31,7 +31,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.13"
+          python-version: "3.14"
 
       - name: Install dependencies
         run: uv sync --all-extras --dev

.github/workflows/unit_tests.yml

@@ -28,7 +28,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest]
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     runs-on: ${{ matrix.os }}
 
     # Service containers to run with `runner-job`
@@ -77,7 +77,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     runs-on: macos-latest
     steps:
       - uses: actions/checkout@v4

pyproject.toml

@@ -22,7 +22,7 @@ requires-python = ">=3.10,<4.0"
 dependencies = [
   "alembic >=1.15.2,<2.0",
   "click >=8.2",
-  "granian[reload] >=2.4.0",
+  "granian[reload] >=2.5.5",
   "httpx >=0.23.3,<1.0",
   "packaging >=24.2,<26",
   "platformdirs >=4.3.7,<5.0",
@@ -33,7 +33,7 @@ dependencies = [
   "redis >=5.2.1,<7.0",
   "reflex-hosting-cli >=0.1.55",
   "rich >=13,<15",
-  "sqlmodel >=0.0.24,<0.1",
+  "sqlmodel >=0.0.27,<0.1",
   "starlette >=0.47.0",
   "typing_extensions >=4.13.0",
   "wrapt >=1.17.0,<2.0",
@@ -47,6 +47,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
 ]
 
 [project.optional-dependencies]

reflex/base.py

@@ -5,7 +5,9 @@
 if find_spec("pydantic") and find_spec("pydantic.v1"):
     from pydantic.v1 import BaseModel
 
-    class Base(BaseModel):
+    from reflex.utils.compat import ModelMetaclassLazyAnnotations
+
+    class Base(BaseModel, metaclass=ModelMetaclassLazyAnnotations):
         """The base class subclassed by all Reflex classes.
 
         This class wraps Pydantic and provides common methods such as
@@ -34,7 +36,7 @@ def __init__(self, *args, **kwargs):
             console.deprecate(
                 feature_name="rx.Base",
                 reason="You can subclass from `pydantic.BaseModel` directly instead or use dataclasses if possible.",
-                deprecation_version="0.8.2",
+                deprecation_version="0.8.15",
                 removal_version="0.9.0",
             )
             super().__init__(*args, **kwargs)

reflex/components/field.py

@@ -7,6 +7,7 @@
 from typing import Annotated, Any, Generic, TypeVar, get_origin
 
 from reflex.utils import types
+from reflex.utils.compat import annotations_from_namespace
 
 FIELD_TYPE = TypeVar("FIELD_TYPE")
 
@@ -117,7 +118,8 @@ def _resolve_annotations(
         cls, namespace: dict[str, Any], name: str
     ) -> dict[str, Any]:
         return types.resolve_annotations(
-            namespace.get("__annotations__", {}), namespace["__module__"]
+            annotations_from_namespace(namespace),
+            namespace["__module__"],
         )
 
     @classmethod

reflex/model.py

@@ -363,7 +363,7 @@ def __pydantic_init_subclass__(cls):
                     reason=(
                         "Register sqlmodel.SQLModel classes with `@rx.ModelRegistry.register`"
                     ),
-                    deprecation_version="0.8.0",
+                    deprecation_version="0.8.15",
                     removal_version="0.9.0",
                 )
             super().__pydantic_init_subclass__()

reflex/state.py

@@ -246,7 +246,7 @@ def __call__(self, *args: Any) -> EventSpec:
                 msg = f"Variable `{args[0]}` cannot be set on `{self.state_cls.get_full_name()}`"
                 raise AttributeError(msg)
 
-            if asyncio.iscoroutinefunction(handler.fn):
+            if inspect.iscoroutinefunction(handler.fn):
                 msg = f"Setter for {args[0]} is async, which is not supported."
                 raise NotImplementedError(msg)
 
@@ -287,7 +287,7 @@ async def _resolve_delta(delta: Delta) -> Delta:
     tasks = {}
     for state_name, state_delta in delta.items():
         for var_name, value in state_delta.items():
-            if asyncio.iscoroutine(value):
+            if inspect.iscoroutine(value):
                 tasks[state_name, var_name] = asyncio.create_task(
                     value,
                     name=f"reflex_resolve_delta|{state_name}|{var_name}|{time.time()}",
@@ -852,7 +852,7 @@ def _check_overridden_basevars(cls):
             ComputedVarShadowsBaseVarsError: When a computed var shadows a base var.
         """
         for name, computed_var_ in cls._get_computed_vars():
-            if name in cls.__annotations__:
+            if name in get_type_hints(cls):
                 msg = f"The computed var name `{computed_var_._js_expr}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
                 raise ComputedVarShadowsBaseVarsError(msg)
 
@@ -1735,7 +1735,7 @@ def _is_valid_type(events: Any) -> bool:
         except TypeError:
             pass
 
-        coroutines = [e for e in events if asyncio.iscoroutine(e)]
+        coroutines = [e for e in events if inspect.iscoroutine(e)]
 
         for coroutine in coroutines:
             coroutine_name = coroutine.__qualname__
@@ -1897,7 +1897,7 @@ async def _process_event(
         # Wrap the function in a try/except block.
         try:
             # Handle async functions.
-            if asyncio.iscoroutinefunction(fn.func):
+            if inspect.iscoroutinefunction(fn.func):
                 events = await fn(**payload)
 
             # Handle regular functions.

reflex/utils/compat.py

@@ -1,6 +1,9 @@
 """Compatibility hacks and helpers."""
 
-from typing import TYPE_CHECKING
+import sys
+from collections.abc import Mapping
+from importlib.util import find_spec
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from pydantic.fields import FieldInfo
@@ -30,6 +33,51 @@ async def windows_hot_reload_lifespan_hack():
         pass
 
 
+def annotations_from_namespace(namespace: Mapping[str, Any]) -> dict[str, Any]:
+    """Get the annotations from a class namespace.
+
+    Args:
+        namespace: The class namespace.
+
+    Returns:
+        The (forward-ref) annotations from the class namespace.
+    """
+    if sys.version_info >= (3, 14) and "__annotations__" not in namespace:
+        from annotationlib import (
+            Format,
+            call_annotate_function,
+            get_annotate_from_class_namespace,
+        )
+
+        if annotate := get_annotate_from_class_namespace(namespace):
+            return call_annotate_function(annotate, format=Format.FORWARDREF)
+    return namespace.get("__annotations__", {})
+
+
+if find_spec("pydantic") and find_spec("pydantic.v1"):
+    from pydantic.v1.main import ModelMetaclass
+
+    class ModelMetaclassLazyAnnotations(ModelMetaclass):
+        """Compatibility metaclass to resolve python3.14 style lazy annotations."""
+
+        def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs):
+            """Resolve python3.14 style lazy annotations before passing off to pydantic v1.
+
+            Args:
+                name: The class name.
+                bases: The base classes.
+                namespace: The class namespace.
+                **kwargs: Additional keyword arguments.
+
+            Returns:
+                The created class.
+            """
+            namespace["__annotations__"] = annotations_from_namespace(namespace)
+            return super().__new__(mcs, name, bases, namespace, **kwargs)
+else:
+    ModelMetaclassLazyAnnotations = type  # type: ignore[assignment]
+
+
 def sqlmodel_field_has_primary_key(field_info: "FieldInfo") -> bool:
     """Determines if a field is a primary.