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

reactpy/__init__.py

@@ -2,7 +2,7 @@ from reactpy import config, logging, types, web, widgets
 from reactpy._html import html
 from reactpy.core import hooks
 from reactpy.core.component import component
-from reactpy.core.events import Event, event
+from reactpy.core.events import event
 from reactpy.core.hooks import (
     create_context,
     use_async_effect,
@@ -18,17 +18,14 @@ from reactpy.core.hooks import (
     use_scope,
     use_state,
 )
-from reactpy.core.layout import Layout
 from reactpy.core.vdom import Vdom
 from reactpy.pyscript.components import pyscript_component
 from reactpy.utils import Ref, reactpy_to_string, string_to_reactpy
 
 __author__ = "The Reactive Python Team"
-__version__ = "2.0.0b3"
+__version__ = "2.0.0b5"
 
 __all__ = [
-    "Event",
-    "Layout",
     "Ref",
     "Vdom",
     "component",

reactpy/_console/rewrite_props.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import ast
+from collections.abc import Callable
 from copy import copy
 from keyword import kwlist
 from pathlib import Path
-from typing import Callable
 
 import click
 
@@ -102,7 +102,7 @@ def _rewrite_props(
         keys: list[ast.expr | None] = []
         values: list[ast.expr] = []
         # Iterate over the keys and values in the dictionary
-        for k, v in zip(props_node.keys, props_node.values):
+        for k, v in zip(props_node.keys, props_node.values, strict=False):
             if isinstance(k, ast.Constant) and isinstance(k.value, str):
                 # Construct the new key and value
                 k_value, new_v = constructor(k.value, v)

reactpy/_option.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import os
+from collections.abc import Callable
 from logging import getLogger
-from typing import Any, Callable, Generic, TypeVar, cast
+from typing import Any, Generic, TypeVar, cast
 
 from reactpy._warnings import warn
 

reactpy/config.py

@@ -85,11 +85,11 @@ REACTPY_TESTS_DEFAULT_TIMEOUT = Option(
 
 REACTPY_ASYNC_RENDERING = Option(
     "REACTPY_ASYNC_RENDERING",
-    default=False,
+    default=True,
     mutable=True,
     validator=boolean,
 )
-"""Whether to render components asynchronously. This is currently an experimental feature."""
+"""Whether to render components asynchronously."""
 
 REACTPY_RECONNECT_INTERVAL = Option(
     "REACTPY_RECONNECT_INTERVAL",

reactpy/core/_life_cycle_hook.py

@@ -3,13 +3,14 @@ from __future__ import annotations
 import logging
 import sys
 from asyncio import Event, Task, create_task, gather
+from collections.abc import Callable
 from contextvars import ContextVar, Token
-from typing import Any, Callable, Protocol, TypeVar
+from typing import Any, Protocol, TypeVar
 
 from anyio import Semaphore
 
 from reactpy.core._thread_local import ThreadLocal
-from reactpy.types import ComponentType, Context, ContextProviderType
+from reactpy.types import Component, Context, ContextProvider
 from reactpy.utils import Singleton
 
 T = TypeVar("T")
@@ -145,13 +146,13 @@ class LifeCycleHook:
         "component",
     )
 
-    component: ComponentType
+    component: Component
 
     def __init__(
         self,
         schedule_render: Callable[[], None],
     ) -> None:
-        self._context_providers: dict[Context[Any], ContextProviderType[Any]] = {}
+        self._context_providers: dict[Context[Any], ContextProvider[Any]] = {}
         self._schedule_render_callback = schedule_render
         self._scheduled_render = False
         self._rendered_atleast_once = False
@@ -200,7 +201,7 @@ class LifeCycleHook:
         """
         self._effect_funcs.append(effect_func)
 
-    def set_context_provider(self, provider: ContextProviderType[Any]) -> None:
+    def set_context_provider(self, provider: ContextProvider[Any]) -> None:
         """Set a context provider for this hook
 
         The context provider will be used to provide state to any child components
@@ -208,9 +209,7 @@ class LifeCycleHook:
         """
         self._context_providers[provider.type] = provider
 
-    def get_context_provider(
-        self, context: Context[T]
-    ) -> ContextProviderType[T] | None:
+    def get_context_provider(self, context: Context[T]) -> ContextProvider[T] | None:
         """Get a context provider for this hook of the given type
 
         The context provider will have been set by a parent component. If no provider
@@ -218,7 +217,7 @@ class LifeCycleHook:
         """
         return self._context_providers.get(context)
 
-    async def affect_component_will_render(self, component: ComponentType) -> None:
+    async def affect_component_will_render(self, component: Component) -> None:
         """The component is about to render"""
         await self._render_access.acquire()
         self._scheduled_render = False

reactpy/core/_thread_local.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable
 from threading import Thread, current_thread
-from typing import Callable, Generic, TypeVar
+from typing import Generic, TypeVar
 from weakref import WeakKeyDictionary
 
 _StateType = TypeVar("_StateType")

reactpy/core/component.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 import inspect
+from collections.abc import Callable
 from functools import wraps
-from typing import Any, Callable
+from typing import Any
 
-from reactpy.types import ComponentType, VdomDict
+from reactpy.types import Component, VdomDict
 
 
 def component(
-    function: Callable[..., ComponentType | VdomDict | str | None],
+    function: Callable[..., Component | VdomDict | str | None],
 ) -> Callable[..., Component]:
     """A decorator for defining a new component.
 
@@ -29,38 +30,3 @@ def component(
         return Component(function, key, args, kwargs, sig)
 
     return constructor
-
-
-class Component:
-    """An object for rending component models."""
-
-    __slots__ = "__weakref__", "_args", "_func", "_kwargs", "_sig", "key", "type"
-
-    def __init__(
-        self,
-        function: Callable[..., ComponentType | 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) -> ComponentType | VdomDict | str | None:
-        return self.type(*self._args, **self._kwargs)
-
-    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})"

reactpy/core/events.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
-import asyncio
 import dis
-from collections.abc import Sequence
-from typing import Any, Callable, Literal, cast, overload
+import inspect
+from collections.abc import Callable, Sequence
+from functools import lru_cache
+from types import CodeType
+from typing import Any, Literal, cast, overload
 
 from anyio import create_task_group
 
-from reactpy.types import EventHandlerFunc, EventHandlerType
+from reactpy.types import BaseEventHandler, EventHandlerFunc
 
 
 @overload
@@ -73,19 +75,7 @@ def event(
     return setup(function) if function is not None else setup
 
 
-class Event(dict):
-    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."""
-
-
-class EventHandler:
+class EventHandler(BaseEventHandler):
     """Turn a function or coroutine into an event handler
 
     Parameters:
@@ -99,14 +89,6 @@ class EventHandler:
             A unique identifier for this event handler (auto-generated by default)
     """
 
-    __slots__ = (
-        "__weakref__",
-        "function",
-        "prevent_default",
-        "stop_propagation",
-        "target",
-    )
-
     def __init__(
         self,
         function: EventHandlerFunc,
@@ -125,26 +107,14 @@ class EventHandler:
         while hasattr(func_to_inspect, "__wrapped__"):
             func_to_inspect = func_to_inspect.__wrapped__
 
-        code = func_to_inspect.__code__
-        if code.co_argcount > 0:
-            event_arg_name = code.co_varnames[0]
-            last_was_event = False
-
-            for instr in dis.get_instructions(func_to_inspect):
-                if instr.opname == "LOAD_FAST" and instr.argval == event_arg_name:
-                    last_was_event = True
-                    continue
-
-                if last_was_event and instr.opname in (
-                    "LOAD_METHOD",
-                    "LOAD_ATTR",
-                ):
-                    if instr.argval == "preventDefault":
-                        self.prevent_default = True
-                    elif instr.argval == "stopPropagation":
-                        self.stop_propagation = True
+        found_prevent_default, found_stop_propagation = _inspect_event_handler_code(
+            func_to_inspect.__code__
+        )
 
-                last_was_event = False
+        if found_prevent_default:
+            self.prevent_default = True
+        if found_stop_propagation:
+            self.stop_propagation = True
 
     __hash__ = None  # type: ignore
 
@@ -180,7 +150,7 @@ def to_event_handler_function(
             Whether to pass the event parameters a positional args or as a list.
     """
     if positional_args:
-        if asyncio.iscoroutinefunction(function):
+        if inspect.iscoroutinefunction(function):
 
             async def wrapper(data: Sequence[Any]) -> None:
                 await function(*data)
@@ -194,7 +164,7 @@ def to_event_handler_function(
 
         cast(Any, wrapper).__wrapped__ = function
         return wrapper
-    elif not asyncio.iscoroutinefunction(function):
+    elif not inspect.iscoroutinefunction(function):
 
         async def wrapper(data: Sequence[Any]) -> None:
             function(data)
@@ -206,8 +176,8 @@ def to_event_handler_function(
 
 
 def merge_event_handlers(
-    event_handlers: Sequence[EventHandlerType],
-) -> EventHandlerType:
+    event_handlers: Sequence[BaseEventHandler],
+) -> BaseEventHandler:
     """Merge multiple event handlers into one
 
     Raises a ValueError if any handlers have conflicting
@@ -259,3 +229,46 @@ def merge_event_handler_funcs(
                 group.start_soon(func, data)
 
     return await_all_event_handlers
+
+
+@lru_cache(maxsize=4096)
+def _inspect_event_handler_code(code: CodeType) -> tuple[bool, bool]:
+    prevent_default = False
+    stop_propagation = False
+
+    if code.co_argcount > 0:
+        names = code.co_names
+        check_prevent_default = "preventDefault" in names
+        check_stop_propagation = "stopPropagation" in names
+
+        if not (check_prevent_default or check_stop_propagation):
+            return False, False
+
+        event_arg_name = code.co_varnames[0]
+        last_was_event = False
+
+        for instr in dis.get_instructions(code):
+            if (
+                instr.opname in ("LOAD_FAST", "LOAD_FAST_BORROW")
+                and instr.argval == event_arg_name
+            ):
+                last_was_event = True
+                continue
+
+            if last_was_event and instr.opname in (
+                "LOAD_METHOD",
+                "LOAD_ATTR",
+            ):
+                if check_prevent_default and instr.argval == "preventDefault":
+                    prevent_default = True
+                    check_prevent_default = False
+                elif check_stop_propagation and instr.argval == "stopPropagation":
+                    stop_propagation = True
+                    check_stop_propagation = False
+
+                if not (check_prevent_default or check_stop_propagation):
+                    break
+
+            last_was_event = False
+
+    return prevent_default, stop_propagation

reactpy/core/hooks.py

@@ -2,31 +2,30 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
-from collections.abc import Coroutine, Sequence
+import inspect
+from collections.abc import Callable, Coroutine, Sequence
 from logging import getLogger
 from types import FunctionType
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Generic,
     Protocol,
+    TypeAlias,
     TypeVar,
     cast,
     overload,
 )
 
-from typing_extensions import TypeAlias
-
 from reactpy.config import REACTPY_DEBUG
 from reactpy.core._life_cycle_hook import HOOK_STACK
 from reactpy.types import (
     Connection,
     Context,
+    ContextProvider,
     Key,
     Location,
     State,
-    VdomDict,
 )
 from reactpy.utils import Ref
 
@@ -146,12 +145,19 @@ def use_effect(
     Returns:
         If not function is provided, a decorator. Otherwise ``None``.
     """
+
     hook = HOOK_STACK.current_hook()
     dependencies = _try_to_infer_closure_values(function, dependencies)
     memoize = use_memo(dependencies=dependencies)
     cleanup_func: Ref[_EffectCleanFunc | None] = use_ref(None)
 
     def decorator(func: _SyncEffectFunc) -> None:
+        if inspect.iscoroutinefunction(func):
+            raise TypeError(
+                "`use_effect` does not support async functions. "
+                "Use `use_async_effect` instead."
+            )
+
         async def effect(stop: asyncio.Event) -> None:
             # Since the effect is asynchronous, we need to make sure we
             # always clean up the previous effect's resources
@@ -297,8 +303,8 @@ def create_context(default_value: _Type) -> Context[_Type]:
         *children: Any,
         value: _Type = default_value,
         key: Key | None = None,
-    ) -> _ContextProvider[_Type]:
-        return _ContextProvider(
+    ) -> ContextProvider[_Type]:
+        return ContextProvider(
             *children,
             value=value,
             key=key,
@@ -354,27 +360,6 @@ def use_location() -> Location:
     return use_connection().location
 
 
-class _ContextProvider(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:
-        HOOK_STACK.current_hook().set_context_provider(self)
-        return VdomDict(tagName="", children=self.children)
-
-    def __repr__(self) -> str:
-        return f"ContextProvider({self.type})"
-
-
 _ActionType = TypeVar("_ActionType")
 
 
@@ -509,7 +494,7 @@ def use_memo(
         # if deps are same length check identity for each item
         or not all(
             strictly_equal(current, new)
-            for current, new in zip(memo.deps, dependencies)
+            for current, new in zip(memo.deps, dependencies, strict=False)
         )
     ):
         memo.deps = dependencies
@@ -611,7 +596,18 @@ def strictly_equal(x: Any, y: Any) -> bool:
             getattr(x.__code__, attr) == getattr(y.__code__, attr)
             for attr in dir(x.__code__)
             if attr.startswith("co_")
-            and attr not in {"co_positions", "co_linetable", "co_lines", "co_lnotab"}
+            and attr
+            not in {
+                "co_positions",
+                "co_linetable",
+                "co_lines",
+                "co_lnotab",
+                "co_branches",
+                "co_firstlineno",
+                "co_end_lineno",
+                "co_col_offset",
+                "co_end_col_offset",
+            }
         )
 
     # Check via the `==` operator if possible