reactpy_django 3.8.1__tar.gz → 4.0.0__tar.gz

{reactpy_django-3.8.1/src/reactpy_django.egg-info → reactpy_django-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reactpy_django
-Version: 3.8.1
+Version: 4.0.0
 Summary: It's React, but in Python. Now with Django integration.
 Home-page: https://github.com/reactive-python/reactpy-django
 Author: Mark Bakhit
@@ -34,7 +34,7 @@ Requires-Dist: orjson>=3.6.0
 Requires-Dist: nest_asyncio>=1.5.0
 Requires-Dist: typing_extensions
 
-# <img src="https://raw.githubusercontent.com/reactive-python/reactpy/main/branding/svg/reactpy-logo-square.svg" align="left" height="45"/> ReactPy Django
+# <img src="https://raw.githubusercontent.com/reactive-python/reactpy/main/branding/svg/reactpy-logo-square.svg" align="left" height="45"/> ReactPy-Django
 
 <p>
     <a href="https://github.com/reactive-python/reactpy-django/actions?query=workflow%3ATest">
@@ -57,6 +57,7 @@ Requires-Dist: typing_extensions
 [ReactPy-Django](https://github.com/reactive-python/reactpy-django) is used to add [ReactPy](https://reactpy.dev/) support to an existing **Django project**. This package also turbocharges ReactPy with features such as...
 
 -   [SEO compatible rendering](https://reactive-python.github.io/reactpy-django/latest/reference/settings/#reactpy_prerender)
+-   [Client-Side Python components](https://reactive-python.github.io/reactpy-django/latest/reference/template-tag/#pyscript-component)
 -   [Single page application (SPA) capabilities](https://reactive-python.github.io/reactpy-django/latest/reference/router/#django-router)
 -   [Distributed computing](https://reactive-python.github.io/reactpy-django/latest/reference/settings/#reactpy_default_hosts)
 -   [Performance enhancements](https://reactive-python.github.io/reactpy-django/latest/reference/settings/#performance-settings)
@@ -118,7 +119,7 @@ def hello_world(recipient: str):
 
 <!--py-code-end-->
 
-## [`my_app/templates/my-template.html`](https://docs.djangoproject.com/en/dev/topics/templates/)
+## [`my_app/templates/my_template.html`](https://docs.djangoproject.com/en/dev/topics/templates/)
 
 <!--html-header-start-->
 

{reactpy_django-3.8.1 → reactpy_django-4.0.0}/README.md

@@ -1,4 +1,4 @@
-# <img src="https://raw.githubusercontent.com/reactive-python/reactpy/main/branding/svg/reactpy-logo-square.svg" align="left" height="45"/> ReactPy Django
+# <img src="https://raw.githubusercontent.com/reactive-python/reactpy/main/branding/svg/reactpy-logo-square.svg" align="left" height="45"/> ReactPy-Django
 
 <p>
     <a href="https://github.com/reactive-python/reactpy-django/actions?query=workflow%3ATest">
@@ -21,6 +21,7 @@
 [ReactPy-Django](https://github.com/reactive-python/reactpy-django) is used to add [ReactPy](https://reactpy.dev/) support to an existing **Django project**. This package also turbocharges ReactPy with features such as...
 
 -   [SEO compatible rendering](https://reactive-python.github.io/reactpy-django/latest/reference/settings/#reactpy_prerender)
+-   [Client-Side Python components](https://reactive-python.github.io/reactpy-django/latest/reference/template-tag/#pyscript-component)
 -   [Single page application (SPA) capabilities](https://reactive-python.github.io/reactpy-django/latest/reference/router/#django-router)
 -   [Distributed computing](https://reactive-python.github.io/reactpy-django/latest/reference/settings/#reactpy_default_hosts)
 -   [Performance enhancements](https://reactive-python.github.io/reactpy-django/latest/reference/settings/#performance-settings)
@@ -82,7 +83,7 @@ def hello_world(recipient: str):
 
 <!--py-code-end-->
 
-## [`my_app/templates/my-template.html`](https://docs.djangoproject.com/en/dev/topics/templates/)
+## [`my_app/templates/my_template.html`](https://docs.djangoproject.com/en/dev/topics/templates/)
 
 <!--html-header-start-->
 

{reactpy_django-3.8.1 → reactpy_django-4.0.0}/setup.py

@@ -1,5 +1,6 @@
 from __future__ import annotations, print_function
 
+import shutil
 import sys
 import traceback
 from distutils import log
@@ -16,7 +17,9 @@ from setuptools.command.sdist import sdist
 name = "reactpy_django"
 root_dir = Path(__file__).parent
 src_dir = root_dir / "src"
+js_dir = src_dir / "js"
 package_dir = src_dir / name
+static_dir = package_dir / "static" / name
 
 
 # -----------------------------------------------------------------------------
@@ -97,22 +100,37 @@ package["long_description_content_type"] = "text/markdown"
 def build_javascript_first(build_cls: type):
     class Command(build_cls):
         def run(self):
-            js_dir = str(src_dir / "js")
 
             log.info("Installing Javascript...")
-            result = npm.call(["install"], cwd=js_dir)
+            result = npm.call(["install"], cwd=str(js_dir))
             if result != 0:
                 log.error(traceback.format_exc())
                 log.error("Failed to install Javascript")
                 raise RuntimeError("Failed to install Javascript")
 
             log.info("Building Javascript...")
-            result = npm.call(["run", "build"], cwd=js_dir)
+            result = npm.call(["run", "build"], cwd=str(js_dir))
             if result != 0:
                 log.error(traceback.format_exc())
                 log.error("Failed to build Javascript")
                 raise RuntimeError("Failed to build Javascript")
 
+            log.info("Copying @pyscript/core distribution")
+            pyscript_dist = js_dir / "node_modules" / "@pyscript" / "core" / "dist"
+            pyscript_static_dir = static_dir / "pyscript"
+            if not pyscript_static_dir.exists():
+                pyscript_static_dir.mkdir()
+            for file in pyscript_dist.iterdir():
+                shutil.copy(file, pyscript_static_dir / file.name)
+
+            log.info("Copying Morphdom distribution")
+            morphdom_dist = js_dir / "node_modules" / "morphdom" / "dist"
+            morphdom_static_dir = static_dir / "morphdom"
+            if not morphdom_static_dir.exists():
+                morphdom_static_dir.mkdir()
+            for file in morphdom_dist.iterdir():
+                shutil.copy(file, morphdom_static_dir / file.name)
+
             log.info("Successfully built Javascript")
             super().run()
 

{reactpy_django-3.8.1 → reactpy_django-4.0.0}/src/reactpy_django/__init__.py

@@ -2,16 +2,26 @@ import contextlib
 
 import nest_asyncio
 
-from reactpy_django import checks, components, decorators, hooks, router, types, utils
+from reactpy_django import (
+    checks,
+    components,
+    decorators,
+    hooks,
+    html,
+    router,
+    types,
+    utils,
+)
 from reactpy_django.websocket.paths import (
     REACTPY_WEBSOCKET_PATH,
     REACTPY_WEBSOCKET_ROUTE,
 )
 
-__version__ = "3.8.1"
+__version__ = "4.0.0"
 __all__ = [
     "REACTPY_WEBSOCKET_PATH",
     "REACTPY_WEBSOCKET_ROUTE",
+    "html",
     "hooks",
     "components",
     "decorators",

{reactpy_django-3.8.1 → reactpy_django-4.0.0}/src/reactpy_django/components.py

@@ -4,6 +4,7 @@ import json
 import os
 from typing import Any, Callable, Sequence, Union, cast, overload
 from urllib.parse import urlencode
+from uuid import uuid4
 from warnings import warn
 
 from django.contrib.staticfiles.finders import find
@@ -12,10 +13,17 @@ from django.http import HttpRequest
 from django.urls import reverse
 from django.views import View
 from reactpy import component, hooks, html, utils
-from reactpy.types import Key, VdomDict
+from reactpy.types import ComponentType, Key, VdomDict
 
 from reactpy_django.exceptions import ViewNotRegisteredError
-from reactpy_django.utils import generate_obj_name, import_module, render_view
+from reactpy_django.html import pyscript
+from reactpy_django.utils import (
+    generate_obj_name,
+    import_module,
+    render_pyscript_template,
+    render_view,
+    vdom_or_component_to_string,
+)
 
 
 # Type hints for:
@@ -27,8 +35,7 @@ def view_to_component(
     compatibility: bool = False,
     transforms: Sequence[Callable[[VdomDict], Any]] = (),
     strict_parsing: bool = True,
-) -> Any:
-    ...
+) -> Any: ...
 
 
 # Type hints for:
@@ -39,8 +46,7 @@ def view_to_component(
     compatibility: bool = False,
     transforms: Sequence[Callable[[VdomDict], Any]] = (),
     strict_parsing: bool = True,
-) -> Callable[[Callable], Any]:
-    ...
+) -> Callable[[Callable], Any]: ...
 
 
 def view_to_component(
@@ -148,6 +154,29 @@ def django_js(static_path: str, key: Key | None = None):
     return _django_js(static_path=static_path, key=key)
 
 
+def pyscript_component(
+    *file_paths: str,
+    initial: str | VdomDict | ComponentType = "",
+    root: str = "root",
+):
+    """
+    Args:
+        file_paths: File path to your client-side component. If multiple paths are \
+            provided, the contents are automatically merged.
+
+    Kwargs:
+        initial: The initial HTML that is displayed prior to the PyScript component \
+            loads. This can either be a string containing raw HTML, a \
+            `#!python reactpy.html` snippet, or a non-interactive component.
+        root: The name of the root component function.
+    """
+    return _pyscript_component(
+        *file_paths,
+        initial=initial,
+        root=root,
+    )
+
+
 @component
 def _view_to_component(
     view: Callable | View | str,
@@ -284,3 +313,29 @@ def _cached_static_contents(static_path: str) -> str:
         )
 
     return file_contents
+
+
+@component
+def _pyscript_component(
+    *file_paths: str,
+    initial: str | VdomDict | ComponentType = "",
+    root: str = "root",
+):
+    rendered, set_rendered = hooks.use_state(False)
+    uuid = uuid4().hex.replace("-", "")
+    initial = vdom_or_component_to_string(initial, uuid=uuid)
+    executor = render_pyscript_template(file_paths, uuid, root)
+
+    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
+
+    return html._(
+        html.div(
+            {"id": f"pyscript-{uuid}", "className": "pyscript", "data-uuid": uuid},
+            initial,
+        ),
+        pyscript({"async": ""}, executor),
+    )

{reactpy_django-3.8.1 → reactpy_django-4.0.0}/src/reactpy_django/config.py

@@ -7,7 +7,7 @@ from django.conf import settings
 from django.core.cache import DEFAULT_CACHE_ALIAS
 from django.db import DEFAULT_DB_ALIAS
 from django.views import View
-from reactpy.config import REACTPY_DEBUG_MODE
+from reactpy.config import REACTPY_DEBUG_MODE as _REACTPY_DEBUG_MODE
 from reactpy.core.types import ComponentConstructor
 
 from reactpy_django.types import (
@@ -17,7 +17,8 @@ from reactpy_django.types import (
 from reactpy_django.utils import import_dotted_path
 
 # Non-configurable values
-REACTPY_DEBUG_MODE.set_current(getattr(settings, "DEBUG"))
+_REACTPY_DEBUG_MODE.set_current(getattr(settings, "DEBUG"))
+REACTPY_DEBUG_MODE = _REACTPY_DEBUG_MODE.current
 REACTPY_REGISTERED_COMPONENTS: dict[str, ComponentConstructor] = {}
 REACTPY_FAILED_COMPONENTS: set[str] = set()
 REACTPY_REGISTERED_IFRAME_VIEWS: dict[str, Callable | View] = {}

{reactpy_django-3.8.1 → reactpy_django-4.0.0}/src/reactpy_django/hooks.py

@@ -11,7 +11,6 @@ from typing import (
     Sequence,
     Union,
     cast,
-    overload,
 )
 from uuid import uuid4
 
@@ -29,16 +28,16 @@ from reactpy_django.exceptions import UserNotFoundError
 from reactpy_django.types import (
     AsyncMessageReceiver,
     AsyncMessageSender,
+    AsyncPostprocessor,
     ConnectionType,
     FuncParams,
     Inferred,
     Mutation,
-    MutationOptions,
     Query,
-    QueryOptions,
+    SyncPostprocessor,
     UserData,
 )
-from reactpy_django.utils import generate_obj_name, get_pk
+from reactpy_django.utils import django_query_postprocessor, generate_obj_name, get_pk
 
 if TYPE_CHECKING:
     from channels_redis.core import RedisChannelLayer
@@ -51,7 +50,6 @@ _REFETCH_CALLBACKS: DefaultDict[Callable[..., Any], set[Callable[[], None]]] = (
 )
 
 
-# TODO: Deprecate this once the equivalent hook gets moved to reactpy.hooks.*
 def use_location() -> Location:
     """Get the current route as a `Location` object"""
     return _use_location()
@@ -85,7 +83,6 @@ def use_origin() -> str | None:
     return None
 
 
-# TODO: Deprecate this once the equivalent hook gets moved to reactpy.hooks.*
 def use_scope() -> dict[str, Any]:
     """Get the current ASGI scope dictionary"""
     scope = _use_scope()
@@ -96,55 +93,55 @@ def use_scope() -> dict[str, Any]:
     raise TypeError(f"Expected scope to be a dict, got {type(scope)}")
 
 
-# TODO: Deprecate this once the equivalent hook gets moved to reactpy.hooks.*
 def use_connection() -> ConnectionType:
     """Get the current `Connection` object"""
     return _use_connection()
 
 
-@overload
 def use_query(
-    options: QueryOptions,
-    /,
     query: Callable[FuncParams, Awaitable[Inferred]] | Callable[FuncParams, Inferred],
-    *args: FuncParams.args,
-    **kwargs: FuncParams.kwargs,
-) -> Query[Inferred]: ...
-
-
-@overload
-def use_query(
-    query: Callable[FuncParams, Awaitable[Inferred]] | Callable[FuncParams, Inferred],
-    *args: FuncParams.args,
-    **kwargs: FuncParams.kwargs,
-) -> Query[Inferred]: ...
-
-
-def use_query(*args, **kwargs) -> Query[Inferred]:
+    kwargs: dict[str, Any] | None = None,
+    *,
+    thread_sensitive: bool = True,
+    postprocessor: (
+        AsyncPostprocessor | SyncPostprocessor | None
+    ) = django_query_postprocessor,
+    postprocessor_kwargs: dict[str, Any] | None = None,
+) -> Query[Inferred]:
     """This hook is used to execute functions in the background and return the result, \
         typically to read data the Django ORM.
 
     Args:
-        options: An optional `QueryOptions` object that can modify how the query is executed.
-        query: A callable that returns a Django `Model` or `QuerySet`.
-        *args: Positional arguments to pass into `query`.
+        query: A function that executes a query and returns some data.
 
-    Keyword Args:
-        **kwargs: Keyword arguments to pass into `query`."""
+    Kwargs:
+        kwargs: Keyword arguments to passed into the `query` function.
+        thread_sensitive: Whether to run the query in thread sensitive mode. \
+            This mode only applies to sync query functions, and is turned on by default \
+            due to Django ORM limitations.
+        postprocessor: A callable that processes the query `data` before it is returned. \
+            The first argument of postprocessor function must be the query `data`. All \
+            proceeding arguments are optional `postprocessor_kwargs`. This postprocessor \
+            function must return the modified `data`. \
+            \
+            If unset, `REACTPY_DEFAULT_QUERY_POSTPROCESSOR` is used. By default, this \
+            is used to prevent Django's lazy query execution and supports `many_to_many` \
+            and `many_to_one` as `postprocessor_kwargs`.
+        postprocessor_kwargs: Keyworded arguments passed into the `postprocessor` function.
+
+    Returns:
+         An object containing `loading`/`#!python error` states, your `data` (if the query \
+         has successfully executed), and a `refetch` callable that can be used to re-run the query.
+    """
 
     should_execute, set_should_execute = use_state(True)
     data, set_data = use_state(cast(Inferred, None))
     loading, set_loading = use_state(True)
     error, set_error = use_state(cast(Union[Exception, None], None))
-    if isinstance(args[0], QueryOptions):
-        query_options, query, query_args, query_kwargs = _use_query_args_1(
-            *args, **kwargs
-        )
-    else:
-        query_options, query, query_args, query_kwargs = _use_query_args_2(
-            *args, **kwargs
-        )
     query_ref = use_ref(query)
+    kwargs = kwargs or {}
+    postprocessor_kwargs = postprocessor_kwargs or {}
+
     if query_ref.current is not query:
         raise ValueError(f"Query function changed from {query_ref.current} to {query}.")
 
@@ -153,31 +150,27 @@ def use_query(*args, **kwargs) -> Query[Inferred]:
         try:
             # Run the query
             if asyncio.iscoroutinefunction(query):
-                new_data = await query(*query_args, **query_kwargs)
+                new_data = await query(**kwargs)
             else:
                 new_data = await database_sync_to_async(
-                    query,
-                    thread_sensitive=query_options.thread_sensitive,
-                )(*query_args, **query_kwargs)
+                    query, thread_sensitive=thread_sensitive
+                )(**kwargs)
 
             # Run the postprocessor
-            if query_options.postprocessor:
-                if asyncio.iscoroutinefunction(query_options.postprocessor):
-                    new_data = await query_options.postprocessor(
-                        new_data, **query_options.postprocessor_kwargs
-                    )
+            if postprocessor:
+                if asyncio.iscoroutinefunction(postprocessor):
+                    new_data = await postprocessor(new_data, **postprocessor_kwargs)
                 else:
                     new_data = await database_sync_to_async(
-                        query_options.postprocessor,
-                        thread_sensitive=query_options.thread_sensitive,
-                    )(new_data, **query_options.postprocessor_kwargs)
+                        postprocessor, thread_sensitive=thread_sensitive
+                    )(new_data, **postprocessor_kwargs)
 
         # Log any errors and set the error state
         except Exception as e:
             set_data(cast(Inferred, None))
             set_loading(False)
             set_error(e)
-            _logger.exception(f"Failed to execute query: {generate_obj_name(query)}")
+            _logger.exception("Failed to execute query: %s", generate_obj_name(query))
             return
 
         # Query was successful
@@ -212,30 +205,18 @@ def use_query(*args, **kwargs) -> Query[Inferred]:
         _REFETCH_CALLBACKS[query].add(refetch)
         return lambda: _REFETCH_CALLBACKS[query].remove(refetch)
 
-    # The query's user API
+    # Return Query user API
     return Query(data, loading, error, refetch)
 
 
-@overload
-def use_mutation(
-    options: MutationOptions,
-    mutation: (
-        Callable[FuncParams, bool | None] | Callable[FuncParams, Awaitable[bool | None]]
-    ),
-    refetch: Callable[..., Any] | Sequence[Callable[..., Any]] | None = None,
-) -> Mutation[FuncParams]: ...
-
-
-@overload
 def use_mutation(
     mutation: (
         Callable[FuncParams, bool | None] | Callable[FuncParams, Awaitable[bool | None]]
     ),
+    *,
+    thread_sensitive: bool = True,
     refetch: Callable[..., Any] | Sequence[Callable[..., Any]] | None = None,
-) -> Mutation[FuncParams]: ...
-
-
-def use_mutation(*args: Any, **kwargs: Any) -> Mutation[FuncParams]:
+) -> Mutation[FuncParams]:
     """This hook is used to modify data in the background, typically to create/update/delete \
     data from the Django ORM.
         
@@ -246,18 +227,24 @@ def use_mutation(*args: Any, **kwargs: Any) -> Mutation[FuncParams]:
         mutation: A callable that performs Django ORM create, update, or delete \
             functionality. If this function returns `False`, then your `refetch` \
             function will not be used.
+
+    Kwargs:
+        thread_sensitive: Whether to run the mutation in thread sensitive mode. \
+            This mode only applies to sync mutation functions, and is turned on by default \
+            due to Django ORM limitations.
         refetch:  A query function (the function you provide to your `use_query` \
             hook) or a sequence of query functions that need a `refetch` if the \
             mutation succeeds. This is useful for refreshing data after a mutation \
             has been performed.
+
+    Returns:
+        An object containing `#!python loading`/`#!python error` states, and a \
+        `#!python reset` callable that will set `#!python loading`/`#!python error` \
+        states to defaults. This object can be called to run the query.
     """
 
     loading, set_loading = use_state(False)
     error, set_error = use_state(cast(Union[Exception, None], None))
-    if isinstance(args[0], MutationOptions):
-        mutation_options, mutation, refetch = _use_mutation_args_1(*args, **kwargs)
-    else:
-        mutation_options, mutation, refetch = _use_mutation_args_2(*args, **kwargs)
 
     # The main "running" function for `use_mutation`
     async def execute_mutation(exec_args, exec_kwargs) -> None:
@@ -267,7 +254,7 @@ def use_mutation(*args: Any, **kwargs: Any) -> Mutation[FuncParams]:
                 should_refetch = await mutation(*exec_args, **exec_kwargs)
             else:
                 should_refetch = await database_sync_to_async(
-                    mutation, thread_sensitive=mutation_options.thread_sensitive
+                    mutation, thread_sensitive=thread_sensitive
                 )(*exec_args, **exec_kwargs)
 
         # Log any errors and set the error state
@@ -275,7 +262,7 @@ def use_mutation(*args: Any, **kwargs: Any) -> Mutation[FuncParams]:
             set_loading(False)
             set_error(e)
             _logger.exception(
-                f"Failed to execute mutation: {generate_obj_name(mutation)}"
+                "Failed to execute mutation: %s", generate_obj_name(mutation)
             )
 
         # Mutation was successful
@@ -311,7 +298,7 @@ def use_mutation(*args: Any, **kwargs: Any) -> Mutation[FuncParams]:
         set_loading(False)
         set_error(None)
 
-    # The mutation's user API
+    # Return mutation user API
     return Mutation(schedule_mutation, loading, error, reset)
 
 
@@ -355,11 +342,13 @@ def use_user_data(
         await model.asave()
 
     query: Query[dict | None] = use_query(
-        QueryOptions(postprocessor=None),
         _get_user_data,
-        user=user,
-        default_data=default_data,
-        save_default_data=save_default_data,
+        kwargs={
+            "user": user,
+            "default_data": default_data,
+            "save_default_data": save_default_data,
+        },
+        postprocessor=None,
     )
     mutation = use_mutation(_set_user_data, refetch=_get_user_data)
 
@@ -444,22 +433,6 @@ def use_root_id() -> str:
     return scope["reactpy"]["id"]
 
 
-def _use_query_args_1(options: QueryOptions, /, query: Query, *args, **kwargs):
-    return options, query, args, kwargs
-
-
-def _use_query_args_2(query: Query, *args, **kwargs):
-    return QueryOptions(), query, args, kwargs
-
-
-def _use_mutation_args_1(options: MutationOptions, mutation: Mutation, refetch=None):
-    return options, mutation, refetch
-
-
-def _use_mutation_args_2(mutation, refetch=None):
-    return MutationOptions(), mutation, refetch
-
-
 async def _get_user_data(
     user: AbstractUser, default_data: None | dict, save_default_data: bool
 ) -> dict | None:

reactpy_django-4.0.0/src/reactpy_django/html.py

@@ -0,0 +1,3 @@
+from reactpy.core.vdom import make_vdom_constructor
+
+pyscript = make_vdom_constructor("py-script")

{reactpy_django-3.8.1 → reactpy_django-4.0.0}/src/reactpy_django/management/commands/clean_reactpy.py

@@ -28,10 +28,10 @@ class Command(BaseCommand):
         parser.add_argument(
             "--sessions",
             action="store_true",
-            help="Configure this clean to only clean session data (and other configured cleaning options).",
+            help="Clean session data. This value can be combined with other cleaning options.",
         )
         parser.add_argument(
             "--user-data",
             action="store_true",
-            help="Configure this clean to only clean user data (and other configured cleaning options).",
+            help="Clean user data. This value can be combined with other cleaning options.",
         )

reactpy_django-4.0.0/src/reactpy_django/pyscript/component_template.py

@@ -0,0 +1,26 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import asyncio
+
+    from reactpy_django.pyscript.layout_handler import ReactPyLayoutHandler
+
+
+# User component is inserted below by regex replacement
+def user_workspace_UUID():
+    """Encapsulate the user's code with a completely unique function (workspace)
+    to prevent overlapping imports and variable names between different components.
+
+    This code is designed to be run directly by PyScript, and is not intended to be run
+    in a normal Python environment.
+
+    ReactPy-Django performs string substitutions to turn this file into valid PyScript.
+    """
+
+    def root(): ...
+
+    return root()
+
+
+# Create a task to run the user's component workspace
+task_UUID = asyncio.create_task(ReactPyLayoutHandler("UUID").run(user_workspace_UUID))