umap-project 2.6.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

umap/tests/integration/test_view_polygon.py

@@ -1,4 +1,5 @@
 import re
+from copy import deepcopy
 
 import pytest
 from playwright.sync_api import expect
@@ -33,19 +34,9 @@ DATALAYER_DATA = {
 }
 
 
-@pytest.fixture
-def bootstrap(map, live_server):
-    map.settings["properties"]["zoom"] = 6
-    map.settings["geometry"] = {
-        "type": "Point",
-        "coordinates": [8.429, 53.239],
-    }
-    map.save()
+def test_should_open_popup_on_click(live_server, map, page):
     DataLayerFactory(map=map, data=DATALAYER_DATA)
-
-
-def test_should_open_popup_on_click(live_server, map, page, bootstrap):
-    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/53.239/8.429")
     polygon = page.locator("path").first
     expect(polygon).to_have_attribute("fill-opacity", "0.3")
     polygon.click()
@@ -57,3 +48,12 @@ def test_should_open_popup_on_click(live_server, map, page, bootstrap):
     # Close popup
     page.locator("#map").click()
     expect(polygon).to_have_attribute("fill-opacity", "0.3")
+
+
+def test_should_not_react_to_click_if_interactive_false(live_server, map, page):
+    data = deepcopy(DATALAYER_DATA)
+    data["features"][0]["properties"]["_umap_options"] = {"interactive": False}
+    DataLayerFactory(map=map, data=data)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/53.239/8.429")
+    polygon = page.locator("path").first
+    expect(polygon).to_have_css("pointer-events", "none")

umap/tests/integration/test_websocket_sync.py

@@ -69,7 +69,7 @@ def test_websocket_connection_can_sync_markers(
 
     # Delete a marker from peer A and check it's been deleted on peer B
     a_first_marker.click(button="right")
-    peerA.get_by_role("link", name="Delete this feature").click()
+    peerA.get_by_role("button", name="Delete this feature").click()
     peerA.locator("dialog").get_by_role("button", name="OK").click()
     expect(a_marker_pane).to_have_count(1)
     expect(b_marker_pane).to_have_count(1)
@@ -153,7 +153,7 @@ def test_websocket_connection_can_sync_polygons(
 
     # Delete a polygon from peer A and check it's been deleted on peer B
     a_polygon.click(button="right")
-    peerA.get_by_role("link", name="Delete this feature").click()
+    peerA.get_by_role("button", name="Delete this feature").click()
     peerA.locator("dialog").get_by_role("button", name="OK").click()
     expect(a_polygons).to_have_count(0)
     expect(b_polygons).to_have_count(0)
@@ -268,7 +268,7 @@ def test_websocket_connection_can_sync_cloned_polygons(
 
     # Clone on peer B and save
     b_polygon.click(button="right")
-    peerB.get_by_role("link", name="Clone this feature").click()
+    peerB.get_by_role("button", name="Clone this feature").click()
 
     expect(peerB.locator("path")).to_have_count(2)
 
@@ -281,3 +281,65 @@ def test_websocket_connection_can_sync_cloned_polygons(
     peerB.get_by_role("button", name="Save").click()
 
     expect(peerB.locator("path")).to_have_count(2)
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_websocket_connection_can_sync_late_joining_peer(
+    new_page, live_server, websocket_server, tilelayer
+):
+    map = MapFactory(name="sync", edit_status=Map.ANONYMOUS)
+    map.settings["properties"]["syncEnabled"] = True
+    map.save()
+    DataLayerFactory(map=map, data={})
+
+    # Create first peer (A) and have it join immediately
+    peerA = new_page("Page A")
+    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    # Add a marker from peer A
+    a_create_marker = peerA.get_by_title("Draw a marker")
+    expect(a_create_marker).to_be_visible()
+    a_create_marker.click()
+
+    a_map_el = peerA.locator("#map")
+    a_map_el.click(position={"x": 220, "y": 220})
+    peerA.locator("body").type("First marker")
+    peerA.locator("body").press("Escape")
+
+    # Add a polygon from peer A
+    create_polygon = peerA.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_polygon.click()
+
+    a_map_el.click(position={"x": 200, "y": 200})
+    a_map_el.click(position={"x": 100, "y": 200})
+    a_map_el.click(position={"x": 100, "y": 100})
+    a_map_el.click(position={"x": 200, "y": 100})
+    a_map_el.click(position={"x": 200, "y": 100})
+    peerA.keyboard.press("Escape")
+
+    # Now create peer B and have it join
+    peerB = new_page("Page B")
+    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    # Check if peer B has received all the updates
+    b_marker_pane = peerB.locator(".leaflet-marker-pane > div")
+    b_polygons = peerB.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
+
+    expect(b_marker_pane).to_have_count(1)
+    expect(b_polygons).to_have_count(1)
+
+    # Verify marker properties
+    peerB.locator(".leaflet-marker-icon").first.click()
+    peerB.get_by_role("link", name="Toggle edit mode (⇧+Click)").click()
+    expect(peerB.locator('input[name="name"]')).to_have_value("First marker")
+
+    # Verify polygon exists (we've already checked the count)
+    b_polygon = peerB.locator("path")
+    expect(b_polygon).to_be_visible()
+
+    # Optional: Verify polygon properties if you have any specific ones set
+
+    # Clean up: close edit mode
+    peerB.locator("body").press("Escape")

umap/tests/test_clean_tilelayer.py

@@ -0,0 +1,83 @@
+import pytest
+from django.core.management import call_command
+
+from umap.models import Map
+
+pytestmark = pytest.mark.django_db
+
+
+def test_can_delete_tilelayer_from_settings(map):
+    map.settings["properties"]["tilelayer"] = {
+        "name": "My TileLayer",
+        "maxZoom": 18,
+        "minZoom": 0,
+        "attribution": "My attribution",
+        "url_template": "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+    }
+    map.save()
+    # Make sure its saved
+    map = Map.objects.get(pk=map.pk)
+    assert "tilelayer" in map.settings["properties"]
+    call_command(
+        "clean_tilelayer", "http://{s}.foo.bar.baz/{z}/{x}/{y}.png", "--no-input"
+    )
+    map = Map.objects.get(pk=map.pk)
+    assert "tilelayer" not in map.settings["properties"]
+
+
+def test_can_replace_tilelayer_url_in_map_settings(map):
+    map.settings["properties"]["tilelayer"] = {
+        "name": "My TileLayer",
+        "maxZoom": 18,
+        "minZoom": 0,
+        "attribution": "My attribution",
+        "url_template": "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+    }
+    map.save()
+    new = "https://{s}.foo.bar.baz/{z}/{x}/{y}.png"
+    call_command(
+        "clean_tilelayer",
+        "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+        new,
+        "--no-input",
+    )
+    map = Map.objects.get(pk=map.pk)
+    assert map.settings["properties"]["tilelayer"]["url_template"] == new
+
+
+def test_can_replace_tilelayer_by_name_in_map_settings(map, tilelayer):
+    map.settings["properties"]["tilelayer"] = {
+        "name": "My TileLayer",
+        "maxZoom": 18,
+        "minZoom": 0,
+        "attribution": "My attribution",
+        "url_template": "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+    }
+    map.save()
+    call_command(
+        "clean_tilelayer",
+        "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+        tilelayer.name,
+        "--no-input",
+    )
+    map = Map.objects.get(pk=map.pk)
+    assert map.settings["properties"]["tilelayer"] == tilelayer.json
+
+
+def test_can_replace_tilelayer_by_id_in_map_settings(map, tilelayer):
+    map.settings["properties"]["tilelayer"] = {
+        "name": "My TileLayer",
+        "maxZoom": 18,
+        "minZoom": 0,
+        "attribution": "My attribution",
+        "url_template": "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+    }
+    map.save()
+    call_command(
+        "clean_tilelayer",
+        "http://{s}.foo.bar.baz/{z}/{x}/{y}.png",
+        tilelayer.pk,
+        "--no-input",
+    )
+    map = Map.objects.get(pk=map.pk)
+    assert map.settings["properties"]["tilelayer"] == tilelayer.json

umap/tests/test_datalayer.py

@@ -1,3 +1,4 @@
+import tempfile
 from pathlib import Path
 
 import pytest
@@ -269,3 +270,26 @@ def test_anonymous_can_edit_in_inherit_mode_and_map_in_public_mode(
     map.save()
     fake_request.user = AnonymousUser()
     assert datalayer.can_edit(fake_request)
+
+
+def test_should_remove_all_versions_on_delete(map, settings):
+    settings.UMAP_PURGATORY_ROOT = tempfile.mkdtemp()
+    datalayer = DataLayerFactory(uuid="0f1161c0-c07f-4ba4-86c5-8d8981d8a813", old_id=17)
+    root = Path(datalayer.storage_root())
+    before = len(datalayer.geojson.storage.listdir(root)[1])
+    other = "123456_1440918637.geojson"
+    files = [
+        f"{datalayer.pk}_1440924889.geojson",
+        f"{datalayer.pk}_1440923687.geojson",
+        f"{datalayer.pk}_1440918637.geojson",
+        f"{datalayer.old_id}_1440918537.geojson",
+        other,
+    ]
+    for path in files:
+        datalayer.geojson.storage.save(root / path, ContentFile("{}"))
+        datalayer.geojson.storage.save(root / f"{path}.gz", ContentFile("{}"))
+    assert len(datalayer.geojson.storage.listdir(root)[1]) == 10 + before
+    datalayer.delete()
+    found = datalayer.geojson.storage.listdir(root)[1]
+    assert found == [other, f"{other}.gz"]
+    assert len(list(Path(settings.UMAP_PURGATORY_ROOT).iterdir())) == 4 + before

umap/tests/test_map_views.py

@@ -368,6 +368,7 @@ def test_anonymous_create(cookieclient, post_data):
     assert (
         created_map.get_anonymous_edit_url() in j["permissions"]["anonymous_edit_url"]
     )
+    assert j["user"]["is_owner"] is True
     assert created_map.name == name
     key, value = created_map.signed_cookie_elements
     assert key in cookieclient.cookies
@@ -860,3 +861,22 @@ def test_ogp_links(client, map, datalayer):
     assert f'<meta property="og:title" content="{map.name}" />' in content
     assert f'<meta property="og:description" content="{map.description}" />' in content
     assert '<meta property="og:site_name" content="uMap" />' in content
+
+
+def test_non_public_map_should_have_noindex_meta(client, map, datalayer):
+    map.share_status = Map.OPEN
+    map.save()
+    response = client.get(map.get_absolute_url())
+    assert response.status_code == 200
+    assert (
+        '<meta name="robots" content="noindex,nofollow">' in response.content.decode()
+    )
+
+
+def test_demo_instance_should_have_noindex(client, map, datalayer, settings):
+    settings.UMAP_DEMO_SITE = True
+    response = client.get(map.get_absolute_url())
+    assert response.status_code == 200
+    assert (
+        '<meta name="robots" content="noindex,nofollow">' in response.content.decode()
+    )

umap/tests/test_purge_purgatory.py

@@ -0,0 +1,25 @@
+import os
+import tempfile
+from pathlib import Path
+
+from django.core.management import call_command
+
+
+def test_purge_purgatory(settings):
+    settings.UMAP_PURGATORY_ROOT = tempfile.mkdtemp()
+    root = Path(settings.UMAP_PURGATORY_ROOT)
+    old = root / "old.json"
+    old.write_text("{}")
+    stat = old.stat()
+    os.utime(old, times=(stat.st_mtime - 31 * 86400, stat.st_mtime - 31 * 86400))
+    recent = root / "recent.json"
+    recent.write_text("{}")
+    stat = recent.stat()
+    os.utime(recent, times=(stat.st_mtime - 8 * 86400, stat.st_mtime - 8 * 86400))
+    now = root / "now.json"
+    now.write_text("{}")
+    assert {f.name for f in root.iterdir()} == {"old.json", "recent.json", "now.json"}
+    call_command("purge_purgatory")
+    assert {f.name for f in root.iterdir()} == {"recent.json", "now.json"}
+    call_command("purge_purgatory", "--days=7")
+    assert {f.name for f in root.iterdir()} == {"now.json"}

umap/tests/test_websocket_server.py

@@ -0,0 +1,22 @@
+from umap.websocket_server import OperationMessage, PeerMessage, Request, ServerRequest
+
+
+def test_messages_are_parsed_correctly():
+    server = Request.model_validate(dict(kind="Server", action="list-peers")).root
+    assert type(server) is ServerRequest
+
+    operation = Request.model_validate(
+        dict(
+            kind="OperationMessage",
+            verb="upsert",
+            subject="map",
+            metadata={},
+            key="key",
+        )
+    ).root
+    assert type(operation) is OperationMessage
+
+    peer_message = Request.model_validate(
+        dict(kind="PeerMessage", sender="Alice", recipient="Bob", message={})
+    ).root
+    assert type(peer_message) is PeerMessage

umap/urls.py

@@ -115,11 +115,15 @@ i18n_urls += decorated_patterns(
         name="map_star",
     ),
     path("me", views.user_dashboard, name="user_dashboard"),
-    path("me/profile", views.user_profile, name="user_profile"),
     path("me/download", views.user_download, name="user_download"),
     path("me/teams", views.UserTeams.as_view(), name="user_teams"),
     path("team/create/", views.TeamNew.as_view(), name="team_new"),
 )
+
+if settings.UMAP_ALLOW_EDIT_PROFILE:
+    i18n_urls.append(
+        path("me/profile", login_required(views.user_profile), name="user_profile")
+    )
 i18n_urls += decorated_patterns(
     [login_required, team_members_only],
     path("team/<int:pk>/edit/", views.TeamUpdate.as_view(), name="team_update"),

umap/views.py

@@ -863,15 +863,17 @@ class MapCreate(FormLessEditMixin, PermissionsMixin, SessionMixin, CreateView):
             form.instance.owner = self.request.user
         self.object = form.save()
         permissions = self.get_permissions()
+        user_data = self.get_user_data()
         # User does not have the cookie yet.
         if not self.object.owner:
             anonymous_url = self.object.get_anonymous_edit_url()
             permissions["anonymous_edit_url"] = anonymous_url
+            user_data["is_owner"] = True
         response = simple_json_response(
             id=self.object.pk,
             url=self.object.get_absolute_url(),
             permissions=permissions,
-            user=self.get_user_data(),
+            user=user_data,
         )
         if not self.request.user.is_authenticated:
             key, value = self.object.signed_cookie_elements
@@ -908,7 +910,7 @@ def get_websocket_auth_token(request, map_id, map_inst):
     return simple_json_response(token=signed_token)
 
 
-class MapUpdate(FormLessEditMixin, PermissionsMixin, UpdateView):
+class MapUpdate(FormLessEditMixin, PermissionsMixin, SessionMixin, UpdateView):
     model = Map
     form_class = MapSettingsForm
     pk_url_kwarg = "map_id"
@@ -920,6 +922,7 @@ class MapUpdate(FormLessEditMixin, PermissionsMixin, UpdateView):
             id=self.object.pk,
             url=self.object.get_absolute_url(),
             permissions=self.get_permissions(),
+            user=self.get_user_data(),
         )
 
 
@@ -1359,7 +1362,7 @@ def logout(request):
 
 class LoginPopupEnd(TemplateView):
     """
-    End of a loggin process in popup.
+    End of a login process in popup.
     Basically close the popup.
     """
 

umap/websocket_server.py

@@ -1,70 +1,173 @@
 #!/usr/bin/env python
 
 import asyncio
+import logging
+import uuid
 from collections import defaultdict
-from typing import Literal, Optional
+from typing import Literal, Optional, Union
 
 import websockets
 from django.conf import settings
 from django.core.signing import TimestampSigner
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel, Field, RootModel, ValidationError
 from websockets import WebSocketClientProtocol
 from websockets.server import serve
 
-from umap.models import Map, User  # NOQA
+
+class Connections:
+    def __init__(self) -> None:
+        self._connections: set[WebSocketClientProtocol] = set()
+        self._ids: dict[WebSocketClientProtocol, str] = dict()
+
+    def join(self, websocket: WebSocketClientProtocol) -> str:
+        self._connections.add(websocket)
+        _id = str(uuid.uuid4())
+        self._ids[websocket] = _id
+        return _id
+
+    def leave(self, websocket: WebSocketClientProtocol) -> None:
+        self._connections.remove(websocket)
+        del self._ids[websocket]
+
+    def get(self, id) -> WebSocketClientProtocol:
+        # use an iterator to stop iterating as soon as we found
+        return next(k for k, v in self._ids.items() if v == id)
+
+    def get_id(self, websocket: WebSocketClientProtocol):
+        return self._ids[websocket]
+
+    def get_other_peers(
+        self, websocket: WebSocketClientProtocol
+    ) -> set[WebSocketClientProtocol]:
+        return self._connections - {websocket}
+
+    def get_all_peers(self) -> set[WebSocketClientProtocol]:
+        return self._connections
+
 
 # Contains the list of websocket connections handled by this process.
 # It's a mapping of map_id to a set of the active websocket connections
-CONNECTIONS = defaultdict(set)
+CONNECTIONS: defaultdict[int, Connections] = defaultdict(Connections)
 
 
-class JoinMessage(BaseModel):
-    kind: str = "join"
+class JoinRequest(BaseModel):
+    kind: Literal["JoinRequest"] = "JoinRequest"
     token: str
 
 
 class OperationMessage(BaseModel):
-    kind: str = "operation"
-    verb: str = Literal["upsert", "update", "delete"]
-    subject: str = Literal["map", "layer", "feature"]
+    """Message sent from one peer to all the others"""
+
+    kind: Literal["OperationMessage"] = "OperationMessage"
+    verb: Literal["upsert", "update", "delete"]
+    subject: Literal["map", "datalayer", "feature"]
     metadata: Optional[dict] = None
     key: Optional[str] = None
 
 
+class PeerMessage(BaseModel):
+    """Message sent from a specific peer to another one"""
+
+    kind: Literal["PeerMessage"] = "PeerMessage"
+    sender: str
+    recipient: str
+    # The message can be whatever the peers want. It's not checked by the server.
+    message: dict
+
+
+class ServerRequest(BaseModel):
+    """A request towards the server"""
+
+    kind: Literal["Server"] = "Server"
+    action: Literal["list-peers"]
+
+
+class Request(RootModel):
+    """Any message coming from the websocket should be one of these, and will be rejected otherwise."""
+
+    root: Union[ServerRequest, PeerMessage, OperationMessage] = Field(
+        discriminator="kind"
+    )
+
+
+class JoinResponse(BaseModel):
+    """Server response containing the list of peers"""
+
+    kind: Literal["JoinResponse"] = "JoinResponse"
+    peers: list
+    uuid: str
+
+
+class ListPeersResponse(BaseModel):
+    kind: Literal["ListPeersResponse"] = "ListPeersResponse"
+    peers: list
+
+
 async def join_and_listen(
     map_id: int, permissions: list, user: str | int, websocket: WebSocketClientProtocol
 ):
-    """Join a "room" whith other connected peers.
+    """Join a "room" with other connected peers, and wait for messages."""
+    logging.debug(f"{user} joined room #{map_id}")
+    connections: Connections = CONNECTIONS[map_id]
+    _id: str = connections.join(websocket)
+
+    # Assign an ID to the joining peer and return it the list of connected peers.
+    peers: list[WebSocketClientProtocol] = [
+        connections.get_id(p) for p in connections.get_all_peers()
+    ]
+    response = JoinResponse(uuid=_id, peers=peers)
+    await websocket.send(response.model_dump_json())
+
+    # Notify all other peers of the new list of connected peers.
+    message = ListPeersResponse(peers=peers)
+    websockets.broadcast(
+        connections.get_other_peers(websocket), message.model_dump_json()
+    )
 
-    New messages will be broadcasted to other connected peers.
-    """
-    print(f"{user} joined room #{map_id}")
-    CONNECTIONS[map_id].add(websocket)
     try:
         async for raw_message in websocket:
-            # recompute the peers-list at the time of message-sending.
+            # recompute the peers list at the time of message-sending.
             # as doing so beforehand would miss new connections
-            peers = CONNECTIONS[map_id] - {websocket}
-            # Only relay valid "operation" messages
+            other_peers = connections.get_other_peers(websocket)
             try:
-                OperationMessage.model_validate_json(raw_message)
-                websockets.broadcast(peers, raw_message)
+                incoming = Request.model_validate_json(raw_message)
             except ValidationError as e:
-                error = f"An error occurred when receiving this message: {raw_message}"
-                print(error, e)
+                error = f"An error occurred when receiving the following message: {raw_message!r}"
+                logging.error(error, e)
+            else:
+                match incoming.root:
+                    # Broadcast all operation messages to connected peers
+                    case OperationMessage():
+                        websockets.broadcast(other_peers, raw_message)
+
+                    # Send peer messages to the proper peer
+                    case PeerMessage(recipient=_id):
+                        peer = connections.get(_id)
+                        if peer:
+                            await peer.send(raw_message)
+
     finally:
-        CONNECTIONS[map_id].remove(websocket)
+        # On disconnect, remove the connection from the pool
+        connections.leave(websocket)
+
+        # TODO: refactor this in a separate method.
+        # Notify all other peers of the new list of connected peers.
+        peers = [connections.get_id(p) for p in connections.get_all_peers()]
+        message = ListPeersResponse(peers=peers)
+        websockets.broadcast(
+            connections.get_other_peers(websocket), message.model_dump_json()
+        )
 
 
-async def handler(websocket):
+async def handler(websocket: WebSocketClientProtocol):
     """Main WebSocket handler.
 
-    If permissions are granted, let the peer enter a room.
+    Check if the permission is granted and let the peer enter a room.
     """
     raw_message = await websocket.recv()
 
     # The first event should always be 'join'
-    message: JoinMessage = JoinMessage.model_validate_json(raw_message)
+    message: JoinRequest = JoinRequest.model_validate_json(raw_message)
     signed = TimestampSigner().unsign_object(message.token, max_age=30)
     user, map_id, permissions = signed.values()
 
@@ -73,7 +176,7 @@ async def handler(websocket):
         await join_and_listen(map_id, permissions, user, websocket)
 
 
-def run(host, port):
+def run(host: str, port: int):
     if not settings.WEBSOCKET_ENABLED:
         msg = (
             "WEBSOCKET_ENABLED should be set to True to run the WebSocket Server. "
@@ -86,7 +189,7 @@ def run(host, port):
 
     async def _serve():
         async with serve(handler, host, port):
-            print(f"Waiting for connections on {host}:{port}")
+            logging.debug(f"Waiting for connections on {host}:{port}")
             await asyncio.Future()  # run forever
 
     asyncio.run(_serve())

{umap_project-2.6.3.dist-info → umap_project-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: umap-project
-Version: 2.6.3
+Version: 2.7.0
 Summary: Create maps with OpenStreetMap layers in a minute and embed them in your site.
 Author-email: Yohan Boniface <yb@enix.org>
 Maintainer-email: David Larlet <david@larlet.fr>
@@ -19,35 +19,39 @@ Requires-Python: >=3.10
 Requires-Dist: django-agnocomplete==2.2.0
 Requires-Dist: django-environ==0.11.2
 Requires-Dist: django-probes==1.7.0
-Requires-Dist: django==5.1.1
-Requires-Dist: pillow==10.4.0
-Requires-Dist: psycopg==3.2.1
-Requires-Dist: pydantic==2.9.1
-Requires-Dist: rcssmin==1.1.2
+Requires-Dist: django==5.1.2
+Requires-Dist: pillow==11.0.0
+Requires-Dist: psycopg==3.2.3
+Requires-Dist: rcssmin==1.1.3
 Requires-Dist: requests==2.32.3
-Requires-Dist: rjsmin==1.2.2
+Requires-Dist: rjsmin==1.2.3
 Requires-Dist: social-auth-app-django==5.4.2
 Requires-Dist: social-auth-core==4.5.4
-Requires-Dist: websockets==13.0.1
 Provides-Extra: dev
 Requires-Dist: djlint==1.35.2; extra == 'dev'
-Requires-Dist: hatch==1.12.0; extra == 'dev'
+Requires-Dist: hatch==1.13.0; extra == 'dev'
 Requires-Dist: isort==5.13.2; extra == 'dev'
-Requires-Dist: mkdocs-material==9.5.34; extra == 'dev'
+Requires-Dist: mkdocs-material==9.5.42; extra == 'dev'
 Requires-Dist: mkdocs-static-i18n==1.2.3; extra == 'dev'
 Requires-Dist: mkdocs==1.6.1; extra == 'dev'
-Requires-Dist: pymdown-extensions==10.9; extra == 'dev'
-Requires-Dist: ruff==0.6.4; extra == 'dev'
+Requires-Dist: pymdown-extensions==10.11.2; extra == 'dev'
+Requires-Dist: ruff==0.7.0; extra == 'dev'
 Requires-Dist: vermin==1.6.0; extra == 'dev'
 Provides-Extra: docker
-Requires-Dist: uwsgi==2.0.26; extra == 'docker'
+Requires-Dist: uwsgi==2.0.27; extra == 'docker'
+Provides-Extra: sync
+Requires-Dist: channels==4.1.0; extra == 'sync'
+Requires-Dist: daphne==4.1.2; extra == 'sync'
+Requires-Dist: pydantic==2.9.2; extra == 'sync'
+Requires-Dist: websockets==13.1; extra == 'sync'
 Provides-Extra: test
 Requires-Dist: factory-boy==3.3.1; extra == 'test'
 Requires-Dist: playwright>=1.39; extra == 'test'
 Requires-Dist: pytest-django==4.9.0; extra == 'test'
 Requires-Dist: pytest-playwright==0.5.2; extra == 'test'
+Requires-Dist: pytest-rerunfailures==14.0; extra == 'test'
 Requires-Dist: pytest-xdist<4,>=3.5.0; extra == 'test'
-Requires-Dist: pytest==8.3.2; extra == 'test'
+Requires-Dist: pytest==8.3.3; extra == 'test'
 Description-Content-Type: text/markdown
 
 # uMap project