reactpy 2.0.0b3__py3-none-any.whl → 2.0.0b5__py3-none-any.whl

reactpy/types.py

@@ -1,22 +1,24 @@
 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,
+    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 +28,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 +114,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):
@@ -787,7 +820,7 @@ class VdomTypeDict(TypedDict):
 
     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]
@@ -815,7 +848,7 @@ class VdomDict(dict):
     @overload
     def __getitem__(
         self, key: Literal["children"]
-    ) -> Sequence[ComponentType | VdomChild]: ...
+    ) -> Sequence[Component | VdomChild]: ...
     @overload
     def __getitem__(self, key: Literal["attributes"]) -> VdomAttributes: ...
     @overload
@@ -833,7 +866,7 @@ class VdomDict(dict):
     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 +890,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 +940,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 +972,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 +1031,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
 
-    type: Context[_Type]
-    """The context type"""
+    def render(self) -> VdomDict:
+        from reactpy.core.hooks import HOOK_STACK
 
-    @property
-    def value(self) -> _Type: ...  # Current context value
+        HOOK_STACK.current_hook().set_context_provider(self)
+        return VdomDict(tagName="", children=self.children)
+
+    def __repr__(self) -> str:
+        return f"ContextProvider({self.type})"
 
 
 @dataclass
@@ -1071,3 +1124,19 @@ class CustomVdomConstructor(Protocol):
 class EllipsisRepr:
     def __repr__(self) -> str:
         return "..."
+
+
+class Event(dict):
+    """
+    A light `dict` wrapper for event data passed to event handler functions.
+    """
+
+    def __getattr__(self, name: str) -> Any:
+        value = self.get(name)
+        return Event(value) if isinstance(value, dict) else value
+
+    def preventDefault(self) -> None:
+        """Prevent the default action of the event."""
+
+    def stopPropagation(self) -> None:
+        """Stop the event from propagating."""

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,14 +232,14 @@ 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()

reactpy/web/module.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import filecmp
+import hashlib
 import logging
 import shutil
 from dataclasses import dataclass
@@ -33,6 +34,30 @@ _FILE_WEB_MODULE_CACHE: dict[str, WebModule] = {}
 _STRING_WEB_MODULE_CACHE: dict[str, WebModule] = {}
 
 
+@overload
+def reactjs_component_from_url(
+    url: str,
+    import_names: str,
+    fallback: Any | None = ...,
+    resolve_imports: bool | None = ...,
+    resolve_imports_depth: int = ...,
+    unmount_before_update: bool = ...,
+    allow_children: bool = ...,
+) -> VdomConstructor: ...
+
+
+@overload
+def reactjs_component_from_url(
+    url: str,
+    import_names: list[str] | tuple[str, ...],
+    fallback: Any | None = ...,
+    resolve_imports: bool | None = ...,
+    resolve_imports_depth: int = ...,
+    unmount_before_update: bool = ...,
+    allow_children: bool = ...,
+) -> list[VdomConstructor]: ...
+
+
 def reactjs_component_from_url(
     url: str,
     import_names: str | list[str] | tuple[str, ...],
@@ -80,10 +105,38 @@ def reactjs_component_from_url(
     return _vdom_from_web_module(module, import_names, fallback, allow_children)
 
 
+@overload
+def reactjs_component_from_file(
+    file: str | Path,
+    import_names: str,
+    name: str = "",
+    fallback: Any | None = ...,
+    resolve_imports: bool | None = ...,
+    resolve_imports_depth: int = ...,
+    unmount_before_update: bool = ...,
+    symlink: bool = ...,
+    allow_children: bool = ...,
+) -> VdomConstructor: ...
+
+
+@overload
+def reactjs_component_from_file(
+    file: str | Path,
+    import_names: list[str] | tuple[str, ...],
+    name: str = "",
+    fallback: Any | None = ...,
+    resolve_imports: bool | None = ...,
+    resolve_imports_depth: int = ...,
+    unmount_before_update: bool = ...,
+    symlink: bool = ...,
+    allow_children: bool = ...,
+) -> list[VdomConstructor]: ...
+
+
 def reactjs_component_from_file(
-    name: str,
     file: str | Path,
     import_names: str | list[str] | tuple[str, ...],
+    name: str = "",
     fallback: Any | None = None,
     resolve_imports: bool | None = None,
     resolve_imports_depth: int = 5,
@@ -94,14 +147,14 @@ def reactjs_component_from_file(
     """Import a component from a file.
 
     Parameters:
-        name:
-            The name of the package
         file:
             The file from which the content of the web module will be created.
         import_names:
             One or more component names to import. If given as a string, a single component
             will be returned. If a list is given, then a list of components will be
             returned.
+        name:
+            The human-readable name of the ReactJS package
         fallback:
             What to temporarily display while the module is being loaded.
         resolve_imports:
@@ -118,6 +171,7 @@ def reactjs_component_from_file(
         allow_children:
             Whether or not these components can have children.
     """
+    name = name or hashlib.sha256(str(file).encode()).hexdigest()[:10]
     key = f"{name}{resolve_imports}{resolve_imports_depth}{unmount_before_update}"
     if key in _FILE_WEB_MODULE_CACHE:
         module = _FILE_WEB_MODULE_CACHE[key]
@@ -135,10 +189,36 @@ def reactjs_component_from_file(
     return _vdom_from_web_module(module, import_names, fallback, allow_children)
 
 
+@overload
+def reactjs_component_from_string(
+    content: str,
+    import_names: str,
+    name: str = "",
+    fallback: Any | None = ...,
+    resolve_imports: bool | None = ...,
+    resolve_imports_depth: int = ...,
+    unmount_before_update: bool = ...,
+    allow_children: bool = ...,
+) -> VdomConstructor: ...
+
+
+@overload
+def reactjs_component_from_string(
+    content: str,
+    import_names: list[str] | tuple[str, ...],
+    name: str = "",
+    fallback: Any | None = ...,
+    resolve_imports: bool | None = ...,
+    resolve_imports_depth: int = ...,
+    unmount_before_update: bool = ...,
+    allow_children: bool = ...,
+) -> list[VdomConstructor]: ...
+
+
 def reactjs_component_from_string(
-    name: str,
     content: str,
     import_names: str | list[str] | tuple[str, ...],
+    name: str = "",
     fallback: Any | None = None,
     resolve_imports: bool | None = None,
     resolve_imports_depth: int = 5,
@@ -148,14 +228,14 @@ def reactjs_component_from_string(
     """Import a component from a string.
 
     Parameters:
-        name:
-            The name of the package
         content:
             The contents of the web module
         import_names:
             One or more component names to import. If given as a string, a single component
             will be returned. If a list is given, then a list of components will be
             returned.
+        name:
+            The human-readable name of the ReactJS package
         fallback:
             What to temporarily display while the module is being loaded.
         resolve_imports:
@@ -170,6 +250,7 @@ def reactjs_component_from_string(
         allow_children:
             Whether or not these components can have children.
     """
+    name = name or hashlib.sha256(content.encode()).hexdigest()[:10]
     key = f"{name}{resolve_imports}{resolve_imports_depth}{unmount_before_update}"
     if key in _STRING_WEB_MODULE_CACHE:
         module = _STRING_WEB_MODULE_CACHE[key]

reactpy/widgets.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 from base64 import b64encode
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Callable, Protocol, TypeVar
+from collections.abc import Callable, Sequence
+from typing import Any, Protocol, TypeVar
 
 import reactpy
 from reactpy._html import html
-from reactpy._warnings import warn
-from reactpy.types import ComponentConstructor, VdomAttributes, VdomDict
+from reactpy.types import VdomAttributes, VdomDict
 
 
 def image(
@@ -22,11 +21,7 @@ def image(
     if format == "svg":
         format = "svg+xml"  # noqa: A001
 
-    if isinstance(value, str):
-        bytes_value = value.encode()
-    else:
-        bytes_value = value
-
+    bytes_value = value.encode() if isinstance(value, str) else value
     base64_value = b64encode(bytes_value).decode()
     src = f"data:image/{format};base64,{base64_value}"
 
@@ -83,20 +78,3 @@ _CastTo_co = TypeVar("_CastTo_co", covariant=True)
 
 class _CastFunc(Protocol[_CastTo_co]):
     def __call__(self, value: str) -> _CastTo_co: ...
-
-
-if TYPE_CHECKING:
-    from reactpy.testing.backend import _MountFunc
-
-
-def hotswap(
-    update_on_change: bool = False,
-) -> tuple[_MountFunc, ComponentConstructor]:  # nocov
-    warn(
-        "The 'hotswap' function is deprecated and will be removed in a future release",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    from reactpy.testing.backend import _hotswap
-
-    return _hotswap(update_on_change)

{reactpy-2.0.0b3.dist-info → reactpy-2.0.0b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactpy
-Version: 2.0.0b3
+Version: 2.0.0b5
 Summary: It's React, but in Python.
 Project-URL: Changelog, https://reactpy.dev/docs/about/changelog.html
 Project-URL: Documentation, https://reactpy.dev/
@@ -8,28 +8,26 @@ Project-URL: Source, https://github.com/reactive-python/reactpy
 Author-email: Mark Bakhit <archiethemonger@gmail.com>, Ryan Morshead <ryan.morshead@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
-Keywords: component,javascript,react,reactpy
+Keywords: asgi,components,interactive,javascript,react,reactive,reactjs,reactpy,server,website,wsgi
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Requires-Dist: anyio>=3
 Requires-Dist: fastjsonschema>=2.14.5
 Requires-Dist: lxml>=4
 Requires-Dist: requests>=2
-Requires-Dist: typing-extensions>=3.10
 Provides-Extra: all
 Requires-Dist: asgi-tools; extra == 'all'
 Requires-Dist: asgiref; extra == 'all'
 Requires-Dist: jinja2-simple-tags; extra == 'all'
 Requires-Dist: jinja2>=3; extra == 'all'
 Requires-Dist: orjson; extra == 'all'
-Requires-Dist: pip; extra == 'all'
 Requires-Dist: playwright; extra == 'all'
 Requires-Dist: servestatic; extra == 'all'
 Requires-Dist: uvicorn[standard]; extra == 'all'
@@ -37,7 +35,6 @@ Provides-Extra: asgi
 Requires-Dist: asgi-tools; extra == 'asgi'
 Requires-Dist: asgiref; extra == 'asgi'
 Requires-Dist: orjson; extra == 'asgi'
-Requires-Dist: pip; extra == 'asgi'
 Requires-Dist: servestatic; extra == 'asgi'
 Provides-Extra: jinja
 Requires-Dist: jinja2-simple-tags; extra == 'jinja'