umap-project 2.0.4__py3-none-any.whl → 2.1.1__py3-none-any.whl

umap/static/umap/vendors/photon/leaflet.photon.js

@@ -388,6 +388,9 @@ L.PhotonSearch = L.PhotonBaseSearch.extend({
         if (this.options.includePosition) {
             params.lat = this.map.getCenter().lat;
             params.lon = this.map.getCenter().lng;
+            if (this.options.location_bias_scale) {
+                params.location_bias_scale = this.options.location_bias_scale;
+            }
         }
         if (this.options.bbox && this.options.bbox.length === 4) {
             params.bbox = this.options.bbox.join(',');

umap/templates/umap/js.html

@@ -2,11 +2,18 @@
 <script type="module"
         src="{% static 'umap/vendors/leaflet/leaflet-src.esm.js' %}"
         defer></script>
+<script type="module"
+        src="{% static 'umap/js/modules/leaflet-configure.js' %}"
+        defer></script>
+{% if locale %}
+  {% with "umap/locale/"|add:locale|add:".js" as path %}
+    <script src="{% static path %}" defer></script>
+  {% endwith %}
+{% endif %}
 <script type="module" src="{% static 'umap/js/modules/global.js' %}" defer></script>
 <script src="{% static 'umap/vendors/editable/Path.Drag.js' %}" defer></script>
 <script src="{% static 'umap/vendors/editable/Leaflet.Editable.js' %}" defer></script>
 <script src="{% static 'umap/vendors/hash/leaflet-hash.js' %}" defer></script>
-<script src="{% static 'umap/vendors/i18n/Leaflet.i18n.js' %}" defer></script>
 <script src="{% static 'umap/vendors/editinosm/Leaflet.EditInOSM.js' %}"
         defer></script>
 <script src="{% static 'umap/vendors/minimap/Control.MiniMap.min.js' %}"
@@ -39,11 +46,6 @@
 <script src="{% static 'umap/vendors/colorbrewer/colorbrewer.js' %}" defer></script>
 <script src="{% static 'umap/vendors/simple-statistics/simple-statistics.min.js' %}"
         defer></script>
-{% if locale %}
-  {% with "umap/locale/"|add:locale|add:".js" as path %}
-    <script src="{% static path %}" defer></script>
-  {% endwith %}
-{% endif %}
 <script src="{% static 'umap/js/umap.core.js' %}" defer></script>
 <script src="{% static 'umap/js/umap.autocomplete.js' %}" defer></script>
 <script src="{% static 'umap/js/umap.popup.js' %}" defer></script>

umap/templatetags/umap_tags.py

@@ -1,9 +1,10 @@
-import json
 from copy import copy
 
 from django import template
 from django.conf import settings
 
+from umap.utils import json_dumps
+
 register = template.Library()
 
 
@@ -25,7 +26,7 @@ def map_fragment(map_instance, **kwargs):
     page = kwargs.pop("page", None) or ""
     unique_id = prefix + str(page) + "_" + str(map_instance.pk)
     return {
-        "map_settings": json.dumps(map_settings),
+        "map_settings": json_dumps(map_settings),
         "map": map_instance,
         "unique_id": unique_id,
     }

umap/tests/integration/test_browser.py

@@ -291,3 +291,43 @@ def test_should_use_color_variable(live_server, map, page):
     expect(features.nth(1)).to_have_css("background-color", "rgb(139, 0, 0)")
     # DarkBlue (default color)
     expect(features.nth(2)).to_have_css("background-color", "rgb(0, 0, 139)")
+
+
+def test_should_allow_to_toggle_datalayer_visibility(live_server, map, page, bootstrap):
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    markers = page.locator(".leaflet-marker-icon")
+    paths = page.locator(".leaflet-overlay-pane path")
+    expect(markers).to_have_count(1)
+    expect(paths).to_have_count(2)
+    toggle = page.locator("#umap-ui-container").get_by_title("Show/hide layer")
+    toggle.click()
+    expect(markers).to_have_count(0)
+    expect(paths).to_have_count(0)
+
+
+def test_should_have_edit_buttons_in_edit_mode(live_server, map, page, bootstrap):
+    # Faster than doing a login
+    map.edit_status = Map.ANONYMOUS
+    map.save()
+    page.goto(f"{live_server.url}{map.get_absolute_url()}")
+    browser = page.locator("#umap-ui-container")
+    edit_layer = browser.get_by_title("Edit", exact=True)
+    in_table = browser.get_by_title("Edit properties in a table")
+    delete_layer = browser.get_by_title("Delete layer")
+    edit_feature = browser.get_by_title("Edit this feature")
+    delete_feature = browser.get_by_title("Delete this feature")
+    expect(edit_layer).to_be_hidden()
+    expect(in_table).to_be_hidden()
+    expect(delete_layer).to_be_hidden()
+    # Does not work
+    # to_have_count does not seem to case about the elements being visible or not
+    # and to_be_hidden is not happy if the selector resolve to more than on element
+    # expect(edit_feature).to_have_count(0)
+    # expect(delete_feature).to_be_hidden()
+    # Switch to edit mode
+    page.get_by_role("button", name="Edit").click()
+    expect(edit_layer).to_be_visible()
+    expect(in_table).to_be_visible()
+    expect(delete_layer).to_be_visible()
+    expect(edit_feature).to_have_count(3)
+    expect(delete_feature).to_have_count(3)

umap/tests/integration/test_collaborative_editing.py

@@ -98,7 +98,7 @@ def test_collaborative_editing_create_markers(context, live_server, tilelayer):
         "name": "test datalayer",
         "inCaption": True,
         "editMode": "advanced",
-        "id": datalayer.pk,
+        "id": str(datalayer.pk),
         "permissions": {"edit_status": 1},
     }
 
@@ -116,7 +116,7 @@ def test_collaborative_editing_create_markers(context, live_server, tilelayer):
         "name": "test datalayer",
         "inCaption": True,
         "editMode": "advanced",
-        "id": datalayer.pk,
+        "id": str(datalayer.pk),
         "permissions": {"edit_status": 1},
     }
     expect(marker_pane_p1).to_have_count(4)
@@ -136,7 +136,7 @@ def test_collaborative_editing_create_markers(context, live_server, tilelayer):
         "name": "test datalayer",
         "inCaption": True,
         "editMode": "advanced",
-        "id": datalayer.pk,
+        "id": str(datalayer.pk),
         "permissions": {"edit_status": 1},
     }
     expect(marker_pane_p2).to_have_count(5)
@@ -196,3 +196,72 @@ def test_empty_datalayers_can_be_merged(context, live_server, tilelayer):
         sleep(1)
 
     expect(marker_pane_p2).to_have_count(2)
+
+
+def test_same_second_edit_doesnt_conflict(context, live_server, tilelayer):
+    # Let's create a new map with an empty datalayer
+    map = MapFactory(name="collaborative editing")
+    datalayer = DataLayerFactory(map=map, edit_status=DataLayer.ANONYMOUS, data={})
+
+    # Open the created map on two pages.
+    page_one = context.new_page()
+    page_one.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+    page_two = context.new_page()
+    page_two.goto(f"{live_server.url}{map.get_absolute_url()}?edit")
+
+    save_p1 = page_one.get_by_role("button", name="Save")
+    expect(save_p1).to_be_visible()
+
+    save_p2 = page_two.get_by_role("button", name="Save")
+    expect(save_p2).to_be_visible()
+
+    # Create a point on the first map
+    create_marker_p1 = page_one.get_by_title("Draw a marker")
+    expect(create_marker_p1).to_be_visible()
+    create_marker_p1.click()
+
+    # Check no marker is present by default.
+    marker_pane_p1 = page_one.locator(".leaflet-marker-pane > div")
+    expect(marker_pane_p1).to_have_count(0)
+
+    # Click on the map, it will place a marker at the given position.
+    map_el_p1 = page_one.locator("#map")
+    map_el_p1.click(position={"x": 200, "y": 200})
+    expect(marker_pane_p1).to_have_count(1)
+
+    # And add one on the second map as well.
+    create_marker_p2 = page_two.get_by_title("Draw a marker")
+    expect(create_marker_p2).to_be_visible()
+    create_marker_p2.click()
+
+    marker_pane_p2 = page_two.locator(".leaflet-marker-pane > div")
+
+    # Click on the map, it will place a marker at the given position.
+    map_el_p2 = page_two.locator("#map")
+    map_el_p2.click(position={"x": 220, "y": 220})
+    expect(marker_pane_p2).to_have_count(1)
+
+    # Save the two tabs at the same time
+    with page_one.expect_response(DATALAYER_UPDATE):
+        save_p1.click()
+        sleep(0.2)  # Needed to avoid having multiple requests coming at the same time.
+        save_p2.click()
+
+    # Now create another marker in the first tab
+    create_marker_p1.click()
+    map_el_p1.click(position={"x": 150, "y": 150})
+    expect(marker_pane_p1).to_have_count(2)
+    with page_one.expect_response(DATALAYER_UPDATE):
+        save_p1.click()
+
+    # Should now get the other marker too
+    expect(marker_pane_p1).to_have_count(3)
+    assert DataLayer.objects.get(pk=datalayer.pk).settings == {
+        "browsable": True,
+        "displayOnLoad": True,
+        "name": "test datalayer",
+        "inCaption": True,
+        "editMode": "advanced",
+        "id": str(datalayer.pk),
+        "permissions": {"edit_status": 1},
+    }

umap/tests/integration/test_export_map.py

@@ -4,10 +4,84 @@ from pathlib import Path
 import pytest
 from playwright.sync_api import expect
 
+from ..base import DataLayerFactory
+
 pytestmark = pytest.mark.django_db
 
+DATALAYER_DATA = {
+    "type": "FeatureCollection",
+    "features": [
+        {
+            "type": "Feature",
+            "properties": {
+                "name": "name poly",
+            },
+            "id": "gyNzM",
+            "geometry": {
+                "type": "Polygon",
+                "coordinates": [
+                    [
+                        [11.25, 53.585984],
+                        [10.151367, 52.975108],
+                        [12.689209, 52.167194],
+                        [14.084473, 53.199452],
+                        [12.634277, 53.618579],
+                        [11.25, 53.585984],
+                        [11.25, 53.585984],
+                    ],
+                ],
+            },
+        },
+        {
+            "type": "Feature",
+            "properties": {
+                "_umap_options": {
+                    "color": "OliveDrab",
+                },
+                "name": "test",
+                "description": "Some description",
+            },
+            "id": "QwNjg",
+            "geometry": {
+                "type": "Point",
+                "coordinates": [-0.274658, 52.57635],
+            },
+        },
+        {
+            "type": "Feature",
+            "properties": {
+                "_umap_options": {
+                    "fill": False,
+                    "opacity": 0.6,
+                },
+                "name": "test",
+            },
+            "id": "YwMTM",
+            "geometry": {
+                "type": "LineString",
+                "coordinates": [
+                    [-0.571289, 54.476422],
+                    [0.439453, 54.610255],
+                    [1.724854, 53.448807],
+                    [4.163818, 53.988395],
+                    [5.306396, 53.533778],
+                    [6.591797, 53.709714],
+                    [7.042236, 53.350551],
+                ],
+            },
+        },
+    ],
+}
+
+
+@pytest.fixture
+def bootstrap(map, live_server):
+    map.settings["properties"]["onLoadPanel"] = "databrowser"
+    map.save()
+    DataLayerFactory(map=map, data=DATALAYER_DATA)
+
 
-def test_umap_export(map, live_server, datalayer, page):
+def test_umap_export(map, live_server, bootstrap, page):
     page.goto(f"{live_server.url}{map.get_absolute_url()}?share")
     link = page.get_by_role("link", name="full backup")
     expect(link).to_be_visible()
@@ -34,16 +108,56 @@ def test_umap_export(map, live_server, datalayer, page):
                 "features": [
                     {
                         "geometry": {
-                            "coordinates": [14.68896484375, 48.55297816440071],
+                            "coordinates": [
+                                [
+                                    [11.25, 53.585984],
+                                    [10.151367, 52.975108],
+                                    [12.689209, 52.167194],
+                                    [14.084473, 53.199452],
+                                    [12.634277, 53.618579],
+                                    [11.25, 53.585984],
+                                    [11.25, 53.585984],
+                                ]
+                            ],
+                            "type": "Polygon",
+                        },
+                        "id": "gyNzM",
+                        "properties": {"name": "name poly"},
+                        "type": "Feature",
+                    },
+                    {
+                        "geometry": {
+                            "coordinates": [-0.274658, 52.57635],
                             "type": "Point",
                         },
+                        "id": "QwNjg",
+                        "properties": {
+                            "_umap_options": {"color": "OliveDrab"},
+                            "name": "test",
+                            "description": "Some description",
+                        },
+                        "type": "Feature",
+                    },
+                    {
+                        "geometry": {
+                            "coordinates": [
+                                [-0.571289, 54.476422],
+                                [0.439453, 54.610255],
+                                [1.724854, 53.448807],
+                                [4.163818, 53.988395],
+                                [5.306396, 53.533778],
+                                [6.591797, 53.709714],
+                                [7.042236, 53.350551],
+                            ],
+                            "type": "LineString",
+                        },
+                        "id": "YwMTM",
                         "properties": {
-                            "_umap_options": {"color": "DarkCyan", "iconClass": "Ball"},
-                            "description": "Da place anonymous " "again 755",
-                            "name": "Here",
+                            "_umap_options": {"fill": False, "opacity": 0.6},
+                            "name": "test",
                         },
                         "type": "Feature",
-                    }
+                    },
                 ],
                 "type": "FeatureCollection",
             }
@@ -66,12 +180,13 @@ def test_umap_export(map, live_server, datalayer, page):
             "tilelayersControl": True,
             "zoom": 7,
             "zoomControl": True,
+            "onLoadPanel": "databrowser",
         },
         "type": "umap",
     }
 
 
-def test_csv_export(map, live_server, datalayer, page):
+def test_csv_export(map, live_server, bootstrap, page):
     page.goto(f"{live_server.url}{map.get_absolute_url()}?share")
     button = page.get_by_role("button", name="csv")
     expect(button).to_be_visible()
@@ -83,6 +198,108 @@ def test_csv_export(map, live_server, datalayer, page):
     download.save_as(path)
     assert (
         path.read_text()
-        == """name,description,Latitude,Longitude
-Here,Da place anonymous again 755,48.55297816440071,14.68896484375"""
+        == """name,Latitude,Longitude,description
+name poly,53.0072070131872,12.182431646910137,
+test,52.57635,-0.274658,Some description
+test,53.725145179688646,2.9700064980570517,"""
+    )
+
+
+def test_gpx_export(map, live_server, bootstrap, page):
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?share")
+    button = page.get_by_role("button", name="gpx")
+    expect(button).to_be_visible()
+    with page.expect_download() as download_info:
+        button.click()
+    download = download_info.value
+    # FIXME assert mimetype (find no way to access it throught PW)
+    assert download.suggested_filename == "test_map.gpx"
+    path = Path("/tmp/") / download.suggested_filename
+    download.save_as(path)
+    assert (
+        path.read_text()
+        == """<gpx xmlns="http://www.topografix.com/GPX/1/1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd" version="1.1" creator="togpx"><metadata/><wpt lat="52.57635" lon="-0.274658"><name>test</name><desc>name=test
+description=Some description</desc></wpt><trk><name>name poly</name><desc>name=name poly</desc><trkseg><trkpt lat="53.585984" lon="11.25"/><trkpt lat="52.975108" lon="10.151367"/><trkpt lat="52.167194" lon="12.689209"/><trkpt lat="53.199452" lon="14.084473"/><trkpt lat="53.618579" lon="12.634277"/><trkpt lat="53.585984" lon="11.25"/><trkpt lat="53.585984" lon="11.25"/></trkseg></trk><trk><name>test</name><desc>name=test</desc><trkseg><trkpt lat="54.476422" lon="-0.571289"/><trkpt lat="54.610255" lon="0.439453"/><trkpt lat="53.448807" lon="1.724854"/><trkpt lat="53.988395" lon="4.163818"/><trkpt lat="53.533778" lon="5.306396"/><trkpt lat="53.709714" lon="6.591797"/><trkpt lat="53.350551" lon="7.042236"/></trkseg></trk></gpx>"""
     )
+
+
+def test_kml_export(map, live_server, bootstrap, page):
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?share")
+    button = page.get_by_role("button", name="kml")
+    expect(button).to_be_visible()
+    with page.expect_download() as download_info:
+        button.click()
+    download = download_info.value
+    assert download.suggested_filename == "test_map.kml"
+    path = Path("/tmp/") / download.suggested_filename
+    download.save_as(path)
+    assert (
+        path.read_text()
+        == """<?xml version="1.0" encoding="UTF-8"?><kml xmlns="http://www.opengis.net/kml/2.2"><Document><Placemark><name>name poly</name><ExtendedData><Data name="name"><value>name poly</value></Data></ExtendedData><Polygon><outerBoundaryIs><LinearRing><coordinates>11.25,53.585984 10.151367,52.975108 12.689209,52.167194 14.084473,53.199452 12.634277,53.618579 11.25,53.585984 11.25,53.585984</coordinates></LinearRing></outerBoundaryIs></Polygon></Placemark><Placemark><name>test</name><description>Some description</description><ExtendedData><Data name="_umap_options"><value>[object Object]</value></Data><Data name="name"><value>test</value></Data><Data name="description"><value>Some description</value></Data></ExtendedData><Point><coordinates>-0.274658,52.57635</coordinates></Point></Placemark><Placemark><name>test</name><ExtendedData><Data name="_umap_options"><value>[object Object]</value></Data><Data name="name"><value>test</value></Data></ExtendedData><LineString><coordinates>-0.571289,54.476422 0.439453,54.610255 1.724854,53.448807 4.163818,53.988395 5.306396,53.533778 6.591797,53.709714 7.042236,53.350551</coordinates></LineString></Placemark></Document></kml>"""
+    )
+
+
+def test_geojson_export(map, live_server, bootstrap, page):
+    page.goto(f"{live_server.url}{map.get_absolute_url()}?share")
+    button = page.get_by_role("button", name="geojson")
+    expect(button).to_be_visible()
+    with page.expect_download() as download_info:
+        button.click()
+    download = download_info.value
+    assert download.suggested_filename == "test_map.geojson"
+    path = Path("/tmp/") / download.suggested_filename
+    download.save_as(path)
+    assert json.loads(path.read_text()) == {
+        "features": [
+            {
+                "geometry": {
+                    "coordinates": [
+                        [
+                            [11.25, 53.585984],
+                            [10.151367, 52.975108],
+                            [12.689209, 52.167194],
+                            [14.084473, 53.199452],
+                            [12.634277, 53.618579],
+                            [11.25, 53.585984],
+                            [11.25, 53.585984],
+                        ]
+                    ],
+                    "type": "Polygon",
+                },
+                "id": "gyNzM",
+                "properties": {"name": "name poly"},
+                "type": "Feature",
+            },
+            {
+                "geometry": {"coordinates": [-0.274658, 52.57635], "type": "Point"},
+                "id": "QwNjg",
+                "properties": {
+                    "_umap_options": {"color": "OliveDrab"},
+                    "name": "test",
+                    "description": "Some description",
+                },
+                "type": "Feature",
+            },
+            {
+                "geometry": {
+                    "coordinates": [
+                        [-0.571289, 54.476422],
+                        [0.439453, 54.610255],
+                        [1.724854, 53.448807],
+                        [4.163818, 53.988395],
+                        [5.306396, 53.533778],
+                        [6.591797, 53.709714],
+                        [7.042236, 53.350551],
+                    ],
+                    "type": "LineString",
+                },
+                "id": "YwMTM",
+                "properties": {
+                    "_umap_options": {"fill": False, "opacity": 0.6},
+                    "name": "test",
+                },
+                "type": "Feature",
+            },
+        ],
+        "type": "FeatureCollection",
+    }

umap/tests/integration/test_features_id_generation.py

@@ -0,0 +1,51 @@
+import json
+from pathlib import Path
+
+
+def test_ids_generation(page, live_server, tilelayer):
+    page.goto(f"{live_server.url}/en/map/new/")
+
+    # Click on the Draw a line button on a new map.
+    create_polyline = page.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polyline"
+    )
+    create_polyline.click()
+
+    map = page.locator("#map")
+    map.click(position={"x": 200, "y": 200})
+    map.click(position={"x": 100, "y": 100})
+    # Click again to finish
+    map.click(position={"x": 100, "y": 100})
+
+    # Click on the Draw a polygon button on a new map.
+    create_polygon = page.locator(".leaflet-control-toolbar ").get_by_title(
+        "Draw a polygon"
+    )
+    create_polygon.click()
+
+    map = page.locator("#map")
+    map.click(position={"x": 300, "y": 300})
+    map.click(position={"x": 300, "y": 400})
+    map.click(position={"x": 350, "y": 450})
+    # Click again to finish
+    map.click(position={"x": 350, "y": 450})
+
+    download_panel = page.get_by_title("Share and download")
+    download_panel.click()
+
+    button = page.get_by_role("button", name="geojson")
+
+    with page.expect_download() as download_info:
+        button.click()
+
+    download = download_info.value
+
+    path = Path("/tmp/") / download.suggested_filename
+    download.save_as(path)
+    downloaded = json.loads(path.read_text())
+
+    assert "features" in downloaded
+    features = downloaded["features"]
+    assert len(features) == 2
+    assert "id" in features[0]
+    assert "id" in features[1]

umap/tests/integration/test_owned_map.py

@@ -134,6 +134,18 @@ def test_owner_has_delete_map_button(map, live_server, login):
     advanced.click()
     delete = page.get_by_role("button", name="Delete", exact=True)
     expect(delete).to_be_visible()
+    dialog_shown = False
+
+    def handle_dialog(dialog):
+        dialog.accept()
+        nonlocal dialog_shown
+        dialog_shown = True
+
+    page.on("dialog", handle_dialog)
+    with page.expect_navigation():
+        delete.click()
+    assert dialog_shown
+    assert Map.objects.all().count() == 0
 
 
 def test_editor_do_not_have_delete_map_button(map, live_server, login, user):
@@ -210,7 +222,8 @@ def test_can_change_owner(map, live_server, login, user):
     close = page.locator(".umap-field-owner .close")
     close.click()
     input = page.locator("input.edit-owner")
-    input.type(user.username)
+    with page.expect_response(re.compile(r".*/agnocomplete/.*")):
+        input.type(user.username)
     input.press("Tab")
     save = page.get_by_role("button", name="Save")
     expect(save).to_be_visible()

umap/tests/integration/test_statics.py

@@ -15,9 +15,9 @@ def staticfiles(settings):
     settings.STATIC_ROOT = static_root
     # Make sure settings are properly reset after the test
     settings.STORAGES = deepcopy(settings.STORAGES)
-    settings.STORAGES["staticfiles"][
-        "BACKEND"
-    ] = "umap.storage.UmapManifestStaticFilesStorage"
+    settings.STORAGES["staticfiles"]["BACKEND"] = (
+        "umap.storage.UmapManifestStaticFilesStorage"
+    )
     try:
         call_command("collectstatic", "--noinput")
         yield

umap/tests/integration/test_tilelayer.py

@@ -101,9 +101,9 @@ def test_map_should_display_custom_tilelayer(map, live_server, tilelayers, page)
     url_pattern = re.compile(
         r"https://[abc]{1}.basemaps.cartocdn.com/rastertiles/voyager/\d+/\d+/\d+.png"
     )
-    map.settings["properties"]["tilelayer"][
-        "url_template"
-    ] = "https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png"
+    map.settings["properties"]["tilelayer"]["url_template"] = (
+        "https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png"
+    )
     map.settings["properties"]["tilelayersControl"] = True
     map.save()
     page.goto(f"{live_server.url}{map.get_absolute_url()}")

umap/tests/settings.py

@@ -5,9 +5,9 @@ from umap.settings.base import *  # pylint: disable=W0614,W0401
 SECRET_KEY = "justfortests"
 DEFAULT_FROM_EMAIL = "test@test.org"
 EMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"
-STORAGES["staticfiles"][
-    "BACKEND"
-] = "django.contrib.staticfiles.storage.StaticFilesStorage"
+STORAGES["staticfiles"]["BACKEND"] = (
+    "django.contrib.staticfiles.storage.StaticFilesStorage"
+)
 
 if os.environ.get("GITHUB_ACTIONS", False) == "true":
     DATABASES = {