reactpy 2.0.0b4__py3-none-any.whl → 2.0.0b6__py3-none-any.whl

reactpy/types.py

@@ -1,22 +1,25 @@
 from __future__ import annotations
 
-from collections.abc import Awaitable, Mapping, Sequence
+import inspect
+from collections.abc import Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 from types import TracebackType
 from typing import (
     Any,
-    Callable,
     Generic,
     Literal,
+    NamedTuple,
+    NewType,
+    NotRequired,
     Protocol,
+    TypeAlias,
+    TypedDict,
     TypeVar,
+    Unpack,
     overload,
-    runtime_checkable,
 )
 
-from typing_extensions import NamedTuple, NotRequired, TypeAlias, TypedDict, Unpack
-
 CarrierType = TypeVar("CarrierType")
 _Type = TypeVar("_Type")
 
@@ -26,54 +29,84 @@ class State(NamedTuple, Generic[_Type]):
     set_value: Callable[[_Type | Callable[[_Type], _Type]], None]
 
 
-ComponentConstructor = Callable[..., "ComponentType"]
+ComponentConstructor = Callable[..., "Component"]
 """Simple function returning a new component"""
 
-RootComponentConstructor = Callable[[], "ComponentType"]
+RootComponentConstructor = Callable[[], "Component"]
 """The root component should be constructed by a function accepting no arguments."""
 
 
 Key: TypeAlias = str | int
 
 
-@runtime_checkable
-class ComponentType(Protocol):
-    """The expected interface for all component-like objects"""
-
-    key: Key | None
-    """An identifier which is unique amongst a component's immediate siblings"""
+class Component:
+    """An object for rending component models."""
 
-    type: Any
-    """The function or class defining the behavior of this component
+    __slots__ = "__weakref__", "_args", "_func", "_kwargs", "_sig", "key", "type"
 
-    This is used to see if two component instances share the same definition.
-    """
+    def __init__(
+        self,
+        function: Callable[..., Component | VdomDict | str | None],
+        key: Any | None,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+        sig: inspect.Signature,
+    ) -> None:
+        self.key = key
+        self.type = function
+        self._args = args
+        self._kwargs = kwargs
+        self._sig = sig
+
+    def render(self) -> Component | VdomDict | str | None:
+        return self.type(*self._args, **self._kwargs)
 
-    def render(self) -> VdomDict | ComponentType | str | None:
-        """Render the component's view model."""
+    def __repr__(self) -> str:
+        try:
+            args = self._sig.bind(*self._args, **self._kwargs).arguments
+        except TypeError:
+            return f"{self.type.__name__}(...)"
+        else:
+            items = ", ".join(f"{k}={v!r}" for k, v in args.items())
+            if items:
+                return f"{self.type.__name__}({id(self):02x}, {items})"
+            else:
+                return f"{self.type.__name__}({id(self):02x})"
 
 
 _Render_co = TypeVar("_Render_co", covariant=True)
 _Event_contra = TypeVar("_Event_contra", contravariant=True)
 
 
-@runtime_checkable
-class LayoutType(Protocol[_Render_co, _Event_contra]):
-    """Renders and delivers, updates to views and events to handlers, respectively"""
+class BaseLayout(Protocol[_Render_co, _Event_contra]):
+    """Renders and delivers views, and submits events to handlers."""
+
+    __slots__: tuple[str, ...] = (
+        "__weakref__",
+        "_event_handlers",
+        "_model_states_by_life_cycle_state_id",
+        "_render_tasks",
+        "_render_tasks_ready",
+        "_rendering_queue",
+        "_root_life_cycle_state_id",
+        "root",
+    )
 
     async def render(
         self,
-    ) -> _Render_co: ...  # Render an update to a view
+    ) -> _Render_co:
+        """Render an update to a view"""
+        ...
 
-    async def deliver(
-        self, event: _Event_contra
-    ) -> None: ...  # Relay an event to its respective handler
+    async def deliver(self, event: _Event_contra) -> None:
+        """Relay an event to its respective handler"""
+        ...
 
     async def __aenter__(
         self,
-    ) -> LayoutType[
-        _Render_co, _Event_contra
-    ]: ...  # Prepare the layout for its first render
+    ) -> BaseLayout[_Render_co, _Event_contra]:
+        """Prepare the layout for its first render"""
+        ...
 
     async def __aexit__(
         self,
@@ -82,6 +115,7 @@ class LayoutType(Protocol[_Render_co, _Event_contra]):
         traceback: TracebackType,
     ) -> bool | None:
         """Clean up the view after its final render"""
+        ...
 
 
 class CssStyleTypeDict(TypedDict, total=False):
@@ -500,7 +534,7 @@ class CssStyleTypeDict(TypedDict, total=False):
     zIndex: str | int
 
 
-# TODO: Enable `extra_items` on `CssStyleDict` when PEP 728 is merged, likely in Python 3.14. Ref: https://peps.python.org/pep-0728/
+# TODO: Enable `extra_items` on `CssStyleDict` when PEP 728 is merged, likely in Python 3.15. Ref: https://peps.python.org/pep-0728/
 CssStyleDict = CssStyleTypeDict | dict[str, Any]
 
 EventFunc = Callable[[dict[str, Any]], Awaitable[None] | None]
@@ -510,8 +544,8 @@ class DangerouslySetInnerHTML(TypedDict):
     __html: str
 
 
-# TODO: It's probably better to break this one attributes dict down into what each specific
-# HTML node's attributes can be, and make sure those types are resolved correctly within `HtmlConstructor`
+# TODO: It's probably better to break this down into what each HTML node's attributes can be,
+# and make sure those types are resolved correctly within `HtmlConstructor`
 # TODO: This could be generated by parsing from `@types/react` in the future
 # https://www.npmjs.com/package/@types/react?activeTab=code
 VdomAttributesTypeDict = TypedDict(
@@ -764,7 +798,6 @@ VdomAttributes = VdomAttributesTypeDict | dict[str, Any]
 
 VdomDictKeys = Literal[
     "tagName",
-    "key",
     "children",
     "attributes",
     "eventHandlers",
@@ -773,7 +806,6 @@ VdomDictKeys = Literal[
 ]
 ALLOWED_VDOM_KEYS = {
     "tagName",
-    "key",
     "children",
     "attributes",
     "eventHandlers",
@@ -786,8 +818,7 @@ class VdomTypeDict(TypedDict):
     """TypedDict representation of what the `VdomDict` should look like."""
 
     tagName: str
-    key: NotRequired[Key | None]
-    children: NotRequired[Sequence[ComponentType | VdomChild]]
+    children: NotRequired[Sequence[Component | VdomChild]]
     attributes: NotRequired[VdomAttributes]
     eventHandlers: NotRequired[EventHandlerDict]
     inlineJavaScript: NotRequired[InlineJavaScriptDict]
@@ -811,11 +842,9 @@ class VdomDict(dict):
     @overload
     def __getitem__(self, key: Literal["tagName"]) -> str: ...
     @overload
-    def __getitem__(self, key: Literal["key"]) -> Key | None: ...
-    @overload
     def __getitem__(
         self, key: Literal["children"]
-    ) -> Sequence[ComponentType | VdomChild]: ...
+    ) -> Sequence[Component | VdomChild]: ...
     @overload
     def __getitem__(self, key: Literal["attributes"]) -> VdomAttributes: ...
     @overload
@@ -830,10 +859,8 @@ class VdomDict(dict):
     @overload
     def __setitem__(self, key: Literal["tagName"], value: str) -> None: ...
     @overload
-    def __setitem__(self, key: Literal["key"], value: Key | None) -> None: ...
-    @overload
     def __setitem__(
-        self, key: Literal["children"], value: Sequence[ComponentType | VdomChild]
+        self, key: Literal["children"], value: Sequence[Component | VdomChild]
     ) -> None: ...
     @overload
     def __setitem__(
@@ -857,7 +884,7 @@ class VdomDict(dict):
         super().__setitem__(key, value)
 
 
-VdomChild: TypeAlias = ComponentType | VdomDict | str | None | Any
+VdomChild: TypeAlias = Component | VdomDict | str | None | Any
 """A single child element of a :class:`VdomDict`"""
 
 VdomChildren: TypeAlias = Sequence[VdomChild] | VdomChild
@@ -907,19 +934,26 @@ class EventHandlerFunc(Protocol):
     async def __call__(self, data: Sequence[Any]) -> None: ...
 
 
-@runtime_checkable
-class EventHandlerType(Protocol):
+class BaseEventHandler:
     """Defines a handler for some event"""
 
+    __slots__ = (
+        "__weakref__",
+        "function",
+        "prevent_default",
+        "stop_propagation",
+        "target",
+    )
+
+    function: EventHandlerFunc
+    """A coroutine which can respond to an event and its data"""
+
     prevent_default: bool
     """Whether to block the event from propagating further up the DOM"""
 
     stop_propagation: bool
     """Stops the default action associate with the event from taking place."""
 
-    function: EventHandlerFunc
-    """A coroutine which can respond to an event and its data"""
-
     target: str | None
     """Typically left as ``None`` except when a static target is useful.
 
@@ -932,10 +966,10 @@ class EventHandlerType(Protocol):
     """
 
 
-EventHandlerMapping = Mapping[str, EventHandlerType]
+EventHandlerMapping = Mapping[str, BaseEventHandler]
 """A generic mapping between event names to their handlers"""
 
-EventHandlerDict: TypeAlias = dict[str, EventHandlerType]
+EventHandlerDict: TypeAlias = dict[str, BaseEventHandler]
 """A dict mapping between event names to their handlers"""
 
 InlineJavaScriptMapping = Mapping[str, InlineJavaScript]
@@ -991,17 +1025,30 @@ class Context(Protocol[_Type]):
         *children: Any,
         value: _Type = ...,
         key: Key | None = ...,
-    ) -> ContextProviderType[_Type]: ...
+    ) -> ContextProvider[_Type]: ...
 
 
-class ContextProviderType(ComponentType, Protocol[_Type]):
-    """A component which provides a context value to its children"""
+class ContextProvider(Component, Generic[_Type]):
+    def __init__(
+        self,
+        *children: Any,
+        value: _Type,
+        key: Key | None,
+        type: Context[_Type],
+    ) -> None:
+        self.children = children
+        self.key = key
+        self.type = type
+        self.value = value
+
+    def render(self) -> VdomDict:
+        from reactpy.core.hooks import HOOK_STACK
 
-    type: Context[_Type]
-    """The context type"""
+        HOOK_STACK.current_hook().set_context_provider(self)
+        return VdomDict(tagName="", children=self.children)
 
-    @property
-    def value(self) -> _Type: ...  # Current context value
+    def __repr__(self) -> str:
+        return f"ContextProvider({self.type})"
 
 
 @dataclass
@@ -1063,7 +1110,6 @@ class CustomVdomConstructor(Protocol):
         self,
         attributes: VdomAttributes,
         children: Sequence[VdomChildren],
-        key: Key | None,
         event_handlers: EventHandlerDict,
     ) -> VdomDict: ...
 
@@ -1087,3 +1133,16 @@ class Event(dict):
 
     def stopPropagation(self) -> None:
         """Stop the event from propagating."""
+
+
+SourceType = NewType("SourceType", str)
+
+
+@dataclass(frozen=True)
+class JavaScriptModule:
+    source: str
+    source_type: SourceType
+    default_fallback: Any | None
+    import_names: set[str] | None
+    file: Path | None
+    unmount_before_update: bool

reactpy/utils.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
 import re
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from importlib import import_module
 from itertools import chain
-from typing import Any, Callable, Generic, TypeVar, cast
+from typing import Any, Generic, TypeVar, cast
 
 from lxml import etree
 from lxml.html import fromstring
 
 from reactpy import html
 from reactpy.transforms import RequiredTransforms, attributes_to_reactjs
-from reactpy.types import ComponentType, VdomDict
+from reactpy.types import Component, VdomDict
 
 _RefValue = TypeVar("_RefValue")
 _ModelTransform = Callable[[VdomDict], Any]
@@ -63,7 +63,7 @@ class Ref(Generic[_RefValue]):
         return f"{type(self).__name__}({current})"
 
 
-def reactpy_to_string(root: VdomDict | ComponentType) -> str:
+def reactpy_to_string(root: VdomDict | Component) -> str:
     """Convert a ReactPy component or `reactpy.html` element into an HTML string.
 
     Parameters:
@@ -186,7 +186,7 @@ def _add_vdom_to_etree(parent: etree._Element, vdom: VdomDict | dict[str, Any])
 
     for c in vdom.get("children", []):
         if hasattr(c, "render"):
-            c = component_to_vdom(cast(ComponentType, c))
+            c = component_to_vdom(cast(Component, c))
         if isinstance(c, dict):
             _add_vdom_to_etree(element, c)
 
@@ -232,17 +232,17 @@ def _generate_vdom_children(
     )
 
 
-def component_to_vdom(component: ComponentType) -> VdomDict:
+def component_to_vdom(component: Component) -> VdomDict:
     """Convert the first render of a component into a VDOM dictionary"""
     result = component.render()
 
     if isinstance(result, dict):
         return result
     if hasattr(result, "render"):
-        return component_to_vdom(cast(ComponentType, result))
+        return component_to_vdom(cast(Component, result))
     elif isinstance(result, str):
         return html.div(result)
-    return html.fragment()
+    return html()
 
 
 def _react_attribute_to_html(key: str, value: Any) -> tuple[str, str]:

reactpy/web/__init__.py

@@ -3,9 +3,6 @@ from reactpy.web.module import (
     module_from_file,
     module_from_string,
     module_from_url,
-    reactjs_component_from_file,
-    reactjs_component_from_string,
-    reactjs_component_from_url,
 )
 
 __all__ = [
@@ -13,7 +10,4 @@ __all__ = [
     "module_from_file",
     "module_from_string",
     "module_from_url",
-    "reactjs_component_from_file",
-    "reactjs_component_from_string",
-    "reactjs_component_from_url",
 ]