reflex 0.7.12__py3-none-any.whl → 0.7.13a1__py3-none-any.whl

reflex/event.py

@@ -1262,6 +1262,118 @@ def get_hydrate_event(state: BaseState) -> str:
     return get_event(state, constants.CompileVars.HYDRATE)
 
 
+def _values_returned_from_event(
+    event_spec: ArgsSpec | Sequence[ArgsSpec],
+) -> list[Any]:
+    return [
+        event_spec_return_type
+        for arg_spec in (
+            [event_spec] if not isinstance(event_spec, Sequence) else list(event_spec)
+        )
+        if (event_spec_return_type := get_type_hints(arg_spec).get("return", None))
+        is not None
+        and get_origin(event_spec_return_type) is tuple
+    ]
+
+
+def _check_event_args_subclass_of_callback(
+    callback_params_names: list[str],
+    provided_event_types: list[Any],
+    callback_param_name_to_type: dict[str, Any],
+    callback_name: str = "",
+    key: str = "",
+):
+    """Check if the event handler arguments are subclass of the callback.
+
+    Args:
+        callback_params_names: The names of the callback parameters.
+        provided_event_types: The event types.
+        callback_param_name_to_type: The callback parameter name to type mapping.
+        callback_name: The name of the callback.
+        key: The key.
+
+    Raises:
+        TypeError: If the event handler arguments are invalid.
+        EventHandlerArgTypeMismatchError: If the event handler arguments do not match the callback.
+
+    # noqa: DAR401 delayed_exceptions[]
+    # noqa: DAR402 EventHandlerArgTypeMismatchError
+    """
+    type_match_found: dict[str, bool] = {}
+    delayed_exceptions: list[EventHandlerArgTypeMismatchError] = []
+
+    for event_spec_index, event_spec_return_type in enumerate(provided_event_types):
+        args = get_args(event_spec_return_type)
+
+        args_types_without_vars = [
+            arg if get_origin(arg) is not Var else get_args(arg)[0] for arg in args
+        ]
+
+        # check that args of event handler are matching the spec if type hints are provided
+        for i, arg in enumerate(callback_params_names[: len(args_types_without_vars)]):
+            if arg not in callback_param_name_to_type:
+                continue
+
+            type_match_found.setdefault(arg, False)
+
+            try:
+                compare_result = typehint_issubclass(
+                    args_types_without_vars[i], callback_param_name_to_type[arg]
+                )
+            except TypeError as te:
+                callback_name_context = f" of {callback_name}" if callback_name else ""
+                key_context = f" for {key}" if key else ""
+                raise TypeError(
+                    f"Could not compare types {args_types_without_vars[i]} and {callback_param_name_to_type[arg]} for argument {arg}{callback_name_context}{key_context}."
+                ) from te
+
+            if compare_result:
+                type_match_found[arg] = True
+                continue
+            else:
+                type_match_found[arg] = False
+                as_annotated_in = (
+                    f" as annotated in {callback_name}" if callback_name else ""
+                )
+                delayed_exceptions.append(
+                    EventHandlerArgTypeMismatchError(
+                        f"Event handler {key} expects {args_types_without_vars[i]} for argument {arg} but got {callback_param_name_to_type[arg]}{as_annotated_in} instead."
+                    )
+                )
+
+        if all(type_match_found.values()):
+            delayed_exceptions.clear()
+            if event_spec_index:
+                args = get_args(provided_event_types[0])
+
+                args_types_without_vars = [
+                    arg if get_origin(arg) is not Var else get_args(arg)[0]
+                    for arg in args
+                ]
+
+                expect_string = ", ".join(
+                    repr(arg) for arg in args_types_without_vars
+                ).replace("[", "\\[")
+
+                given_string = ", ".join(
+                    repr(callback_param_name_to_type.get(arg, Any))
+                    for arg in callback_params_names
+                ).replace("[", "\\[")
+
+                as_annotated_in = (
+                    f" as annotated in {callback_name}" if callback_name else ""
+                )
+
+                console.warn(
+                    f"Event handler {key} expects ({expect_string}) -> () but got ({given_string}) -> (){as_annotated_in} instead. "
+                    f"This may lead to unexpected behavior but is intentionally ignored for {key}."
+                )
+            break
+
+    if delayed_exceptions:
+        raise delayed_exceptions[0]
+
+
 def call_event_handler(
     event_callback: EventHandler | EventSpec,
     event_spec: ArgsSpec | Sequence[ArgsSpec],
@@ -1278,17 +1390,13 @@ def call_event_handler(
         event_spec: The lambda that define the argument(s) to pass to the event handler.
         key: The key to pass to the event handler.
 
-    Raises:
-        EventHandlerArgTypeMismatchError: If the event handler arguments do not match the event spec. #noqa: DAR402
-        TypeError: If the event handler arguments are invalid.
-
     Returns:
         The event spec from calling the event handler.
-
-    #noqa: DAR401
     """
     event_spec_args = parse_args_spec(event_spec)
 
+    event_spec_return_types = _values_returned_from_event(event_spec)
+
     if isinstance(event_callback, EventSpec):
         check_fn_match_arg_spec(
             event_callback.handler.fn,
@@ -1297,6 +1405,32 @@ def call_event_handler(
             bool(event_callback.handler.state_full_name) + len(event_callback.args),
             event_callback.handler.fn.__qualname__,
         )
+
+        event_callback_spec_args = list(
+            inspect.signature(event_callback.handler.fn).parameters.keys()
+        )
+
+        try:
+            type_hints_of_provided_callback = get_type_hints(event_callback.handler.fn)
+        except NameError:
+            type_hints_of_provided_callback = {}
+
+        argument_names = [str(arg) for arg, value in event_callback.args]
+
+        _check_event_args_subclass_of_callback(
+            [
+                arg
+                for arg in event_callback_spec_args[
+                    bool(event_callback.handler.state_full_name) :
+                ]
+                if arg not in argument_names
+            ],
+            event_spec_return_types,
+            type_hints_of_provided_callback,
+            event_callback.handler.fn.__qualname__,
+            key or "",
+        )
+
         # Handle partial application of EventSpec args
         return event_callback.add_args(*event_spec_args)
 
@@ -1308,98 +1442,23 @@ def call_event_handler(
         event_callback.fn.__qualname__,
     )
 
-    all_acceptable_specs = (
-        [event_spec] if not isinstance(event_spec, Sequence) else event_spec
-    )
-
-    event_spec_return_types = list(
-        filter(
-            lambda event_spec_return_type: event_spec_return_type is not None
-            and get_origin(event_spec_return_type) is tuple,
-            (
-                get_type_hints(arg_spec).get("return", None)
-                for arg_spec in all_acceptable_specs
-            ),
-        )
-    )
-    type_match_found: dict[str, bool] = {}
-    delayed_exceptions: list[EventHandlerArgTypeMismatchError] = []
-
-    try:
-        type_hints_of_provided_callback = get_type_hints(event_callback.fn)
-    except NameError:
-        type_hints_of_provided_callback = {}
-
     if event_spec_return_types:
         event_callback_spec_args = list(
             inspect.signature(event_callback.fn).parameters.keys()
         )
 
-        for event_spec_index, event_spec_return_type in enumerate(
-            event_spec_return_types
-        ):
-            args = get_args(event_spec_return_type)
-
-            args_types_without_vars = [
-                arg if get_origin(arg) is not Var else get_args(arg)[0] for arg in args
-            ]
-
-            # check that args of event handler are matching the spec if type hints are provided
-            for i, arg in enumerate(
-                event_callback_spec_args[1 : len(args_types_without_vars) + 1]
-            ):
-                if arg not in type_hints_of_provided_callback:
-                    continue
-
-                type_match_found.setdefault(arg, False)
-
-                try:
-                    compare_result = typehint_issubclass(
-                        args_types_without_vars[i], type_hints_of_provided_callback[arg]
-                    )
-                except TypeError as te:
-                    raise TypeError(
-                        f"Could not compare types {args_types_without_vars[i]} and {type_hints_of_provided_callback[arg]} for argument {arg} of {event_callback.fn.__qualname__} provided for {key}."
-                    ) from te
-
-                if compare_result:
-                    type_match_found[arg] = True
-                    continue
-                else:
-                    type_match_found[arg] = False
-                    delayed_exceptions.append(
-                        EventHandlerArgTypeMismatchError(
-                            f"Event handler {key} expects {args_types_without_vars[i]} for argument {arg} but got {type_hints_of_provided_callback[arg]} as annotated in {event_callback.fn.__qualname__} instead."
-                        )
-                    )
-
-            if all(type_match_found.values()):
-                delayed_exceptions.clear()
-                if event_spec_index:
-                    args = get_args(event_spec_return_types[0])
-
-                    args_types_without_vars = [
-                        arg if get_origin(arg) is not Var else get_args(arg)[0]
-                        for arg in args
-                    ]
-
-                    expect_string = ", ".join(
-                        repr(arg) for arg in args_types_without_vars
-                    ).replace("[", "\\[")
-
-                    given_string = ", ".join(
-                        repr(type_hints_of_provided_callback.get(arg, Any))
-                        for arg in event_callback_spec_args[1:]
-                    ).replace("[", "\\[")
-
-                    console.warn(
-                        f"Event handler {key} expects ({expect_string}) -> () but got ({given_string}) -> () as annotated in {event_callback.fn.__qualname__} instead. "
-                        f"This may lead to unexpected behavior but is intentionally ignored for {key}."
-                    )
-                break
-
-    if delayed_exceptions:
-        raise delayed_exceptions[0]
+        try:
+            type_hints_of_provided_callback = get_type_hints(event_callback.fn)
+        except NameError:
+            type_hints_of_provided_callback = {}
+
+        _check_event_args_subclass_of_callback(
+            event_callback_spec_args[1:],
+            event_spec_return_types,
+            type_hints_of_provided_callback,
+            event_callback.fn.__qualname__,
+            key or "",
+        )
 
     return event_callback(*event_spec_args)
 
@@ -1958,6 +2017,8 @@ class EventCallback(Generic[Unpack[P]], EventActionsMixin):
 class LambdaEventCallback(Protocol[Unpack[P]]):
     """A protocol for a lambda event callback."""
 
+    __code__: types.CodeType
+
     @overload
     def __call__(self: LambdaEventCallback[()]) -> Any: ...
 

reflex/plugins/__init__.py

@@ -0,0 +1,7 @@
+"""Reflex Plugin System."""
+
+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

reflex/plugins/base.py

@@ -0,0 +1,101 @@
+"""Base class for all plugins."""
+
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import ParamSpec, Protocol, TypedDict
+
+from typing_extensions import Unpack
+
+
+class CommonContext(TypedDict):
+    """Common context for all plugins."""
+
+
+P = ParamSpec("P")
+
+
+class AddTaskProtcol(Protocol):
+    """Protocol for adding a task to the pre-compile context."""
+
+    def __call__(
+        self,
+        task: Callable[P, list[tuple[str, str]] | tuple[str, str] | None],
+        /,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
+        """Add a task to the pre-compile context.
+
+        Args:
+            task: The task to add.
+            args: The arguments to pass to the task
+            kwargs: The keyword arguments to pass to the task
+        """
+
+
+class PreCompileContext(CommonContext):
+    """Context for pre-compile hooks."""
+
+    add_save_task: AddTaskProtcol
+    add_modify_task: Callable[[str, Callable[[str], str]], None]
+
+
+class Plugin:
+    """Base class for all plugins."""
+
+    def get_frontend_development_dependencies(
+        self, **context: Unpack[CommonContext]
+    ) -> list[str] | set[str] | tuple[str, ...]:
+        """Get the NPM packages required by the plugin for development.
+
+        Args:
+            context: The context for the plugin.
+
+        Returns:
+            A list of packages required by the plugin for development.
+        """
+        return []
+
+    def get_frontend_dependencies(
+        self, **context: Unpack[CommonContext]
+    ) -> list[str] | set[str] | tuple[str, ...]:
+        """Get the NPM packages required by the plugin.
+
+        Args:
+            context: The context for the plugin.
+
+        Returns:
+            A list of packages required by the plugin.
+        """
+        return []
+
+    def get_static_assets(
+        self, **context: Unpack[CommonContext]
+    ) -> Sequence[tuple[Path, str | bytes]]:
+        """Get the static assets required by the plugin.
+
+        Args:
+            context: The context for the plugin.
+
+        Returns:
+            A list of static assets required by the plugin.
+        """
+        return []
+
+    def get_stylesheet_paths(self, **context: Unpack[CommonContext]) -> Sequence[str]:
+        """Get the paths to the stylesheets required by the plugin relative to the styles directory.
+
+        Args:
+            context: The context for the plugin.
+
+        Returns:
+            A list of paths to the stylesheets required by the plugin.
+        """
+        return []
+
+    def pre_compile(self, **context: Unpack[PreCompileContext]) -> None:
+        """Called before the compilation of the plugin.
+
+        Args:
+            context: The context for the plugin.
+        """

reflex/plugins/tailwind_v3.py

@@ -0,0 +1,255 @@
+"""Base class for all plugins."""
+
+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
+
+
+class Constants(SimpleNamespace):
+    """Tailwind constants."""
+
+    # The Tailwindcss version
+    VERSION = "tailwindcss@3.4.17"
+    # The Tailwind config.
+    CONFIG = "tailwind.config.js"
+    # Default Tailwind content paths
+    CONTENT = ["./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"
+
+    # Content of the style content.
+    ROOT_STYLE_CONTENT = """
+@import "tailwindcss/base";
+
+@import url('{radix_url}');
+
+@tailwind components;
+@tailwind utilities;
+"""
+
+    # The default tailwind css.
+    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,
+):
+    """Compile the Tailwind config.
+
+    Args:
+        config: The Tailwind config.
+
+    Returns:
+        The compiled Tailwind config.
+    """
+    return Constants.CONFIG, tailwind_config_js_template().render(
+        **config,
+    )
+
+
+def compile_root_style():
+    """Compile the Tailwind root style.
+
+    Returns:
+        The compiled Tailwind root style.
+    """
+    from reflex.compiler.compiler import RADIX_THEMES_STYLESHEET
+
+    return str(
+        Path(Dirs.STYLES) / Constants.ROOT_STYLE_PATH
+    ), Constants.ROOT_STYLE_CONTENT.format(
+        radix_url=RADIX_THEMES_STYLESHEET,
+    )
+
+
+def _index_of_element_that_has(haystack: list[str], needle: str) -> int | None:
+    return next(
+        (i for i, line in enumerate(haystack) if needle in line),
+        None,
+    )
+
+
+def add_tailwind_to_postcss_config(postcss_file_content: str) -> str:
+    """Add tailwind to the postcss config.
+
+    Args:
+        postcss_file_content: The content of the postcss config file.
+
+    Returns:
+        The modified postcss config file content.
+    """
+    from reflex.constants import Dirs
+
+    postcss_file_lines = postcss_file_content.splitlines()
+
+    if _index_of_element_that_has(postcss_file_lines, "tailwindcss") is not None:
+        return postcss_file_content
+
+    line_with_postcss_plugins = _index_of_element_that_has(
+        postcss_file_lines, "plugins"
+    )
+    if not line_with_postcss_plugins:
+        print(  # noqa: T201
+            f"Could not find line with 'plugins' in {Dirs.POSTCSS_JS}. "
+            "Please make sure the file exists and is valid."
+        )
+        return postcss_file_content
+
+    postcss_import_line = _index_of_element_that_has(
+        postcss_file_lines, '"postcss-import"'
+    )
+    postcss_file_lines.insert(
+        (postcss_import_line or line_with_postcss_plugins) + 1, "tailwindcss: {},"
+    )
+
+    return "\n".join(postcss_file_lines)
+
+
+def add_tailwind_to_css_file(css_file_content: str) -> str:
+    """Add tailwind to the css file.
+
+    Args:
+        css_file_content: The content of the css file.
+
+    Returns:
+        The modified css file content.
+    """
+    from reflex.compiler.compiler import RADIX_THEMES_STYLESHEET
+
+    if Constants.TAILWIND_CSS.splitlines()[0] in css_file_content:
+        return css_file_content
+    if RADIX_THEMES_STYLESHEET not in css_file_content:
+        print(  # noqa: T201
+            f"Could not find line with '{RADIX_THEMES_STYLESHEET}' in {Dirs.STYLES}. "
+            "Please make sure the file exists and is valid."
+        )
+        return css_file_content
+    return css_file_content.replace(
+        f"@import url('{RADIX_THEMES_STYLESHEET}');",
+        Constants.TAILWIND_CSS,
+    )
+
+
+class Plugin(PluginBase):
+    """Plugin for Tailwind CSS."""
+
+    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.
+        """
+        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", [])
+        ] + [Constants.VERSION]
+
+    def pre_compile(self, **context):
+        """Pre-compile the plugin.
+
+        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_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,
+        )