- :pull:`1113` - Renamed ``reactpy.config.REACTPY_DEBUG_MODE`` to ``reactpy.config.REACTPY_DEBUG``.

- :pull:`1113` - ``@reactpy/client`` now exports ``React`` and ``ReactDOM``.

- :pull:`1263` - ReactPy no longer auto-converts ``snake_case`` props to ``camelCase``. It is now the responsibility of the user to ensure that props are in the correct format.

**Removed**

- :pull:`1113` - Removed ``reactpy.run``. See the documentation for the new method to run ReactPy applications.

- :pull:`1113` - Removed ``reactpy.backend.*``. See the documentation for the new method to run ReactPy applications.

- :pull:`1113` - Removed ``reactpy.core.types`` module. Use ``reactpy.types`` instead.

- :pull:`1113` - All backend related installation extras (such as ``pip install reactpy[starlette]``) have been removed.

- :pull:`1113` - Removed deprecated function ``module_from_template``.

- :pull:`1113` - Removed support for Python 3.9.

from reactpy.core.layout import Layout

from reactpy.core.vdom import vdom

from reactpy.pyscript.components import pyscript_component

__author__ = "The Reactive Python Team"

__version__ = "2.0.0a1"

"event",

"hooks",

"html",

"logging",

"pyscript_component",

"types",

"use_async_effect",

"use_callback",

"use_scope",

"use_state",

"vdom",

"web",

"widgets",

]

logger = logging.getLogger(__name__)

"""A singleton object which manages the current component tree's hooks.

_StateType = TypeVar("_StateType")

"""Utility for managing per-thread state information. This is only used in

return x == y # type: ignore

# Fallback to identity check

def run_effect_cleanup(cleanup_func: Ref[_EffectCleanFunc | None]) -> None:

msg: dict[str, str] = orjson.loads(event["text"])

if msg.get("type") == "layout-event":

await ws.rendering_queue.put(msg)

await asyncio.to_thread(

_logger.warning, f"Unknown message type: {msg.get('type')}"

)

# Determine component to serve by analyzing the URL and/or class parameters.

if self.parent.multiple_root_components:

url_match = re.match(self.parent.dispatcher_pattern, self.scope["path"])

raise RuntimeError("Could not find component in URL path.")

dotted_path = url_match["dotted_path"]

if dotted_path not in self.parent.root_components:

component = self.parent.root_components[dotted_path]

elif self.parent.root_component:

component = self.parent.root_component

raise RuntimeError("No root component provided.")

# Create a connection object by analyzing the websocket's query string.

self.html_head = html_head or html.head()

self.html_lang = html_lang

"""We do not use a WebSocket dispatcher for Client-Side Rendering (CSR)."""

return False

RootComponentConstructor,

VdomDict,

)

_logger = getLogger(__name__)

extra_py = pyscript_options.get("extra_py", [])

extra_js = pyscript_options.get("extra_js", {})

config = pyscript_options.get("config", {})

pyscript_setup_html(extra_py, extra_js, config)

)

pyscript_head_vdom["tagName"] = ""

async def __call__(

self, scope: AsgiScope, receive: AsgiReceive, send: AsgiSend

) -> None:

if scope["type"] != "lifespan":

msg = (

"ReactPy app received unsupported request of type '%s' at path '%s'",

REACTPY_RECONNECT_MAX_RETRIES,

)

from reactpy.types import ReactPyConfig, VdomDict

logger = logging.getLogger(__name__)

}

"""Check that a path is valid URL path."""

if not url_path:

return "URL path must not be empty."

def vdom_head_to_html(head: VdomDict) -> str:

if isinstance(head, dict) and head.get("tagName") == "head":

raise ValueError(

"Invalid head element! Element must be either `html.head` or a string."

from reactpy import component, hooks

from reactpy.pyscript.utils import pyscript_component_html

from reactpy.types import ComponentType, Key

if TYPE_CHECKING:

from reactpy.types import VdomDict

raise ValueError("At least one file path must be provided.")

rendered, set_rendered = hooks.use_state(False)

if not rendered:

# FIXME: This is needed to properly re-render PyScript during a WebSocket

# disconnection / reconnection. There may be a better way to do this in the future.

set_rendered(True)

return None

pyscript_component_html(tuple(str(fp) for fp in file_paths), initial, root)

)

component_vdom["tagName"] = ""

import reactpy

from reactpy.config import REACTPY_DEBUG, REACTPY_PATH_PREFIX, REACTPY_WEB_MODULES_DIR

from reactpy.types import VdomDict

if TYPE_CHECKING:

from collections.abc import Sequence

file_paths: Sequence[str], initial: str | VdomDict, root: str

) -> str:

"""Renders a PyScript component with the user's code."""

uuid = uuid4().hex

executor_code = pyscript_executor_html(file_paths=file_paths, uuid=uuid, root=root)

return orjson.dumps(pyscript_config).decode("utf-8")

from reactpy.testing.common import GITHUB_ACTIONS

local_version = reactpy.__version__

return pyscript_setup(*args, **kwargs)

# This should never happen, but we validate it for safety.

def component(dotted_path: str, **kwargs: str) -> str:

from reactpy.config import REACTPY_TESTS_DEFAULT_TIMEOUT, REACTPY_WEB_MODULES_DIR

from reactpy.core._life_cycle_hook import HOOK_STACK, LifeCycleHook

from reactpy.core.events import EventHandler, to_event_handler_function

def clear_reactpy_web_modules_dir() -> None:

_DEFAULT_POLL_DELAY = 0.1

class poll(Generic[_R]): # noqa: N801

self.page.set_default_timeout(REACTPY_TESTS_DEFAULT_TIMEOUT.current * 1000)

self.backend = BackendFixture()

await es.enter_async_context(self.backend)

def find_available_port(

host: str, port_min: int = 8000, port_max: int = 9000

"""Get a port that's available for the given host and port range"""

for port in range(port_min, port_max):

with closing(socket.socket()) as sock: