goodmap 1.1.4__tar.gz → 1.1.7__tar.gz

{goodmap-1.1.4 → goodmap-1.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: goodmap
-Version: 1.1.4
+Version: 1.1.7
 Summary: Map engine to serve all the people :)
 License-File: LICENSE.md
 Author: Krzysztof Kolodzinski
@@ -26,8 +26,11 @@ Requires-Dist: gql (>=3.4.0,<4.0.0)
 Requires-Dist: gunicorn (>=20.1.0,<21.0.0)
 Requires-Dist: humanize (>=4.6.0,<5.0.0)
 Requires-Dist: myst-parser (>=4.0.0,<5.0.0) ; extra == "docs"
+Requires-Dist: numpy (>=2.2.0,<3.0.0)
 Requires-Dist: platzky (>=1.0.0,<2.0.0)
 Requires-Dist: pydantic (>=2.7.1,<3.0.0)
+Requires-Dist: pysupercluster-problematy (>=0.7.8,<0.8.0)
+Requires-Dist: scipy (>=1.15.1,<2.0.0)
 Requires-Dist: sphinx (>=8.0.0,<9.0.0) ; extra == "docs"
 Requires-Dist: sphinx-rtd-theme (>=3.0.0,<4.0.0) ; extra == "docs"
 Requires-Dist: tomli (>=2.0.0,<3.0.0) ; extra == "docs"
@@ -82,9 +85,9 @@ poetry run <command>
 
 ### TL;DR
 If you don't want to go through all the configuration, e.g. you just simply want to test if everything works,
-you can simply run app with test dataset provided in `tests/e2e_tests` directory:
+you can simply run app with test dataset provided in `examples` directory:
 
-> poetry run flask --app 'goodmap.goodmap:create_app(config_path="./tests/e2e_tests/e2e_test_config.yml")' run
+> poetry run flask --app 'goodmap.goodmap:create_app(config_path="./examples/e2e_test_config.yml")' run
 
 ### Configuration
 
@@ -102,7 +105,7 @@ Afterwards run it with:
 
 ## Database
 
-The database is stored in JSON, in the `map` section. For an example database see `tests/e2e_tests/e2e_test_data.json`. The first subsection `data` consists of the actual datapoints, representing points on a map.
+The database is stored in JSON, in the `map` section. For an example database see `examples/e2e_test_data.json`. The first subsection `data` consists of the actual datapoints, representing points on a map.
 
 Datapoints have fields. The next subsections define special types of fields:
 - `obligatory_fields` - here are explicitely stated all the fields that the application assumes are presnt in all datapoints. E.g.
@@ -130,9 +133,10 @@ You can define the fields in all these subsections. Besides these types of field
 
 ## Examples
 
-You can find examples of working configuration and database in `tests/e2e_tests` named:
-- `e2e_test_config.yml`
-- `e2e_test_data.json`
+You can find examples of working configuration and database in `examples/` directory:
+- `e2e_test_config.yml` - Basic configuration example
+- `e2e_test_data.json` - Example database with sample location data
+- `mongo_e2e_test_config.yml` - MongoDB configuration example
 
 
 

{goodmap-1.1.4 → goodmap-1.1.7}/README.md

@@ -47,9 +47,9 @@ poetry run <command>
 
 ### TL;DR
 If you don't want to go through all the configuration, e.g. you just simply want to test if everything works,
-you can simply run app with test dataset provided in `tests/e2e_tests` directory:
+you can simply run app with test dataset provided in `examples` directory:
 
-> poetry run flask --app 'goodmap.goodmap:create_app(config_path="./tests/e2e_tests/e2e_test_config.yml")' run
+> poetry run flask --app 'goodmap.goodmap:create_app(config_path="./examples/e2e_test_config.yml")' run
 
 ### Configuration
 
@@ -67,7 +67,7 @@ Afterwards run it with:
 
 ## Database
 
-The database is stored in JSON, in the `map` section. For an example database see `tests/e2e_tests/e2e_test_data.json`. The first subsection `data` consists of the actual datapoints, representing points on a map.
+The database is stored in JSON, in the `map` section. For an example database see `examples/e2e_test_data.json`. The first subsection `data` consists of the actual datapoints, representing points on a map.
 
 Datapoints have fields. The next subsections define special types of fields:
 - `obligatory_fields` - here are explicitely stated all the fields that the application assumes are presnt in all datapoints. E.g.
@@ -95,8 +95,9 @@ You can define the fields in all these subsections. Besides these types of field
 
 ## Examples
 
-You can find examples of working configuration and database in `tests/e2e_tests` named:
-- `e2e_test_config.yml`
-- `e2e_test_data.json`
+You can find examples of working configuration and database in `examples/` directory:
+- `e2e_test_config.yml` - Basic configuration example
+- `e2e_test_data.json` - Example database with sample location data
+- `mongo_e2e_test_config.yml` - MongoDB configuration example
 
 

goodmap-1.1.7/goodmap/clustering.py

@@ -0,0 +1,75 @@
+import logging
+import uuid
+
+from scipy.spatial import KDTree
+
+# Maximum distance to consider a point-cluster match (accounts for floating point errors)
+DISTANCE_THRESHOLD = 1e-8
+
+logger = logging.getLogger(__name__)
+
+
+def map_clustering_data_to_proper_lazy_loading_object(input_array):
+    response_array = []
+    for item in input_array:
+        if item["count"] == 1:
+            response_object = {
+                "position": [item["longitude"], item["latitude"]],
+                "uuid": item["uuid"],
+                "cluster_uuid": None,
+                "cluster_count": None,
+                "type": "point",
+            }
+            response_array.append(response_object)
+            continue
+        response_object = {
+            "position": [item["longitude"], item["latitude"]],
+            "uuid": None,
+            "cluster_uuid": str(uuid.uuid4()),
+            "cluster_count": item["count"],
+            "type": "cluster",
+        }
+        response_array.append(response_object)
+    return response_array
+
+
+# Since there can be some floating point errors
+# we need to check if the distance is close enough to 0
+def match_clusters_uuids(points, clusters):
+    """
+    Match single-point clusters to their original point UUIDs.
+
+    For clusters containing exactly one point, this function attempts to match the cluster
+    coordinates back to the original point to retrieve its UUID. The 'uuid' key is optional
+    and will only be present in single-point clusters where a matching point is found.
+
+    Args:
+        points: List of point dicts with 'position' and 'uuid' keys
+        clusters: List of cluster dicts with 'longitude', 'latitude', and 'count' keys.
+                 For single-point clusters (count=1), a 'uuid' key will be added if a
+                 matching point is found (modified in place)
+
+    Returns:
+        The modified clusters list with 'uuid' keys added to matched single-point clusters
+    """
+    points_coords = [(point["position"][0], point["position"][1]) for point in points]
+    tree = KDTree(points_coords)
+    for cluster in clusters:
+        if cluster["count"] == 1:
+            cluster_coords = (cluster["longitude"], cluster["latitude"])
+            dist, idx = tree.query(cluster_coords)
+            if dist < DISTANCE_THRESHOLD:
+                closest_point = points[idx]
+                cluster["uuid"] = closest_point["uuid"]
+            else:
+                # Log warning when no match is found - indicates data inconsistency
+                logger.warning(
+                    "No matching UUID found for cluster at coordinates (%f, %f). "
+                    "Distance to nearest point: %f (threshold: %f)",
+                    cluster["longitude"],
+                    cluster["latitude"],
+                    dist,
+                    DISTANCE_THRESHOLD,
+                )
+                cluster["uuid"] = None
+    return clusters

{goodmap-1.1.4 → goodmap-1.1.7}/goodmap/core_api.py

@@ -1,13 +1,40 @@
 import importlib.metadata
+import logging
 import uuid
 
+import numpy
+import pysupercluster
 from flask import Blueprint, jsonify, make_response, request
 from flask_babel import gettext
 from flask_restx import Api, Resource, fields
 from platzky.config import LanguagesMapping
-
+from werkzeug.exceptions import BadRequest
+
+from goodmap.clustering import (
+    map_clustering_data_to_proper_lazy_loading_object,
+    match_clusters_uuids,
+)
+from goodmap.exceptions import (
+    LocationAlreadyExistsError,
+    LocationNotFoundError,
+    LocationValidationError,
+    ReportNotFoundError,
+)
 from goodmap.formatter import prepare_pin
 
+# SuperCluster configuration constants
+MIN_ZOOM = 0
+MAX_ZOOM = 16
+CLUSTER_RADIUS = 200
+CLUSTER_EXTENT = 512
+
+# Error message constants
+ERROR_INVALID_REQUEST_DATA = "Invalid request data"
+ERROR_INVALID_LOCATION_DATA = "Invalid location data"
+ERROR_INTERNAL_ERROR = "An internal error occurred"
+
+logger = logging.getLogger(__name__)
+
 
 def make_tuple_translation(keys_to_translate):
     return [(x, gettext(x)) for x in keys_to_translate]
@@ -22,6 +49,27 @@ def get_or_none(data, *keys):
     return data
 
 
+def get_locations_from_request(database, request_args, as_basic_info=False):
+    """
+    Shared helper to fetch locations from database based on request arguments.
+
+    Args:
+        database: Database instance
+        request_args: Request arguments (flask.request.args)
+        as_basic_info: If True, returns list of basic_info dicts, otherwise returns Location objects
+
+    Returns:
+        List of locations (either as objects or basic_info dicts)
+    """
+    query_params = request_args.to_dict(flat=False)
+    all_locations = database.get_locations(query_params)
+
+    if as_basic_info:
+        return [x.basic_info() for x in all_locations]
+
+    return all_locations
+
+
 def core_pages(
     database,
     languages: LanguagesMapping,
@@ -66,10 +114,20 @@ def core_pages(
                     f"at position: {location.position}"
                 )
                 notifier_function(message)
-            except ValueError as e:
-                return make_response(jsonify({"message": f"Invalid location data: {e}"}), 400)
-            except Exception as e:
-                return make_response(jsonify({"message": f"Error sending notification : {e}"}), 400)
+            except BadRequest:
+                logger.warning("Invalid JSON in suggest endpoint")
+                return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
+            except LocationValidationError as e:
+                logger.warning(
+                    "Location validation failed in suggest endpoint",
+                    extra={"errors": e.validation_errors},
+                )
+                return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+            except Exception:
+                logger.error("Error in suggest location endpoint", exc_info=True)
+                return make_response(
+                    jsonify({"message": "An error occurred while processing your suggestion"}), 500
+                )
             return make_response(jsonify({"message": "Location suggested"}), 200)
 
     @core_api.route("/report-location")
@@ -92,12 +150,19 @@ def core_pages(
                     f"with problem: {location_report['description']}"
                 )
                 notifier_function(message)
+            except BadRequest:
+                logger.warning("Invalid JSON in report location endpoint")
+                return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
             except KeyError as e:
+                logger.warning(
+                    "Missing required field in report location", extra={"missing_field": str(e)}
+                )
                 error_message = gettext("Error reporting location")
-                return make_response(jsonify({"message": f"{error_message} : {e}"}), 400)
-            except Exception as e:
+                return make_response(jsonify({"message": error_message}), 400)
+            except Exception:
+                logger.error("Error in report location endpoint", exc_info=True)
                 error_message = gettext("Error sending notification")
-                return make_response(jsonify({"message": f"{error_message} : {e}"}), 400)
+                return make_response(jsonify({"message": error_message}), 500)
             return make_response(jsonify({"message": gettext("Location reported")}), 200)
 
     @core_api.route("/locations")
@@ -106,9 +171,58 @@ def core_pages(
             """
             Shows list of locations with uuid and position
             """
-            query_params = request.args.to_dict(flat=False)
-            all_locations = database.get_locations(query_params)
-            return jsonify([x.basic_info() for x in all_locations])
+            locations = get_locations_from_request(database, request.args, as_basic_info=True)
+            return jsonify(locations)
+
+    @core_api.route("/locations-clustered")
+    class GetLocationsClustered(Resource):
+        def get(self):
+            """
+            Shows list of locations with uuid, position and clusters
+            """
+            try:
+                query_params = request.args.to_dict(flat=False)
+                zoom = int(query_params.get("zoom", [7])[0])
+
+                # Validate zoom level (aligned with SuperCluster min_zoom/max_zoom)
+                if not MIN_ZOOM <= zoom <= MAX_ZOOM:
+                    return make_response(
+                        jsonify({"message": f"Zoom must be between {MIN_ZOOM} and {MAX_ZOOM}"}),
+                        400,
+                    )
+
+                points = get_locations_from_request(database, request.args, as_basic_info=True)
+                if not points:
+                    return jsonify([])
+
+                points_numpy = numpy.array(
+                    [(point["position"][0], point["position"][1]) for point in points]
+                )
+
+                index = pysupercluster.SuperCluster(
+                    points_numpy,
+                    min_zoom=MIN_ZOOM,
+                    max_zoom=MAX_ZOOM,
+                    radius=CLUSTER_RADIUS,
+                    extent=CLUSTER_EXTENT,
+                )
+
+                clusters = index.getClusters(
+                    top_left=(-180.0, 90.0),
+                    bottom_right=(180.0, -90.0),
+                    zoom=zoom,
+                )
+                clusters = match_clusters_uuids(points, clusters)
+
+                return jsonify(map_clustering_data_to_proper_lazy_loading_object(clusters))
+            except ValueError as e:
+                logger.warning("Invalid parameter in clustering request: %s", e)
+                return make_response(jsonify({"message": "Invalid parameters provided"}), 400)
+            except Exception as e:
+                logger.error("Clustering operation failed: %s", e, exc_info=True)
+                return make_response(
+                    jsonify({"message": "An error occurred during clustering"}), 500
+                )
 
     @core_api.route("/location/<location_id>")
     class GetLocation(Resource):
@@ -211,10 +325,15 @@ def core_pages(
                 location_data.update({"uuid": str(uuid.uuid4())})
                 location = location_model.model_validate(location_data)
                 database.add_location(location.model_dump())
-            except ValueError as e:
-                return make_response(jsonify({"message": f"Invalid location data: {e}"}), 400)
-            except Exception as e:
-                return make_response(jsonify({"message": f"Error creating location: {e}"}), 400)
+            except LocationValidationError as e:
+                logger.warning(
+                    "Location validation failed",
+                    extra={"uuid": e.uuid, "errors": e.validation_errors},
+                )
+                return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+            except Exception:
+                logger.error("Error creating location", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return jsonify(location.model_dump())
 
     @core_api.route("/admin/locations/<location_id>")
@@ -228,10 +347,18 @@ def core_pages(
                 location_data.update({"uuid": location_id})
                 location = location_model.model_validate(location_data)
                 database.update_location(location_id, location.model_dump())
-            except ValueError as e:
-                return make_response(jsonify({"message": f"Invalid location data: {e}"}), 400)
-            except Exception as e:
-                return make_response(jsonify({"message": f"Error updating location: {e}"}), 400)
+            except LocationValidationError as e:
+                logger.warning(
+                    "Location validation failed",
+                    extra={"uuid": e.uuid, "errors": e.validation_errors},
+                )
+                return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+            except LocationNotFoundError as e:
+                logger.info("Location not found for update", extra={"uuid": e.uuid})
+                return make_response(jsonify({"message": "Location not found"}), 404)
+            except Exception:
+                logger.error("Error updating location", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return jsonify(location.model_dump())
 
         def delete(self, location_id):
@@ -240,10 +367,12 @@ def core_pages(
             """
             try:
                 database.delete_location(location_id)
-            except ValueError as e:
-                return make_response(jsonify({"message": f"Location not found: {e}"}), 404)
-            except Exception as e:
-                return make_response(jsonify({"message": f"Error deleting location: {e}"}), 400)
+            except LocationNotFoundError as e:
+                logger.info("Location not found for deletion", extra={"uuid": e.uuid})
+                return make_response(jsonify({"message": "Location not found"}), 404)
+            except Exception:
+                logger.error("Error deleting location", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return "", 204
 
     @core_api.route("/admin/suggestions")
@@ -267,7 +396,7 @@ def core_pages(
                 data = request.get_json()
                 status = data.get("status")
                 if status not in ("accepted", "rejected"):
-                    return make_response(jsonify({"message": f"Invalid status: {status}"}), 400)
+                    return make_response(jsonify({"message": "Invalid status"}), 400)
                 suggestion = database.get_suggestion(suggestion_id)
                 if not suggestion:
                     return make_response(jsonify({"message": "Suggestion not found"}), 404)
@@ -277,8 +406,20 @@ def core_pages(
                     suggestion_data = {k: v for k, v in suggestion.items() if k != "status"}
                     database.add_location(suggestion_data)
                 database.update_suggestion(suggestion_id, status)
-            except ValueError as e:
-                return make_response(jsonify({"message": f"{e}"}), 400)
+            except LocationValidationError as e:
+                logger.warning(
+                    "Location validation failed in suggestion",
+                    extra={"uuid": e.uuid, "errors": e.validation_errors},
+                )
+                return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+            except LocationAlreadyExistsError as e:
+                logger.warning(
+                    "Attempted to create duplicate location from suggestion", extra={"uuid": e.uuid}
+                )
+                return make_response(jsonify({"message": "Location already exists"}), 409)
+            except Exception:
+                logger.error("Error processing suggestion", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return jsonify(database.get_suggestion(suggestion_id))
 
     @core_api.route("/admin/reports")
@@ -305,15 +446,22 @@ def core_pages(
                 valid_status = ("resolved", "rejected")
                 valid_priority = ("critical", "high", "medium", "low")
                 if status and status not in valid_status:
-                    return make_response(jsonify({"message": f"Invalid status: {status}"}), 400)
+                    return make_response(jsonify({"message": "Invalid status"}), 400)
                 if priority and priority not in valid_priority:
-                    return make_response(jsonify({"message": f"Invalid priority: {priority}"}), 400)
+                    return make_response(jsonify({"message": "Invalid priority"}), 400)
                 report = database.get_report(report_id)
                 if not report:
                     return make_response(jsonify({"message": "Report not found"}), 404)
                 database.update_report(report_id, status=status, priority=priority)
-            except ValueError as e:
-                return make_response(jsonify({"message": f"{e}"}), 400)
+            except BadRequest:
+                logger.warning("Invalid JSON in report update endpoint")
+                return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
+            except ReportNotFoundError as e:
+                logger.info("Report not found for update", extra={"uuid": e.uuid})
+                return make_response(jsonify({"message": "Report not found"}), 404)
+            except Exception:
+                logger.error("Error updating report", exc_info=True)
+                return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
             return jsonify(database.get_report(report_id))
 
     return core_api_blueprint

{goodmap-1.1.4 → goodmap-1.1.7}/goodmap/data_models/location.py

@@ -1,6 +1,15 @@
 from typing import Any, Type
 
-from pydantic import BaseModel, Field, create_model, field_validator
+from pydantic import (
+    BaseModel,
+    Field,
+    ValidationError,
+    create_model,
+    field_validator,
+    model_validator,
+)
+
+from goodmap.exceptions import LocationValidationError
 
 
 class LocationBase(BaseModel, extra="allow"):
@@ -16,6 +25,24 @@ class LocationBase(BaseModel, extra="allow"):
             raise ValueError("longitude must be in range -180 to 180")
         return v
 
+    @model_validator(mode="before")
+    @classmethod
+    def validate_uuid_exists(cls, data: Any) -> Any:
+        """Ensure UUID is present before validation for better error messages."""
+        if isinstance(data, dict) and "uuid" not in data:
+            raise ValueError("Location data must include 'uuid' field")
+        return data
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def enrich_validation_errors(cls, data, handler):
+        """Wrap validation errors with UUID context for better debugging."""
+        try:
+            return handler(data)
+        except ValidationError as e:
+            uuid = data.get("uuid") if isinstance(data, dict) else None
+            raise LocationValidationError(e, uuid=uuid) from e
+
     def basic_info(self):
         return {
             "uuid": self.uuid,

{goodmap-1.1.4 → goodmap-1.1.7}/goodmap/db.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 import tempfile
 from functools import partial
@@ -6,6 +7,14 @@ from typing import Any
 
 from goodmap.core import get_queried_data
 from goodmap.data_models.location import LocationBase
+from goodmap.exceptions import (
+    AlreadyExistsError,
+    LocationAlreadyExistsError,
+    LocationNotFoundError,
+    ReportNotFoundError,
+)
+
+logger = logging.getLogger(__name__)
 
 # TODO file is temporary solution to be compatible with old, static code,
 #  it should be replaced with dynamic solution
@@ -227,61 +236,28 @@ class FileIOHelper:
         return json_data.get(data_key, {})
 
 
-class ErrorHelper:
-    """Common error handling utilities."""
-
-    @staticmethod
-    def raise_already_exists_error(item_type, uuid):
-        """Raise standardized 'already exists' error."""
-        raise ValueError(f"{item_type} with uuid {uuid} already exists")
+class CRUDHelper:
+    """Common CRUD operation utilities to eliminate duplication."""
 
     @staticmethod
-    def raise_not_found_error(item_type, uuid):
-        """Raise standardized 'not found' error."""
-        raise ValueError(f"{item_type} with uuid {uuid} not found")
+    def add_item_to_json_db(db_data, collection_name, item_data, default_status=None):
+        """Add item to JSON in-memory database."""
+        collection = db_data.setdefault(collection_name, [])
+        uuid = item_data.get("uuid")
+        resource_type = collection_name.rstrip("s").capitalize()
 
-    @staticmethod
-    def check_item_exists(items, uuid, item_type):
-        """Check if item with UUID exists and raise error if it does."""
+        # Check if item already exists
         existing = next(
             (
                 item
-                for item in items
+                for item in collection
                 if (item.get("uuid") if isinstance(item, dict) else getattr(item, "uuid", None))
                 == uuid
             ),
             None,
         )
         if existing:
-            ErrorHelper.raise_already_exists_error(item_type, uuid)
-
-    @staticmethod
-    def find_item_by_uuid(items, uuid, item_type):
-        """Find item by UUID and raise error if not found."""
-        item = next(
-            (
-                item
-                for item in items
-                if (item.get("uuid") if isinstance(item, dict) else getattr(item, "uuid", None))
-                == uuid
-            ),
-            None,
-        )
-        if not item:
-            ErrorHelper.raise_not_found_error(item_type, uuid)
-        return item
-
-
-class CRUDHelper:
-    """Common CRUD operation utilities to eliminate duplication."""
-
-    @staticmethod
-    def add_item_to_json_db(db_data, collection_name, item_data, default_status=None):
-        """Add item to JSON in-memory database."""
-        collection = db_data.setdefault(collection_name, [])
-        ErrorHelper.check_item_exists(
-            collection, item_data.get("uuid"), collection_name.rstrip("s").capitalize()
-        )
+            raise AlreadyExistsError(uuid, resource_type)
 
         record = dict(item_data)
         if default_status:
@@ -294,9 +270,21 @@ class CRUDHelper:
         json_file = FileIOHelper.read_json_file(file_path)
         collection = json_file["map"].get(collection_name, [])
 
-        ErrorHelper.check_item_exists(
-            collection, item_data.get("uuid"), collection_name.rstrip("s").capitalize()
+        uuid = item_data.get("uuid")
+        resource_type = collection_name.rstrip("s").capitalize()
+
+        # Check if item already exists
+        existing = next(
+            (
+                item
+                for item in collection
+                if (item.get("uuid") if isinstance(item, dict) else getattr(item, "uuid", None))
+                == uuid
+            ),
+            None,
         )
+        if existing:
+            raise AlreadyExistsError(uuid, resource_type)
 
         record = dict(item_data)
         if default_status:
@@ -311,7 +299,7 @@ class CRUDHelper:
         """Add item to MongoDB database."""
         existing = db_collection.find_one({"uuid": item_data.get("uuid")})
         if existing:
-            ErrorHelper.raise_already_exists_error(item_type, item_data.get("uuid"))
+            raise AlreadyExistsError(item_data.get("uuid"), item_type)
 
         record = dict(item_data)
         if default_status:
@@ -787,7 +775,7 @@ def json_file_db_add_location(self, location_data, location_model):
         (i for i, point in enumerate(map_data) if point.get("uuid") == location_data["uuid"]), None
     )
     if idx is not None:
-        raise ValueError(f"Location with uuid {location_data['uuid']} already exists")
+        raise LocationAlreadyExistsError(location_data["uuid"])
 
     map_data.append(location.model_dump())
     json_file["map"]["data"] = map_data
@@ -806,7 +794,7 @@ def json_db_add_location(self, location_data, location_model):
         None,
     )
     if idx is not None:
-        raise ValueError(f"Location with uuid {location_data['uuid']} already exists")
+        raise LocationAlreadyExistsError(location_data["uuid"])
     self.data["data"].append(location.model_dump())
 
 
@@ -814,7 +802,7 @@ def mongodb_db_add_location(self, location_data, location_model):
     location = location_model.model_validate(location_data)
     existing = self.db.locations.find_one({"uuid": location_data["uuid"]})
     if existing:
-        raise ValueError(f"Location with uuid {location_data['uuid']} already exists")
+        raise LocationAlreadyExistsError(location_data["uuid"])
     self.db.locations.insert_one(location.model_dump())
 
 
@@ -834,7 +822,7 @@ def json_file_db_update_location(self, uuid, location_data, location_model):
     map_data = json_file["map"].get("data", [])
     idx = next((i for i, point in enumerate(map_data) if point.get("uuid") == uuid), None)
     if idx is None:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
 
     map_data[idx] = location.model_dump()
     json_file["map"]["data"] = map_data
@@ -848,7 +836,7 @@ def json_db_update_location(self, uuid, location_data, location_model):
         (i for i, point in enumerate(self.data.get("data", [])) if point.get("uuid") == uuid), None
     )
     if idx is None:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
     self.data["data"][idx] = location.model_dump()
 
 
@@ -856,7 +844,7 @@ def mongodb_db_update_location(self, uuid, location_data, location_model):
     location = location_model.model_validate(location_data)
     result = self.db.locations.update_one({"uuid": uuid}, {"$set": location.model_dump()})
     if result.matched_count == 0:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
 
 
 def update_location(db, uuid, location_data, location_model):
@@ -874,7 +862,7 @@ def json_file_db_delete_location(self, uuid):
     map_data = json_file["map"].get("data", [])
     idx = next((i for i, point in enumerate(map_data) if point.get("uuid") == uuid), None)
     if idx is None:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
 
     del map_data[idx]
     json_file["map"]["data"] = map_data
@@ -887,14 +875,14 @@ def json_db_delete_location(self, uuid):
         (i for i, point in enumerate(self.data.get("data", [])) if point.get("uuid") == uuid), None
     )
     if idx is None:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
     del self.data["data"][idx]
 
 
 def mongodb_db_delete_location(self, uuid):
     result = self.db.locations.delete_one({"uuid": uuid})
     if result.deleted_count == 0:
-        raise ValueError(f"Location with uuid {uuid} not found")
+        raise LocationNotFoundError(uuid)
 
 
 def delete_location(db, uuid):
@@ -1359,7 +1347,7 @@ def json_db_update_report(self, report_id, status=None, priority=None):
             if priority:
                 r["priority"] = priority
             return
-    raise ValueError(f"Report with uuid {report_id} not found")
+    raise ReportNotFoundError(report_id)
 
 
 def json_file_db_update_report(self, report_id, status=None, priority=None):
@@ -1375,7 +1363,7 @@ def json_file_db_update_report(self, report_id, status=None, priority=None):
                 r["priority"] = priority
             break
     else:
-        raise ValueError(f"Report with uuid {report_id} not found")
+        raise ReportNotFoundError(report_id)
 
     json_file["map"]["reports"] = reports
 
@@ -1392,7 +1380,7 @@ def mongodb_db_update_report(self, report_id, status=None, priority=None):
     if update_doc:
         result = self.db.reports.update_one({"uuid": report_id}, {"$set": update_doc})
         if result.matched_count == 0:
-            raise ValueError(f"Report with uuid {report_id} not found")
+            raise ReportNotFoundError(report_id)
 
 
 def google_json_db_update_report(self, report_id, status=None, priority=None):
@@ -1412,7 +1400,7 @@ def json_db_delete_report(self, report_id):
     reports = self.data.get("reports", [])
     idx = next((i for i, r in enumerate(reports) if r.get("uuid") == report_id), None)
     if idx is None:
-        raise ValueError(f"Report with uuid {report_id} not found")
+        raise ReportNotFoundError(report_id)
     del reports[idx]
 
 
@@ -1423,7 +1411,7 @@ def json_file_db_delete_report(self, report_id):
     reports = json_file["map"].get("reports", [])
     idx = next((i for i, r in enumerate(reports) if r.get("uuid") == report_id), None)
     if idx is None:
-        raise ValueError(f"Report with uuid {report_id} not found")
+        raise ReportNotFoundError(report_id)
 
     del reports[idx]
     json_file["map"]["reports"] = reports
@@ -1434,7 +1422,7 @@ def json_file_db_delete_report(self, report_id):
 def mongodb_db_delete_report(self, report_id):
     result = self.db.reports.delete_one({"uuid": report_id})
     if result.deleted_count == 0:
-        raise ValueError(f"Report with uuid {report_id} not found")
+        raise ReportNotFoundError(report_id)
 
 
 def google_json_db_delete_report(self, report_id):

goodmap-1.1.7/goodmap/exceptions.py

@@ -0,0 +1,100 @@
+"""Custom exceptions for Goodmap application."""
+
+import logging
+import uuid as uuid_lib
+
+from pydantic import ValidationError as PydanticValidationError
+
+logger = logging.getLogger(__name__)
+
+
+def _sanitize_uuid(uuid: str | None) -> str:
+    """Validate and sanitize UUID to prevent injection attacks."""
+    if uuid is None:
+        return "<unknown>"
+    try:
+        # Validate UUID format
+        uuid_lib.UUID(uuid)
+        return uuid
+    except (ValueError, AttributeError, TypeError):
+        logger.warning("Invalid UUID format detected", extra={"raw_uuid": repr(uuid)})
+        return "<invalid-uuid>"
+
+
+class GoodmapError(Exception):
+    """Base exception for all Goodmap errors."""
+
+    pass
+
+
+class ValidationError(GoodmapError):
+    """Base validation error."""
+
+    pass
+
+
+class LocationValidationError(ValidationError):
+    """Validation error for location data with enhanced context."""
+
+    def __init__(self, validation_error: PydanticValidationError, uuid: str | None = None):
+        self.uuid = _sanitize_uuid(uuid)
+        self.original_error = validation_error
+        self.validation_errors = validation_error.errors()
+        super().__init__(str(validation_error))
+
+    def __str__(self):
+        # Don't expose error details in string representation
+        if self.uuid and self.uuid not in ("<unknown>", "<invalid-uuid>"):
+            return f"Validation failed for location '{self.uuid}'"
+        return "Validation failed"
+
+
+class NotFoundError(GoodmapError):
+    """Resource not found error."""
+
+    def __init__(self, uuid: str, resource_type: str = "Resource"):
+        self.uuid = _sanitize_uuid(uuid)
+        super().__init__(f"{resource_type} with uuid '{self.uuid}' not found")
+
+
+class LocationNotFoundError(NotFoundError):
+    """Location with specified UUID not found."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Location")
+
+
+class AlreadyExistsError(GoodmapError):
+    """Resource already exists error."""
+
+    def __init__(self, uuid: str, resource_type: str = "Resource"):
+        self.uuid = _sanitize_uuid(uuid)
+        super().__init__(f"{resource_type} with uuid '{self.uuid}' already exists")
+
+
+class LocationAlreadyExistsError(AlreadyExistsError):
+    """Location with specified UUID already exists."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Location")
+
+
+class SuggestionNotFoundError(NotFoundError):
+    """Suggestion with specified UUID not found."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Suggestion")
+
+
+class SuggestionAlreadyExistsError(AlreadyExistsError):
+    """Suggestion with specified UUID already exists."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Suggestion")
+
+
+class ReportNotFoundError(NotFoundError):
+    """Report with specified UUID not found."""
+
+    def __init__(self, uuid: str):
+        super().__init__(uuid, "Report")

{goodmap-1.1.4 → goodmap-1.1.7}/goodmap/templates/map.html

@@ -116,6 +116,7 @@ window.PRIMARY_COLOR = "{{ primary_color }}";
 window.SHOW_SUGGEST_NEW_POINT_BUTTON = {{ feature_flags.SHOW_SUGGEST_NEW_POINT_BUTTON | default(false) | tojson }};
 window.SHOW_SEARCH_BAR = {{ feature_flags.SHOW_SEARCH_BAR | default(false) | tojson }};
 window.USE_LAZY_LOADING = {{ feature_flags.USE_LAZY_LOADING | default(false) | tojson }};
+window.USE_SERVER_SIDE_CLUSTERING = {{ feature_flags.USE_SERVER_SIDE_CLUSTERING | default(false) | tojson }};
 window.SHOW_ACCESSIBILITY_TABLE = {{ feature_flags.SHOW_ACCESSIBILITY_TABLE | default(false) | tojson }};
 window.FEATURE_FLAGS = {{ feature_flags | tojson }};
 </script>

{goodmap-1.1.4 → goodmap-1.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "goodmap"
-version = "1.1.4"
+version = "1.1.7"
 description = "Map engine to serve all the people :)"
 authors = ["Krzysztof Kolodzinski <krzysztof.kolodzinski@problematy.pl>"]
 readme = "README.md"
@@ -22,6 +22,11 @@ aiohttp = "^3.8.4"
 pydantic = "^2.7.1"
 platzky = "^1.0.0"
 deprecation = "^2.1.0"
+numpy = "^2.2.0"
+# Using fork because official PyPI version (0.7.7) has outdated numpy setup hack
+# that breaks with numpy >= 2.0. Fork simply removes the obsolete hack.
+pysupercluster-problematy = "^0.7.8"
+scipy = "^1.15.1"
 sphinx = {version = "^8.0.0", optional = true}
 sphinx-rtd-theme = {version = "^3.0.0", optional = true}
 tomli = {version = "^2.0.0", optional = true}
@@ -51,7 +56,7 @@ interrogate = "^1.7.0"
 platzky = {path = "vendor/platzky", develop = true}
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
+requires = ["poetry-core>=1.0.0", "numpy"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.pyright]