goodmap 1.2.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

goodmap/admin_api.py

@@ -0,0 +1,251 @@
+import logging
+import uuid
+from typing import Any, Type
+
+from flask import Blueprint, jsonify, make_response, request
+from spectree import Response, SpecTree
+from werkzeug.exceptions import BadRequest
+
+from goodmap.api_models import (
+    ErrorResponse,
+    ReportUpdateRequest,
+    SuggestionStatusRequest,
+)
+from goodmap.exceptions import (
+    LocationAlreadyExistsError,
+    LocationNotFoundError,
+    LocationValidationError,
+    ReportNotFoundError,
+)
+
+# Error message constants
+ERROR_INVALID_REQUEST_DATA = "Invalid request data"
+ERROR_INVALID_LOCATION_DATA = "Invalid location data"
+ERROR_INTERNAL_ERROR = "An internal error occurred"
+ERROR_LOCATION_NOT_FOUND = "Location not found"
+
+logger = logging.getLogger(__name__)
+
+
+def _clean_model_name(model: Type[Any]) -> str:
+    return model.__name__
+
+
+def _handle_location_validation_error(e: LocationValidationError):
+    """Handle LocationValidationError and return appropriate response."""
+    logger.warning(
+        "Location validation failed",
+        extra={"uuid": e.uuid, "errors": e.validation_errors},
+    )
+    return make_response(jsonify({"message": ERROR_INVALID_LOCATION_DATA}), 400)
+
+
+def _get_locations_handler(database):
+    """Handle GET /locations request."""
+    query_params = request.args.to_dict(flat=False)
+    if "sort_by" not in query_params:
+        query_params["sort_by"] = ["name"]
+    result = database.get_locations_paginated(query_params)
+    return jsonify(result)
+
+
+def _create_location_handler(database, location_model):
+    """Handle POST /locations request."""
+    location_data = request.get_json()
+    if location_data is None:
+        logger.warning("Empty or invalid JSON in admin create location endpoint")
+        return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
+    # TODO: Catch pydantic.ValidationError separately to return 400 instead of 500
+    try:
+        location_data.update({"uuid": str(uuid.uuid4())})
+        location = location_model.model_validate(location_data)
+        database.add_location(location.model_dump())
+    except LocationValidationError as e:
+        return _handle_location_validation_error(e)
+    except Exception:
+        logger.error("Error creating location", exc_info=True)
+        return make_response(jsonify({"message": ERROR_INTERNAL_ERROR}), 500)
+    return jsonify(location.model_dump())
+
+
+def _update_location_handler(database, location_model, location_id):
+    """Handle PUT /locations/<location_id> request."""
+    location_data = request.get_json()
+    if location_data is None:
+        logger.warning("Empty or invalid JSON in admin update location endpoint")
+        return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
+    # TODO: Catch pydantic.ValidationError separately to return 400 instead of 500
+    try:
+        location_data.update({"uuid": location_id})
+        location = location_model.model_validate(location_data)
+        database.update_location(location_id, location.model_dump())
+    except LocationValidationError as e:
+        return _handle_location_validation_error(e)
+    except LocationNotFoundError as e:
+        logger.info("Location not found for update", extra={"uuid": e.uuid})
+        return make_response(jsonify({"message": ERROR_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_location_handler(database, location_id):
+    """Handle DELETE /locations/<location_id> request."""
+    try:
+        database.delete_location(location_id)
+    except LocationNotFoundError as e:
+        logger.info("Location not found for deletion", extra={"uuid": e.uuid})
+        return make_response(jsonify({"message": ERROR_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
+
+
+def _get_suggestions_handler(database):
+    """Handle GET /suggestions request."""
+    query_params = request.args.to_dict(flat=False)
+    result = database.get_suggestions_paginated(query_params)
+    return jsonify(result)
+
+
+def _update_suggestion_handler(database, suggestion_id):
+    """Handle PUT /suggestions/<suggestion_id> request."""
+    try:
+        data = request.get_json()
+        status = data["status"]  # Validated by Spectree
+        suggestion = database.get_suggestion(suggestion_id)
+        if not suggestion:
+            return make_response(jsonify({"message": "Suggestion not found"}), 404)
+        if suggestion.get("status") != "pending":
+            return make_response(jsonify({"message": "Suggestion already processed"}), 409)
+        if status == "accepted":
+            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 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))
+
+
+def _get_reports_handler(database):
+    """Handle GET /reports request."""
+    query_params = request.args.to_dict(flat=False)
+    result = database.get_reports_paginated(query_params)
+    return jsonify(result)
+
+
+def _update_report_handler(database, report_id):
+    """Handle PUT /reports/<report_id> request."""
+    try:
+        data = request.get_json()
+        status = data.get("status")
+        priority = data.get("priority")
+        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 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))
+
+
+def admin_pages(database, location_model) -> Blueprint:
+    """Create and return the admin API blueprint.
+
+    Args:
+        database: Database instance for data operations
+        location_model: Pydantic model for location validation
+
+    Returns:
+        Blueprint: Flask blueprint with all admin endpoints
+    """
+    admin_api_blueprint = Blueprint("admin_api", __name__, url_prefix="/api/admin")
+
+    spec = SpecTree(
+        "flask",
+        title="Goodmap Admin API",
+        version="0.1",
+        path="doc",
+        annotations=True,
+        naming_strategy=_clean_model_name,
+    )
+
+    @admin_api_blueprint.route("/locations", methods=["GET"])
+    @spec.validate()
+    def admin_get_locations():
+        """Get paginated list of all locations for admin panel."""
+        return _get_locations_handler(database)
+
+    @admin_api_blueprint.route("/locations", methods=["POST"])
+    @spec.validate(resp=Response(HTTP_400=ErrorResponse))
+    def admin_create_location():
+        """Create a new location (admin only)."""
+        return _create_location_handler(database, location_model)
+
+    @admin_api_blueprint.route("/locations/<location_id>", methods=["PUT"])
+    @spec.validate(resp=Response(HTTP_400=ErrorResponse, HTTP_404=ErrorResponse))
+    def admin_update_location(location_id):
+        """Update an existing location (admin only)."""
+        return _update_location_handler(database, location_model, location_id)
+
+    @admin_api_blueprint.route("/locations/<location_id>", methods=["DELETE"])
+    @spec.validate(resp=Response(HTTP_404=ErrorResponse))
+    def admin_delete_location(location_id):
+        """Delete a location (admin only)."""
+        return _delete_location_handler(database, location_id)
+
+    @admin_api_blueprint.route("/suggestions", methods=["GET"])
+    @spec.validate()
+    def admin_get_suggestions():
+        """Get paginated list of location suggestions (admin only)."""
+        return _get_suggestions_handler(database)
+
+    @admin_api_blueprint.route("/suggestions/<suggestion_id>", methods=["PUT"])
+    @spec.validate(
+        json=SuggestionStatusRequest,
+        resp=Response(HTTP_400=ErrorResponse, HTTP_404=ErrorResponse, HTTP_409=ErrorResponse),
+    )
+    def admin_update_suggestion(suggestion_id):
+        """Accept or reject a location suggestion (admin only)."""
+        return _update_suggestion_handler(database, suggestion_id)
+
+    @admin_api_blueprint.route("/reports", methods=["GET"])
+    @spec.validate()
+    def admin_get_reports():
+        """Get paginated list of location reports (admin only)."""
+        return _get_reports_handler(database)
+
+    @admin_api_blueprint.route("/reports/<report_id>", methods=["PUT"])
+    @spec.validate(
+        json=ReportUpdateRequest,
+        resp=Response(HTTP_400=ErrorResponse, HTTP_404=ErrorResponse),
+    )
+    def admin_update_report(report_id):
+        """Update a report's status and/or priority (admin only)."""
+        return _update_report_handler(database, report_id)
+
+    # Register Spectree with blueprint after all routes are defined
+    spec.register(admin_api_blueprint)
+
+    return admin_api_blueprint

goodmap/core_api.py

@@ -9,28 +9,20 @@ from flask import Blueprint, jsonify, make_response, request
 from flask_babel import gettext
 from platzky.config import LanguagesMapping
 from spectree import Response, SpecTree
-from werkzeug.exceptions import BadRequest
 
 from goodmap.api_models import (
     CSRFTokenResponse,
     ErrorResponse,
     LocationReportRequest,
     LocationReportResponse,
-    ReportUpdateRequest,
     SuccessResponse,
-    SuggestionStatusRequest,
     VersionResponse,
 )
 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.exceptions import LocationValidationError
 from goodmap.formatter import prepare_pin
 from goodmap.json_security import (
     MAX_JSON_DEPTH_LOCATION,
@@ -48,7 +40,6 @@ 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"
 ERROR_LOCATION_NOT_FOUND = "Location not found"
 
 logger = logging.getLogger(__name__)
@@ -370,6 +361,48 @@ def core_pages(
 
         return jsonify({"categories": categories, "categories_help": proper_categories_help})
 
+    @core_api_blueprint.route("/categories-full", methods=["GET"])
+    @spec.validate()
+    def get_categories_full():
+        """Get all categories with their subcategory options in a single request.
+
+        Returns combined category data to reduce API calls for filter panel loading.
+        This endpoint eliminates the need for multiple sequential requests.
+        """
+        categories_data = database.get_category_data()
+        result = []
+
+        categories_options_help = categories_data.get("categories_options_help", {})
+
+        for key, options in categories_data["categories"].items():
+            category_entry = {
+                "key": key,
+                "name": gettext(key),
+                "options": make_tuple_translation(options),
+            }
+
+            if feature_flags.get("CATEGORIES_HELP", False):
+                option_help_list = categories_options_help.get(key, [])
+                proper_options_help = []
+                for option in option_help_list:
+                    proper_options_help.append(
+                        {option: gettext(f"categories_options_help_{option}")}
+                    )
+                category_entry["options_help"] = proper_options_help
+
+            result.append(category_entry)
+
+        response = {"categories": result}
+
+        if feature_flags.get("CATEGORIES_HELP", False):
+            categories_help = categories_data.get("categories_help", [])
+            proper_categories_help = []
+            for option in categories_help:
+                proper_categories_help.append({option: gettext(f"categories_help_{option}")})
+            response["categories_help"] = proper_categories_help
+
+        return jsonify(response)
+
     @core_api_blueprint.route("/languages", methods=["GET"])
     @spec.validate()
     def get_languages():
@@ -409,187 +442,6 @@ def core_pages(
                 }
             )
 
-    @core_api_blueprint.route("/admin/locations", methods=["GET"])
-    @spec.validate()
-    def admin_get_locations():
-        """Get paginated list of all locations for admin panel.
-
-        Supports server-side pagination, sorting, and filtering.
-        Defaults to sorting by name.
-        """
-        query_params = request.args.to_dict(flat=False)
-        if "sort_by" not in query_params:
-            query_params["sort_by"] = ["name"]
-        result = database.get_locations_paginated(query_params)
-        return jsonify(result)
-
-    @core_api_blueprint.route("/admin/locations", methods=["POST"])
-    @spec.validate(resp=Response(HTTP_400=ErrorResponse))
-    def admin_create_location():
-        """Create a new location (admin only).
-
-        Validates location data using Pydantic model and
-        adds it to the database.
-        """
-        location_data = request.get_json()
-        if location_data is None:
-            logger.warning("Empty or invalid JSON in admin create location endpoint")
-            return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
-        try:
-            location_data.update({"uuid": str(uuid.uuid4())})
-            location = location_model.model_validate(location_data)
-            database.add_location(location.model_dump())
-        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_blueprint.route("/admin/locations/<location_id>", methods=["PUT"])
-    @spec.validate(resp=Response(HTTP_400=ErrorResponse, HTTP_404=ErrorResponse))
-    def admin_update_location(location_id):
-        """Update an existing location (admin only).
-
-        Validates updated location data and persists changes.
-        Returns 404 if location not found.
-        """
-        location_data = request.get_json()
-        if location_data is None:
-            logger.warning("Empty or invalid JSON in admin update location endpoint")
-            return make_response(jsonify({"message": ERROR_INVALID_REQUEST_DATA}), 400)
-        try:
-            location_data.update({"uuid": location_id})
-            location = location_model.model_validate(location_data)
-            database.update_location(location_id, location.model_dump())
-        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": ERROR_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())
-
-    @core_api_blueprint.route("/admin/locations/<location_id>", methods=["DELETE"])
-    @spec.validate(resp=Response(HTTP_404=ErrorResponse))
-    def admin_delete_location(location_id):
-        """Delete a location (admin only).
-
-        Permanently removes location from database.
-        Returns 204 on success, 404 if not found.
-        """
-        try:
-            database.delete_location(location_id)
-        except LocationNotFoundError as e:
-            logger.info("Location not found for deletion", extra={"uuid": e.uuid})
-            return make_response(jsonify({"message": ERROR_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_blueprint.route("/admin/suggestions", methods=["GET"])
-    @spec.validate()
-    def admin_get_suggestions():
-        """Get paginated list of location suggestions (admin only).
-
-        Supports server-side pagination, sorting, and filtering by status.
-        """
-        query_params = request.args.to_dict(flat=False)
-        result = database.get_suggestions_paginated(query_params)
-        return jsonify(result)
-
-    @core_api_blueprint.route("/admin/suggestions/<suggestion_id>", methods=["PUT"])
-    @spec.validate(
-        json=SuggestionStatusRequest,
-        resp=Response(HTTP_400=ErrorResponse, HTTP_404=ErrorResponse, HTTP_409=ErrorResponse),
-    )
-    def admin_update_suggestion(suggestion_id):
-        """Accept or reject a location suggestion (admin only).
-
-        Accepted suggestions are added to locations database.
-        Rejected suggestions are marked as rejected.
-        """
-        try:
-            data = request.get_json()
-            status = data["status"]  # Validated by Spectree
-            suggestion = database.get_suggestion(suggestion_id)
-            if not suggestion:
-                return make_response(jsonify({"message": "Suggestion not found"}), 404)
-            if suggestion.get("status") != "pending":
-                return make_response(jsonify({"message": "Suggestion already processed"}), 409)
-            if status == "accepted":
-                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 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_blueprint.route("/admin/reports", methods=["GET"])
-    @spec.validate()
-    def admin_get_reports():
-        """Get paginated list of location reports (admin only).
-
-        Supports server-side pagination, sorting,
-        and filtering by status/priority.
-        """
-        query_params = request.args.to_dict(flat=False)
-        result = database.get_reports_paginated(query_params)
-        return jsonify(result)
-
-    @core_api_blueprint.route("/admin/reports/<report_id>", methods=["PUT"])
-    @spec.validate(
-        json=ReportUpdateRequest,
-        resp=Response(HTTP_400=ErrorResponse, HTTP_404=ErrorResponse),
-    )
-    def admin_update_report(report_id):
-        """Update a report's status and/or priority (admin only).
-
-        Allows changing report status to resolved/rejected
-        and adjusting priority level.
-        """
-        try:
-            data = request.get_json()
-            status = data.get("status")
-            priority = data.get("priority")
-            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 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))
-
     # Register Spectree with blueprint after all routes are defined
     spec.register(core_api_blueprint)
 

goodmap/goodmap.py

@@ -8,6 +8,7 @@ from platzky import platzky
 from platzky.config import languages_dict
 from platzky.models import CmsModule
 
+from goodmap.admin_api import admin_pages
 from goodmap.config import GoodmapConfig
 from goodmap.core_api import core_pages
 from goodmap.data_models.location import create_location_model
@@ -76,7 +77,7 @@ def create_app_from_config(config: GoodmapConfig) -> platzky.Engine:
 
         # Use the extended db method directly (already bound by extend_db_with_goodmap_queries)
         try:
-            category_data = app.db.get_category_data()
+            category_data = app.db.get_category_data()  # type: ignore[attr-defined]
             categories = category_data.get("categories", {})
         except (KeyError, AttributeError):
             # Handle case where categories don't exist in the data
@@ -105,6 +106,7 @@ def create_app_from_config(config: GoodmapConfig) -> platzky.Engine:
         feature_flags=config.feature_flags,
     )
     app.register_blueprint(cp)
+
     goodmap = Blueprint("goodmap", __name__, url_prefix="/", template_folder="templates")
 
     @goodmap.route("/")
@@ -119,7 +121,7 @@ def create_app_from_config(config: GoodmapConfig) -> platzky.Engine:
         """
         # Prepare location schema for frontend dynamic forms
         # Include full schema from Pydantic model for better type information
-        category_data = app.db.get_category_data()
+        category_data = app.db.get_category_data()  # type: ignore[attr-defined]
         categories = category_data.get("categories", {})
 
         # Get full JSON schema from Pydantic model
@@ -152,10 +154,14 @@ def create_app_from_config(config: GoodmapConfig) -> platzky.Engine:
 
         Requires user to be logged in (redirects to /admin if not).
         Provides admin panel for managing locations, suggestions, and reports.
+        Only available when ENABLE_ADMIN_PANEL feature flag is enabled.
 
         Returns:
             Rendered goodmap-admin.html template or redirect to login
         """
+        if not is_feature_enabled(config, "ENABLE_ADMIN_PANEL"):
+            return redirect("/")
+
         user = session.get("user", None)
         if not user:
             return redirect("/admin")
@@ -171,14 +177,19 @@ def create_app_from_config(config: GoodmapConfig) -> platzky.Engine:
         )
 
     app.register_blueprint(goodmap)
-    goodmap_cms_modules = CmsModule.model_validate(
-        {
-            "name": "Map admin panel",
-            "description": "Admin panel for managing map data",
-            "slug": "goodmap-admin",
-            "template": "goodmap-admin.html",
-        }
-    )
-    app.add_cms_module(goodmap_cms_modules)
+
+    if is_feature_enabled(config, "ENABLE_ADMIN_PANEL"):
+        admin_bp = admin_pages(app.db, location_model)
+        app.register_blueprint(admin_bp)
+
+        goodmap_cms_modules = CmsModule.model_validate(
+            {
+                "name": "Map admin panel",
+                "description": "Admin panel for managing map data",
+                "slug": "goodmap-admin",
+                "template": "goodmap-admin.html",
+            }
+        )
+        app.add_cms_module(goodmap_cms_modules)
 
     return app

{goodmap-1.2.0.dist-info → goodmap-1.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: goodmap
-Version: 1.2.0
+Version: 1.3.1
 Summary: Map engine to serve all the people :)
 Author: Krzysztof Kolodzinski
 Author-email: krzysztof.kolodzinski@problematy.pl

{goodmap-1.2.0.dist-info → goodmap-1.3.1.dist-info}/RECORD

@@ -1,19 +1,20 @@
 goodmap/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+goodmap/admin_api.py,sha256=dt0R_ZVREDy06RtnE-fTYYezU4NaZe5CBl2KGJx87Jw,10146
 goodmap/api_models.py,sha256=Bv4OTGuckNneCrxaQ1Y_PMeu7YFLvGUqU2EorvDlUjY,3438
 goodmap/clustering.py,sha256=ULB-fPNOUDblgpBK4vzuo0o2yqIcvG84F3R6Za2X_l4,2905
 goodmap/config.py,sha256=CsmC1zuvVab90VW50dtARHbFJpy2vfsIfbque8Zgc-U,1313
 goodmap/core.py,sha256=AgdGLfeJvL7TlTX893NR2YdCS8EuXx93Gx6ndvWws7s,2673
-goodmap/core_api.py,sha256=KuCj--d058t46uGrpapyuIQfVrzHp9TR2qLFzSR78SU,25097
+goodmap/core_api.py,sha256=Av-kim3NjkHQD4B139O3IyXGl7PABzkyVui1hmkiv5I,18089
 goodmap/data_models/location.py,sha256=_I27R06ovEL9ctv_SZ3yoLL-RwmyE3VDsVOG4a89q50,6798
 goodmap/data_validator.py,sha256=lBmVAPxvSmEOdUGeVYSjUvVVmKfPyq4CWoHfczTtEMM,4090
 goodmap/db.py,sha256=TcqYGbK5yk6S735Si1AzjNqcbB1nsd9pFGOy5qN9Vec,46589
 goodmap/exceptions.py,sha256=jkFAUoc5LHk8iPjxHxbcRp8W6qFCSEA25A8XaSwxwyo,2906
 goodmap/formatter.py,sha256=4rqcg9A9Y9opAi7eb8kMDdUC03M3uzZgCxx29cvvIag,1403
-goodmap/goodmap.py,sha256=0DrebQhbdYSxf7Aac4tZ-z0pkZs-FClTT89NNHc0W0Y,6808
+goodmap/goodmap.py,sha256=uWjnOt00gWwAFydDw6EMD-EgAmlp-6ZSEdhSevDUBKg,7273
 goodmap/json_security.py,sha256=EHAxNlb16AVwphgf4F7yObtMZpbR9M538dwn_STRcMo,3275
 goodmap/templates/goodmap-admin.html,sha256=LSiOZ9-n29CnlfVNwdgmXwT7Xe7t5gvGh1xSrFGqOIY,35669
 goodmap/templates/map.html,sha256=Uk7FFrZwvHZvG0DDaQrGW5ZrIMD21XrJzMub76uIlAg,4348
-goodmap-1.2.0.dist-info/LICENSE.md,sha256=nkCQOR7uheLRvHRfXmwx9LhBnMcPeBU9d4ebLojDiQU,1067
-goodmap-1.2.0.dist-info/METADATA,sha256=qpiCIiQvKk6OxOQ8zbNwKjvBBiQtti85ALIn5pdP7hI,5798
-goodmap-1.2.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-goodmap-1.2.0.dist-info/RECORD,,
+goodmap-1.3.1.dist-info/LICENSE.md,sha256=nkCQOR7uheLRvHRfXmwx9LhBnMcPeBU9d4ebLojDiQU,1067
+goodmap-1.3.1.dist-info/METADATA,sha256=bdXqFG7LTW-rAtkmXCKgu5pq9KINVOvRAUsaCuHHEHQ,5798
+goodmap-1.3.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+goodmap-1.3.1.dist-info/RECORD,,