reflex 0.7.14a6__py3-none-any.whl → 0.8.0a2__py3-none-any.whl

reflex/utils/prerequisites.py

@@ -39,9 +39,7 @@ from reflex.compiler import templates
 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.decorator import once
 from reflex.utils.exceptions import SystemPackageMissingError
-from reflex.utils.format import format_library_name
 from reflex.utils.registry import get_npm_registry
 
 if typing.TYPE_CHECKING:
@@ -74,7 +72,7 @@ class CpuInfo:
 
 
 def get_web_dir() -> Path:
-    """Get the working directory for the next.js commands.
+    """Get the working directory for the frontend.
 
     Can be overridden with REFLEX_WEB_WORKDIR.
 
@@ -334,13 +332,14 @@ def npm_escape_hatch() -> bool:
 
 
 def _check_app_name(config: Config):
-    """Check if the app name is set in the config.
+    """Check if the app name is valid and matches the folder structure.
 
     Args:
         config: The config object.
 
     Raises:
-        RuntimeError: If the app name is not set in the config.
+        RuntimeError: If the app name is not set, folder doesn't exist, or doesn't match config.
+        ModuleNotFoundError: If the app_name is not importable (i.e., not a valid Python package, folder structure being wrong).
     """
     if not config.app_name:
         msg = (
@@ -349,6 +348,21 @@ def _check_app_name(config: Config):
         )
         raise RuntimeError(msg)
 
+    from reflex.utils.misc import 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:
+            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."
+            else:
+                msg += f"Ensure app_name='{config.app_name}' in rxconfig.py matches your folder structure."
+            raise ModuleNotFoundError(msg)
+
 
 def get_app(reload: bool = False) -> ModuleType:
     """Get the app module based on the default config.
@@ -439,7 +453,7 @@ def validate_app(
 
 def get_compiled_app(
     reload: bool = False,
-    export: bool = False,
+    prerender_routes: bool = False,
     dry_run: bool = False,
     check_if_schema_up_to_date: bool = False,
 ) -> ModuleType:
@@ -447,7 +461,7 @@ def get_compiled_app(
 
     Args:
         reload: Re-import the app module from disk
-        export: Compile the app for export
+        prerender_routes: Whether to prerender routes.
         dry_run: If True, do not write the compiled app to disk.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
 
@@ -460,13 +474,13 @@ def get_compiled_app(
     # For py3.9 compatibility when redis is used, we MUST add any decorator pages
     # before compiling the app in a thread to avoid event loop error (REF-2172).
     app._apply_decorated_pages()
-    app._compile(export=export, dry_run=dry_run)
+    app._compile(prerender_routes=prerender_routes, dry_run=dry_run)
     return app_module
 
 
 def compile_app(
     reload: bool = False,
-    export: bool = False,
+    prerender_routes: bool = False,
     dry_run: bool = False,
     check_if_schema_up_to_date: bool = False,
 ) -> None:
@@ -474,13 +488,13 @@ def compile_app(
 
     Args:
         reload: Re-import the app module from disk
-        export: Compile the app for export
+        prerender_routes: Whether to prerender routes.
         dry_run: If True, do not write the compiled app to disk.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
     """
     get_compiled_app(
         reload=reload,
-        export=export,
+        prerender_routes=prerender_routes,
         dry_run=dry_run,
         check_if_schema_up_to_date=check_if_schema_up_to_date,
     )
@@ -529,20 +543,26 @@ def _can_colorize() -> bool:
 
 
 def compile_or_validate_app(
-    compile: bool = False, check_if_schema_up_to_date: bool = False
+    compile: bool = False,
+    check_if_schema_up_to_date: bool = False,
+    prerender_routes: bool = False,
 ) -> bool:
     """Compile or validate the app module based on the default config.
 
     Args:
         compile: Whether to compile the app.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
+        prerender_routes: Whether to prerender routes.
 
     Returns:
         If the app is compiled successfully.
     """
     try:
         if compile:
-            compile_app(check_if_schema_up_to_date=check_if_schema_up_to_date)
+            compile_app(
+                check_if_schema_up_to_date=check_if_schema_up_to_date,
+                prerender_routes=prerender_routes,
+            )
         else:
             validate_app(check_if_schema_up_to_date=check_if_schema_up_to_date)
     except Exception as e:
@@ -591,19 +611,19 @@ def get_redis_sync() -> RedisSync | None:
 
 
 def parse_redis_url() -> str | None:
-    """Parse the REDIS_URL in config if applicable.
+    """Parse the REFLEX_REDIS_URL in config if applicable.
 
     Returns:
         If url is non-empty, return the URL as it is.
 
     Raises:
-        ValueError: If the REDIS_URL is not a supported scheme.
+        ValueError: If the REFLEX_REDIS_URL is not a supported scheme.
     """
     config = get_config()
     if not config.redis_url:
         return None
     if not config.redis_url.startswith(("redis://", "rediss://", "unix://")):
-        msg = "REDIS_URL must start with 'redis://', 'rediss://', or 'unix://'."
+        msg = "REFLEX_REDIS_URL must start with 'redis://', 'rediss://', or 'unix://'."
         raise ValueError(msg)
     return config.redis_url
 
@@ -1017,29 +1037,19 @@ def initialize_web_directory():
     console.debug("Initializing the public directory.")
     path_ops.mkdir(get_web_dir() / constants.Dirs.PUBLIC)
 
-    console.debug("Initializing the next.config.js file.")
-    update_next_config()
+    console.debug("Initializing the react-router.config.js file.")
+    update_react_router_config()
 
     console.debug("Initializing the reflex.json file.")
     # Initialize the reflex json file.
     init_reflex_json(project_hash=project_hash)
 
 
-@once
-def _turbopack_flag() -> str:
-    return " --turbopack" if environment.REFLEX_USE_TURBOPACK.get() else ""
-
-
 def _compile_package_json():
     return templates.PACKAGE_JSON.render(
         scripts={
-            "dev": constants.PackageJson.Commands.DEV.format(flags=_turbopack_flag()),
-            "export": constants.PackageJson.Commands.EXPORT.format(
-                flags=_turbopack_flag()
-            ),
-            "export_sitemap": constants.PackageJson.Commands.EXPORT_SITEMAP.format(
-                flags=_turbopack_flag()
-            ),
+            "dev": constants.PackageJson.Commands.DEV,
+            "export": constants.PackageJson.Commands.EXPORT,
             "prod": constants.PackageJson.Commands.PROD,
         },
         dependencies=constants.PackageJson.DEPENDENCIES,
@@ -1107,50 +1117,43 @@ def init_reflex_json(project_hash: int | None):
     path_ops.update_json_file(get_web_dir() / constants.Reflex.JSON, reflex_json)
 
 
-def update_next_config(
-    export: bool = False, transpile_packages: list[str] | None = None
-):
-    """Update Next.js config from Reflex config.
+def update_react_router_config(prerender_routes: bool = False):
+    """Update react-router.config.js config from Reflex config.
 
     Args:
-        export: if the method run during reflex export.
-        transpile_packages: list of packages to transpile via next.config.js.
+        prerender_routes: Whether to enable prerendering of routes.
     """
-    next_config_file = get_web_dir() / constants.Next.CONFIG_FILE
+    react_router_config_file_path = get_web_dir() / constants.ReactRouter.CONFIG_FILE
 
-    next_config = _update_next_config(
-        get_config(), export=export, transpile_packages=transpile_packages
+    new_react_router_config = _update_react_router_config(
+        get_config(), prerender_routes=prerender_routes
     )
 
-    # Overwriting the next.config.js triggers a full server reload, so make sure
+    # Overwriting the config file triggers a full server reload, so make sure
     # there is actually a diff.
-    orig_next_config = next_config_file.read_text() if next_config_file.exists() else ""
-    if orig_next_config != next_config:
-        next_config_file.write_text(next_config)
+    old_react_router_config = (
+        react_router_config_file_path.read_text()
+        if react_router_config_file_path.exists()
+        else ""
+    )
+    if old_react_router_config != new_react_router_config:
+        react_router_config_file_path.write_text(new_react_router_config)
 
 
-def _update_next_config(
-    config: Config, export: bool = False, transpile_packages: list[str] | None = None
-):
-    next_config = {
-        "basePath": config.frontend_path or "",
-        "compress": config.next_compression,
-        "trailingSlash": True,
-        "staticPageGenerationTimeout": config.static_page_generation_timeout,
+def _update_react_router_config(config: Config, prerender_routes: bool = False):
+    react_router_config = {
+        "basename": "/" + (config.frontend_path or "").removeprefix("/"),
+        "future": {
+            "unstable_optimizeDeps": True,
+        },
+        "ssr": False,
     }
-    if not config.next_dev_indicators:
-        next_config["devIndicators"] = False
 
-    if transpile_packages:
-        next_config["transpilePackages"] = list(
-            dict.fromkeys([format_library_name(p) for p in transpile_packages])
-        )
-    if export:
-        next_config["output"] = "export"
-        next_config["distDir"] = constants.Dirs.STATIC
+    if prerender_routes:
+        react_router_config["prerender"] = True
+        react_router_config["build"] = constants.Dirs.BUILD_DIR
 
-    next_config_json = re.sub(r'"([^"]+)"(?=:)', r"\1", json.dumps(next_config))
-    return f"module.exports = {next_config_json};"
+    return f"export default {json.dumps(react_router_config)};"
 
 
 def remove_existing_bun_installation():

reflex/utils/processes.py

@@ -320,7 +320,8 @@ def stream_logs(
 
     # Windows uvicorn bug
     # https://github.com/reflex-dev/reflex/issues/2335
-    accepted_return_codes = [0, -2, 15] if constants.IS_WINDOWS else [0, -2]
+    # 130 is the exit code that react router returns when it is interrupted by a signal.
+    accepted_return_codes = [0, -2, 15, 130] if constants.IS_WINDOWS else [0, -2, 130]
     if process.returncode not in accepted_return_codes and not suppress_errors:
         console.error(f"{message} failed with exit code {process.returncode}")
         if "".join(logs).count("CERT_HAS_EXPIRED") > 0:
@@ -412,12 +413,12 @@ def show_progress(message: str, process: subprocess.Popen, checkpoints: list[str
         task = progress.add_task(f"{message}: ", total=len(checkpoints))
         for line in stream_logs(message, process, progress=progress):
             # Check for special strings and update the progress bar.
-            for special_string in checkpoints:
-                if special_string in line:
-                    progress.update(task, advance=1)
-                    if special_string == checkpoints[-1]:
-                        progress.update(task, completed=len(checkpoints))
-                    break
+            special_string = checkpoints[0]
+            if special_string in line:
+                progress.update(task, advance=1)
+                checkpoints.pop(0)
+            if not checkpoints:
+                break
 
 
 def atexit_handler():

reflex/utils/pyi_generator.py

@@ -90,6 +90,7 @@ DEFAULT_IMPORTS = {
         "EventSpec",
         "EventType",
         "KeyInputInfo",
+        "PointerEventInfo",
     ],
     "reflex.style": ["Style"],
     "reflex.vars.base": ["Var"],
@@ -366,7 +367,7 @@ def _extract_class_props_as_ast_nodes(
     all_props = []
     kwargs = []
     for target_class in clzs:
-        event_triggers = target_class._create([]).get_event_triggers()
+        event_triggers = target_class.get_event_triggers()
         # Import from the target class to ensure type hints are resolvable.
         exec(f"from {target_class.__module__} import *", type_hint_globals)
         for name, value in target_class.__annotations__.items():
@@ -409,7 +410,7 @@ def _extract_class_props_as_ast_nodes(
                             )
                         ),
                     ),
-                    ast.Constant(value=default),
+                    ast.Constant(value=default),  # pyright: ignore [reportArgumentType]
                 )
             )
     return kwargs
@@ -444,7 +445,11 @@ def type_to_ast(typ: Any, cls: type) -> ast.expr:
 
                 if all(a == b for a, b in zipped) and len(typ_parts) == len(cls_parts):
                     return ast.Name(id=typ.__name__)
-
+                if (
+                    typ.__module__ in DEFAULT_IMPORTS
+                    and typ.__name__ in DEFAULT_IMPORTS[typ.__module__]
+                ):
+                    return ast.Name(id=typ.__name__)
                 return ast.Name(id=typ.__module__ + "." + typ.__name__)
             return ast.Name(id=typ.__name__)
         if hasattr(typ, "_name"):
@@ -607,7 +612,7 @@ def _generate_component_create_functiondef(
             return ast.Name(id=f"{' | '.join(map(ast.unparse, all_count_args_type))}")
         return ast.Name(id="EventType[Any]")
 
-    event_triggers = clz._create([]).get_event_triggers()
+    event_triggers = clz.get_event_triggers()
 
     # event handler kwargs
     kwargs.extend(
@@ -1337,12 +1342,19 @@ class PyiGenerator:
 
 
 if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate .pyi stub files")
+    parser.add_argument(
+        "targets",
+        nargs="*",
+        default=["reflex/components", "reflex/experimental", "reflex/__init__.py"],
+        help="Target directories/files to process",
+    )
+    args = parser.parse_args()
+
     logging.basicConfig(level=logging.INFO)
     logging.getLogger("blib2to3.pgen2.driver").setLevel(logging.INFO)
 
     gen = PyiGenerator()
-    gen.scan_all(
-        ["reflex/components", "reflex/experimental", "reflex/__init__.py"],
-        None,
-        use_json=True,
-    )
+    gen.scan_all(args.targets, None, use_json=True)

reflex/utils/serializers.py

@@ -9,7 +9,7 @@ import functools
 import inspect
 import json
 import warnings
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from datetime import date, datetime, time, timedelta
 from enum import Enum
 from pathlib import Path
@@ -335,6 +335,19 @@ def serialize_sequence(value: Sequence) -> list:
     return list(value)
 
 
+@serializer(to=dict)
+def serialize_mapping(value: Mapping) -> dict:
+    """Serialize a mapping type to a dictionary.
+
+    Args:
+        value: The mapping instance to serialize.
+
+    Returns:
+        A new dictionary containing the same key-value pairs as the input mapping.
+    """
+    return {**value}
+
+
 @serializer(to=str)
 def serialize_datetime(dt: date | datetime | time | timedelta) -> str:
     """Serialize a datetime to a JSON string.