reflex 0.8.0a3__py3-none-any.whl → 0.8.0a5__py3-none-any.whl

reflex/environment.py

@@ -69,7 +69,7 @@ def interpret_boolean_env(value: str, field_name: str) -> bool:
         return True
     if value.lower() in false_values:
         return False
-    msg = f"Invalid boolean value: {value} for {field_name}"
+    msg = f"Invalid boolean value: {value!r} for {field_name}"
     raise EnvironmentVarValueError(msg)
 
 
@@ -89,7 +89,7 @@ def interpret_int_env(value: str, field_name: str) -> int:
     try:
         return int(value)
     except ValueError as ve:
-        msg = f"Invalid integer value: {value} for {field_name}"
+        msg = f"Invalid integer value: {value!r} for {field_name}"
         raise EnvironmentVarValueError(msg) from ve
 
 
@@ -108,7 +108,7 @@ def interpret_existing_path_env(value: str, field_name: str) -> ExistingPath:
     """
     path = Path(value)
     if not path.exists():
-        msg = f"Path does not exist: {path} for {field_name}"
+        msg = f"Path does not exist: {path!r} for {field_name}"
         raise EnvironmentVarValueError(msg)
     return path
 
@@ -143,7 +143,7 @@ def interpret_enum_env(value: str, field_type: GenericType, field_name: str) ->
     try:
         return field_type(value)
     except ValueError as ve:
-        msg = f"Invalid enum value: {value} for {field_name}"
+        msg = f"Invalid enum value: {value!r} for {field_name}"
         raise EnvironmentVarValueError(msg) from ve
 
 
@@ -169,6 +169,8 @@ def interpret_env_var_value(
         msg = f"Union types are not supported for environment variables: {field_name}."
         raise ValueError(msg)
 
+    value = value.strip()
+
     if field_type is bool:
         return interpret_boolean_env(value, field_name)
     if field_type is str:

reflex/route.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Callable
 
 from reflex import constants
 
@@ -16,13 +17,39 @@ def verify_route_validity(route: str) -> None:
     Raises:
         ValueError: If the route is invalid.
     """
-    pattern = catchall_in_route(route)
-    if pattern:
-        if pattern != "[[...splat]]":
-            msg = f"Catchall pattern `{pattern}` is not valid. Only `[[...splat]]` is allowed."
+    route_parts = route.removeprefix("/").split("/")
+    for i, part in enumerate(route_parts):
+        if constants.RouteRegex.SLUG.fullmatch(part):
+            continue
+        if not part.startswith("[") or not part.endswith("]"):
+            msg = (
+                f"Route part `{part}` is not valid. Reflex only supports "
+                "alphabetic characters, underscores, and hyphens in route parts. "
+            )
             raise ValueError(msg)
-        if not route.endswith(pattern):
-            msg = f"Catchall pattern `{pattern}` must be at the end of the route."
+        if part.startswith(("[[...", "[...")):
+            if part != constants.RouteRegex.SPLAT_CATCHALL:
+                msg = f"Catchall pattern `{part}` is not valid. Only `{constants.RouteRegex.SPLAT_CATCHALL}` is allowed."
+                raise ValueError(msg)
+            if i != len(route_parts) - 1:
+                msg = f"Catchall pattern `{part}` must be at the end of the route."
+                raise ValueError(msg)
+            continue
+        if part.startswith("[["):
+            if constants.RouteRegex.OPTIONAL_ARG.fullmatch(part):
+                continue
+            msg = (
+                f"Route part `{part}` with optional argument is not valid. "
+                "Reflex only supports optional arguments that start with an alphabetic character or underscore, "
+                "followed by alphanumeric characters or underscores."
+            )
+            raise ValueError(msg)
+        if not constants.RouteRegex.ARG.fullmatch(part):
+            msg = (
+                f"Route part `{part}` with argument is not valid. "
+                "Reflex only supports argument names that start with an alphabetic character or underscore, "
+                "followed by alphanumeric characters or underscores."
+            )
             raise ValueError(msg)
 
 
@@ -37,98 +64,159 @@ def get_route_args(route: str) -> dict[str, str]:
     """
     args = {}
 
-    def add_route_arg(match: re.Match[str], type_: str):
-        """Add arg from regex search result.
-
-        Args:
-            match: Result of a regex search
-            type_: The assigned type for this arg
-
-        Raises:
-            ValueError: If the route is invalid.
-        """
-        arg_name = match.groups()[0]
+    def _add_route_arg(arg_name: str, type_: str):
         if arg_name in args:
-            msg = f"Arg name [{arg_name}] is used more than once in this URL"
+            msg = (
+                f"Arg name `{arg_name}` is used more than once in the route `{route}`."
+            )
             raise ValueError(msg)
         args[arg_name] = type_
 
     # Regex to check for route args.
-    check = constants.RouteRegex.ARG
-    check_strict_catchall = constants.RouteRegex.STRICT_CATCHALL
-    check_opt_catchall = constants.RouteRegex.OPT_CATCHALL
+    argument_regex = constants.RouteRegex.ARG
+    optional_argument_regex = constants.RouteRegex.OPTIONAL_ARG
 
     # Iterate over the route parts and check for route args.
     for part in route.split("/"):
-        match_opt = check_opt_catchall.match(part)
-        if match_opt:
-            add_route_arg(match_opt, constants.RouteArgType.LIST)
+        if part == constants.RouteRegex.SPLAT_CATCHALL:
+            _add_route_arg("splat", constants.RouteArgType.LIST)
             break
 
-        match_strict = check_strict_catchall.match(part)
-        if match_strict:
-            add_route_arg(match_strict, constants.RouteArgType.LIST)
-            break
+        optional_argument = optional_argument_regex.match(part)
+        if optional_argument:
+            _add_route_arg(optional_argument.group(1), constants.RouteArgType.SINGLE)
+            continue
+
+        argument = argument_regex.match(part)
+        if argument:
+            _add_route_arg(argument.group(1), constants.RouteArgType.SINGLE)
+            continue
 
-        match = check.match(part)
-        if match:
-            # Add the route arg to the list.
-            add_route_arg(match, constants.RouteArgType.SINGLE)
     return args
 
 
-def catchall_in_route(route: str) -> str:
-    """Extract the catchall part from a route.
+def replace_brackets_with_keywords(input_string: str) -> str:
+    """Replace brackets and everything inside it in a string with a keyword.
 
     Example:
-        >>> catchall_in_route("/posts/[...slug]")
-        '[...slug]'
-        >>> catchall_in_route("/posts/[[...slug]]")
-        '[[...slug]]'
-        >>> catchall_in_route("/posts/[slug]")
-        ''
+        >>> replace_brackets_with_keywords("/posts")
+        '/posts'
+        >>> replace_brackets_with_keywords("/posts/[slug]")
+        '/posts/__SINGLE_SEGMENT__'
+        >>> replace_brackets_with_keywords("/posts/[slug]/comments")
+        '/posts/__SINGLE_SEGMENT__/comments'
+        >>> replace_brackets_with_keywords("/posts/[[slug]]")
+        '/posts/__DOUBLE_SEGMENT__'
+        >>> replace_brackets_with_keywords("/posts/[[...splat]]")
+        '/posts/__DOUBLE_CATCHALL_SEGMENT__'
 
     Args:
-        route: the route from which to extract
+        input_string: String to replace.
 
     Returns:
-        str: the catchall part of the URI
+        new string containing keywords.
     """
-    match_ = constants.RouteRegex.CATCHALL.search(route)
-    return match_.group() if match_ else ""
+    # Replace [<slug>] with __SINGLE_SEGMENT__
+    return constants.RouteRegex.ARG.sub(
+        constants.RouteRegex.SINGLE_SEGMENT,
+        # Replace [[slug]] with __DOUBLE_SEGMENT__
+        constants.RouteRegex.OPTIONAL_ARG.sub(
+            constants.RouteRegex.DOUBLE_SEGMENT,
+            # Replace [[...splat]] with __DOUBLE_CATCHALL_SEGMENT__
+            input_string.replace(
+                constants.RouteRegex.SPLAT_CATCHALL,
+                constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT,
+            ),
+        ),
+    )
 
 
-def replace_brackets_with_keywords(input_string: str) -> str:
-    """Replace brackets and everything inside it in a string with a keyword.
+def route_specifity(keyworded_route: str) -> tuple[int, int, int]:
+    """Get the specificity of a route with keywords.
+
+    The smaller the number, the more specific the route is.
 
     Args:
-        input_string: String to replace.
+        keyworded_route: The route with keywords.
 
     Returns:
-        new string containing keywords.
+        A tuple containing the counts of double catchall segments,
+        double segments, and single segments in the route.
     """
-    # /posts -> /post
-    # /posts/[slug] -> /posts/__SINGLE_SEGMENT__
-    # /posts/[slug]/comments -> /posts/__SINGLE_SEGMENT__/comments
-    # /posts/[[slug]] -> /posts/__DOUBLE_SEGMENT__
-    # / posts/[[...slug2]]-> /posts/__DOUBLE_CATCHALL_SEGMENT__
-    # /posts/[...slug3]-> /posts/__SINGLE_CATCHALL_SEGMENT__
-
-    # Replace [[...<slug>]] with __DOUBLE_CATCHALL_SEGMENT__
-    output_string = re.sub(
-        r"\[\[\.\.\..+?\]\]",
-        constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT,
-        input_string,
-    )
-    # Replace [...<slug>] with __SINGLE_CATCHALL_SEGMENT__
-    output_string = re.sub(
-        r"\[\.\.\..+?\]",
-        constants.RouteRegex.SINGLE_CATCHALL_SEGMENT,
-        output_string,
+    return (
+        keyworded_route.count(constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT),
+        keyworded_route.count(constants.RouteRegex.DOUBLE_SEGMENT),
+        keyworded_route.count(constants.RouteRegex.SINGLE_SEGMENT),
     )
-    # Replace [[<slug>]] with __DOUBLE_SEGMENT__
-    output_string = re.sub(
-        r"\[\[.+?\]\]", constants.RouteRegex.DOUBLE_SEGMENT, output_string
+
+
+def get_route_regex(keyworded_route: str) -> re.Pattern:
+    """Get the regex pattern for a route with keywords.
+
+    Args:
+        keyworded_route: The route with keywords.
+
+    Returns:
+        A compiled regex pattern for the route.
+    """
+    if keyworded_route == "index":
+        return re.compile(re.escape("/"))
+    path_parts = keyworded_route.split("/")
+    regex_parts = []
+    for part in path_parts:
+        if part == constants.RouteRegex.SINGLE_SEGMENT:
+            # Match a single segment (/slug)
+            regex_parts.append(r"/[^/]*")
+        elif part == constants.RouteRegex.DOUBLE_SEGMENT:
+            # Match a single optional segment (/slug or nothing)
+            regex_parts.append(r"(/[^/]+)?")
+        elif part == constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT:
+            regex_parts.append(".*")
+        else:
+            regex_parts.append(re.escape("/" + part))
+    # Join the regex parts and compile the regex
+    regex_pattern = "".join(regex_parts)
+    regex_pattern = f"^{regex_pattern}/?$"
+    return re.compile(regex_pattern)
+
+
+def get_router(routes: list[str]) -> Callable[[str], str | None]:
+    """Get a function that computes the route for a given path.
+
+    Args:
+        routes: A list of routes to match against.
+
+    Returns:
+        A function that takes a path and returns the first matching route,
+        or None if no match is found.
+    """
+    keyworded_routes = {
+        replace_brackets_with_keywords(route): route for route in routes
+    }
+    sorted_routes_by_specifity = sorted(
+        keyworded_routes.items(),
+        key=lambda item: route_specifity(item[0]),
     )
-    # Replace [<slug>] with __SINGLE_SEGMENT__
-    return re.sub(r"\[.+?\]", constants.RouteRegex.SINGLE_SEGMENT, output_string)
+    regexed_routes = [
+        (get_route_regex(keyworded_route), original_route)
+        for keyworded_route, original_route in sorted_routes_by_specifity
+    ]
+
+    def get_route(path: str) -> str | None:
+        """Get the first matching route for a given path.
+
+        Args:
+            path: The path to match against the routes.
+
+        Returns:
+            The first matching route, or None if no match is found.
+        """
+        path = "/" + path.removeprefix("/").removesuffix("/")
+        if path == "/index":
+            path = "/"
+        for regex, original_route in regexed_routes:
+            if regex.fullmatch(path):
+                return original_route
+        return None
+
+    return get_route

reflex/state.py

@@ -2053,11 +2053,28 @@ class BaseState(EvenMoreBasicBaseState):
 
         Returns:
             The value of the field.
+
+        Raises:
+            TypeError: If the key is not a string or MutableProxy.
         """
-        value = getattr(self, key)
-        if isinstance(value, MutableProxy):
-            return value.__wrapped__
-        return value
+        if isinstance(key, MutableProxy):
+            # Legacy behavior from v0.7.14: handle non-string keys with deprecation warning
+            from reflex.utils import console
+
+            console.deprecate(
+                feature_name="Non-string keys in get_value",
+                reason="Passing non-string keys to get_value is deprecated and will no longer be supported",
+                deprecation_version="0.8.0",
+                removal_version="0.9.0",
+            )
+
+            return key.__wrapped__
+
+        if isinstance(key, str):
+            return getattr(self, key)
+
+        msg = f"Invalid key type: {type(key)}. Expected str."
+        raise TypeError(msg)
 
     def dict(
         self, include_computed: bool = True, initial: bool = False, **kwargs

reflex/utils/exec.py

@@ -23,6 +23,7 @@ from reflex.constants.base import LogLevel
 from reflex.environment import environment
 from reflex.utils import console, path_ops
 from reflex.utils.decorator import once
+from reflex.utils.misc import get_module_path
 from reflex.utils.prerequisites import get_web_dir
 
 # For uvicorn windows bug fix (#2335)
@@ -323,15 +324,12 @@ def get_app_file() -> Path:
     if current_working_dir not in sys.path:
         # Add the current working directory to sys.path
         sys.path.insert(0, current_working_dir)
-    module_spec = importlib.util.find_spec(get_app_module())
-    if module_spec is None:
-        msg = f"Module {get_app_module()} not found. Make sure the module is installed."
+    app_module = get_app_module()
+    module_path = get_module_path(app_module)
+    if module_path is None:
+        msg = f"Module {app_module} not found. Make sure the module is installed."
         raise ImportError(msg)
-    file_name = module_spec.origin
-    if file_name is None:
-        msg = f"Module {get_app_module()} not found. Make sure the module is installed."
-        raise ImportError(msg)
-    return Path(file_name).resolve()
+    return module_path
 
 
 def get_app_instance_from_file() -> str:
@@ -396,8 +394,10 @@ def get_reload_paths() -> Sequence[Path]:
     """
     config = get_config()
     reload_paths = [Path.cwd()]
-    if (spec := importlib.util.find_spec(config.module)) is not None and spec.origin:
-        module_path = Path(spec.origin).resolve().parent
+    app_module = config.module
+    module_path = get_module_path(app_module)
+    if module_path is not None:
+        module_path = module_path.parent
 
         while module_path.parent.name and _has_child_file(module_path, "__init__.py"):
             if _has_child_file(module_path, "rxconfig.py"):

reflex/utils/format.py

@@ -310,20 +310,16 @@ def format_var(var: Var) -> str:
     return str(var)
 
 
-def format_route(route: str, format_case: bool = True) -> str:
+def format_route(route: str) -> str:
     """Format the given route.
 
     Args:
         route: The route to format.
-        format_case: whether to format case to kebab case.
 
     Returns:
         The formatted route.
     """
     route = route.strip("/")
-    # Strip the route and format casing.
-    if format_case:
-        route = to_kebab_case(route)
 
     # If the route is empty, return the index route.
     if route == "":

reflex/utils/misc.py

@@ -9,6 +9,46 @@ from pathlib import Path
 from typing import Any
 
 
+def get_module_path(module_name: str) -> Path | None:
+    """Check if a module exists and return its path.
+
+    This function searches for a module by navigating through the module hierarchy
+    in each path of sys.path, checking for both .py files and packages with __init__.py.
+
+    Args:
+        module_name: The name of the module to search for (e.g., "package.submodule").
+
+    Returns:
+        The path to the module file if found, None otherwise.
+    """
+    parts = module_name.split(".")
+
+    # Check each path in sys.path
+    for path in sys.path:
+        current_path = Path(path)
+
+        # Navigate through the module hierarchy
+        for i, part in enumerate(parts):
+            potential_file = current_path / (part + ".py")
+            potential_dir = current_path / part
+            potential_init = current_path / part / "__init__.py"
+
+            if potential_file.is_file():
+                # We encountered a file, but we can't continue deeper
+                if i == len(parts) - 1:
+                    return potential_file
+                return None  # Can't continue deeper
+            if potential_dir.is_dir() and potential_init.is_file():
+                # It's a package, so we can continue deeper
+                current_path = potential_dir
+            else:
+                break  # Path doesn't exist, break out of the loop
+        else:
+            return current_path / "__init__.py"  # Made it through all parts
+
+    return None
+
+
 async def run_in_thread(func: Callable) -> Any:
     """Run a function in a separate thread.
 

reflex/utils/prerequisites.py

@@ -40,6 +40,7 @@ from reflex.config import Config, get_config
 from reflex.environment import environment
 from reflex.utils import console, net, path_ops, processes, redir
 from reflex.utils.exceptions import SystemPackageMissingError
+from reflex.utils.misc import get_module_path
 from reflex.utils.registry import get_npm_registry
 
 if typing.TYPE_CHECKING:
@@ -348,14 +349,11 @@ def _check_app_name(config: Config):
         )
         raise RuntimeError(msg)
 
-    from reflex.utils.misc import with_cwd_in_syspath
+    from reflex.utils.misc import get_module_path, with_cwd_in_syspath
 
     with with_cwd_in_syspath():
-        try:
-            mod_spec = importlib.util.find_spec(config.module)
-        except ModuleNotFoundError:
-            mod_spec = None
-        if mod_spec is None:
+        module_path = get_module_path(config.module)
+        if module_path is None:
             msg = f"Module {config.module} not found. "
             if config.app_module_import is not None:
                 msg += f"Ensure app_module_import='{config.app_module_import}' in rxconfig.py matches your folder structure."
@@ -740,14 +738,11 @@ def rename_app(new_app_name: str, loglevel: constants.LogLevel):
     sys.path.insert(0, str(Path.cwd()))
 
     config = get_config()
-    module_path = importlib.util.find_spec(config.module)
+    module_path = get_module_path(config.module)
     if module_path is None:
         console.error(f"Could not find module {config.module}.")
         raise click.exceptions.Exit(1)
 
-    if not module_path.origin:
-        console.error(f"Could not find origin for module {config.module}.")
-        raise click.exceptions.Exit(1)
     console.info(f"Renaming app directory to {new_app_name}.")
     process_directory(
         Path.cwd(),
@@ -756,7 +751,7 @@ def rename_app(new_app_name: str, loglevel: constants.LogLevel):
         exclude_dirs=[constants.Dirs.WEB, constants.Dirs.APP_ASSETS],
     )
 
-    rename_path_up_tree(Path(module_path.origin), config.app_name, new_app_name)
+    rename_path_up_tree(module_path, config.app_name, new_app_name)
 
     console.success(f"App directory renamed to [bold]{new_app_name}[/bold].")
 

reflex/utils/pyi_generator.py

@@ -13,7 +13,6 @@ import subprocess
 import sys
 import typing
 from collections.abc import Callable, Iterable, Sequence
-from fileinput import FileInput
 from hashlib import md5
 from inspect import getfullargspec
 from itertools import chain
@@ -67,7 +66,6 @@ OVERWRITE_TYPES = {
 }
 
 DEFAULT_TYPING_IMPORTS = {
-    "overload",
     "Any",
     "Callable",
     "Dict",
@@ -677,10 +675,7 @@ def _generate_component_create_functiondef(
                 value=ast.Constant(value=Ellipsis),
             ),
         ],
-        decorator_list=[
-            ast.Name(id="overload"),
-            *decorator_list,
-        ],
+        decorator_list=list(decorator_list),
         lineno=lineno,
         returns=ast.Constant(value=clz.__name__),
     )
@@ -896,7 +891,7 @@ class StubGenerator(ast.NodeTransformer):
             The modified ImportFrom node.
         """
         if node.module == "__future__":
-            return None  # ignore __future__ imports
+            return None  # ignore __future__ imports: https://docs.astral.sh/ruff/rules/future-annotations-in-stub/
         return self.visit_Import(node)
 
     def visit_ClassDef(self, node: ast.ClassDef) -> ast.ClassDef:
@@ -1109,9 +1104,10 @@ class PyiGenerator:
 
     def _get_init_lazy_imports(self, mod: tuple | ModuleType, new_tree: ast.AST):
         # retrieve the _SUBMODULES and _SUBMOD_ATTRS from an init file if present.
-        sub_mods = getattr(mod, "_SUBMODULES", None)
-        sub_mod_attrs = getattr(mod, "_SUBMOD_ATTRS", None)
-        pyright_ignore_imports = getattr(mod, "_PYRIGHT_IGNORE_IMPORTS", [])
+        sub_mods: set[str] | None = getattr(mod, "_SUBMODULES", None)
+        sub_mod_attrs: dict[str, list[str | tuple[str, str]]] | None = getattr(
+            mod, "_SUBMOD_ATTRS", None
+        )
 
         if not sub_mods and not sub_mod_attrs:
             return None
@@ -1119,31 +1115,34 @@ class PyiGenerator:
         sub_mod_attrs_imports = []
 
         if sub_mods:
-            sub_mods_imports = [
-                f"from . import {mod} as {mod}" for mod in sorted(sub_mods)
-            ]
+            sub_mods_imports = [f"from . import {mod}" for mod in sorted(sub_mods)]
             sub_mods_imports.append("")
 
         if sub_mod_attrs:
-            sub_mod_attrs = {
-                attr: mod for mod, attrs in sub_mod_attrs.items() for attr in attrs
+            flattened_sub_mod_attrs = {
+                imported: module
+                for module, attrs in sub_mod_attrs.items()
+                for imported in attrs
             }
             # construct the import statement and handle special cases for aliases
             sub_mod_attrs_imports = [
-                f"from .{path} import {mod if not isinstance(mod, tuple) else mod[0]} as {mod if not isinstance(mod, tuple) else mod[1]}"
+                f"from .{module} import "
                 + (
-                    "  # type: ignore"
-                    if mod in pyright_ignore_imports
-                    else "  # noqa: F401"  # ignore ruff formatting here for cases like rx.list.
-                    if isinstance(mod, tuple)
-                    else ""
+                    (
+                        (imported[0] + " as " + imported[1])
+                        if imported[0] != imported[1]
+                        else imported[0]
+                    )
+                    if isinstance(imported, tuple)
+                    else imported
                 )
-                for mod, path in sub_mod_attrs.items()
+                for imported, module in flattened_sub_mod_attrs.items()
             ]
             sub_mod_attrs_imports.append("")
 
         text = "\n" + "\n".join([*sub_mods_imports, *sub_mod_attrs_imports])
-        text += ast.unparse(new_tree) + "\n"
+        text += ast.unparse(new_tree) + "\n\n"
+        text += f"__all__ = {getattr(mod, '__all__', [])!r}\n"
         return text
 
     def _scan_file(self, module_path: Path) -> tuple[str, str] | None:
@@ -1258,10 +1257,7 @@ class PyiGenerator:
         if file_paths:
             subprocess.run(["ruff", "format", *file_paths])
             subprocess.run(["ruff", "check", "--fix", *file_paths])
-
-        # For some reason, we need to format the __init__.pyi files again after fixing...
-        init_files = [f for f in file_paths if "/__init__.pyi" in f]
-        subprocess.run(["ruff", "format", *init_files])
+            subprocess.run(["ruff", "format", *file_paths])
 
         if use_json:
             if file_paths and changed_files is None:
@@ -1327,19 +1323,6 @@ class PyiGenerator:
                         json.dumps(pyi_hashes, indent=2, sort_keys=True) + "\n"
                     )
 
-        # Post-process the generated pyi files to add hacky type: ignore comments
-        for file_path in file_paths:
-            with FileInput(file_path, inplace=True) as f:
-                for line in f:
-                    # Hack due to ast not supporting comments in the tree.
-                    if (
-                        "def create(" in line
-                        or "Var[Figure]" in line
-                        or "Var[Template]" in line
-                    ):
-                        line = line.rstrip() + "  # type: ignore\n"
-                    print(line, end="")  # noqa: T201
-
 
 if __name__ == "__main__":
     import argparse

reflex/utils/types.py

@@ -495,7 +495,7 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
                 return list[
                     get_attribute_access_type(
                         attr.target_class,
-                        attr.remote_attr.key,  # type: ignore[attr-defined]
+                        attr.remote_attr.key,  # pyright: ignore [reportAttributeAccessIssue]
                     )
                 ]
     elif isinstance(cls, type) and not is_generic_alias(cls) and issubclass(cls, Model):