goodmap 0.4.0__tar.gz → 0.4.2__tar.gz

{goodmap-0.4.0 → goodmap-0.4.2}/PKG-INFO

@@ -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.0 → goodmap-0.4.2}/README.md

@@ -7,6 +7,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`.
 
@@ -69,7 +82,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.0 → goodmap-0.4.2}/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-0.4.0 → goodmap-0.4.2}/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-0.4.2/goodmap/data_models/location.py

@@ -0,0 +1,37 @@
+from typing import Any, Type
+
+from pydantic import BaseModel, Field, create_model, field_validator
+
+
+class LocationBase(BaseModel, extra="allow"):
+    position: tuple[float, float]
+    uuid: str
+
+    @field_validator("position")
+    @classmethod
+    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-0.4.0 → goodmap-0.4.2}/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-0.4.2/goodmap/db.py

@@ -0,0 +1,116 @@
+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):
+    return json.loads(self.blob.download_as_text(client=None))["map"]
+
+
+def json_file_db_get_data(self):
+    with open(self.data_file_path, "r") as file:
+        return json.load(file)["map"]
+
+
+def json_db_get_data(self):
+    return self.data
+
+
+def get_data(db):
+    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-0.4.2/goodmap/goodmap.py

@@ -0,0 +1,52 @@
+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 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:
+    config = Config.parse_yaml(config_path)
+    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)
+
+    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, location_model
+    )
+    app.register_blueprint(cp)
+    goodmap = Blueprint("goodmap", __name__, url_prefix="/", template_folder="templates")
+
+    @goodmap.route("/")
+    def index():
+        return render_template("map.html", feature_flags=config.feature_flags)
+
+    app.register_blueprint(goodmap)
+    return app

{goodmap-0.4.0 → goodmap-0.4.2}/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 → goodmap-0.4.2}/pyproject.toml

@@ -1,9 +1,10 @@
 [tool.poetry]
 name = "goodmap"
-version = "0.4.0"
+version = "0.4.2"
 description = "Map engine to serve all the people :)"
 authors = ["Krzysztof Kolodzinski <krzysztof.kolodzinski@problematy.pl>"]
 readme = "README.md"
+exclude = ["goodmap/locale/*/LC_MESSAGES/*.po"]
 
 [tool.poetry.dependencies]
 python = "^3.10"
@@ -20,6 +21,7 @@ gql = "^3.4.0"
 aiohttp = "^3.8.4"
 pydantic = "^2.7.1"
 platzky = "^0.2.5"
+deprecation = "^2.1.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.1.2"

goodmap-0.4.0/goodmap/data_models/location.py

@@ -1,15 +0,0 @@
-from pydantic import BaseModel, field_validator
-
-
-class Location(BaseModel):
-    name: str
-    coordinates: tuple[float, float]
-
-    @field_validator("coordinates")
-    @classmethod
-    def coordinates_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

goodmap-0.4.0/goodmap/db.py

@@ -1,23 +0,0 @@
-import json
-
-# TODO file is temporary solution to be compatible with old, static code,
-#  it should be replaced with dynamic solution
-
-
-def google_json_db_get_data(self):
-    raw_data = self.blob.download_as_text(client=None)
-    return json.loads(raw_data)["map"]
-
-
-def json_file_db_get_data(self):
-    with open(self.data_file_path, "r") as file:
-        return json.load(file)["map"]
-
-
-def json_db_get_data(self):
-    return self.data
-
-
-def get_data(db):
-    function_name = f"{db.module_name}_get_data"
-    return globals()[function_name]

goodmap-0.4.0/goodmap/goodmap.py

@@ -1,30 +0,0 @@
-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
-
-
-def create_app(config_path: str) -> platzky.Engine:
-    config = Config.parse_yaml(config_path)
-    return create_app_from_config(config)
-
-
-def create_app_from_config(config: Config) -> platzky.Engine:
-    app = platzky.create_app_from_config(config)
-
-    app.db.extend("get_data", get_data(app.db))
-    CSRFProtect(app)
-
-    cp = core_pages(app.db, languages_dict(config.languages), app.notify, generate_csrf)
-    app.register_blueprint(cp)
-    goodmap = Blueprint("goodmap", __name__, url_prefix="/", template_folder="templates")
-
-    @goodmap.route("/")
-    def index():
-        return render_template("map.html")
-
-    app.register_blueprint(goodmap)
-    return app