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

reactpy/testing/display.py

@@ -1,38 +1,47 @@
 from __future__ import annotations
 
+import os
 from contextlib import AsyncExitStack
+from logging import getLogger
 from types import TracebackType
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from playwright.async_api import (
-    Browser,
-    BrowserContext,
-    Page,
-    async_playwright,
-)
+from playwright.async_api import Browser, Page, async_playwright, expect
 
-from reactpy.config import REACTPY_TESTS_DEFAULT_TIMEOUT
+from reactpy.config import REACTPY_TESTS_DEFAULT_TIMEOUT as DEFAULT_TIMEOUT
 from reactpy.testing.backend import BackendFixture
 from reactpy.types import RootComponentConstructor
 
+if TYPE_CHECKING:
+    import pytest
+
+_logger = getLogger(__name__)
+
 
 class DisplayFixture:
     """A fixture for running web-based tests using ``playwright``"""
 
-    _exit_stack: AsyncExitStack
+    page: Page
+    browser_is_external: bool = False
+    backend_is_external: bool = False
 
     def __init__(
         self,
         backend: BackendFixture | None = None,
-        driver: Browser | BrowserContext | Page | None = None,
+        browser: Browser | None = None,
+        headless: bool = False,
+        timeout: float | None = None,
     ) -> None:
-        if backend is not None:
+        if backend:
+            self.backend_is_external = True
             self.backend = backend
-        if driver is not None:
-            if isinstance(driver, Page):
-                self.page = driver
-            else:
-                self._browser = driver
+
+        if browser:
+            self.browser_is_external = True
+            self.browser = browser
+
+        self.timeout = DEFAULT_TIMEOUT.current if timeout is None else timeout
+        self.headless = headless
 
     async def show(
         self,
@@ -42,28 +51,47 @@ class DisplayFixture:
         await self.goto("/")
 
     async def goto(self, path: str, query: Any | None = None) -> None:
+        await self.configure_page()
         await self.page.goto(self.backend.url(path, query))
 
     async def __aenter__(self) -> DisplayFixture:
-        es = self._exit_stack = AsyncExitStack()
+        self.exit_stack = AsyncExitStack()
 
-        browser: Browser | BrowserContext
-        if not hasattr(self, "page"):
-            if not hasattr(self, "_browser"):
-                pw = await es.enter_async_context(async_playwright())
-                browser = await pw.chromium.launch()
-            else:
-                browser = self._browser
-            self.page = await browser.new_page()
+        if not hasattr(self, "browser"):
+            pw = await self.exit_stack.enter_async_context(async_playwright())
+            self.browser = await self.exit_stack.enter_async_context(
+                await pw.chromium.launch(headless=not _playwright_visible())
+            )
 
-        self.page.set_default_timeout(REACTPY_TESTS_DEFAULT_TIMEOUT.current * 1000)
+        expect.set_options(timeout=self.timeout * 1000)
+        await self.configure_page()
 
         if not hasattr(self, "backend"):  # nocov
             self.backend = BackendFixture()
-            await es.enter_async_context(self.backend)
+            await self.exit_stack.enter_async_context(self.backend)
 
         return self
 
+    async def configure_page(self) -> None:
+        if getattr(self, "page", None) is None:
+            self.page = await self.browser.new_page()
+            self.page = await self.exit_stack.enter_async_context(self.page)
+            self.page.set_default_navigation_timeout(self.timeout * 1000)
+            self.page.set_default_timeout(self.timeout * 1000)
+            self.page.on(
+                "requestfailed",
+                lambda x: _logger.error(f"BROWSER LOAD ERROR: {x.url}\n{x.failure}"),
+            )
+            self.page.on(
+                "console", lambda x: _logger.info(f"BROWSER CONSOLE: {x.text}")
+            )
+            self.page.on(
+                "pageerror",
+                lambda x: _logger.error(
+                    f"BROWSER ERROR: {x.name} - {x.message}\n{x.stack}"
+                ),
+            )
+
     async def __aexit__(
         self,
         exc_type: type[BaseException] | None,
@@ -71,4 +99,13 @@ class DisplayFixture:
         traceback: TracebackType | None,
     ) -> None:
         self.backend.mount(None)
-        await self._exit_stack.aclose()
+        await self.exit_stack.aclose()
+
+
+def _playwright_visible(pytestconfig: pytest.Config | None = None) -> bool:
+    if (pytestconfig and pytestconfig.getoption("visible")) or os.environ.get(
+        "PLAYWRIGHT_VISIBLE"
+    ) == "1":
+        os.environ.setdefault("PLAYWRIGHT_VISIBLE", "1")
+        return True
+    return False

reactpy/testing/logs.py

@@ -175,4 +175,4 @@ def _raise_log_message_error(
         conditions.append(f"exception type {error_type}")
     if match_error:
         conditions.append(f"error message pattern {match_error!r}")
-    raise LogAssertionError(prefix + " " + " and ".join(conditions))
+    raise LogAssertionError(f"{prefix} " + " and ".join(conditions))

reactpy/transforms.py

@@ -113,8 +113,8 @@ class RequiredTransforms:
         if key is None and vdom["tagName"] in {"input", "select", "textarea"}:
             key = attributes.get("name")
 
-        if key:
-            vdom["key"] = key
+        if key and "key" not in attributes:
+            attributes["key"] = key
 
     def intercept_link_clicks(self, vdom: VdomDict) -> None:
         """Intercepts anchor link clicks and prevents the default behavior.

reactpy/types.py

@@ -10,6 +10,7 @@ from typing import (
     Generic,
     Literal,
     NamedTuple,
+    NewType,
     NotRequired,
     Protocol,
     TypeAlias,
@@ -533,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]
@@ -543,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(
@@ -797,7 +798,6 @@ VdomAttributes = VdomAttributesTypeDict | dict[str, Any]
 
 VdomDictKeys = Literal[
     "tagName",
-    "key",
     "children",
     "attributes",
     "eventHandlers",
@@ -806,7 +806,6 @@ VdomDictKeys = Literal[
 ]
 ALLOWED_VDOM_KEYS = {
     "tagName",
-    "key",
     "children",
     "attributes",
     "eventHandlers",
@@ -819,7 +818,6 @@ class VdomTypeDict(TypedDict):
     """TypedDict representation of what the `VdomDict` should look like."""
 
     tagName: str
-    key: NotRequired[Key | None]
     children: NotRequired[Sequence[Component | VdomChild]]
     attributes: NotRequired[VdomAttributes]
     eventHandlers: NotRequired[EventHandlerDict]
@@ -844,8 +842,6 @@ 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[Component | VdomChild]: ...
@@ -863,8 +859,6 @@ 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[Component | VdomChild]
     ) -> None: ...
@@ -1116,7 +1110,6 @@ class CustomVdomConstructor(Protocol):
         self,
         attributes: VdomAttributes,
         children: Sequence[VdomChildren],
-        key: Key | None,
         event_handlers: EventHandlerDict,
     ) -> VdomDict: ...
 
@@ -1140,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

@@ -242,7 +242,7 @@ def component_to_vdom(component: Component) -> VdomDict:
         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",
 ]