reflex 0.7.14a5__py3-none-any.whl → 0.8.0__py3-none-any.whl

reflex/istate/__init__.py

@@ -1 +1,70 @@
 """This module will provide interfaces for the state."""
+
+import pickle
+import sys
+from collections.abc import Callable
+from typing import Any
+
+# Errors caught during pickling of state
+HANDLED_PICKLE_ERRORS = (
+    pickle.PicklingError,
+    AttributeError,
+    IndexError,
+    TypeError,
+    ValueError,
+)
+
+
+def _is_picklable(obj: Any, dumps: Callable[[object], bytes]) -> bool:
+    try:
+        dumps(obj)
+    except Exception:
+        return False
+    else:
+        return True
+
+
+def debug_failed_pickles(obj: object, dumps: Callable[[object], bytes]):
+    """Recursively check the picklability of an object and its contents.
+
+    Args:
+        obj: The object to check.
+        dumps: The pickle dump function to use.
+
+    Raises:
+        HANDLED_PICKLE_ERRORS: If the object or any of its contents are not picklable.
+    """
+    if _is_picklable(obj, dumps):
+        return
+    if sys.version_info < (3, 11):
+        return
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            try:
+                debug_failed_pickles(v, dumps)
+            except HANDLED_PICKLE_ERRORS as e:
+                e.add_note(f"While pickling dict value for key {k!r}")
+                raise
+            try:
+                debug_failed_pickles(k, dumps)
+            except HANDLED_PICKLE_ERRORS as e:
+                e.add_note(f"While pickling dict key {k!r}")
+                raise
+        return
+    if isinstance(obj, (list, tuple)):
+        for i, v in enumerate(obj):
+            try:
+                debug_failed_pickles(v, dumps)
+            except HANDLED_PICKLE_ERRORS as e:  # noqa: PERF203
+                e.add_note(f"While pickling index {i} of {type(obj).__name__}")
+                raise
+        return
+    picklable_thing = obj.__getstate__()
+    if picklable_thing is not None:
+        debug_failed_pickles(picklable_thing, dumps)
+    else:
+        try:
+            dumps(obj)
+        except HANDLED_PICKLE_ERRORS as e:
+            e.add_note(f"While pickling object of type {type(obj).__name__}")
+            raise

reflex/istate/manager.py

@@ -179,6 +179,7 @@ def _default_token_expiration() -> int:
 
 def reset_disk_state_manager():
     """Reset the disk state manager."""
+    console.debug("Resetting disk state manager.")
     states_directory = prerequisites.get_states_dir()
     if states_directory.exists():
         for path in states_directory.iterdir():

reflex/istate/proxy.py

@@ -10,7 +10,7 @@ import inspect
 import json
 from collections.abc import Callable, Sequence
 from types import MethodType
-from typing import TYPE_CHECKING, Any, SupportsIndex
+from typing import TYPE_CHECKING, Any, SupportsIndex, TypeVar
 
 import pydantic
 import wrapt
@@ -27,6 +27,8 @@ from reflex.vars.base import Var
 if TYPE_CHECKING:
     from reflex.state import BaseState, StateUpdate
 
+T_STATE = TypeVar("T_STATE", bound="BaseState")
+
 
 class StateProxy(wrapt.ObjectProxy):
     """Proxy of a state instance to control mutability of vars for a background task.
@@ -269,7 +271,7 @@ class StateProxy(wrapt.ObjectProxy):
             raise ImmutableStateError(msg)
         return self.__wrapped__.get_substate(path)
 
-    async def get_state(self, state_cls: type[BaseState]) -> BaseState:
+    async def get_state(self, state_cls: type[T_STATE]) -> T_STATE:
         """Get an instance of the state associated with this token.
 
         Args:
@@ -289,7 +291,7 @@ class StateProxy(wrapt.ObjectProxy):
             raise ImmutableStateError(msg)
         return type(self)(
             await self.__wrapped__.get_state(state_cls), parent_state_proxy=self
-        )
+        )  # pyright: ignore [reportReturnType]
 
     async def _as_state_update(self, *args, **kwargs) -> StateUpdate:
         """Temporarily allow mutability to access parent_state.

reflex/page.py

@@ -8,7 +8,6 @@ from typing import Any
 
 from reflex.config import get_config
 from reflex.event import EventType
-from reflex.utils import console
 
 DECORATED_PAGES: dict[str, list] = defaultdict(list)
 
@@ -66,29 +65,3 @@ def page(
         return render_fn
 
     return decorator
-
-
-def get_decorated_pages(omit_implicit_routes: bool = True) -> list[dict[str, Any]]:
-    """Get the decorated pages.
-
-    Args:
-        omit_implicit_routes: Whether to omit pages where the route will be implicitly guessed later.
-
-    Returns:
-        The decorated pages.
-    """
-    console.deprecate(
-        "get_decorated_pages",
-        reason="This function is deprecated and will be removed in a future version.",
-        deprecation_version="0.7.9",
-        removal_version="0.8.0",
-        dedupe=True,
-    )
-    return sorted(
-        [
-            page_data
-            for _, page_data in DECORATED_PAGES[get_config().app_name]
-            if not omit_implicit_routes or "route" in page_data
-        ],
-        key=lambda x: x.get("route", ""),
-    )

reflex/plugins/__init__.py

@@ -3,5 +3,6 @@
 from .base import CommonContext as CommonContext
 from .base import Plugin as Plugin
 from .base import PreCompileContext as PreCompileContext
-from .tailwind_v3 import Plugin as TailwindV3Plugin
-from .tailwind_v4 import Plugin as TailwindV4Plugin
+from .sitemap import Plugin as SitemapPlugin
+from .tailwind_v3 import TailwindV3Plugin as TailwindV3Plugin
+from .tailwind_v4 import TailwindV4Plugin as TailwindV4Plugin

reflex/plugins/base.py

@@ -2,10 +2,13 @@
 
 from collections.abc import Callable, Sequence
 from pathlib import Path
-from typing import ParamSpec, Protocol, TypedDict
+from typing import TYPE_CHECKING, ParamSpec, Protocol, TypedDict
 
 from typing_extensions import Unpack
 
+if TYPE_CHECKING:
+    from reflex.app import UnevaluatedPage
+
 
 class CommonContext(TypedDict):
     """Common context for all plugins."""
@@ -38,6 +41,7 @@ class PreCompileContext(CommonContext):
 
     add_save_task: AddTaskProtcol
     add_modify_task: Callable[[str, Callable[[str], str]], None]
+    unevaluated_pages: Sequence["UnevaluatedPage"]
 
 
 class Plugin:

reflex/plugins/shared_tailwind.py

@@ -0,0 +1,215 @@
+"""Tailwind CSS configuration types for Reflex plugins."""
+
+import dataclasses
+from copy import deepcopy
+from typing import Any, Literal, TypedDict
+
+from typing_extensions import NotRequired
+
+from reflex.utils.decorator import once
+
+from .base import Plugin as PluginBase
+
+TailwindPluginImport = TypedDict(
+    "TailwindPluginImport",
+    {
+        "name": str,
+        "from": str,
+    },
+)
+
+TailwindPluginWithCallConfig = TypedDict(
+    "TailwindPluginWithCallConfig",
+    {
+        "name": str,
+        "import": NotRequired[TailwindPluginImport],
+        "call": str,
+        "args": NotRequired[dict[str, Any]],
+    },
+)
+
+TailwindPluginWithoutCallConfig = TypedDict(
+    "TailwindPluginWithoutCallConfig",
+    {
+        "name": str,
+        "import": NotRequired[TailwindPluginImport],
+    },
+)
+
+TailwindPluginConfig = (
+    TailwindPluginWithCallConfig | TailwindPluginWithoutCallConfig | str
+)
+
+
+def remove_version_from_plugin(plugin: TailwindPluginConfig) -> TailwindPluginConfig:
+    """Remove the version from a plugin name.
+
+    Args:
+        plugin: The plugin to remove the version from.
+
+    Returns:
+        The plugin without the version.
+    """
+    from reflex.utils.format import format_library_name
+
+    if isinstance(plugin, str):
+        return format_library_name(plugin)
+
+    if plugin_import := plugin.get("import"):
+        plugin_import["from"] = format_library_name(plugin_import["from"])
+
+    plugin["name"] = format_library_name(plugin["name"])
+
+    return plugin
+
+
+class TailwindConfig(TypedDict):
+    """Tailwind CSS configuration options.
+
+    See: https://tailwindcss.com/docs/configuration
+    """
+
+    content: NotRequired[list[str]]
+    important: NotRequired[str | bool]
+    prefix: NotRequired[str]
+    separator: NotRequired[str]
+    presets: NotRequired[list[str]]
+    darkMode: NotRequired[Literal["media", "class", "selector"]]
+    theme: NotRequired[dict[str, Any]]
+    corePlugins: NotRequired[list[str] | dict[str, bool]]
+    plugins: NotRequired[list[TailwindPluginConfig]]
+
+
+@once
+def tailwind_config_js_template():
+    """Get the Tailwind config template.
+
+    Returns:
+        The Tailwind config template.
+    """
+    from reflex.compiler.templates import from_string
+
+    source = r"""
+{# Extract destructured imports from plugin dicts only #}
+{%- set imports = [] %}
+
+{%- for plugin in plugins if plugin is mapping and plugin.import is defined %}
+  {%- set _ = imports.append(plugin.import) %}
+{%- endfor %}
+
+{%- for imp in imports %}
+import { {{ imp.name }} } from {{ imp.from | tojson }};
+{%- endfor %}
+
+{%- for plugin in plugins %}
+{% if plugin is mapping and plugin.call is not defined %}
+import plugin{{ loop.index }} from {{ plugin.name | tojson }};
+{%- elif plugin is not mapping %}
+import plugin{{ loop.index }} from {{ plugin | tojson }};
+{%- endif %}
+{%- endfor %}
+
+{%- for preset in presets %}
+import preset{{ loop.index }} from {{ preset | tojson }};
+{%- endfor %}
+
+export default {
+    content: {{ (content if content is defined else DEFAULT_CONTENT) | tojson }},
+    {% if theme is defined %}theme: {{ theme | tojson }},{% else %}theme: {},{% endif %}
+    {% if darkMode is defined %}darkMode: {{ darkMode | tojson }},{% endif %}
+    {% if corePlugins is defined %}corePlugins: {{ corePlugins | tojson }},{% endif %}
+    {% if important is defined %}important: {{ important | tojson }},{% endif %}
+    {% if prefix is defined %}prefix: {{ prefix | tojson }},{% endif %}
+    {% if separator is defined %}separator: {{ separator | tojson }},{% endif %}
+    {% if presets is defined %}
+    presets: [
+        {% for preset in presets %}
+            preset{{ loop.index }},
+        {% endfor %}
+    ],
+    {% endif %}
+    plugins: [
+        {% for plugin in plugins %}
+            {% if plugin is mapping and plugin.call is defined %}
+                {{ plugin.call }}(
+                    {%- if plugin.args is defined -%}
+                        {{ plugin.args | tojson }}
+                    {%- endif -%}
+                ),
+            {% else %}
+                plugin{{ loop.index }},
+            {% endif %}
+        {% endfor %}
+    ]
+};
+"""
+
+    return from_string(source)
+
+
+@dataclasses.dataclass
+class TailwindPlugin(PluginBase):
+    """Plugin for Tailwind CSS."""
+
+    config: TailwindConfig = dataclasses.field(
+        default_factory=lambda: TailwindConfig(
+            plugins=[
+                "@tailwindcss/typography@0.5.16",
+            ],
+        )
+    )
+
+    def get_frontend_development_dependencies(self, **context) -> list[str]:
+        """Get the packages required by the plugin.
+
+        Args:
+            **context: The context for the plugin.
+
+        Returns:
+            A list of packages required by the plugin.
+        """
+        config = self.get_config()
+
+        return [
+            plugin if isinstance(plugin, str) else plugin.get("name")
+            for plugin in config.get("plugins", [])
+        ] + config.get("presets", [])
+
+    def get_config(self) -> TailwindConfig:
+        """Get the Tailwind CSS configuration.
+
+        Returns:
+            The Tailwind CSS configuration.
+        """
+        from reflex.config import get_config
+
+        rxconfig_config = getattr(get_config(), "tailwind", None)
+
+        if rxconfig_config is not None and rxconfig_config != self.config:
+            from reflex.utils import console
+
+            console.warn(
+                "It seems you have provided a tailwind configuration in your call to `rx.Config`."
+                f" You should provide the configuration as an argument to `rx.plugins.{self.__class__.__name__}()` instead."
+            )
+            return rxconfig_config
+
+        return self.config
+
+    def get_unversioned_config(self) -> TailwindConfig:
+        """Get the Tailwind CSS configuration without version-specific adjustments.
+
+        Returns:
+            The Tailwind CSS configuration without version-specific adjustments.
+        """
+        from reflex.utils.format import format_library_name
+
+        config = deepcopy(self.get_config())
+        if presets := config.get("presets"):
+            # Somehow, having an empty list of presets breaks Tailwind.
+            # So we only set the presets if there are any.
+            config["presets"] = [format_library_name(preset) for preset in presets]
+        config["plugins"] = [
+            remove_version_from_plugin(plugin) for plugin in config.get("plugins", [])
+        ]
+        return config

reflex/plugins/sitemap.py

@@ -0,0 +1,206 @@
+"""Sitemap plugin for Reflex."""
+
+import datetime
+from collections.abc import Sequence
+from pathlib import Path
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, Literal, TypedDict
+from xml.dom import minidom
+from xml.etree.ElementTree import Element, SubElement, tostring
+
+from typing_extensions import NotRequired
+
+from reflex import constants
+
+from .base import Plugin as PluginBase
+
+if TYPE_CHECKING:
+    from reflex.app import UnevaluatedPage
+
+Location = str
+LastModified = datetime.datetime
+ChangeFrequency = Literal[
+    "always", "hourly", "daily", "weekly", "monthly", "yearly", "never"
+]
+Priority = float
+
+
+class SitemapLink(TypedDict):
+    """A link in the sitemap."""
+
+    loc: Location
+    lastmod: NotRequired[LastModified]
+    changefreq: NotRequired[ChangeFrequency]
+    priority: NotRequired[Priority]
+
+
+class SitemapLinkConfiguration(TypedDict):
+    """Configuration for a sitemap link."""
+
+    loc: NotRequired[Location]
+    lastmod: NotRequired[LastModified]
+    changefreq: NotRequired[ChangeFrequency]
+    priority: NotRequired[Priority]
+
+
+class Constants(SimpleNamespace):
+    """Sitemap constants."""
+
+    FILE_PATH: Path = Path(constants.Dirs.PUBLIC) / "sitemap.xml"
+
+
+def configuration_with_loc(
+    *, config: SitemapLinkConfiguration, deploy_url: str | None, loc: Location
+) -> SitemapLink:
+    """Set the 'loc' field of the configuration.
+
+    Args:
+        config: The configuration dictionary.
+        deploy_url: The deployment URL, if any.
+        loc: The location to set.
+
+    Returns:
+        A SitemapLink dictionary with the 'loc' field set.
+    """
+    if deploy_url and not loc.startswith("http://") and not loc.startswith("https://"):
+        loc = f"{deploy_url.rstrip('/')}/{loc.lstrip('/')}"
+    link: SitemapLink = {"loc": loc}
+    if (lastmod := config.get("lastmod")) is not None:
+        link["lastmod"] = lastmod
+    if (changefreq := config.get("changefreq")) is not None:
+        link["changefreq"] = changefreq
+    if (priority := config.get("priority")) is not None:
+        link["priority"] = min(1.0, max(0.0, priority))
+    return link
+
+
+def generate_xml(links: Sequence[SitemapLink]) -> str:
+    """Generate an XML sitemap from a list of links.
+
+    Args:
+        links: A sequence of SitemapLink dictionaries.
+
+    Returns:
+        A pretty-printed XML string representing the sitemap.
+    """
+    urlset = Element("urlset", xmlns="https://www.sitemaps.org/schemas/sitemap/0.9")
+
+    for link in links:
+        url = SubElement(urlset, "url")
+
+        loc_element = SubElement(url, "loc")
+        loc_element.text = link["loc"]
+
+        if (changefreq := link.get("changefreq")) is not None:
+            changefreq_element = SubElement(url, "changefreq")
+            changefreq_element.text = changefreq
+
+        if (lastmod := link.get("lastmod")) is not None:
+            lastmod_element = SubElement(url, "lastmod")
+            if isinstance(lastmod, datetime.datetime):
+                lastmod = lastmod.isoformat()
+            lastmod_element.text = lastmod
+
+        if (priority := link.get("priority")) is not None:
+            priority_element = SubElement(url, "priority")
+            priority_element.text = str(priority)
+
+    rough_string = tostring(urlset, "utf-8")
+    reparsed = minidom.parseString(rough_string)
+    return reparsed.toprettyxml(indent="  ")
+
+
+def is_route_dynamic(route: str) -> bool:
+    """Check if a route is dynamic.
+
+    Args:
+        route: The route to check.
+
+    Returns:
+        True if the route is dynamic, False otherwise.
+    """
+    return "[" in route and "]" in route
+
+
+def generate_links_for_sitemap(
+    unevaluated_pages: Sequence["UnevaluatedPage"],
+) -> list[SitemapLink]:
+    """Generate sitemap links from unevaluated pages.
+
+    Args:
+        unevaluated_pages: Sequence of unevaluated pages.
+
+    Returns:
+        A list of SitemapLink dictionaries.
+    """
+    from reflex.config import get_config
+    from reflex.utils import console
+
+    deploy_url = get_config().deploy_url
+
+    links: list[SitemapLink] = []
+
+    for page in unevaluated_pages:
+        sitemap_config: SitemapLinkConfiguration = page.context.get("sitemap", {})
+
+        if is_route_dynamic(page.route) or page.route == "404":
+            if not sitemap_config:
+                continue
+
+            if (loc := sitemap_config.get("loc")) is None:
+                route_message = (
+                    "Dynamic route" if is_route_dynamic(page.route) else "Route 404"
+                )
+                console.warn(
+                    route_message
+                    + f" '{page.route}' does not have a 'loc' in sitemap configuration. Skipping."
+                )
+                continue
+
+            sitemap_link = configuration_with_loc(
+                config=sitemap_config, deploy_url=deploy_url, loc=loc
+            )
+
+        elif (loc := sitemap_config.get("loc")) is not None:
+            sitemap_link = configuration_with_loc(
+                config=sitemap_config, deploy_url=deploy_url, loc=loc
+            )
+
+        else:
+            loc = page.route if page.route != "index" else "/"
+            if not loc.startswith("/"):
+                loc = "/" + loc
+            sitemap_link = configuration_with_loc(
+                config=sitemap_config, deploy_url=deploy_url, loc=loc
+            )
+
+        links.append(sitemap_link)
+    return links
+
+
+def sitemap_task(unevaluated_pages: Sequence["UnevaluatedPage"]) -> tuple[str, str]:
+    """Task to generate the sitemap XML file.
+
+    Args:
+        unevaluated_pages: Sequence of unevaluated pages.
+
+    Returns:
+        A tuple containing the file path and the generated XML content.
+    """
+    return (
+        str(Constants.FILE_PATH),
+        generate_xml(generate_links_for_sitemap(unevaluated_pages)),
+    )
+
+
+class Plugin(PluginBase):
+    """Sitemap plugin for Reflex."""
+
+    def pre_compile(self, **context):
+        """Generate the sitemap XML file before compilation.
+
+        Args:
+            context: The context for the plugin.
+        """
+        unevaluated_pages = context.get("unevaluated_pages", [])
+        context["add_save_task"](sitemap_task, unevaluated_pages)