reflex 0.8.0a4__py3-none-any.whl → 0.8.0a6__py3-none-any.whl

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

@@ -37,6 +37,7 @@ from reflex.event import (
     EventSpec,
     fix_events,
 )
+from reflex.istate import HANDLED_PICKLE_ERRORS, debug_failed_pickles
 from reflex.istate.data import RouterData
 from reflex.istate.proxy import ImmutableMutableProxy as ImmutableMutableProxy
 from reflex.istate.proxy import MutableProxy, StateProxy
@@ -85,14 +86,6 @@ if environment.REFLEX_PERF_MODE.get() != PerformanceMode.OFF:
     # Only warn about each state class size once.
     _WARNED_ABOUT_STATE_SIZE: set[str] = set()
 
-# Errors caught during pickling of state
-HANDLED_PICKLE_ERRORS = (
-    pickle.PicklingError,
-    AttributeError,
-    IndexError,
-    TypeError,
-    ValueError,
-)
 
 # For BaseState.get_var_value
 VAR_TYPE = TypeVar("VAR_TYPE")
@@ -2053,11 +2046,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
@@ -2234,11 +2244,16 @@ class BaseState(EvenMoreBasicBaseState):
 
         Raises:
             StateSerializationError: If the state cannot be serialized.
+
+        # noqa: DAR401: e
+        # noqa: DAR402: StateSerializationError
         """
         payload = b""
         error = ""
+        self_schema = self._to_schema()
+        pickle_function = pickle.dumps
         try:
-            payload = pickle.dumps((self._to_schema(), self))
+            payload = pickle.dumps((self_schema, self))
         except HANDLED_PICKLE_ERRORS as og_pickle_error:
             error = (
                 f"Failed to serialize state {self.get_full_name()} due to unpicklable object. "
@@ -2247,7 +2262,8 @@ class BaseState(EvenMoreBasicBaseState):
             try:
                 import dill
 
-                payload = dill.dumps((self._to_schema(), self))
+                pickle_function = dill.dumps
+                payload = dill.dumps((self_schema, self))
             except ImportError:
                 error += (
                     f"Pickle error: {og_pickle_error}. "
@@ -2255,13 +2271,19 @@ class BaseState(EvenMoreBasicBaseState):
                 )
             except HANDLED_PICKLE_ERRORS as ex:
                 error += f"Dill was also unable to pickle the state: {ex}"
-            console.warn(error)
 
         if environment.REFLEX_PERF_MODE.get() != PerformanceMode.OFF:
             self._check_state_size(len(payload))
 
         if not payload:
-            raise StateSerializationError(error)
+            e = StateSerializationError(error)
+            if sys.version_info >= (3, 11):
+                try:
+                    debug_failed_pickles(self, pickle_function)
+                except HANDLED_PICKLE_ERRORS as ex:
+                    for note in ex.__notes__:
+                        e.add_note(note)
+            raise e
 
         return payload
 

reflex/testing.py

@@ -24,7 +24,6 @@ from http.server import SimpleHTTPRequestHandler
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, TypeVar
 
-import psutil
 import uvicorn
 
 import reflex
@@ -478,6 +477,8 @@ class AppHarness:
 
     def stop(self) -> None:
         """Stop the frontend and backend servers."""
+        import psutil
+
         # Quit browsers first to avoid any lingering events being sent during shutdown.
         for driver in self._frontends:
             driver.quit()

reflex/utils/exec.py

@@ -15,14 +15,13 @@ from pathlib import Path
 from typing import Any, NamedTuple, TypedDict
 from urllib.parse import urljoin
 
-import psutil
-
 from reflex import constants
 from reflex.config import get_config
 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)
@@ -130,12 +129,16 @@ def get_different_packages(
 def kill(proc_pid: int):
     """Kills a process and all its child processes.
 
+    Requires the `psutil` library to be installed.
+
     Args:
-        proc_pid (int): The process ID of the process to be killed.
+        proc_pid: The process ID of the process to be killed.
 
     Example:
         >>> kill(1234)
     """
+    import psutil
+
     process = psutil.Process(proc_pid)
     for proc in process.children(recursive=True):
         proc.kill()
@@ -323,15 +326,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:
@@ -367,6 +367,9 @@ def run_backend(
 
     # Run the backend in development mode.
     if should_use_granian():
+        # We import reflex app because this lets granian cache the module
+        import reflex.app  # noqa: F401
+
         run_granian_backend(host, port, loglevel)
     else:
         run_uvicorn_backend(host, port, loglevel)
@@ -396,8 +399,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/imports.py

@@ -52,19 +52,12 @@ def parse_imports(
     Returns:
         The parsed import dict.
     """
-
-    def _make_list(
-        value: ImmutableImportTypes,
-    ) -> list[str | ImportVar] | list[ImportVar]:
-        if isinstance(value, (str, ImportVar)):
-            return [value]
-        return list(value)
-
     return {
-        package: [
-            ImportVar(tag=tag) if isinstance(tag, str) else tag
-            for tag in _make_list(maybe_tags)
-        ]
+        package: [maybe_tags]
+        if isinstance(maybe_tags, ImportVar)
+        else [ImportVar(tag=maybe_tags)]
+        if isinstance(maybe_tags, str)
+        else [ImportVar(tag=tag) if isinstance(tag, str) else tag for tag in maybe_tags]
         for package, maybe_tags in imports.items()
     }
 

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:
@@ -115,7 +116,7 @@ def check_latest_package_version(package_name: str):
         # Get the latest version from PyPI
         current_version = importlib.metadata.version(package_name)
         url = f"https://pypi.org/pypi/{package_name}/json"
-        response = net.get(url)
+        response = net.get(url, timeout=2)
         latest_version = response.json()["info"]["version"]
         console.debug(f"Latest version of {package_name}: {latest_version}")
         if get_or_set_last_reflex_version_check_datetime():
@@ -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].")