goodmap 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

goodmap/core.py

@@ -1,3 +1,6 @@
+# TODO move filtering to db site
+
+
 def does_fulfill_requirement(entry, requirements):
     matches = []
     for category, values in requirements:

goodmap/core_api.py

@@ -1,14 +1,14 @@
 import importlib.metadata
+import uuid
 
+import deprecation
 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 goodmap.data_models.location import Location
-
-from .core import get_queried_data
-from .formatter import prepare_pin
+from goodmap.core import get_queried_data
+from goodmap.formatter import prepare_pin
 
 
 def make_tuple_translation(keys_to_translate):
@@ -16,7 +16,7 @@ def make_tuple_translation(keys_to_translate):
 
 
 def core_pages(
-    database, languages: LanguagesMapping, notifier_function, csrf_generator
+    database, languages: LanguagesMapping, notifier_function, csrf_generator, location_model
 ) -> Blueprint:
     core_api_blueprint = Blueprint("api", __name__, url_prefix="/api")
     core_api = Api(core_api_blueprint, doc="/doc", version="0.1")
@@ -29,26 +29,28 @@ def core_pages(
         },
     )
 
-    location_suggest_model = core_api.model(
+    # TODO get this from Location pydantic model
+    suggested_location_model = core_api.model(
         "LocationSuggestion",
         {
-            "name": fields.String(required=True, description="Organization name"),
-            "coordinates": fields.String(required=True, description="Location of the suggestion"),
+            "name": fields.String(required=False, description="Organization name"),
+            "position": fields.String(required=True, description="Location of the suggestion"),
             "photo": fields.String(required=False, description="Photo of the location"),
         },
     )
 
     @core_api.route("/suggest-new-point")
     class NewLocation(Resource):
-        @core_api.expect(location_suggest_model)
+        @core_api.expect(suggested_location_model)
         def post(self):
             """Suggest new location"""
             try:
-                location_suggest = request.get_json()
-                location = Location.model_validate(location_suggest)
+                suggested_location = request.get_json()
+                suggested_location.update({"uuid": str(uuid.uuid4())})
+                location = location_model.model_validate(suggested_location)
                 message = (
-                    f"A new location has been suggested: '{location.name}' "
-                    f"at position: {location.coordinates}"
+                    f"A new location has been suggested under uuid: '{location.uuid}' "
+                    f"at position: {location.position}"
                 )
                 notifier_function(message)
             except ValueError as e:
@@ -75,6 +77,12 @@ def core_pages(
 
     @core_api.route("/data")
     class Data(Resource):
+        @deprecation.deprecated(
+            deprecated_in="0.4.1",
+            removed_in="0.5.0",
+            current_version=importlib.metadata.version("goodmap"),
+            details="Use /locations or /location/<point_id> instead",
+        )
         def get(self):
             """
             Shows all data filtered by query parameters
@@ -90,6 +98,34 @@ def core_pages(
             formatted_data = [prepare_pin(x, visible_data, meta_data) for x in queried_data]
             return jsonify(formatted_data)
 
+    @core_api.route("/locations")
+    class GetLocations(Resource):
+        def get(self):
+            """
+            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])
+
+    @core_api.route("/location/<location_id>")
+    class GetLocation(Resource):
+        def get(self, location_id):
+            """
+            Shows a single location with all data
+            """
+            location = database.get_location(location_id)
+
+            # TODO getting visible_data and meta_data should be taken from db methods
+            #    e.g. db.get_visible_data() and db.get_meta_data()
+            #    visible_data and meta_data should be models
+            all_data = database.get_data()
+            visible_data = all_data["visible_data"]
+            meta_data = all_data["meta_data"]
+
+            formatted_data = prepare_pin(location.model_dump(), visible_data, meta_data)
+            return jsonify(formatted_data)
+
     @core_api.route("/version")
     class Version(Resource):
         def get(self):

goodmap/data_models/location.py

@@ -1,15 +1,37 @@
-from pydantic import BaseModel, field_validator
+from typing import Any, Type
 
+from pydantic import BaseModel, Field, create_model, field_validator
 
-class Location(BaseModel):
-    name: str
-    coordinates: tuple[float, float]
 
-    @field_validator("coordinates")
+class LocationBase(BaseModel, extra="allow"):
+    position: tuple[float, float]
+    uuid: str
+
+    @field_validator("position")
     @classmethod
-    def coordinates_must_be_valid(cls, v):
+    def position_must_be_valid(cls, v):
         if v[0] < -90 or v[0] > 90:
             raise ValueError("latitude must be in range -90 to 90")
         if v[1] < -180 or v[1] > 180:
             raise ValueError("longitude must be in range -180 to 180")
         return v
+
+    def basic_info(self):
+        return {"uuid": self.uuid, "position": self.position}
+
+
+def create_location_model(obligatory_fields: list[tuple[str, Type[Any]]]) -> Type[BaseModel]:
+    fields = {
+        field_name: (field_type, Field(...)) for (field_name, field_type) in obligatory_fields
+    }
+
+    return create_model(
+        "Location",
+        __config__=None,
+        __doc__=None,
+        __module__="Location",
+        __validators__=None,
+        __base__=LocationBase,
+        __cls_kwargs__=None,
+        **fields,
+    )

goodmap/data_validator.py

@@ -76,7 +76,7 @@ def report_data_violations_from_json(json_database):
     map_data = json_database["map"]
     datapoints = map_data["data"]
     categories = map_data["categories"]
-    obligatory_fields = map_data["obligatory_fields"]
+    obligatory_fields = map_data["location_obligatory_fields"]
 
     data_violations = []
 

goodmap/db.py

@@ -1,12 +1,37 @@
 import json
+from functools import partial
+
+from goodmap.core import get_queried_data
 
 # TODO file is temporary solution to be compatible with old, static code,
 #  it should be replaced with dynamic solution
 
 
+# ------------------------------------------------
+# get_location_obligatory_fields
+
+
+def json_db_get_location_obligatory_fields(db):
+    return db.data["location_obligatory_fields"]
+
+
+def json_file_db_get_location_obligatory_fields(db):
+    with open(db.data_file_path, "r") as file:
+        return json.load(file)["map"]["location_obligatory_fields"]
+
+
+def google_json_db_get_location_obligatory_fields(db):
+    return json.loads(db.blob.download_as_text(client=None))["map"]["location_obligatory_fields"]
+
+
+def get_location_obligatory_fields(db):
+    return globals()[f"{db.module_name}_get_location_obligatory_fields"](db)
+
+
+# ------------------------------------------------
+# get_data
 def google_json_db_get_data(self):
-    raw_data = self.blob.download_as_text(client=None)
-    return json.loads(raw_data)["map"]
+    return json.loads(self.blob.download_as_text(client=None))["map"]
 
 
 def json_file_db_get_data(self):
@@ -19,5 +44,73 @@ def json_db_get_data(self):
 
 
 def get_data(db):
-    function_name = f"{db.module_name}_get_data"
-    return globals()[function_name]
+    return globals()[f"{db.module_name}_get_data"]
+
+
+# ------------------------------------------------
+# get_location
+
+
+def get_location_from_raw_data(raw_data, uuid, location_model):
+    point = next((point for point in raw_data["data"] if point["uuid"] == uuid), None)
+    return location_model.model_validate(point) if point else None
+
+
+def google_json_db_get_location(self, uuid, location_model):
+    return get_location_from_raw_data(
+        json.loads(self.blob.download_as_text(client=None))["map"], uuid, location_model
+    )
+
+
+def json_file_db_get_location(self, uuid, location_model):
+    with open(self.data_file_path, "r") as file:
+        point = get_location_from_raw_data(json.load(file)["map"], uuid, location_model)
+        return point
+
+
+def json_db_get_location(self, uuid, location_model):
+    return get_location_from_raw_data(self.data, uuid, location_model)
+
+
+def get_location(db, location_model):
+    return partial(globals()[f"{db.module_name}_get_location"], location_model=location_model)
+
+
+# ------------------------------------------------
+# get_locations
+
+
+def get_locations_list_from_raw_data(map_data, query, location_model):
+    filtered_locations = get_queried_data(map_data["data"], map_data["categories"], query)
+    return [location_model.model_validate(point) for point in filtered_locations]
+
+
+def google_json_db_get_locations(self, query, location_model):
+    return get_locations_list_from_raw_data(
+        json.loads(self.blob.download_as_text(client=None))["map"], query, location_model
+    )
+
+
+def json_file_db_get_locations(self, query, location_model):
+    with open(self.data_file_path, "r") as file:
+        return get_locations_list_from_raw_data(json.load(file)["map"], query, location_model)
+
+
+def json_db_get_locations(self, query, location_model):
+    return get_locations_list_from_raw_data(self.data, query, location_model)
+
+
+def get_locations(db, location_model):
+    return partial(globals()[f"{db.module_name}_get_locations"], location_model=location_model)
+
+
+# TODO extension function should be replaced with simple extend which would take a db plugin
+# it could look like that:
+#   `db.extend(goodmap_db_plugin)` in plugin all those functions would be organized
+
+
+def extend_db_with_goodmap_queries(db, location_model):
+    db.extend("get_data", get_data(db))
+    db.extend("get_locations", get_locations(db, location_model))
+    db.extend("get_location", get_location(db, location_model))
+    return db

goodmap/goodmap.py

@@ -1,10 +1,13 @@
+import os
+
 from flask import Blueprint, render_template
 from flask_wtf.csrf import CSRFProtect, generate_csrf
 from platzky import platzky
 from platzky.config import Config, languages_dict
 
-from .core_api import core_pages
-from .db import get_data
+from goodmap.core_api import core_pages
+from goodmap.data_models.location import create_location_model
+from goodmap.db import extend_db_with_goodmap_queries, get_location_obligatory_fields
 
 
 def create_app(config_path: str) -> platzky.Engine:
@@ -12,19 +15,38 @@ def create_app(config_path: str) -> platzky.Engine:
     return create_app_from_config(config)
 
 
+# TODO Checking if there is a feature flag secition should be part of configs logic not client app
+def is_feature_enabled(config: Config, feature: str) -> bool:
+    return config.feature_flags.get(feature, False) if config.feature_flags else False
+
+
 def create_app_from_config(config: Config) -> platzky.Engine:
+    directory = os.path.dirname(os.path.realpath(__file__))
+
+    locale_dir = os.path.join(directory, "locale")
+    config.translation_directories.append(locale_dir)
     app = platzky.create_app_from_config(config)
 
-    app.db.extend("get_data", get_data(app.db))
+    if is_feature_enabled(config, "USE_LAZY_LOADING"):
+        location_obligatory_fields = get_location_obligatory_fields(app.db)
+    else:
+        location_obligatory_fields = []
+
+    location_model = create_location_model(location_obligatory_fields)
+
+    app.db = extend_db_with_goodmap_queries(app.db, location_model)
+
     CSRFProtect(app)
 
-    cp = core_pages(app.db, languages_dict(config.languages), app.notify, generate_csrf)
+    cp = core_pages(
+        app.db, languages_dict(config.languages), app.notify, generate_csrf, location_model
+    )
     app.register_blueprint(cp)
     goodmap = Blueprint("goodmap", __name__, url_prefix="/", template_folder="templates")
 
     @goodmap.route("/")
     def index():
-        return render_template("map.html")
+        return render_template("map.html", feature_flags=config.feature_flags)
 
     app.register_blueprint(goodmap)
     return app

goodmap/templates/map.html

@@ -35,12 +35,11 @@
     </style>
 
 <div id="loadingPopup" class="loading-popup">
-    Loading...
+  {{ gettext('Loading') }}...
 </div>
 
 <div id="map" class="map h-100 w-100"></div>
 
-
 <script type="text/javascript">
 
 (function() {
@@ -113,6 +112,10 @@ function hideLoading() {
 window.APP_LANG = "{{ current_language }}";
 window.SECONDARY_COLOR = "{{ secondary_color }}";
 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 }};
 </script>
 <script src="/static/map.js"></script>
 {% endblock %}

{goodmap-0.4.0.dist-info → goodmap-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: goodmap
-Version: 0.4.0
+Version: 0.4.2
 Summary: Map engine to serve all the people :)
 Author: Krzysztof Kolodzinski
 Author-email: krzysztof.kolodzinski@problematy.pl
@@ -16,6 +16,7 @@ Requires-Dist: Flask-Babel (>=4.0.0,<5.0.0)
 Requires-Dist: Flask-WTF (>=1.2.1,<2.0.0)
 Requires-Dist: PyYAML (>=6.0,<7.0)
 Requires-Dist: aiohttp (>=3.8.4,<4.0.0)
+Requires-Dist: deprecation (>=2.1.0,<3.0.0)
 Requires-Dist: flask-restx (>=1.3.0,<2.0.0)
 Requires-Dist: google-cloud-storage (>=2.7.0,<3.0.0)
 Requires-Dist: gql (>=3.4.0,<4.0.0)
@@ -34,6 +35,19 @@ Map engine to serve all the people ;)
 
 ## Setup
 
+#### 0. Clone the repo
+```
+git clone --recursive
+```
+Remember, everytime you want to pull the newest changes, run:
+```
+git pull
+git submodule update
+```
+because `goodmap` contains a submodule.
+
+#TODO remove all submodule connected instructions after removing platzky submodule (see #157)
+
 #### 1. Use python 3.10
 If you have a different version of Python on your system, install python 3.10 alongside. For that, you can use [`pyenv`](https://github.com/pyenv/pyenv). Follow the [documentation](https://github.com/pyenv/pyenv?tab=readme-ov-file#installation). Useful commands: `pyenv help <command>`, `pyenv install`, `pyenv shell`, `pyenv versions`.
 
@@ -96,7 +110,7 @@ TODO: `obligatory_fields` is a new subsection, start using it in the actual appl
 ```
 - `meta-data` - some special data like 
 ```
-"UUID"
+"uuid"
 ```
 
 You can define the fields in all these subsections. Besides these types of fields, there is no restriction on the number of fields a datapoint can have.

goodmap-0.4.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+goodmap/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+goodmap/core.py,sha256=hOTHrDRzbqkfSeKAoD01lzSoY4W8JwupXlJTwTzcvAU,586
+goodmap/core_api.py,sha256=R7c6NywWYyudIOzekbY_Xa2izszIFv-5YFEe5BrkJFw,6476
+goodmap/data_models/location.py,sha256=ESR4Z_zINIjldJKhlXImMaQrdtUPJBQc6SatpPPJyNQ,1054
+goodmap/data_validator.py,sha256=e_PCc2CTgiEBK6inF_HDX5mb5R8poh3KkcbhyrLrFVA,4086
+goodmap/db.py,sha256=AJHUP3n29BRjgt6GoGnPtxLNg5TL-KSJhtSZtsZKmGM,3665
+goodmap/formatter.py,sha256=VlUHcK1HtM_IEU0VE3S5TOkZLVheMdakvUeW2tCKdq0,783
+goodmap/goodmap.py,sha256=cPTTyGqajuza3RDlfFuCl8idxy7TFo6LPuANP8hmg7U,1806
+goodmap/templates/admin.html,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goodmap/templates/map.html,sha256=eU_h61l404g8e3_wszUokDrOC92bQ1nFl8yGMKRXFww,3820
+goodmap-0.4.2.dist-info/LICENSE.md,sha256=nkCQOR7uheLRvHRfXmwx9LhBnMcPeBU9d4ebLojDiQU,1067
+goodmap-0.4.2.dist-info/METADATA,sha256=rSIeCJEqtI6SKaeD8TgBJ6HempDKjy8tJRafe3XystA,4525
+goodmap-0.4.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+goodmap-0.4.2.dist-info/RECORD,,

goodmap-0.4.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-goodmap/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-goodmap/core.py,sha256=rU0RIoDR3trdaFH2F2DrO73P_SuYSPbbHZuYzPZiUj8,551
-goodmap/core_api.py,sha256=yhZT_w9ImIH6j2gU7U9QsBWNId5VzX3NntEHZUrPGfg,4957
-goodmap/data_models/location.py,sha256=mqECJ2K1RCcUX4wJJJUqQY2uX2eBuJlVOME5D9HtYV8,455
-goodmap/data_validator.py,sha256=sEyQEQcdDKSFYwendQxSFoOVL61JsVSYRnZVYNxAw3g,4077
-goodmap/db.py,sha256=tcjjh5vMzmOwB3p1MU5Mj6rim5WIsWllBts577qVhj0,543
-goodmap/formatter.py,sha256=VlUHcK1HtM_IEU0VE3S5TOkZLVheMdakvUeW2tCKdq0,783
-goodmap/goodmap.py,sha256=CQ1B6cD3qgSM7pZjPBr6D2xZIJaZ-Yg9F6oyYLxuYNA,907
-goodmap/templates/admin.html,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-goodmap/templates/map.html,sha256=l5sn8jmFoh3mdV-PAIy8fHxxB7JU3SA-kMLOKvWVGnM,3511
-goodmap-0.4.0.dist-info/LICENSE.md,sha256=nkCQOR7uheLRvHRfXmwx9LhBnMcPeBU9d4ebLojDiQU,1067
-goodmap-0.4.0.dist-info/METADATA,sha256=O72F5pISxOSZGqXTzWWdlB3Yhdq20pWitVXtFYlKNPg,4192
-goodmap-0.4.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-goodmap-0.4.0.dist-info/RECORD,,