reflex 0.8.0a6__py3-none-any.whl → 0.8.1__py3-none-any.whl

reflex/istate/data.py

@@ -2,9 +2,11 @@
 
 import dataclasses
 from collections.abc import Mapping
+from typing import TYPE_CHECKING
+from urllib.parse import _NetlocResultMixinStr, urlsplit
 
 from reflex import constants
-from reflex.utils import format
+from reflex.utils import console, format
 from reflex.utils.serializers import serializer
 
 
@@ -45,36 +47,40 @@ class _HeaderData:
     )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+_HEADER_DATA_FIELDS = frozenset(
+    [field.name for field in dataclasses.fields(_HeaderData)]
+)
+
+
+@dataclasses.dataclass(frozen=True)
 class HeaderData(_HeaderData):
     """An object containing headers data."""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the HeaderData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "HeaderData":
+        """Create a HeaderData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A HeaderData object initialized with the provided router_data.
         """
-        super().__init__()
-        if router_data:
-            fields_names = [f.name for f in dataclasses.fields(self)]
-            for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items():
-                snake_case_key = format.to_snake_case(k)
-                if snake_case_key in fields_names:
-                    object.__setattr__(self, snake_case_key, v)
-            object.__setattr__(
-                self,
-                "raw_headers",
-                _FrozenDictStrStr(
-                    **{
-                        k: v
-                        for k, v in router_data.get(
-                            constants.RouteVar.HEADERS, {}
-                        ).items()
-                        if v
-                    }
-                ),
-            )
+        return cls(
+            **{
+                snake_case_key: v
+                for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items()
+                if v
+                and (snake_case_key := format.to_snake_case(k)) in _HEADER_DATA_FIELDS
+            },
+            raw_headers=_FrozenDictStrStr(
+                **{
+                    k: v
+                    for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items()
+                    if v
+                }
+            ),
+        )
 
 
 @serializer(to=dict)
@@ -90,6 +96,35 @@ def serialize_frozen_dict_str_str(obj: _FrozenDictStrStr) -> dict:
     return dict(obj._data)
 
 
+class ReflexURL(str, _NetlocResultMixinStr):
+    """A class representing a URL split result."""
+
+    if TYPE_CHECKING:
+        scheme: str
+        netloc: str
+        path: str
+        query: str
+        fragment: str
+
+    def __new__(cls, url: str):
+        """Create a new ReflexURL instance.
+
+        Args:
+            url: the URL to split.
+
+        Returns:
+            A new ReflexURL instance.
+        """
+        (scheme, netloc, path, query, fragment) = urlsplit(url)
+        obj = super().__new__(cls, url)
+        object.__setattr__(obj, "scheme", scheme)
+        object.__setattr__(obj, "netloc", netloc)
+        object.__setattr__(obj, "path", path)
+        object.__setattr__(obj, "query", query)
+        object.__setattr__(obj, "fragment", fragment)
+        return obj
+
+
 @dataclasses.dataclass(frozen=True)
 class PageData:
     """An object containing page data."""
@@ -101,39 +136,30 @@ class PageData:
     full_raw_path: str = ""
     params: dict = dataclasses.field(default_factory=dict)
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the PageData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "PageData":
+        """Create a PageData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A PageData object initialized with the provided router_data.
         """
-        if router_data:
-            object.__setattr__(
-                self,
-                "host",
-                router_data.get(constants.RouteVar.HEADERS, {}).get("origin", ""),
-            )
-            object.__setattr__(
-                self, "path", router_data.get(constants.RouteVar.PATH, "")
-            )
-            object.__setattr__(
-                self, "raw_path", router_data.get(constants.RouteVar.ORIGIN, "")
-            )
-            object.__setattr__(self, "full_path", f"{self.host}{self.path}")
-            object.__setattr__(self, "full_raw_path", f"{self.host}{self.raw_path}")
-            object.__setattr__(
-                self, "params", router_data.get(constants.RouteVar.QUERY, {})
-            )
-        else:
-            object.__setattr__(self, "host", "")
-            object.__setattr__(self, "path", "")
-            object.__setattr__(self, "raw_path", "")
-            object.__setattr__(self, "full_path", "")
-            object.__setattr__(self, "full_raw_path", "")
-            object.__setattr__(self, "params", {})
+        host = router_data.get(constants.RouteVar.HEADERS, {}).get("origin", "")
+        path = router_data.get(constants.RouteVar.PATH, "")
+        raw_path = router_data.get(constants.RouteVar.ORIGIN, "")
+        return cls(
+            host=host,
+            path=path,
+            raw_path=raw_path,
+            full_path=f"{host}{path}",
+            full_raw_path=f"{host}{raw_path}",
+            params=router_data.get(constants.RouteVar.QUERY, {}),
+        )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+@dataclasses.dataclass(frozen=True)
 class SessionData:
     """An object containing session data."""
 
@@ -141,37 +167,84 @@ class SessionData:
     client_ip: str = ""
     session_id: str = ""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the SessionData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "SessionData":
+        """Create a SessionData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A SessionData object initialized with the provided router_data.
         """
-        if router_data:
-            client_token = router_data.get(constants.RouteVar.CLIENT_TOKEN, "")
-            client_ip = router_data.get(constants.RouteVar.CLIENT_IP, "")
-            session_id = router_data.get(constants.RouteVar.SESSION_ID, "")
-        else:
-            client_token = client_ip = session_id = ""
-        object.__setattr__(self, "client_token", client_token)
-        object.__setattr__(self, "client_ip", client_ip)
-        object.__setattr__(self, "session_id", session_id)
+        return cls(
+            client_token=router_data.get(constants.RouteVar.CLIENT_TOKEN, ""),
+            client_ip=router_data.get(constants.RouteVar.CLIENT_IP, ""),
+            session_id=router_data.get(constants.RouteVar.SESSION_ID, ""),
+        )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+@dataclasses.dataclass(frozen=True)
 class RouterData:
     """An object containing RouterData."""
 
     session: SessionData = dataclasses.field(default_factory=SessionData)
     headers: HeaderData = dataclasses.field(default_factory=HeaderData)
-    page: PageData = dataclasses.field(default_factory=PageData)
+    _page: PageData = dataclasses.field(default_factory=PageData)
+    url: ReflexURL = dataclasses.field(default=ReflexURL(""))
+    route_id: str = ""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the RouterData object.
+    @property
+    def page(self) -> PageData:
+        """Get the page data.
+
+        Returns:
+            The PageData object.
+        """
+        console.deprecate(
+            "RouterData.page",
+            "Use RouterData.url instead",
+            deprecation_version="0.8.1",
+            removal_version="0.9.0",
+        )
+        return self._page
+
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "RouterData":
+        """Create a RouterData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A RouterData object initialized with the provided router_data.
         """
-        object.__setattr__(self, "session", SessionData(router_data))
-        object.__setattr__(self, "headers", HeaderData(router_data))
-        object.__setattr__(self, "page", PageData(router_data))
+        return cls(
+            session=SessionData.from_router_data(router_data),
+            headers=HeaderData.from_router_data(router_data),
+            _page=PageData.from_router_data(router_data),
+            url=ReflexURL(
+                router_data.get(constants.RouteVar.HEADERS, {}).get("origin", "")
+                + router_data.get(constants.RouteVar.ORIGIN, "")
+            ),
+            route_id=router_data.get(constants.RouteVar.PATH, ""),
+        )
+
+
+@serializer(to=dict)
+def serialize_router_data(obj: RouterData) -> dict:
+    """Serialize a RouterData object to a dict.
+
+    Args:
+        obj: the RouterData object.
+
+    Returns:
+        A dict representation of the RouterData object.
+    """
+    return {
+        "session": obj.session,
+        "headers": obj.headers,
+        "page": obj._page,
+        "url": obj.url,
+        "route_id": obj.route_id,
+    }

reflex/plugins/tailwind_v4.py

@@ -17,7 +17,7 @@ class Constants(SimpleNamespace):
     """Tailwind constants."""
 
     # The Tailwindcss version
-    VERSION = "tailwindcss@4.1.10"
+    VERSION = "tailwindcss@4.1.11"
     # The Tailwind config.
     CONFIG = "tailwind.config.js"
     # Default Tailwind content paths
@@ -156,7 +156,7 @@ class TailwindV4Plugin(TailwindPlugin):
         return [
             *super().get_frontend_development_dependencies(**context),
             Constants.VERSION,
-            "@tailwindcss/postcss@4.1.10",
+            "@tailwindcss/postcss@4.1.11",
         ]
 
     def pre_compile(self, **context):

reflex/state.py

@@ -1204,7 +1204,7 @@ class BaseState(EvenMoreBasicBaseState):
 
         def argsingle_factory(param: str):
             def inner_func(self: BaseState) -> str:
-                return self.router.page.params.get(param, "")
+                return self.router._page.params.get(param, "")
 
             inner_func.__name__ = param
 
@@ -1212,7 +1212,7 @@ class BaseState(EvenMoreBasicBaseState):
 
         def arglist_factory(param: str):
             def inner_func(self: BaseState) -> list[str]:
-                return self.router.page.params.get(param, [])
+                return self.router._page.params.get(param, [])
 
             inner_func.__name__ = param
 
@@ -2466,7 +2466,7 @@ class OnLoadInternalState(State):
         """
         # Do not app._compile()!  It should be already compiled by now.
         load_events = prerequisites.get_and_validate_app().app.get_load_events(
-            self.router.page.path
+            self.router._page.path
         )
         if not load_events:
             self.is_hydrated = True

reflex/utils/exec.py

@@ -519,9 +519,11 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
 
     from granian.constants import Interfaces
     from granian.log import LogLevels
-    from granian.server import MPServer as Granian
+    from granian.server import Server as Granian
 
-    Granian(
+    from reflex.environment import _paths_from_environment
+
+    granian_app = Granian(
         target=get_app_instance_from_file(),
         factory=True,
         address=host,
@@ -533,8 +535,11 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
         reload_ignore_worker_failure=True,
         reload_ignore_patterns=HOTRELOAD_IGNORE_PATTERNS,
         reload_tick=100,
+        env_files=_paths_from_environment() or None,
         workers_kill_timeout=2,
-    ).serve()
+    )
+
+    granian_app.serve()
 
 
 def run_backend_prod(
@@ -568,15 +573,37 @@ def run_uvicorn_backend_prod(host: str, port: int, loglevel: LogLevel):
         port: The app port
         loglevel: The log level.
     """
+    import os
+    import shlex
+
     from reflex.utils import processes
 
     app_module = get_app_instance()
 
-    command = (
-        ["uvicorn", *("--host", host), *("--port", str(port)), "--factory", app_module]
-        if constants.IS_WINDOWS
-        else ["gunicorn", "--preload", *("--bind", f"{host}:{port}"), f"{app_module}()"]
-    )
+    if constants.IS_WINDOWS:
+        command = [
+            "uvicorn",
+            *("--host", host),
+            *("--port", str(port)),
+            "--factory",
+            app_module,
+        ]
+    else:
+        # Parse GUNICORN_CMD_ARGS for user overrides
+        env_args = []
+        if gunicorn_cmd_args := os.environ.get("GUNICORN_CMD_ARGS", ""):
+            env_args = shlex.split(gunicorn_cmd_args)
+
+        # Our default args, then env args (env args win on conflicts)
+        command = [
+            "gunicorn",
+            "--preload",
+            "--worker-class",
+            "uvicorn.workers.UvicornH11Worker",
+            *("--bind", f"{host}:{port}"),
+            *env_args,
+            f"{app_module}()",
+        ]
 
     command += [
         *("--log-level", loglevel.value),

reflex/utils/lazy_loader.py

@@ -27,6 +27,7 @@ def attach(
     package_name: str,
     submodules: set[str] | None = None,
     submod_attrs: dict[str, list[str]] | None = None,
+    **extra_mappings,
 ):
     """Replaces a package's __getattr__, __dir__, and __all__ attributes using lazy.attach.
     The lazy loader __getattr__ doesn't support tuples as list values. We needed to add
@@ -39,6 +40,7 @@ def attach(
         submodules : List of submodules to attach.
         submod_attrs : Dictionary of submodule -> list of attributes / functions.
                     These attributes are imported as they are used.
+        extra_mappings: Additional mappings to resolve lazily.
 
     Returns:
         __getattr__, __dir__, __all__
@@ -60,9 +62,13 @@ def attach(
         attr: mod for mod, attrs in submod_attrs.items() for attr in attrs
     }
 
-    __all__ = sorted(submodules | attr_to_modules.keys())
+    __all__ = sorted([*(submodules | attr_to_modules.keys()), *(extra_mappings or [])])
 
     def __getattr__(name: str):  # noqa: N807
+        if name in extra_mappings:
+            submod_path, attr = extra_mappings[name].rsplit(".", 1)
+            submod = importlib.import_module(submod_path)
+            return getattr(submod, attr)
         if name in submodules:
             return importlib.import_module(f"{package_name}.{name}")
         if name in attr_to_modules:

reflex/utils/misc.py

@@ -31,14 +31,13 @@ def get_module_path(module_name: str) -> Path | None:
         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():
+            if potential_dir.is_dir():
                 # It's a package, so we can continue deeper
                 current_path = potential_dir
             else:

reflex/utils/processes.py

@@ -15,6 +15,7 @@ from pathlib import Path
 from typing import Any, Literal, overload
 
 import click
+import rich.markup
 from redis.exceptions import RedisError
 from rich.progress import Progress
 
@@ -52,6 +53,26 @@ def get_num_workers() -> int:
     return (os.cpu_count() or 1) * 2 + 1
 
 
+def _is_address_responsive(
+    address_family: socket.AddressFamily | int, address: str, port: int
+) -> bool:
+    """Check if a given address and port are responsive.
+
+    Args:
+        address_family: The address family (e.g., socket.AF_INET or socket.AF_INET6).
+        address: The address to check.
+        port: The port to check.
+
+    Returns:
+        Whether the address and port are responsive.
+    """
+    try:
+        with closing(socket.socket(address_family, socket.SOCK_STREAM)) as sock:
+            return sock.connect_ex((address, port)) == 0
+    except OSError:
+        return False
+
+
 def is_process_on_port(port: int) -> bool:
     """Check if a process is running on the given port.
 
@@ -61,8 +82,11 @@ def is_process_on_port(port: int) -> bool:
     Returns:
         Whether a process is running on the given port.
     """
-    with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
-        return sock.connect_ex(("127.0.0.1", port)) == 0
+    return _is_address_responsive(  # Test IPv4 localhost (127.0.0.1)
+        socket.AF_INET, "127.0.0.1", port
+    ) or _is_address_responsive(
+        socket.AF_INET6, "::1", port
+    )  # Test IPv6 localhost (::1)
 
 
 def change_port(port: int, _type: str) -> int:
@@ -273,7 +297,7 @@ def stream_logs(
             return
         try:
             for line in process.stdout:
-                console.debug(line, end="", progress=progress)
+                console.debug(rich.markup.escape(line), end="", progress=progress)
                 logs.append(line)
                 yield line
         except ValueError:

reflex/utils/pyi_generator.py

@@ -1108,11 +1108,13 @@ class PyiGenerator:
         sub_mod_attrs: dict[str, list[str | tuple[str, str]]] | None = getattr(
             mod, "_SUBMOD_ATTRS", None
         )
+        extra_mappings: dict[str, str] | None = getattr(mod, "_EXTRA_MAPPINGS", None)
 
-        if not sub_mods and not sub_mod_attrs:
+        if not sub_mods and not sub_mod_attrs and not extra_mappings:
             return None
         sub_mods_imports = []
         sub_mod_attrs_imports = []
+        extra_mappings_imports = []
 
         if sub_mods:
             sub_mods_imports = [f"from . import {mod}" for mod in sorted(sub_mods)]
@@ -1140,7 +1142,20 @@ class PyiGenerator:
             ]
             sub_mod_attrs_imports.append("")
 
-        text = "\n" + "\n".join([*sub_mods_imports, *sub_mod_attrs_imports])
+        if extra_mappings:
+            for alias, import_path in extra_mappings.items():
+                module_name, import_name = import_path.rsplit(".", 1)
+                extra_mappings_imports.append(
+                    f"from {module_name} import {import_name} as {alias}"
+                )
+
+        text = (
+            "\n"
+            + "\n".join(
+                [*sub_mods_imports, *sub_mod_attrs_imports, *extra_mappings_imports]
+            )
+            + "\n"
+        )
         text += ast.unparse(new_tree) + "\n\n"
         text += f"__all__ = {getattr(mod, '__all__', [])!r}\n"
         return text

{reflex-0.8.0a6.dist-info → reflex-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.8.0a6
+Version: 0.8.1
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex
@@ -21,7 +21,7 @@ Requires-Python: <4.0,>=3.10
 Requires-Dist: alembic<2.0,>=1.15.2
 Requires-Dist: click>=8.2
 Requires-Dist: fastapi>=0.115.0
-Requires-Dist: granian[reload]>=2.2.5
+Requires-Dist: granian[reload]>=2.4.0
 Requires-Dist: httpx<1.0,>=0.28.0
 Requires-Dist: jinja2<4.0,>=3.1.2
 Requires-Dist: packaging<26,>=24.2
@@ -31,7 +31,7 @@ Requires-Dist: pydantic<3.0,>=1.10.21
 Requires-Dist: python-multipart<1.0,>=0.0.20
 Requires-Dist: python-socketio<6.0,>=5.12.0
 Requires-Dist: redis<7.0,>=5.2.1
-Requires-Dist: reflex-hosting-cli>=0.1.47
+Requires-Dist: reflex-hosting-cli>=0.1.51
 Requires-Dist: rich<15,>=13
 Requires-Dist: sqlmodel<0.1,>=0.0.24
 Requires-Dist: typing-extensions>=4.13.0