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

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,158 @@
+"""Tailwind CSS configuration types for Reflex plugins."""
+
+import dataclasses
+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
+)
+
+
+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",
+            ],
+        )
+    )
+
+    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

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)

reflex/plugins/tailwind_v3.py

@@ -1,12 +1,16 @@
 """Base class for all plugins."""
 
+import dataclasses
 from pathlib import Path
 from types import SimpleNamespace
 
 from reflex.constants.base import Dirs
 from reflex.constants.compiler import Ext, PageNames
-from reflex.plugins.base import Plugin as PluginBase
-from reflex.utils.decorator import once
+from reflex.plugins.shared_tailwind import (
+    TailwindConfig,
+    TailwindPlugin,
+    tailwind_config_js_template,
+)
 
 
 class Constants(SimpleNamespace):
@@ -17,7 +21,7 @@ class Constants(SimpleNamespace):
     # The Tailwind config.
     CONFIG = "tailwind.config.js"
     # Default Tailwind content paths
-    CONTENT = ["./pages/**/*.{js,ts,jsx,tsx}", "./utils/**/*.{js,ts,jsx,tsx}"]
+    CONTENT = [f"./{Dirs.PAGES}/**/*.{{js,ts,jsx,tsx}}", "./utils/**/*.{js,ts,jsx,tsx}"]
     # Relative tailwind style path to root stylesheet in Dirs.STYLES.
     ROOT_STYLE_PATH = "./tailwind.css"
 
@@ -35,90 +39,7 @@ class Constants(SimpleNamespace):
     TAILWIND_CSS = "@import url('./tailwind.css');"
 
 
-@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"""
-{# Helper macro to render JS objects and arrays #}
-{% macro render_js(val, indent=2, level=0) -%}
-{%- set space = ' ' * (indent * level) -%}
-{%- set next_space = ' ' * (indent * (level + 1)) -%}
-
-{%- if val is mapping -%}
-{
-{%- for k, v in val.items() %}
-{{ next_space }}{{ k if k is string and k.isidentifier() else k|tojson }}: {{ render_js(v, indent, level + 1) }}{{ "," if not loop.last }}
-{%- endfor %}
-{{ space }}}
-{%- elif val is iterable and val is not string -%}
-[
-{%- for item in val %}
-{{ next_space }}{{ render_js(item, indent, level + 1) }}{{ "," if not loop.last }}
-{%- endfor %}
-{{ space }}]
-{%- else -%}
-{{ val | tojson }}
-{%- endif -%}
-{%- endmacro %}
-
-{# 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 %}
-
-/** @type {import('tailwindcss').Config} */
-{%- for imp in imports %}
-const { {{ imp.name }} } = require({{ imp.from | tojson }});
-{%- endfor %}
-
-module.exports = {
-  content: {{ render_js(content) }},
-  theme: {{ render_js(theme) }},
-  {% if darkMode is defined %}darkMode: {{ darkMode | tojson }},{% endif %}
-  {% if corePlugins is defined %}corePlugins: {{ render_js(corePlugins) }},{% 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 %}
-    require({{ preset | tojson }}){{ "," if not loop.last }}
-    {% endfor %}
-  ],
-  {% endif %}
-  plugins: [
-    {% for plugin in plugins %}
-      {% if plugin is mapping %}
-        {% if plugin.call is defined %}
-          {{ plugin.call }}(
-            {%- if plugin.args is defined -%}
-              {{ render_js(plugin.args) }}
-            {%- endif -%}
-          ){{ "," if not loop.last }}
-        {% else %}
-          require({{ plugin.name | tojson }}){{ "," if not loop.last }}
-        {% endif %}
-      {% else %}
-        require({{ plugin | tojson }}){{ "," if not loop.last }}
-      {% endif %}
-    {% endfor %}
-  ]
-};
-"""
-
-    return from_string(source)
-
-
-def compile_config(
-    config: dict,
-):
+def compile_config(config: TailwindConfig):
     """Compile the Tailwind config.
 
     Args:
@@ -129,6 +50,7 @@ def compile_config(
     """
     return Constants.CONFIG, tailwind_config_js_template().render(
         **config,
+        DEFAULT_CONTENT=Constants.CONTENT,
     )
 
 
@@ -215,7 +137,8 @@ def add_tailwind_to_css_file(css_file_content: str) -> str:
     )
 
 
-class Plugin(PluginBase):
+@dataclasses.dataclass
+class TailwindV3Plugin(TailwindPlugin):
     """Plugin for Tailwind CSS."""
 
     def get_frontend_development_dependencies(self, **context) -> list[str]:
@@ -227,12 +150,9 @@ class Plugin(PluginBase):
         Returns:
             A list of packages required by the plugin.
         """
-        from reflex.config import get_config
-
-        config = get_config()
         return [
             plugin if isinstance(plugin, str) else plugin.get("name")
-            for plugin in (config.tailwind or {}).get("plugins", [])
+            for plugin in self.get_config().get("plugins", [])
         ] + [Constants.VERSION]
 
     def pre_compile(self, **context):
@@ -241,23 +161,10 @@ class Plugin(PluginBase):
         Args:
             context: The context for the plugin.
         """
-        from reflex.config import get_config
-
-        config = get_config().tailwind or {}
-
-        config["content"] = config.get("content", Constants.CONTENT)
-        context["add_save_task"](compile_config, config)
+        context["add_save_task"](compile_config, self.get_config())
         context["add_save_task"](compile_root_style)
         context["add_modify_task"](Dirs.POSTCSS_JS, add_tailwind_to_postcss_config)
         context["add_modify_task"](
             str(Path(Dirs.STYLES) / (PageNames.STYLESHEET_ROOT + Ext.CSS)),
             add_tailwind_to_css_file,
         )
-
-    def __repr__(self):
-        """Return a string representation of the plugin.
-
-        Returns:
-            A string representation of the plugin.
-        """
-        return "TailwindV3Plugin()"