reflex 0.4.4a2__py3-none-any.whl → 0.4.5__py3-none-any.whl

reflex/state.py

@@ -472,7 +472,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 events[name] = value
 
         for name, fn in events.items():
-            handler = EventHandler(fn=fn)
+            handler = cls._create_event_handler(fn)
             cls.event_handlers[name] = handler
             setattr(cls, name, handler)
 
@@ -677,7 +677,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
     @classmethod
     @functools.lru_cache()
-    def get_class_substate(cls, path: Sequence[str]) -> Type[BaseState]:
+    def get_class_substate(cls, path: Sequence[str] | str) -> Type[BaseState]:
         """Get the class substate.
 
         Args:
@@ -689,6 +689,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         Raises:
             ValueError: If the substate is not found.
         """
+        if isinstance(path, str):
+            path = tuple(path.split("."))
+
         if len(path) == 0:
             return cls
         if path[0] == cls.get_name():
@@ -789,6 +792,18 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         """
         setattr(cls, prop._var_name, prop)
 
+    @classmethod
+    def _create_event_handler(cls, fn):
+        """Create an event handler for the given function.
+
+        Args:
+            fn: The function to create an event handler for.
+
+        Returns:
+            The event handler.
+        """
+        return EventHandler(fn=fn, state_full_name=cls.get_full_name())
+
     @classmethod
     def _create_setter(cls, prop: BaseVar):
         """Create a setter for the var.
@@ -798,7 +813,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         """
         setter_name = prop.get_setter_name(include_state=False)
         if setter_name not in cls.__dict__:
-            event_handler = EventHandler(fn=prop.get_setter())
+            event_handler = cls._create_event_handler(prop.get_setter())
             cls.event_handlers[setter_name] = event_handler
             setattr(cls, setter_name, event_handler)
 
@@ -1752,7 +1767,7 @@ class UpdateVarsInternalState(State):
         """
         for var, value in vars.items():
             state_name, _, var_name = var.rpartition(".")
-            var_state_cls = State.get_class_substate(tuple(state_name.split(".")))
+            var_state_cls = State.get_class_substate(state_name)
             var_state = await self.get_state(var_state_cls)
             setattr(var_state, var_name, value)
 
@@ -2268,7 +2283,7 @@ class StateManagerRedis(StateManager):
         _, state_path = _split_substate_key(token)
         if state_path:
             # Get the State class associated with the given path.
-            state_cls = self.state.get_class_substate(tuple(state_path.split(".")))
+            state_cls = self.state.get_class_substate(state_path)
         else:
             raise RuntimeError(
                 "StateManagerRedis requires token to be specified in the form of {token}_{state_full_name}"

reflex/testing.py

@@ -211,7 +211,9 @@ class AppHarness:
             # get the source from a function or module object
             source_code = "\n".join(
                 [
-                    "\n".join(f"{k} = {v!r}" for k, v in app_globals.items()),
+                    "\n".join(
+                        self.get_app_global_source(k, v) for k, v in app_globals.items()
+                    ),
                     self._get_source_from_app_source(self.app_source),
                 ]
             )
@@ -331,6 +333,24 @@ class AppHarness:
         self._wait_frontend()
         return self
 
+    @staticmethod
+    def get_app_global_source(key, value):
+        """Get the source code of a global object.
+        If value is a function or class we render the actual
+        source of value otherwise we assign value to key.
+
+        Args:
+            key: variable name to assign value to.
+            value: value of the global variable.
+
+        Returns:
+            The rendered app global code.
+
+        """
+        if not inspect.isclass(value) and not inspect.isfunction(value):
+            return f"{key} = {value!r}"
+        return inspect.getsource(value)
+
     def __enter__(self) -> "AppHarness":
         """Contextmanager protocol for `start()`.
 

reflex/utils/exec.py

@@ -307,3 +307,12 @@ def is_prod_mode() -> bool:
         constants.Env.DEV.value,
     )
     return current_mode == constants.Env.PROD.value
+
+
+def should_skip_compile() -> bool:
+    """Whether the app should skip compile.
+
+    Returns:
+        True if the app should skip compile.
+    """
+    return os.environ.get(constants.SKIP_COMPILE_ENV_VAR) == "yes"

reflex/utils/format.py

@@ -6,8 +6,7 @@ import inspect
 import json
 import os
 import re
-import sys
-from typing import TYPE_CHECKING, Any, List, Union
+from typing import TYPE_CHECKING, Any, List, Optional, Union
 
 from reflex import constants
 from reflex.utils import exceptions, serializers, types
@@ -161,16 +160,17 @@ def to_camel_case(text: str, allow_hyphens: bool = False) -> str:
     return leading_underscores_or_hyphens + converted_word
 
 
-def to_title_case(text: str) -> str:
+def to_title_case(text: str, sep: str = "") -> str:
     """Convert a string from snake case to title case.
 
     Args:
         text: The string to convert.
+        sep: The separator to use to join the words.
 
     Returns:
         The title case string.
     """
-    return "".join(word.capitalize() for word in text.split("_"))
+    return sep.join(word.title() for word in text.split("_"))
 
 
 def to_kebab_case(text: str) -> str:
@@ -188,6 +188,20 @@ def to_kebab_case(text: str) -> str:
     return to_snake_case(text).replace("_", "-")
 
 
+def make_default_page_title(app_name: str, route: str) -> str:
+    """Make a default page title from a route.
+
+    Args:
+        app_name: The name of the app owning the page.
+        route: The route to make the title from.
+
+    Returns:
+        The default page title.
+    """
+    title = constants.DefaultPage.TITLE.format(app_name, route)
+    return to_title_case(title, " ")
+
+
 def _escape_js_string(string: str) -> str:
     """Escape the string for use as a JS string literal.
 
@@ -470,18 +484,18 @@ def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
     if len(parts) == 1:
         return ("", parts[-1])
 
-    # Get the state and the function name.
-    state_name, name = parts[-2:]
+    # Get the state full name
+    state_full_name = handler.state_full_name
 
-    # Construct the full event handler name.
-    try:
-        # Try to get the state from the module.
-        state = vars(sys.modules[handler.fn.__module__])[state_name]
-    except Exception:
-        # If the state isn't in the module, just return the function name.
+    # Get the function name
+    name = parts[-1]
+
+    from reflex.state import State
+
+    if state_full_name == "state" and name not in State.__dict__:
         return ("", to_snake_case(handler.fn.__qualname__))
 
-    return (state.get_full_name(), name)
+    return (state_full_name, name)
 
 
 def format_event_handler(handler: EventHandler) -> str:
@@ -513,9 +527,14 @@ def format_event(event_spec: EventSpec) -> str:
             ":".join(
                 (
                     name._var_name,
-                    wrap(json.dumps(val._var_name).strip('"').replace("`", "\\`"), "`")
-                    if val._var_is_string
-                    else val._var_full_name,
+                    (
+                        wrap(
+                            json.dumps(val._var_name).strip('"').replace("`", "\\`"),
+                            "`",
+                        )
+                        if val._var_is_string
+                        else val._var_full_name
+                    ),
                 )
             )
             for name, val in event_spec.args
@@ -584,11 +603,12 @@ def format_query_params(router_data: dict[str, Any]) -> dict[str, str]:
     return {k.replace("-", "_"): v for k, v in params.items()}
 
 
-def format_state(value: Any) -> Any:
+def format_state(value: Any, key: Optional[str] = None) -> Any:
     """Recursively format values in the given state.
 
     Args:
         value: The state to format.
+        key: The key associated with the value (optional).
 
     Returns:
         The formatted state.
@@ -598,7 +618,7 @@ def format_state(value: Any) -> Any:
     """
     # Handle dicts.
     if isinstance(value, dict):
-        return {k: format_state(v) for k, v in value.items()}
+        return {k: format_state(v, k) for k, v in value.items()}
 
     # Handle lists, sets, typles.
     if isinstance(value, types.StateIterBases):
@@ -613,7 +633,14 @@ def format_state(value: Any) -> Any:
     if serialized is not None:
         return serialized
 
-    raise TypeError(f"No JSON serializer found for var {value} of type {type(value)}.")
+    if key is None:
+        raise TypeError(
+            f"No JSON serializer found for var {value} of type {type(value)}."
+        )
+    else:
+        raise TypeError(
+            f"No JSON serializer found for State Var '{key}' of value {value} of type {type(value)}."
+        )
 
 
 def format_state_name(state_name: str) -> str:

reflex/utils/prerequisites.py

@@ -34,6 +34,8 @@ from reflex.compiler import templates
 from reflex.config import Config, get_config
 from reflex.utils import console, path_ops, processes
 
+CURRENTLY_INSTALLING_NODE = False
+
 
 def check_latest_package_version(package_name: str):
     """Check if the latest version of the package is installed.
@@ -103,8 +105,11 @@ def get_node_version() -> version.Version | None:
     Returns:
         The version of node.
     """
+    node_path = path_ops.get_node_path()
+    if node_path is None:
+        return None
     try:
-        result = processes.new_process([path_ops.get_node_path(), "-v"], run=True)
+        result = processes.new_process([node_path, "-v"], run=True)
         # The output will be in the form "vX.Y.Z", but version.parse() can handle it
         return version.parse(result.stdout)  # type: ignore
     except (FileNotFoundError, TypeError):
@@ -211,7 +216,11 @@ def get_compiled_app(reload: bool = False) -> ModuleType:
         The compiled app based on the default config.
     """
     app_module = get_app(reload=reload)
-    getattr(app_module, constants.CompileVars.APP).compile_()
+    app = getattr(app_module, constants.CompileVars.APP)
+    # For py3.8 and 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_()
     return app_module
 
 
@@ -425,19 +434,21 @@ def initialize_app_directory(app_name: str, template: constants.Templates.Kind):
     )
 
 
-def get_project_hash() -> int | None:
+def get_project_hash(raise_on_fail: bool = False) -> int | None:
     """Get the project hash from the reflex.json file if the file exists.
 
+    Args:
+        raise_on_fail: Whether to raise an error if the file does not exist.
+
     Returns:
         project_hash: The app hash.
     """
-    if not os.path.exists(constants.Reflex.JSON):
+    if not os.path.exists(constants.Reflex.JSON) and not raise_on_fail:
         return None
     # Open and read the file
     with open(constants.Reflex.JSON, "r") as file:
         data = json.load(file)
-        project_hash = data["project_hash"]
-        return project_hash
+        return data.get("project_hash")
 
 
 def initialize_web_directory():
@@ -611,6 +622,11 @@ def install_node():
         console.debug("")
         return
 
+    # Skip installation if check_node_version() checks out
+    if check_node_version():
+        console.debug("Skipping node installation as it is already installed.")
+        return
+
     path_ops.mkdir(constants.Fnm.DIR)
     if not os.path.exists(constants.Fnm.EXE):
         download_and_extract_fnm_zip()
@@ -627,10 +643,6 @@ def install_node():
             ],
         )
     else:  # All other platforms (Linux, MacOS).
-        # TODO we can skip installation if check_node_version() checks out
-        if check_node_version():
-            console.debug("Skipping node installation as it is already installed.")
-            return
         # Add execute permissions to fnm executable.
         os.chmod(constants.Fnm.EXE, stat.S_IXUSR)
         # Install node.
@@ -812,6 +824,11 @@ def check_initialized(frontend: bool = True):
         console.warn(
             """Windows Subsystem for Linux (WSL) is recommended for improving initial install times."""
         )
+        if sys.version_info >= (3, 12):
+            console.warn(
+                "Python 3.12 on Windows has known issues with hot reload (reflex-dev/reflex#2335). "
+                "Python 3.11 is recommended with this release of Reflex."
+            )
 
 
 def is_latest_template() -> bool:
@@ -931,8 +948,12 @@ def initialize_frontend_dependencies():
     """Initialize all the frontend dependencies."""
     # validate dependencies before install
     validate_frontend_dependencies()
+    # Avoid warning about Node installation while we're trying to install it.
+    global CURRENTLY_INSTALLING_NODE
+    CURRENTLY_INSTALLING_NODE = True
     # Install the frontend dependencies.
     processes.run_concurrently(install_node, install_bun)
+    CURRENTLY_INSTALLING_NODE = False
     # Set up the web directory.
     initialize_web_directory()
 

reflex/utils/processes.py

@@ -135,13 +135,20 @@ def new_process(args, run: bool = False, show_logs: bool = False, **kwargs):
 
     Returns:
         Execute a child program in a new process.
+
+    Raises:
+        Exit: When attempting to run a command with a None value.
     """
     node_bin_path = path_ops.get_node_bin_path()
-    if not node_bin_path:
+    if not node_bin_path and not prerequisites.CURRENTLY_INSTALLING_NODE:
         console.warn(
             "The path to the Node binary could not be found. Please ensure that Node is properly "
-            "installed and added to your system's PATH environment variable."
+            "installed and added to your system's PATH environment variable or try running "
+            "`reflex init` again."
         )
+    if None in args:
+        console.error(f"Invalid command: {args}")
+        raise typer.Exit(1)
     # Add the node bin path to the PATH environment variable.
     env = {
         **os.environ,

reflex/utils/telemetry.py

@@ -2,15 +2,17 @@
 
 from __future__ import annotations
 
-import json
 import multiprocessing
 import platform
 from datetime import datetime
 
+import httpx
 import psutil
 
 from reflex import constants
-from reflex.utils.prerequisites import ensure_reflex_installation_id
+from reflex.utils import console
+from reflex.utils.exec import should_skip_compile
+from reflex.utils.prerequisites import ensure_reflex_installation_id, get_project_hash
 
 POSTHOG_API_URL: str = "https://app.posthog.com/capture/"
 
@@ -57,7 +59,68 @@ def get_memory() -> int:
     Returns:
         The total memory in MB.
     """
-    return psutil.virtual_memory().total >> 20
+    try:
+        return psutil.virtual_memory().total >> 20
+    except ValueError:  # needed to pass ubuntu test
+        return 0
+
+
+def _raise_on_missing_project_hash() -> bool:
+    """Check if an error should be raised when project hash is missing.
+
+    When running reflex with --backend-only, or doing database migration
+    operations, there is no requirement for a .web directory, so the reflex.json
+    file may not exist, and this should not be considered an error.
+
+    Returns:
+        False when compilation should be skipped (i.e. no .web directory is required).
+        Otherwise return True.
+    """
+    if should_skip_compile():
+        return False
+    return True
+
+
+def _prepare_event(event: str) -> dict:
+    """Prepare the event to be sent to the PostHog server.
+
+    Args:
+        event: The event name.
+
+    Returns:
+        The event data.
+    """
+    installation_id = ensure_reflex_installation_id()
+    project_hash = get_project_hash(raise_on_fail=_raise_on_missing_project_hash())
+
+    if installation_id is None or project_hash is None:
+        console.debug(
+            f"Could not get installation_id or project_hash: {installation_id}, {project_hash}"
+        )
+        return {}
+
+    return {
+        "api_key": "phc_JoMo0fOyi0GQAooY3UyO9k0hebGkMyFJrrCw1Gt5SGb",
+        "event": event,
+        "properties": {
+            "distinct_id": installation_id,
+            "distinct_app_id": project_hash,
+            "user_os": get_os(),
+            "reflex_version": get_reflex_version(),
+            "python_version": get_python_version(),
+            "cpu_count": get_cpu_count(),
+            "memory": get_memory(),
+        },
+        "timestamp": datetime.utcnow().isoformat(),
+    }
+
+
+def _send_event(event_data: dict) -> bool:
+    try:
+        httpx.post(POSTHOG_API_URL, json=event_data)
+        return True
+    except Exception:
+        return False
 
 
 def send(event: str, telemetry_enabled: bool | None = None) -> bool:
@@ -70,8 +133,6 @@ def send(event: str, telemetry_enabled: bool | None = None) -> bool:
     Returns:
         Whether the telemetry was sent successfully.
     """
-    import httpx
-
     from reflex.config import get_config
 
     # Get the telemetry_enabled from the config if it is not specified.
@@ -82,29 +143,8 @@ def send(event: str, telemetry_enabled: bool | None = None) -> bool:
     if not telemetry_enabled:
         return False
 
-    installation_id = ensure_reflex_installation_id()
-    if installation_id is None:
+    event_data = _prepare_event(event)
+    if not event_data:
         return False
 
-    try:
-        with open(constants.Dirs.REFLEX_JSON) as f:
-            reflex_json = json.load(f)
-            project_hash = reflex_json["project_hash"]
-        post_hog = {
-            "api_key": "phc_JoMo0fOyi0GQAooY3UyO9k0hebGkMyFJrrCw1Gt5SGb",
-            "event": event,
-            "properties": {
-                "distinct_id": installation_id,
-                "distinct_app_id": project_hash,
-                "user_os": get_os(),
-                "reflex_version": get_reflex_version(),
-                "python_version": get_python_version(),
-                "cpu_count": get_cpu_count(),
-                "memory": get_memory(),
-            },
-            "timestamp": datetime.utcnow().isoformat(),
-        }
-        httpx.post(POSTHOG_API_URL, json=post_hog)
-        return True
-    except Exception:
-        return False
+    return _send_event(event_data)

reflex/vars.py

@@ -633,7 +633,7 @@ class Var:
             if types.is_generic_alias(self._var_type):
                 index = i if not isinstance(i, Var) else 0
                 type_ = types.get_args(self._var_type)
-                type_ = type_[index % len(type_)]
+                type_ = type_[index % len(type_)] if type_ else Any
             elif types._issubclass(self._var_type, str):
                 type_ = str
 
@@ -1449,7 +1449,7 @@ class Var:
         return self._replace(
             _var_name=f"{self._var_name}.split({other._var_full_name})",
             _var_is_string=False,
-            _var_type=list[str],
+            _var_type=List[str],
             merge_var_data=other._var_data,
         )
 
@@ -1555,7 +1555,7 @@ class Var:
 
         return BaseVar(
             _var_name=f"Array.from(range({v1._var_full_name}, {v2._var_full_name}, {step._var_name}))",
-            _var_type=list[int],
+            _var_type=List[int],
             _var_is_local=False,
             _var_data=VarData.merge(
                 v1._var_data,
@@ -1861,6 +1861,8 @@ class ComputedVar(Var, property):
         # handle caching
         if not hasattr(instance, self._cache_attr):
             setattr(instance, self._cache_attr, super().__get__(instance, owner))
+            # Ensure the computed var gets serialized to redis.
+            instance._was_touched = True
         return getattr(instance, self._cache_attr)
 
     def _deps(

{reflex-0.4.4a2.dist-info → reflex-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reflex
-Version: 0.4.4a2
+Version: 0.4.5
 Summary: Web apps in pure Python.
 Home-page: https://reflex.dev
 License: Apache-2.0