goodmap 0.5.2__tar.gz → 1.0.1__tar.gz

{goodmap-0.5.2 → goodmap-1.0.1}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: goodmap
-Version: 0.5.2
+Version: 1.0.1
 Summary: Map engine to serve all the people :)
+License-File: LICENSE.md
 Author: Krzysztof Kolodzinski
 Author-email: krzysztof.kolodzinski@problematy.pl
 Requires-Python: >=3.10,<4.0
@@ -10,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Babel (>=2.10.3,<3.0.0)
 Requires-Dist: Flask (==3.0.3)
 Requires-Dist: Flask-Babel (>=4.0.0,<5.0.0)
@@ -22,7 +24,7 @@ Requires-Dist: google-cloud-storage (>=2.7.0,<3.0.0)
 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: platzky (>=0.3.6,<0.4.0)
+Requires-Dist: platzky (>=0.4.0,<0.5.0)
 Requires-Dist: pydantic (>=2.7.1,<3.0.0)
 Description-Content-Type: text/markdown
 

{goodmap-0.5.2 → goodmap-1.0.1}/goodmap/core_api.py

@@ -13,76 +13,22 @@ def make_tuple_translation(keys_to_translate):
     return [(x, gettext(x)) for x in keys_to_translate]
 
 
-def paginate_results(items, raw_params, sort_by_default=None):
-    """
-    Apply pagination and sorting to a list of items.
-
-    Args:
-        items: The list of items to paginate
-        raw_params: The query parameters dictionary
-
-    Returns:
-        Tuple of (paginated_items, pagination_metadata)
-    """
-    # Extract pagination parameters
-    try:
-        page = int(raw_params.pop("page", ["1"])[0])
-    except ValueError:
-        page = 1
-
-    per_page_raw = raw_params.pop("per_page", [None])[0]
-    if per_page_raw is None:
-        per_page = 20
-    elif per_page_raw == "all":
-        per_page = None
-    else:
-        try:
-            per_page = max(1, int(per_page_raw))
-        except ValueError:
-            per_page = 20
-
-    sort_by = raw_params.pop("sort_by", [None])[0] or sort_by_default
-    sort_order = raw_params.pop("sort_order", ["asc"])[0].lower()
-
-    def get_sort_key(item):
-        if not sort_by:
-            return None
-
-        value = None
-        if isinstance(item, dict):
-            value = item.get(sort_by)
+def get_or_none(data, *keys):
+    for key in keys:
+        if isinstance(data, dict):
+            data = data.get(key)
         else:
-            value = getattr(item, sort_by, None)
-
-        return (value is not None, value)
-
-    if sort_by:
-        reverse = sort_order == "desc"
-        items.sort(key=get_sort_key, reverse=reverse)
-
-    # Apply pagination
-    total = len(items)
-    if per_page:
-        start = (page - 1) * per_page
-        end = start + per_page
-        page_items = items[start:end]
-        total_pages = (total + per_page - 1) // per_page
-    else:
-        page_items = items
-        total_pages = 1
-        page = 1
-        per_page = total
-
-    return page_items, {
-        "total": total,
-        "page": page,
-        "per_page": per_page,
-        "total_pages": total_pages,
-    }
+            return None
+    return data
 
 
 def core_pages(
-    database, languages: LanguagesMapping, notifier_function, csrf_generator, location_model
+    database,
+    languages: LanguagesMapping,
+    notifier_function,
+    csrf_generator,
+    location_model,
+    feature_flags={},
 ) -> Blueprint:
     core_api_blueprint = Blueprint("api", __name__, url_prefix="/api")
     core_api = Api(core_api_blueprint, doc="/doc", version="0.1")
@@ -193,9 +139,22 @@ def core_pages(
     class Categories(Resource):
         def get(self):
             """Shows all available categories"""
-            all_data = database.get_data()
-            categories = make_tuple_translation(all_data["categories"].keys())
-            return jsonify(categories)
+            raw_categories = database.get_categories()
+            categories = make_tuple_translation(raw_categories)
+
+            if not feature_flags.get("CATEGORIES_HELP", False):
+                return jsonify(categories)
+            else:
+                category_data = database.get_category_data()
+                categories_help = category_data["categories_help"]
+                proper_categories_help = []
+                if categories_help is not None:
+                    for option in categories_help:
+                        proper_categories_help.append(
+                            {option: gettext(f"categories_help_{option}")}
+                        )
+
+            return jsonify({"categories": categories, "categories_help": proper_categories_help})
 
     @core_api.route("/languages")
     class Languages(Resource):
@@ -207,9 +166,27 @@ def core_pages(
     class CategoryTypes(Resource):
         def get(self, category_type):
             """Shows all available types in category"""
-            all_data = database.get_data()
-            local_data = make_tuple_translation(all_data["categories"][category_type])
-            return jsonify(local_data)
+            category_data = database.get_category_data(category_type)
+            local_data = make_tuple_translation(category_data["categories"][category_type])
+
+            categories_options_help = get_or_none(
+                category_data, "categories_options_help", category_type
+            )
+            proper_categories_options_help = []
+            if categories_options_help is not None:
+                for option in categories_options_help:
+                    proper_categories_options_help.append(
+                        {option: gettext(f"categories_options_help_{option}")}
+                    )
+            if not feature_flags.get("CATEGORIES_HELP", False):
+                return jsonify(local_data)
+            else:
+                return jsonify(
+                    {
+                        "categories_options": local_data,
+                        "categories_options_help": proper_categories_options_help,
+                    }
+                )
 
     @core_api.route("/generate-csrf-token")
     class CsrfToken(Resource):
@@ -224,14 +201,11 @@ def core_pages(
             Shows full list of locations, with optional server-side pagination, sorting,
             and filtering.
             """
-            # Raw query params from request
-            raw_params = request.args.to_dict(flat=False)
-            all_locations = database.get_locations(raw_params)
-            page_items, pagination = paginate_results(
-                all_locations, raw_params, sort_by_default="name"
-            )
-            items = [x.model_dump() for x in page_items]
-            return jsonify({"items": items, **pagination})
+            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 post(self):
             """
@@ -284,10 +258,9 @@ def core_pages(
             List location suggestions, with optional server-side pagination, sorting,
             and filtering by status.
             """
-            raw_params = request.args.to_dict(flat=False)
-            suggestions = database.get_suggestions(raw_params)
-            page_items, pagination = paginate_results(suggestions, raw_params)
-            return jsonify({"items": page_items, **pagination})
+            query_params = request.args.to_dict(flat=False)
+            result = database.get_suggestions_paginated(query_params)
+            return jsonify(result)
 
     @core_api.route("/admin/suggestions/<suggestion_id>")
     class AdminManageSuggestion(Resource):
@@ -320,10 +293,9 @@ def core_pages(
             List location reports, with optional server-side pagination, sorting,
             and filtering by status/priority.
             """
-            raw_params = request.args.to_dict(flat=False)
-            reports = database.get_reports(raw_params)
-            page_items, pagination = paginate_results(reports, raw_params)
-            return jsonify({"items": page_items, **pagination})
+            query_params = request.args.to_dict(flat=False)
+            result = database.get_reports_paginated(query_params)
+            return jsonify(result)
 
     @core_api.route("/admin/reports/<report_id>")
     class AdminManageReport(Resource):