umap-project 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

umap/tests/integration/test_websocket_sync.py

@@ -0,0 +1,283 @@
+import re
+
+import pytest
+from playwright.sync_api import expect
+
+from umap.models import Map
+
+from ..base import DataLayerFactory, MapFactory
+
+DATALAYER_UPDATE = re.compile(r".*/datalayer/update/.*")
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_websocket_connection_can_sync_markers(
+    context, 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 two tabs
+    peerA = context.new_page()
+    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB = context.new_page()
+    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    a_marker_pane = peerA.locator(".leaflet-marker-pane > div")
+    b_marker_pane = peerB.locator(".leaflet-marker-pane > div")
+    expect(a_marker_pane).to_have_count(0)
+    expect(b_marker_pane).to_have_count(0)
+
+    # 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})
+    expect(a_marker_pane).to_have_count(1)
+    expect(b_marker_pane).to_have_count(1)
+    peerA.locator("body").type("Synced name")
+    peerA.locator("body").press("Escape")
+
+    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("Synced name")
+
+    a_first_marker = peerA.locator("div:nth-child(4) > div:nth-child(2)").first
+    b_first_marker = peerB.locator("div:nth-child(4) > div:nth-child(2)").first
+
+    # Add a second marker from peer B
+    b_create_marker = peerB.get_by_title("Draw a marker")
+    expect(b_create_marker).to_be_visible()
+    b_create_marker.click()
+
+    b_map_el = peerB.locator("#map")
+    b_map_el.click(position={"x": 225, "y": 225})
+    expect(a_marker_pane).to_have_count(2)
+    expect(b_marker_pane).to_have_count(2)
+
+    # Drag a marker on peer B and check that it moved on peer A
+    a_first_marker.bounding_box() == b_first_marker.bounding_box()
+    b_old_bbox = b_first_marker.bounding_box()
+    b_first_marker.drag_to(b_map_el, target_position={"x": 250, "y": 250})
+
+    assert b_old_bbox is not b_first_marker.bounding_box()
+    a_first_marker.bounding_box() == b_first_marker.bounding_box()
+
+    # Delete a marker from peer A and check it's been deleted on peer B
+    a_first_marker.click(button="right")
+    peerA.on("dialog", lambda dialog: dialog.accept())
+    peerA.get_by_role("link", name="Delete this feature").click()
+    expect(a_marker_pane).to_have_count(1)
+    expect(b_marker_pane).to_have_count(1)
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_websocket_connection_can_sync_polygons(
+    context, 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 two tabs
+    peerA = context.new_page()
+    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB = context.new_page()
+    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    b_map_el = peerB.locator("#map")
+
+    # Click on the Draw a polygon button on a new map.
+    create_line = peerA.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_line.click()
+
+    a_polygons = peerA.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
+    b_polygons = peerB.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
+    expect(a_polygons).to_have_count(0)
+    expect(b_polygons).to_have_count(0)
+
+    # Click on the map, it will create a polygon.
+    map = peerA.locator("#map")
+    map.click(position={"x": 200, "y": 200})
+    map.click(position={"x": 100, "y": 200})
+    map.click(position={"x": 100, "y": 100})
+    map.click(position={"x": 100, "y": 100})
+
+    # It is created on peerA, but not yet synced
+    expect(a_polygons).to_have_count(1)
+    expect(b_polygons).to_have_count(0)
+
+    # Escaping the edition syncs
+    peerA.keyboard.press("Escape")
+    expect(a_polygons).to_have_count(1)
+    expect(b_polygons).to_have_count(1)
+
+    # change the geometry by moving a point on peer B
+    a_polygon = peerA.locator("path")
+    b_polygon = peerB.locator("path")
+    b_polygon_bbox_t1 = b_polygon.bounding_box()
+    a_polygon_bbox_t1 = a_polygon.bounding_box()
+    assert b_polygon_bbox_t1 == a_polygon_bbox_t1
+
+    b_polygon.click()
+    peerB.get_by_role("link", name="Toggle edit mode (⇧+Click)").click()
+
+    edited_vertex = peerB.locator("div:nth-child(6)").first
+    edited_vertex.drag_to(b_map_el, target_position={"x": 233, "y": 126})
+    peerB.keyboard.press("Escape")
+
+    b_polygon_bbox_t2 = b_polygon.bounding_box()
+    a_polygon_bbox_t2 = a_polygon.bounding_box()
+
+    assert b_polygon_bbox_t2 != b_polygon_bbox_t1
+    assert b_polygon_bbox_t2 == a_polygon_bbox_t2
+
+    # Move the polygon on peer B and check it moved also on peer A
+    b_polygon.click()
+    peerB.get_by_role("link", name="Toggle edit mode (⇧+Click)").click()
+
+    b_polygon.drag_to(b_map_el, target_position={"x": 400, "y": 400})
+    peerB.keyboard.press("Escape")
+    b_polygon_bbox_t3 = b_polygon.bounding_box()
+    a_polygon_bbox_t3 = a_polygon.bounding_box()
+
+    assert b_polygon_bbox_t3 != b_polygon_bbox_t2
+    assert b_polygon_bbox_t3 == a_polygon_bbox_t3
+
+    # Delete a polygon from peer A and check it's been deleted on peer B
+    a_polygon.click(button="right")
+    peerA.on("dialog", lambda dialog: dialog.accept())
+    peerA.get_by_role("link", name="Delete this feature").click()
+    expect(a_polygons).to_have_count(0)
+    expect(b_polygons).to_have_count(0)
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_websocket_connection_can_sync_map_properties(
+    context, 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 two tabs
+    peerA = context.new_page()
+    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB = context.new_page()
+    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    # Name change is synced
+    peerA.get_by_role("link", name="Edit map name and caption").click()
+    peerA.locator('input[name="name"]').click()
+    peerA.locator('input[name="name"]').fill("it syncs!")
+
+    expect(peerB.locator(".map-name").last).to_have_text("it syncs!")
+
+    # Zoom control is synced
+    peerB.get_by_role("link", name="Map advanced properties").click()
+    peerB.locator("summary").filter(has_text="User interface options").click()
+    peerB.locator("div").filter(
+        has_text=re.compile(r"^Display the zoom control")
+    ).locator("label").nth(2).click()
+
+    expect(peerA.locator(".leaflet-control-zoom")).to_be_hidden()
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_websocket_connection_can_sync_datalayer_properties(
+    context, 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 two tabs
+    peerA = context.new_page()
+    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB = context.new_page()
+    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    # Layer addition, name and type are synced
+    peerA.get_by_role("link", name="Manage layers").click()
+    peerA.get_by_role("button", name="Add a layer").click()
+    peerA.locator('input[name="name"]').click()
+    peerA.locator('input[name="name"]').fill("synced layer!")
+    peerA.get_by_role("combobox").select_option("Choropleth")
+    peerA.locator("body").press("Escape")
+
+    peerB.get_by_role("link", name="Manage layers").click()
+    peerB.get_by_role("button", name="Edit").first.click()
+    expect(peerB.locator('input[name="name"]')).to_have_value("synced layer!")
+    expect(peerB.get_by_role("combobox")).to_have_value("Choropleth")
+
+
+@pytest.mark.xdist_group(name="websockets")
+def test_websocket_connection_can_sync_cloned_polygons(
+    context, 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 two tabs
+    peerA = context.new_page()
+    peerA.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    peerB = context.new_page()
+    peerB.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    b_map_el = peerB.locator("#map")
+
+    # Click on the Draw a polygon button on a new map.
+    create_line = peerA.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_line.click()
+
+    a_polygons = peerA.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
+    b_polygons = peerB.locator(".leaflet-overlay-pane path[fill='DarkBlue']")
+    expect(a_polygons).to_have_count(0)
+    expect(b_polygons).to_have_count(0)
+
+    # Click on the map, it will create a polygon.
+    map = peerA.locator("#map")
+    map.click(position={"x": 200, "y": 200})
+    map.click(position={"x": 100, "y": 200})
+    map.click(position={"x": 100, "y": 100})
+    map.click(position={"x": 200, "y": 100})
+    map.click(position={"x": 200, "y": 100})
+
+    # Escaping the edition syncs
+    peerA.keyboard.press("Escape")
+    expect(a_polygons).to_have_count(1)
+    expect(b_polygons).to_have_count(1)
+
+    # Save from peer A
+    peerA.get_by_role("button", name="Save").click()
+
+    b_polygon = peerB.locator("path")
+
+    # Clone on peer B and save
+    b_polygon.click(button="right")
+    peerB.get_by_role("link", name="Clone this feature").click()
+
+    expect(peerB.locator("path")).to_have_count(2)
+
+    peerB.locator("path").nth(1).drag_to(b_map_el, target_position={"x": 400, "y": 400})
+    peerB.locator("path").nth(1).click()
+    peerB.locator("summary").filter(has_text="Shape properties").click()
+    peerB.locator(".header > a:nth-child(2)").first.click()
+    peerB.get_by_title("Orchid", exact=True).first.click()
+    peerB.locator("#map").press("Escape")
+    peerB.get_by_role("button", name="Save").click()
+
+    expect(peerB.locator("path")).to_have_count(2)

umap/tests/settings.py

@@ -24,3 +24,8 @@ if os.environ.get("GITHUB_ACTIONS", False) == "true":
 PASSWORD_HASHERS = [
     "django.contrib.auth.hashers.MD5PasswordHasher",
 ]
+
+
+WEBSOCKET_ENABLED = True
+WEBSOCKET_BACK_PORT = "8010"
+WEBSOCKET_FRONT_URI = "ws://localhost:8010"

umap/tests/test_datalayer_views.py

@@ -1,5 +1,4 @@
 import json
-import time
 from copy import deepcopy
 from pathlib import Path
 

umap/tests/test_views.py

@@ -5,6 +5,7 @@ from datetime import datetime, timedelta
 import pytest
 from django.conf import settings
 from django.contrib.auth import get_user, get_user_model
+from django.core.signing import TimestampSigner
 from django.test import RequestFactory
 from django.urls import reverse
 from django.utils.timezone import make_aware
@@ -430,3 +431,55 @@ def test_home_feed(client, settings, user, tilelayer):
     assert "A public map starred by non staff" not in content
     assert "A private map starred by staff" not in content
     assert "A reserved map starred by staff" not in content
+
+
+@pytest.mark.django_db
+def test_websocket_token_returns_login_required_if_not_connected(client, user, map):
+    token_url = reverse("map_websocket_auth_token", kwargs={"map_id": map.id})
+    resp = client.get(token_url)
+    assert "login_required" in resp.json()
+
+
+@pytest.mark.django_db
+def test_websocket_token_returns_403_if_unauthorized(client, user, user2, map):
+    client.login(username=map.owner.username, password="123123")
+    map.owner = user2
+    map.save()
+
+    token_url = reverse("map_websocket_auth_token", kwargs={"map_id": map.id})
+    resp = client.get(token_url)
+    assert resp.status_code == 403
+
+
+@pytest.mark.django_db
+def test_websocket_token_is_generated_for_anonymous(client, user, user2, map):
+    map.edit_status = Map.ANONYMOUS
+    map.save()
+
+    token_url = reverse("map_websocket_auth_token", kwargs={"map_id": map.id})
+    resp = client.get(token_url)
+    token = resp.json().get("token")
+    assert TimestampSigner().unsign_object(token, max_age=30)
+
+
+@pytest.mark.django_db
+def test_websocket_token_returns_a_valid_token_when_authorized(client, user, map):
+    client.login(username=map.owner.username, password="123123")
+    token_url = reverse("map_websocket_auth_token", kwargs={"map_id": map.id})
+    resp = client.get(token_url)
+    assert resp.status_code == 200
+    token = resp.json().get("token")
+    assert TimestampSigner().unsign_object(token, max_age=30)
+
+
+@pytest.mark.django_db
+def test_websocket_token_is_generated_for_editors(client, user, user2, map):
+    map.edit_status = Map.EDITORS
+    map.editors.add(user2)
+    map.save()
+
+    assert client.login(username=user2.username, password="456456")
+    token_url = reverse("map_websocket_auth_token", kwargs={"map_id": map.id})
+    resp = client.get(token_url)
+    token = resp.json().get("token")
+    assert TimestampSigner().unsign_object(token, max_age=30)

umap/urls.py

@@ -155,6 +155,11 @@ map_urls = [
         views.UpdateDataLayerPermissions.as_view(),
         name="datalayer_permissions",
     ),
+    path(
+        "map/<int:map_id>/ws-token/",
+        views.get_websocket_auth_token,
+        name="map_websocket_auth_token",
+    ),
 ]
 if settings.DEFAULT_FROM_EMAIL:
     map_urls.append(

umap/views.py

@@ -24,7 +24,7 @@ from django.contrib.staticfiles.storage import staticfiles_storage
 from django.core.exceptions import PermissionDenied
 from django.core.mail import send_mail
 from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator
-from django.core.signing import BadSignature, Signer
+from django.core.signing import BadSignature, Signer, TimestampSigner
 from django.core.validators import URLValidator, ValidationError
 from django.http import (
     Http404,
@@ -40,7 +40,6 @@ from django.shortcuts import get_object_or_404
 from django.urls import resolve, reverse, reverse_lazy
 from django.utils import translation
 from django.utils.encoding import smart_bytes
-from django.utils.http import http_date
 from django.utils.timezone import make_aware
 from django.utils.translation import gettext as _
 from django.views.decorators.cache import cache_control
@@ -504,6 +503,9 @@ class MapDetailMixin:
             ],
             "umap_version": VERSION,
             "featuresHaveOwner": settings.UMAP_DEFAULT_FEATURES_HAVE_OWNERS,
+            "websocketEnabled": settings.WEBSOCKET_ENABLED,
+            "websocketURI": settings.WEBSOCKET_FRONT_URI,
+            "importers": settings.UMAP_IMPORTERS,
         }
         created = bool(getattr(self, "object", None))
         if (created and self.object.owner) or (not created and not user.is_anonymous):
@@ -624,8 +626,8 @@ class MapView(MapDetailMixin, PermissionsMixin, DetailView):
 
     def get_datalayers(self):
         return [
-            l.metadata(self.request.user, self.request)
-            for l in self.object.datalayer_set.all()
+            dl.metadata(self.request.user, self.request)
+            for dl in self.object.datalayer_set.all()
         ]
 
     @property
@@ -778,6 +780,33 @@ class MapCreate(FormLessEditMixin, PermissionsMixin, CreateView):
         return response
 
 
+def get_websocket_auth_token(request, map_id, map_inst):
+    """Return an signed authentication token for the currently
+    connected user, allowing edits for this map over WebSocket.
+
+    If the user is anonymous, return a signed token with the map id.
+
+    The returned token is a signed object with the following keys:
+    - user: user primary key OR "anonymous"
+    - map_id: the map id
+    - permissions: a list of allowed permissions for this user and this map
+    """
+    map_object: Map = Map.objects.get(pk=map_id)
+
+    permissions = ["edit"]
+    if map_object.is_owner(request.user, request):
+        permissions.append("owner")
+
+    if request.user.is_authenticated:
+        user = request.user.pk
+    else:
+        user = "anonymous"
+    signed_token = TimestampSigner().sign_object(
+        {"user": user, "map_id": map_id, "permissions": permissions}
+    )
+    return simple_json_response(token=signed_token)
+
+
 class MapUpdate(FormLessEditMixin, PermissionsMixin, UpdateView):
     model = Map
     form_class = MapSettingsForm
@@ -850,11 +879,10 @@ class SendEditLink(FormLessEditMixin, FormView):
             return HttpResponseBadRequest("Invalid")
         link = self.object.get_anonymous_edit_url()
 
-        subject = _(
-            "The uMap edit link for your map: %(map_name)s"
-            % {"map_name": self.object.name}
-        )
-        body = _("Here is your secret edit link: %(link)s" % {"link": link})
+        subject = _("The uMap edit link for your map: %(map_name)s") % {
+            "map_name": self.object.name
+        }
+        body = _("Here is your secret edit link: %(link)s") % {"link": link}
         try:
             send_mail(
                 subject, body, settings.DEFAULT_FROM_EMAIL, [email], fail_silently=False
@@ -864,7 +892,7 @@ class SendEditLink(FormLessEditMixin, FormView):
                 error=_("Can't send email to %(email)s" % {"email": email})
             )
         return simple_json_response(
-            info=_("Email sent to %(email)s" % {"email": email})
+            info=_("Email sent to %(email)s") % {"email": email}
         )
 
 
@@ -878,6 +906,7 @@ class MapDelete(DeleteView):
             return HttpResponseForbidden(_("Only its owner can delete the map."))
         self.object.delete()
         home_url = reverse("home")
+        messages.info(self.request, _("Map successfully deleted."))
         if is_ajax(self.request):
             return simple_json_response(redirect=home_url)
         else:
@@ -1081,7 +1110,7 @@ class DataLayerUpdate(FormLessEditMixin, GZipMixin, UpdateView):
                     reference = json.loads(f.read())
                 break
         else:
-            # If the document is not found, we can't merge.
+            # If the reference document is not found, we can't merge.
             return None
         # New data received in the request.
         incoming = json.loads(self.request.FILES["geojson"].read())

umap/websocket_server.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+import asyncio
+from collections import defaultdict
+from typing import Literal, Optional
+
+import websockets
+from django.conf import settings
+from django.core.signing import TimestampSigner
+from pydantic import BaseModel, ValidationError
+from websockets import WebSocketClientProtocol
+from websockets.server import serve
+
+from umap.models import Map, User  # NOQA
+
+# 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)
+
+
+class JoinMessage(BaseModel):
+    kind: str = "join"
+    token: str
+
+
+class OperationMessage(BaseModel):
+    kind: str = "operation"
+    verb: str = Literal["upsert", "update", "delete"]
+    subject: str = Literal["map", "layer", "feature"]
+    metadata: Optional[dict] = None
+    key: Optional[str] = None
+
+
+async def join_and_listen(
+    map_id: int, permissions: list, user: str | int, websocket: WebSocketClientProtocol
+):
+    """Join a "room" whith other connected peers.
+
+    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.
+            # as doing so beforehand would miss new connections
+            peers = CONNECTIONS[map_id] - {websocket}
+            # Only relay valid "operation" messages
+            try:
+                OperationMessage.model_validate_json(raw_message)
+                websockets.broadcast(peers, raw_message)
+            except ValidationError as e:
+                error = f"An error occurred when receiving this message: {raw_message}"
+                print(error, e)
+    finally:
+        CONNECTIONS[map_id].remove(websocket)
+
+
+async def handler(websocket):
+    """Main WebSocket handler.
+
+    If permissions are granted, 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)
+    signed = TimestampSigner().unsign_object(message.token, max_age=30)
+    user, map_id, permissions = signed.values()
+
+    # Check if permissions for this map have been granted by the server
+    if "edit" in signed["permissions"]:
+        await join_and_listen(map_id, permissions, user, websocket)
+
+
+def run(host, port):
+    if not settings.WEBSOCKET_ENABLED:
+        msg = (
+            "WEBSOCKET_ENABLED should be set to True to run the WebSocket Server. "
+            "See the documentation at "
+            "https://docs.umap-project.org/en/stable/config/settings/#websocket_enabled "
+            "for more information."
+        )
+        print(msg)
+        exit(1)
+
+    async def _serve():
+        async with serve(handler, host, port):
+            print(f"Waiting for connections on {host}:{port}")
+            await asyncio.Future()  # run forever
+
+    asyncio.run(_serve())

{umap_project-2.3.0.dist-info → umap_project-2.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: umap-project
-Version: 2.3.0
+Version: 2.4.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,33 +19,35 @@ 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.0.5
+Requires-Dist: django==5.0.6
 Requires-Dist: pillow==10.3.0
-Requires-Dist: psycopg==3.1.18
+Requires-Dist: psycopg==3.1.19
+Requires-Dist: pydantic==2.7.4
 Requires-Dist: rcssmin==1.1.2
-Requires-Dist: requests==2.31.0
+Requires-Dist: requests==2.32.3
 Requires-Dist: rjsmin==1.2.2
 Requires-Dist: social-auth-app-django==5.4.1
 Requires-Dist: social-auth-core==4.5.4
+Requires-Dist: websockets==12.0
 Provides-Extra: dev
 Requires-Dist: djlint==1.34.1; extra == 'dev'
-Requires-Dist: hatch==1.10.0; extra == 'dev'
+Requires-Dist: hatch==1.12.0; extra == 'dev'
 Requires-Dist: isort==5.13.2; extra == 'dev'
-Requires-Dist: mkdocs-material==9.5.21; extra == 'dev'
-Requires-Dist: mkdocs-static-i18n==1.2.2; extra == 'dev'
+Requires-Dist: mkdocs-material==9.5.27; extra == 'dev'
+Requires-Dist: mkdocs-static-i18n==1.2.3; extra == 'dev'
 Requires-Dist: mkdocs==1.6.0; extra == 'dev'
 Requires-Dist: pymdown-extensions==10.8.1; extra == 'dev'
-Requires-Dist: ruff==0.4.3; extra == 'dev'
+Requires-Dist: ruff==0.4.9; extra == 'dev'
 Requires-Dist: vermin==1.6.0; extra == 'dev'
 Provides-Extra: docker
-Requires-Dist: uwsgi==2.0.25.1; extra == 'docker'
+Requires-Dist: uwsgi==2.0.26; extra == 'docker'
 Provides-Extra: test
 Requires-Dist: factory-boy==3.2.1; extra == 'test'
 Requires-Dist: playwright>=1.39; extra == 'test'
 Requires-Dist: pytest-django==4.8.0; extra == 'test'
-Requires-Dist: pytest-playwright==0.4.4; extra == 'test'
+Requires-Dist: pytest-playwright==0.5.0; extra == 'test'
 Requires-Dist: pytest-xdist<4,>=3.5.0; extra == 'test'
-Requires-Dist: pytest==8.2.0; extra == 'test'
+Requires-Dist: pytest==8.2.2; extra == 'test'
 Description-Content-Type: text/markdown
 
 # uMap project