reactpy_django 5.0.0__py3-none-any.whl

reactpy_django/migrations/0004_config.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.2.3 on 2023-08-04 05:49
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("reactpy_django", "0003_componentsession_delete_componentparams"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Config",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("cleaned_at", models.DateTimeField(auto_now_add=True)),
+            ],
+        ),
+    ]

reactpy_django/migrations/0005_alter_componentsession_last_accessed.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.3 on 2023-08-23 19:56
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("reactpy_django", "0004_config"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="componentsession",
+            name="last_accessed",
+            field=models.DateTimeField(auto_now=True),
+        ),
+    ]

reactpy_django/migrations/0006_userdatamodel.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.5 on 2023-10-09 01:02
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("reactpy_django", "0005_alter_componentsession_last_accessed"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="UserDataModel",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("user_pk", models.CharField(max_length=255, unique=True)),
+                ("data", models.BinaryField(blank=True, null=True)),
+            ],
+        ),
+    ]

reactpy_django/models.py

@@ -0,0 +1,48 @@
+from django.contrib.auth import get_user_model
+from django.db import models
+from django.db.models.signals import pre_delete
+from django.dispatch import receiver
+
+from reactpy_django.utils import get_pk
+
+
+class ComponentSession(models.Model):
+    """A model for storing component sessions."""
+
+    uuid = models.UUIDField(primary_key=True, editable=False, unique=True)  # type: ignore
+    params = models.BinaryField(editable=False)  # type: ignore
+    last_accessed = models.DateTimeField(auto_now=True)  # type: ignore
+
+
+class Config(models.Model):
+    """A singleton model for storing ReactPy configuration."""
+
+    cleaned_at = models.DateTimeField(auto_now_add=True)  # type: ignore
+
+    def save(self, *args, **kwargs):
+        """Singleton save method."""
+        self.pk = 1
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def load(cls):
+        obj, _ = cls.objects.get_or_create(pk=1)
+        return obj
+
+
+class UserDataModel(models.Model):
+    """A model for storing `user_state` data."""
+
+    # We can't store User as a ForeignKey/OneToOneField because it may not be in the same database
+    # and Django does not allow cross-database relations. Also, since we can't know the type of the UserModel PK,
+    # we store it as a string to normalize.
+    user_pk = models.CharField(max_length=255, unique=True)  # type: ignore
+    data = models.BinaryField(null=True, blank=True)  # type: ignore
+
+
+@receiver(pre_delete, sender=get_user_model(), dispatch_uid="reactpy_delete_user_data")
+def delete_user_data(sender, instance, **kwargs):
+    """Delete ReactPy's `UserDataModel` when a Django `User` is deleted."""
+    pk = get_pk(instance)
+
+    UserDataModel.objects.filter(user_pk=pk).delete()

reactpy_django/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

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))

reactpy_django/pyscript/layout_handler.py

@@ -0,0 +1,139 @@
+# mypy: disable-error-code=attr-defined
+import asyncio
+
+
+class ReactPyLayoutHandler:
+    """Encapsulate the entire layout handler with a class to prevent overlapping
+    variable names between user code.
+
+    This code is designed to be run directly by PyScript, and is not intended to be run
+    in a normal Python environment.
+    """
+
+    def __init__(self, uuid):
+        self.uuid = uuid
+
+    @staticmethod
+    def update_model(update, root_model):
+        """Apply an update ReactPy's internal DOM model."""
+        from jsonpointer import set_pointer
+
+        if update["path"]:
+            set_pointer(root_model, update["path"], update["model"])
+        else:
+            root_model.update(update["model"])
+
+    def render_html(self, layout, model):
+        """Submit ReactPy's internal DOM model into the HTML DOM."""
+        from pyscript.js_modules import morphdom
+
+        import js
+
+        # Create a new container to render the layout into
+        container = js.document.getElementById(f"pyscript-{self.uuid}")
+        temp_root_container = container.cloneNode(False)
+        self.build_element_tree(layout, temp_root_container, model)
+
+        # Use morphdom to update the DOM
+        morphdom.default(container, temp_root_container)
+
+        # Remove the cloned container to prevent memory leaks
+        temp_root_container.remove()
+
+    def build_element_tree(self, layout, parent, model):
+        """Recursively build an element tree, starting from the root component."""
+        import js
+
+        if isinstance(model, str):
+            parent.appendChild(js.document.createTextNode(model))
+        elif isinstance(model, dict):
+            if not model["tagName"]:
+                for child in model.get("children", []):
+                    self.build_element_tree(layout, parent, child)
+                return
+            tag = model["tagName"]
+            attributes = model.get("attributes", {})
+            children = model.get("children", [])
+            element = js.document.createElement(tag)
+            for key, value in attributes.items():
+                if key == "style":
+                    for style_key, style_value in value.items():
+                        setattr(element.style, style_key, style_value)
+                elif key == "className":
+                    element.className = value
+                else:
+                    element.setAttribute(key, value)
+            for event_name, event_handler_model in model.get(
+                "eventHandlers", {}
+            ).items():
+                self.create_event_handler(
+                    layout, element, event_name, event_handler_model
+                )
+            for child in children:
+                self.build_element_tree(layout, element, child)
+            parent.appendChild(element)
+        else:
+            raise ValueError(f"Unknown model type: {type(model)}")
+
+    @staticmethod
+    def create_event_handler(layout, element, event_name, event_handler_model):
+        """Create an event handler for an element. This function is used as an
+        adapter between ReactPy and browser events."""
+        from pyodide.ffi.wrappers import add_event_listener
+
+        target = event_handler_model["target"]
+
+        def event_handler(*args):
+            asyncio.create_task(
+                layout.deliver({"type": "layout-event", "target": target, "data": args})
+            )
+
+        event_name = event_name.lstrip("on_").lower().replace("_", "")
+        add_event_listener(element, event_name, event_handler)
+
+    @staticmethod
+    def delete_old_workspaces():
+        """To prevent memory leaks, we must delete all user generated Python code when
+        it is no longer in use (removed from the page). To do this, we compare what
+        UUIDs exist on the DOM, versus what UUIDs exist within the PyScript global
+        interpreter."""
+        import js
+
+        dom_workspaces = js.document.querySelectorAll(".pyscript")
+        dom_uuids = {element.dataset.uuid for element in dom_workspaces}
+        python_uuids = {
+            value.split("_")[-1]
+            for value in globals()
+            if value.startswith("user_workspace_")
+        }
+
+        # Delete the workspace if it exists at the moment when we check
+        for uuid in python_uuids - dom_uuids:
+            task_name = f"task_{uuid}"
+            if task_name in globals():
+                task: asyncio.Task = globals()[task_name]
+                task.cancel()
+                del globals()[task_name]
+            else:
+                print(f"Warning: Could not auto delete PyScript task {task_name}")
+
+            workspace_name = f"user_workspace_{uuid}"
+            if workspace_name in globals():
+                del globals()[workspace_name]
+            else:
+                print(
+                    f"Warning: Could not auto delete PyScript workspace {workspace_name}"
+                )
+
+    async def run(self, workspace_function):
+        """Run the layout handler. This function is main executor for all user generated code."""
+        from reactpy.core.layout import Layout
+
+        self.delete_old_workspaces()
+        root_model: dict = {}
+
+        async with Layout(workspace_function()) as root_layout:
+            while True:
+                update = await root_layout.render()
+                self.update_model(update, root_model)
+                self.render_html(root_layout, root_model)

reactpy_django/router/__init__.py

@@ -0,0 +1,5 @@
+from reactpy_router import create_router
+
+from reactpy_django.router.resolvers import DjangoResolver
+
+django_router = create_router(DjangoResolver)

reactpy_django/router/converters.py

@@ -0,0 +1,8 @@
+from django.urls.converters import get_converters
+from reactpy_router.types import ConversionInfo
+
+CONVERTERS: dict[str, ConversionInfo] = {
+    name: {"regex": converter.regex, "func": converter.to_python}
+    for name, converter in get_converters().items()
+}
+CONVERTERS["any"] = {"regex": r".*", "func": str}

reactpy_django/router/resolvers.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from reactpy_router.resolvers import StarletteResolver
+from reactpy_router.types import ConversionInfo, Route
+
+from reactpy_django.router.converters import CONVERTERS
+
+
+class DjangoResolver(StarletteResolver):
+    """A simple route resolver that uses regex to match paths"""
+
+    def __init__(
+        self,
+        route: Route,
+        param_pattern=r"<(?P<type>\w+:)?(?P<name>\w+)>",
+        converters: dict[str, ConversionInfo] | None = None,
+    ) -> None:
+        super().__init__(
+            route=route,
+            param_pattern=param_pattern,
+            converters=converters or CONVERTERS,
+        )