reactpy_django 3.8.1__py2.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/router/__init__.py

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

reactpy_django/router/converters.py

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

reactpy_django/router/resolvers.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from reactpy_router.simple import ConverterMapping
+from reactpy_router.types import Route
+
+from reactpy_django.router.converters import CONVERTERS
+
+PARAM_PATTERN = re.compile(r"<(?P<type>\w+:)?(?P<name>\w+)>")
+
+
+# TODO: Make reactpy_router's SimpleResolver generic enough to where we don't have to define our own
+class DjangoResolver:
+    """A simple route resolver that uses regex to match paths"""
+
+    def __init__(self, route: Route) -> None:
+        self.element = route.element
+        self.pattern, self.converters = parse_path(route.path)
+        self.key = self.pattern.pattern
+
+    def resolve(self, path: str) -> tuple[Any, dict[str, Any]] | None:
+        match = self.pattern.match(path)
+        if match:
+            return (
+                self.element,
+                {k: self.converters[k](v) for k, v in match.groupdict().items()},
+            )
+        return None
+
+
+# TODO: Make reactpy_router's parse_path generic enough to where we don't have to define our own
+def parse_path(path: str) -> tuple[re.Pattern[str], ConverterMapping]:
+    # Convert path to regex pattern, and make sure to interpret the registered converters (ex. <int:foo>)
+    pattern = "^"
+    last_match_end = 0
+    converters: ConverterMapping = {}
+    for match in PARAM_PATTERN.finditer(path):
+        param_name = match.group("name")
+        param_type = (match.group("type") or "str").strip(":")
+        try:
+            param_conv = CONVERTERS[param_type]
+        except KeyError as e:
+            raise ValueError(
+                f"Unknown conversion type {param_type!r} in {path!r}"
+            ) from e
+        pattern += re.escape(path[last_match_end : match.start()])
+        pattern += f"(?P<{param_name}>{param_conv['regex']})"
+        converters[param_name] = param_conv["func"]
+        last_match_end = match.end()
+    pattern += f"{re.escape(path[last_match_end:])}$"
+
+    # Replace literal `*` with "match anything" regex pattern, if it's at the end of the path
+    if pattern.endswith(r"\*$"):
+        pattern = f"{pattern[:-3]}.*$"
+
+    return re.compile(pattern), converters