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

reflex/components/props.py

@@ -2,17 +2,280 @@
 
 from __future__ import annotations
 
-from pydantic import ValidationError
+from collections.abc import Callable
+from dataclasses import _MISSING_TYPE, MISSING
+from typing import Any, TypeVar, get_args, get_origin
 
-from reflex.base import Base
+from typing_extensions import dataclass_transform
+
+from reflex.components.field import BaseField, FieldBasedMeta
 from reflex.utils import format
 from reflex.utils.exceptions import InvalidPropValueError
+from reflex.utils.serializers import serializer
+from reflex.utils.types import is_union
 from reflex.vars.object import LiteralObjectVar
 
+PROPS_FIELD_TYPE = TypeVar("PROPS_FIELD_TYPE")
+
+
+def _get_props_subclass(field_type: Any) -> type | None:
+    """Extract the Props subclass from a field type annotation.
+
+    Args:
+        field_type: The type annotation to check.
+
+    Returns:
+        The Props subclass if found, None otherwise.
+    """
+    from reflex.utils.types import typehint_issubclass
+
+    # For direct class types, we can return them directly if they're Props subclasses
+    if isinstance(field_type, type):
+        return field_type if typehint_issubclass(field_type, PropsBase) else None
+
+    # For Union types, check each union member
+    if is_union(field_type):
+        for arg in get_args(field_type):
+            result = _get_props_subclass(arg)
+            if result is not None:
+                return result
+
+    return None
+
+
+def _find_props_in_list_annotation(field_type: Any) -> type | None:
+    """Find Props subclass within a list type annotation.
+
+    Args:
+        field_type: The type annotation to check (e.g., list[SomeProps] or list[SomeProps] | None).
+
+    Returns:
+        The Props subclass if found in a list annotation, None otherwise.
+    """
+    origin = get_origin(field_type)
+    if origin is list:
+        args = get_args(field_type)
+        if args:
+            return _get_props_subclass(args[0])
+
+    # Handle Union types - check if any union member is a list
+    if is_union(field_type):
+        for arg in get_args(field_type):
+            if arg is not type(None):  # Skip None from Optional
+                list_element = _find_props_in_list_annotation(arg)
+                if list_element is not None:
+                    return list_element
+
+    return None
+
+
+class PropsField(BaseField[PROPS_FIELD_TYPE]):
+    """A field for a props class."""
+
+    def __init__(
+        self,
+        default: PROPS_FIELD_TYPE | _MISSING_TYPE = MISSING,
+        default_factory: Callable[[], PROPS_FIELD_TYPE] | None = None,
+        annotated_type: type[Any] | _MISSING_TYPE = MISSING,
+    ) -> None:
+        """Initialize the field.
+
+        Args:
+            default: The default value for the field.
+            default_factory: The default factory for the field.
+            annotated_type: The annotated type for the field.
+        """
+        super().__init__(default, default_factory, annotated_type)
+        self._name: str = ""  # Will be set by metaclass
+
+    @property
+    def required(self) -> bool:
+        """Check if the field is required (for Pydantic compatibility).
+
+        Returns:
+            True if the field has no default value or factory.
+        """
+        return self.default is MISSING and self.default_factory is None
+
+    @property
+    def name(self) -> str | None:
+        """Field name (for Pydantic compatibility).
+
+        Note: This is set by the metaclass when processing fields.
+
+        Returns:
+            The field name if set, None otherwise.
+        """
+        return getattr(self, "_name", None)
+
+    def get_default(self) -> Any:
+        """Get the default value (for Pydantic compatibility).
+
+        Returns:
+            The default value for the field, or None if required.
+        """
+        try:
+            return self.default_value()
+        except ValueError:
+            # Field is required (no default)
+            return None
+
+    def __repr__(self) -> str:
+        """Represent the field in a readable format.
+
+        Returns:
+            The string representation of the field.
+        """
+        annotated_type_str = (
+            f", annotated_type={self.annotated_type!r}"
+            if self.annotated_type is not MISSING
+            else ""
+        )
+        if self.default is not MISSING:
+            return f"PropsField(default={self.default!r}{annotated_type_str})"
+        return (
+            f"PropsField(default_factory={self.default_factory!r}{annotated_type_str})"
+        )
+
+
+def props_field(
+    default: PROPS_FIELD_TYPE | _MISSING_TYPE = MISSING,
+    default_factory: Callable[[], PROPS_FIELD_TYPE] | None = None,
+) -> PROPS_FIELD_TYPE:
+    """Create a field for a props class.
+
+    Args:
+        default: The default value for the field.
+        default_factory: The default factory for the field.
+
+    Returns:
+        The field for the props class.
+
+    Raises:
+        ValueError: If both default and default_factory are specified.
+    """
+    if default is not MISSING and default_factory is not None:
+        msg = "cannot specify both default and default_factory"
+        raise ValueError(msg)
+    return PropsField(  # pyright: ignore [reportReturnType]
+        default=default,
+        default_factory=default_factory,
+        annotated_type=MISSING,
+    )
+
 
-class PropsBase(Base):
+@dataclass_transform(field_specifiers=(props_field,))
+class PropsBaseMeta(FieldBasedMeta):
+    """Meta class for PropsBase."""
+
+    @classmethod
+    def _process_annotated_fields(
+        cls,
+        namespace: dict[str, Any],
+        annotations: dict[str, Any],
+        inherited_fields: dict[str, PropsField],
+    ) -> dict[str, PropsField]:
+        own_fields: dict[str, PropsField] = {}
+
+        for key, annotation in annotations.items():
+            value = namespace.get(key, MISSING)
+
+            if value is MISSING:
+                # Field with only annotation, no default value
+                field = PropsField(annotated_type=annotation, default=None)
+            elif not isinstance(value, PropsField):
+                # Field with default value
+                field = PropsField(annotated_type=annotation, default=value)
+            else:
+                # Field is already a PropsField, update annotation
+                field = PropsField(
+                    annotated_type=annotation,
+                    default=value.default,
+                    default_factory=value.default_factory,
+                )
+
+            own_fields[key] = field
+
+        return own_fields
+
+    @classmethod
+    def _create_field(
+        cls,
+        annotated_type: Any,
+        default: Any = MISSING,
+        default_factory: Callable[[], Any] | None = None,
+    ) -> PropsField:
+        return PropsField(
+            annotated_type=annotated_type,
+            default=default,
+            default_factory=default_factory,
+        )
+
+    @classmethod
+    def _finalize_fields(
+        cls,
+        namespace: dict[str, Any],
+        inherited_fields: dict[str, PropsField],
+        own_fields: dict[str, PropsField],
+    ) -> None:
+        # Call parent implementation
+        super()._finalize_fields(namespace, inherited_fields, own_fields)
+
+        # Add Pydantic compatibility
+        namespace["__fields__"] = namespace["_fields"]
+
+
+class PropsBase(metaclass=PropsBaseMeta):
     """Base for a class containing props that can be serialized as a JS object."""
 
+    def __init__(self, **kwargs):
+        """Initialize the props with field values.
+
+        Args:
+            **kwargs: The field values to set.
+        """
+        # Set field values from kwargs with nested object instantiation
+        for key, value in kwargs.items():
+            field_info = self.get_fields().get(key)
+            if field_info:
+                field_type = field_info.annotated_type
+
+                # Check if this field expects a specific Props type and we got a dict
+                if isinstance(value, dict):
+                    props_class = _get_props_subclass(field_type)
+                    if props_class is not None:
+                        value = props_class(**value)
+
+                # Check if this field expects a list of Props and we got a list of dicts
+                elif isinstance(value, list):
+                    element_type = _find_props_in_list_annotation(field_type)
+                    if element_type is not None:
+                        # Convert each dict in the list to the appropriate Props class
+                        value = [
+                            element_type(**item) if isinstance(item, dict) else item
+                            for item in value
+                        ]
+
+            setattr(self, key, value)
+
+        # Set default values for fields not provided
+        for field_name, field in self.get_fields().items():
+            if field_name not in kwargs:
+                if field.default is not MISSING:
+                    setattr(self, field_name, field.default)
+                elif field.default_factory is not None:
+                    setattr(self, field_name, field.default_factory())
+                # Note: Fields with no default and no factory remain unset (required fields)
+
+    @classmethod
+    def get_fields(cls) -> dict[str, Any]:
+        """Get the fields of the object.
+
+        Returns:
+            The fields of the object.
+        """
+        return getattr(cls, "_fields", {})
+
     def json(self) -> str:
         """Convert the object to a json-like string.
 
@@ -27,31 +290,117 @@ class PropsBase(Base):
             {format.to_camel_case(key): value for key, value in self.dict().items()}
         ).json()
 
-    def dict(self, *args, **kwargs):
+    def dict(
+        self,
+        exclude_none: bool = True,
+        include: set[str] | None = None,
+        exclude: set[str] | None = None,
+        **kwargs,
+    ):
         """Convert the object to a dictionary.
 
         Keys will be converted to camelCase.
         By default, None values are excluded (exclude_none=True).
 
         Args:
-            *args: Arguments to pass to the parent class.
-            **kwargs: Keyword arguments to pass to the parent class.
+            exclude_none: Whether to exclude None values.
+            include: Fields to include in the output.
+            exclude: Fields to exclude from the output.
+            **kwargs: Additional keyword arguments (for compatibility).
 
         Returns:
             The object as a dictionary.
         """
-        kwargs.setdefault("exclude_none", True)
-        return {
-            format.to_camel_case(key): value
-            for key, value in super().dict(*args, **kwargs).items()
-        }
+        result = {}
 
+        for field_name in self.get_fields():
+            if hasattr(self, field_name):
+                value = getattr(self, field_name)
 
-class NoExtrasAllowedProps(Base):
+                # Apply include/exclude filters
+                if include is not None and field_name not in include:
+                    continue
+                if exclude is not None and field_name in exclude:
+                    continue
+
+                # Apply exclude_none logic
+                if exclude_none and value is None:
+                    continue
+
+                # Recursively convert nested structures
+                value = self._convert_to_camel_case(
+                    value, exclude_none, include, exclude
+                )
+
+                # Convert key to camelCase
+                camel_key = format.to_camel_case(field_name)
+                result[camel_key] = value
+
+        return result
+
+    def _convert_to_camel_case(
+        self,
+        value: Any,
+        exclude_none: bool = True,
+        include: set[str] | None = None,
+        exclude: set[str] | None = None,
+    ) -> Any:
+        """Recursively convert nested dictionaries and lists to camelCase.
+
+        Args:
+            value: The value to convert.
+            exclude_none: Whether to exclude None values.
+            include: Fields to include in the output.
+            exclude: Fields to exclude from the output.
+
+        Returns:
+            The converted value with camelCase keys.
+        """
+        if isinstance(value, PropsBase):
+            # Convert nested PropsBase objects
+            return value.dict(
+                exclude_none=exclude_none, include=include, exclude=exclude
+            )
+        if isinstance(value, dict):
+            # Convert dictionary keys to camelCase
+            return {
+                format.to_camel_case(k): self._convert_to_camel_case(
+                    v, exclude_none, include, exclude
+                )
+                for k, v in value.items()
+                if not (exclude_none and v is None)
+            }
+        if isinstance(value, (list, tuple)):
+            # Convert list/tuple items recursively
+            return [
+                self._convert_to_camel_case(item, exclude_none, include, exclude)
+                for item in value
+            ]
+        # Return primitive values as-is
+        return value
+
+
+@serializer(to=dict)
+def serialize_props_base(value: PropsBase) -> dict:
+    """Serialize a PropsBase instance.
+
+    Unlike serialize_base, this preserves callables (lambdas) since they're
+    needed for AG Grid and other components that process them on the frontend.
+
+    Args:
+        value: The PropsBase instance to serialize.
+
+    Returns:
+        Dictionary representation of the PropsBase instance.
+    """
+    return value.dict()
+
+
+class NoExtrasAllowedProps(PropsBase):
     """A class that holds props to be passed or applied to a component with no extra props allowed."""
 
     def __init__(self, component_name: str | None = None, **kwargs):
-        """Initialize the props.
+        """Initialize the props with validation.
 
         Args:
             component_name: The custom name of the component.
@@ -61,17 +410,17 @@ class NoExtrasAllowedProps(Base):
             InvalidPropValueError: If invalid props are passed on instantiation.
         """
         component_name = component_name or type(self).__name__
-        try:
-            super().__init__(**kwargs)
-        except ValidationError as e:
-            invalid_fields = ", ".join([error["loc"][0] for error in e.errors()])  # pyright: ignore [reportCallIssue, reportArgumentType]
-            supported_props_str = ", ".join(f'"{field}"' for field in self.get_fields())
-            msg = f"Invalid prop(s) {invalid_fields} for {component_name!r}. Supported props are {supported_props_str}"
-            raise InvalidPropValueError(msg) from None
-
-    class Config:  # pyright: ignore [reportIncompatibleVariableOverride]
-        """Pydantic config."""
-
-        arbitrary_types_allowed = True
-        use_enum_values = True
-        extra = "forbid"
+
+        # Validate fields BEFORE setting them
+        known_fields = set(self.__class__.get_fields().keys())
+        provided_fields = set(kwargs.keys())
+        invalid_fields = provided_fields - known_fields
+
+        if invalid_fields:
+            invalid_fields_str = ", ".join(invalid_fields)
+            supported_props_str = ", ".join(f'"{field}"' for field in known_fields)
+            msg = f"Invalid prop(s) {invalid_fields_str} for {component_name!r}. Supported props are {supported_props_str}"
+            raise InvalidPropValueError(msg)
+
+        # Use parent class initialization after validation
+        super().__init__(**kwargs)

reflex/components/radix/__init__.pyi

@@ -3,68 +3,126 @@
 # This file was generated by `reflex/utils/pyi_generator.py`!
 # ------------------------------------------------------
 
-from . import primitives as primitives
-from . import themes as themes
-from .primitives.accordion import accordion as accordion
-from .primitives.drawer import drawer as drawer
-from .primitives.form import form as form
-from .themes.base import theme as theme
-from .themes.base import theme_panel as theme_panel
-from .themes.color_mode import color_mode as color_mode
-from .themes.components.alert_dialog import alert_dialog as alert_dialog
-from .themes.components.aspect_ratio import aspect_ratio as aspect_ratio
-from .themes.components.avatar import avatar as avatar
-from .themes.components.badge import badge as badge
-from .themes.components.button import button as button
-from .themes.components.callout import callout as callout
-from .themes.components.card import card as card
-from .themes.components.checkbox import checkbox as checkbox
-from .themes.components.checkbox_cards import checkbox_cards as checkbox_cards
-from .themes.components.checkbox_group import checkbox_group as checkbox_group
-from .themes.components.context_menu import context_menu as context_menu
-from .themes.components.data_list import data_list as data_list
-from .themes.components.dialog import dialog as dialog
-from .themes.components.dropdown_menu import dropdown_menu as dropdown_menu
-from .themes.components.dropdown_menu import menu as menu
-from .themes.components.hover_card import hover_card as hover_card
-from .themes.components.icon_button import icon_button as icon_button
-from .themes.components.inset import inset as inset
-from .themes.components.popover import popover as popover
-from .themes.components.progress import progress as progress
-from .themes.components.radio_cards import radio_cards as radio_cards
-from .themes.components.radio_group import radio as radio
-from .themes.components.radio_group import radio_group as radio_group
-from .themes.components.scroll_area import scroll_area as scroll_area
-from .themes.components.segmented_control import segmented_control as segmented_control
-from .themes.components.select import select as select
-from .themes.components.separator import divider as divider
-from .themes.components.separator import separator as separator
-from .themes.components.skeleton import skeleton as skeleton
-from .themes.components.slider import slider as slider
-from .themes.components.spinner import spinner as spinner
-from .themes.components.switch import switch as switch
-from .themes.components.table import table as table
-from .themes.components.tabs import tabs as tabs
-from .themes.components.text_area import text_area as text_area
-from .themes.components.text_field import input as input
-from .themes.components.text_field import text_field as text_field
-from .themes.components.tooltip import tooltip as tooltip
-from .themes.layout.box import box as box
-from .themes.layout.center import center as center
-from .themes.layout.container import container as container
-from .themes.layout.flex import flex as flex
-from .themes.layout.grid import grid as grid
-from .themes.layout.list import list_item as list_item
-from .themes.layout.list import list_ns as list  # noqa: F401
-from .themes.layout.list import ordered_list as ordered_list
-from .themes.layout.list import unordered_list as unordered_list
-from .themes.layout.section import section as section
-from .themes.layout.spacer import spacer as spacer
-from .themes.layout.stack import hstack as hstack
-from .themes.layout.stack import stack as stack
-from .themes.layout.stack import vstack as vstack
-from .themes.typography.blockquote import blockquote as blockquote
-from .themes.typography.code import code as code
-from .themes.typography.heading import heading as heading
-from .themes.typography.link import link as link
-from .themes.typography.text import text as text
+from . import primitives, themes
+from .primitives.accordion import accordion
+from .primitives.drawer import drawer
+from .primitives.form import form
+from .themes.base import theme, theme_panel
+from .themes.color_mode import color_mode
+from .themes.components.alert_dialog import alert_dialog
+from .themes.components.aspect_ratio import aspect_ratio
+from .themes.components.avatar import avatar
+from .themes.components.badge import badge
+from .themes.components.button import button
+from .themes.components.callout import callout
+from .themes.components.card import card
+from .themes.components.checkbox import checkbox
+from .themes.components.checkbox_cards import checkbox_cards
+from .themes.components.checkbox_group import checkbox_group
+from .themes.components.context_menu import context_menu
+from .themes.components.data_list import data_list
+from .themes.components.dialog import dialog
+from .themes.components.dropdown_menu import dropdown_menu, menu
+from .themes.components.hover_card import hover_card
+from .themes.components.icon_button import icon_button
+from .themes.components.inset import inset
+from .themes.components.popover import popover
+from .themes.components.progress import progress
+from .themes.components.radio_cards import radio_cards
+from .themes.components.radio_group import radio, radio_group
+from .themes.components.scroll_area import scroll_area
+from .themes.components.segmented_control import segmented_control
+from .themes.components.select import select
+from .themes.components.separator import divider, separator
+from .themes.components.skeleton import skeleton
+from .themes.components.slider import slider
+from .themes.components.spinner import spinner
+from .themes.components.switch import switch
+from .themes.components.table import table
+from .themes.components.tabs import tabs
+from .themes.components.text_area import text_area
+from .themes.components.text_field import input, text_field
+from .themes.components.tooltip import tooltip
+from .themes.layout.box import box
+from .themes.layout.center import center
+from .themes.layout.container import container
+from .themes.layout.flex import flex
+from .themes.layout.grid import grid
+from .themes.layout.list import list_item, ordered_list, unordered_list
+from .themes.layout.list import list_ns as list
+from .themes.layout.section import section
+from .themes.layout.spacer import spacer
+from .themes.layout.stack import hstack, stack, vstack
+from .themes.typography.blockquote import blockquote
+from .themes.typography.code import code
+from .themes.typography.heading import heading
+from .themes.typography.link import link
+from .themes.typography.text import text
+
+__all__ = [
+    "accordion",
+    "alert_dialog",
+    "aspect_ratio",
+    "avatar",
+    "badge",
+    "blockquote",
+    "box",
+    "button",
+    "callout",
+    "card",
+    "center",
+    "checkbox",
+    "checkbox_cards",
+    "checkbox_group",
+    "code",
+    "color_mode",
+    "container",
+    "context_menu",
+    "data_list",
+    "dialog",
+    "divider",
+    "drawer",
+    "dropdown_menu",
+    "flex",
+    "form",
+    "grid",
+    "heading",
+    "hover_card",
+    "hstack",
+    "icon_button",
+    "input",
+    "inset",
+    "link",
+    "list",
+    "list_item",
+    "menu",
+    "ordered_list",
+    "popover",
+    "primitives",
+    "progress",
+    "radio",
+    "radio_cards",
+    "radio_group",
+    "scroll_area",
+    "section",
+    "segmented_control",
+    "select",
+    "separator",
+    "skeleton",
+    "slider",
+    "spacer",
+    "spinner",
+    "stack",
+    "switch",
+    "table",
+    "tabs",
+    "text",
+    "text_area",
+    "text_field",
+    "theme",
+    "theme_panel",
+    "themes",
+    "tooltip",
+    "unordered_list",
+    "vstack",
+]

reflex/components/radix/primitives/__init__.pyi

@@ -3,7 +3,9 @@
 # This file was generated by `reflex/utils/pyi_generator.py`!
 # ------------------------------------------------------
 
-from .accordion import accordion as accordion
-from .drawer import drawer as drawer
-from .form import form as form
-from .progress import progress as progress
+from .accordion import accordion
+from .drawer import drawer
+from .form import form
+from .progress import progress
+
+__all__ = ["accordion", "drawer", "form", "progress"]

reflex/components/radix/primitives/accordion.py

@@ -334,7 +334,11 @@ class AccordionHeader(AccordionComponent):
         Returns:
             The style of the component.
         """
-        return {"display": "flex"}
+        return {
+            "display": "flex",
+            # Reset some values to ensure consistent styling without tailwind reset.
+            "margin": "0",
+        }
 
 
 class AccordionTrigger(AccordionComponent):
@@ -399,6 +403,9 @@ class AccordionTrigger(AccordionComponent):
                     "color": "var(--accent-contrast)",
                 },
             },
+            # Reset some values to ensure consistent styling without tailwind reset.
+            "background": "none",
+            "border": "none",
         }