goodmap 1.1.12__tar.gz

goodmap-1.1.12/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 problematy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

goodmap-1.1.12/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.3
+Name: goodmap
+Version: 1.1.12
+Summary: Map engine to serve all the people :)
+Author: Krzysztof Kolodzinski
+Author-email: krzysztof.kolodzinski@problematy.pl
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: docs
+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)
+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)
+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"
+Description-Content-Type: text/markdown
+
+![Github Actions](https://github.com/problematy/goodmap/actions/workflows/release.yml/badge.svg?event=push&branch=main)
+[![Coverage Status](https://coveralls.io/repos/github/Problematy/goodmap/badge.png)](https://coveralls.io/github/Problematy/goodmap)
+
+# Good Map
+
+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`.
+
+#### 2. Install `poetry` in Python 3.10
+`poetry` can create virtual environments associated with a project. \
+Make sure you are in the Python 3.10 environment and install:
+```
+pip install poetry
+```
+Useful commands: `poetry -h <command>`, `poetry env list`, `poetry env info`.
+
+#### 3. Install dependencies
+```
+poetry install
+```
+
+#### 4. You're ready
+
+When you enter the project directory, you can invoke any commands in your project like this:
+```
+poetry run <command>
+```
+
+## Running App locally
+
+### 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 `examples` directory:
+
+> poetry run flask --app 'goodmap.goodmap:create_app(config_path="./examples/e2e_test_config.yml")' run
+
+### Configuration
+
+If you want to serve app with your configuration rename config-template.yml to config.yml and change its contents according to your needs.
+
+Afterwards run it with:
+> poetry run flask --app 'goodmap.goodmap:create_app(config_path="/PATH/TO/YOUR/CONFIG")' --debug run
+
+
+| Option                   | Description                                                                                                                        |
+|--------------------------|------------------------------------------------------------------------------------------------------------------------------------|
+| USE_LAZY_LOADING         | Loads point data only after the user clicks a point. If set to false, point data is loaded together with the initial map.          |
+| FAKE_LOGIN               | If set to true, allows access to the admin panel by simply selecting the role instead of logging in. **DO NOT USE IN PRODUCTION!** |
+| SHOW_ACCESSIBILITY_TABLE | If set as true it shows special view to help with accessing application.                                                           |
+
+## Database
+
+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.
+```
+"position",
+"name",
+"accessible_by"
+```
+TODO: `obligatory_fields` is a new subsection, start using it in the actual application
+- `categories` - fields that can somehow be used in the app, for example by which datapoints can be filtered. Every category has a specified list of allowed values. E.g.
+```
+"accessible_by": ["bikes", "cars", "pedestrians"]
+```
+- `visible_data` - when a datapoint will be rendered as a pin on a map, these fields will be shown in the box when clicking on a pin. E.g.
+```
+"name",
+"type_of_place"
+```
+- `meta-data` - some special data like 
+```
+"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.
+
+## Examples
+
+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.12/README.md

@@ -0,0 +1,103 @@
+![Github Actions](https://github.com/problematy/goodmap/actions/workflows/release.yml/badge.svg?event=push&branch=main)
+[![Coverage Status](https://coveralls.io/repos/github/Problematy/goodmap/badge.png)](https://coveralls.io/github/Problematy/goodmap)
+
+# Good Map
+
+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`.
+
+#### 2. Install `poetry` in Python 3.10
+`poetry` can create virtual environments associated with a project. \
+Make sure you are in the Python 3.10 environment and install:
+```
+pip install poetry
+```
+Useful commands: `poetry -h <command>`, `poetry env list`, `poetry env info`.
+
+#### 3. Install dependencies
+```
+poetry install
+```
+
+#### 4. You're ready
+
+When you enter the project directory, you can invoke any commands in your project like this:
+```
+poetry run <command>
+```
+
+## Running App locally
+
+### 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 `examples` directory:
+
+> poetry run flask --app 'goodmap.goodmap:create_app(config_path="./examples/e2e_test_config.yml")' run
+
+### Configuration
+
+If you want to serve app with your configuration rename config-template.yml to config.yml and change its contents according to your needs.
+
+Afterwards run it with:
+> poetry run flask --app 'goodmap.goodmap:create_app(config_path="/PATH/TO/YOUR/CONFIG")' --debug run
+
+
+| Option                   | Description                                                                                                                        |
+|--------------------------|------------------------------------------------------------------------------------------------------------------------------------|
+| USE_LAZY_LOADING         | Loads point data only after the user clicks a point. If set to false, point data is loaded together with the initial map.          |
+| FAKE_LOGIN               | If set to true, allows access to the admin panel by simply selecting the role instead of logging in. **DO NOT USE IN PRODUCTION!** |
+| SHOW_ACCESSIBILITY_TABLE | If set as true it shows special view to help with accessing application.                                                           |
+
+## Database
+
+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.
+```
+"position",
+"name",
+"accessible_by"
+```
+TODO: `obligatory_fields` is a new subsection, start using it in the actual application
+- `categories` - fields that can somehow be used in the app, for example by which datapoints can be filtered. Every category has a specified list of allowed values. E.g.
+```
+"accessible_by": ["bikes", "cars", "pedestrians"]
+```
+- `visible_data` - when a datapoint will be rendered as a pin on a map, these fields will be shown in the box when clicking on a pin. E.g.
+```
+"name",
+"type_of_place"
+```
+- `meta-data` - some special data like 
+```
+"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.
+
+## Examples
+
+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.12/goodmap/__init__.py

@@ -0,0 +1 @@
+

goodmap-1.1.12/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.12/goodmap/config.py

@@ -0,0 +1,42 @@
+import sys
+import typing as t
+
+import yaml
+from platzky.config import Config as PlatzkyConfig
+from pydantic import Field
+
+
+class GoodmapConfig(PlatzkyConfig):
+    """Extended configuration for Goodmap with additional frontend library URL."""
+
+    goodmap_frontend_lib_url: str = Field(
+        default="https://cdn.jsdelivr.net/npm/@problematy/goodmap@1.0.4",
+        alias="GOODMAP_FRONTEND_LIB_URL",
+    )
+
+    @classmethod
+    def model_validate(
+        cls,
+        obj: t.Any,
+        *,
+        strict: bool | None = None,
+        from_attributes: bool | None = None,
+        context: dict[str, t.Any] | None = None,
+    ) -> "GoodmapConfig":
+        """Override to return correct type for GoodmapConfig."""
+        return t.cast(
+            "GoodmapConfig",
+            super().model_validate(
+                obj, strict=strict, from_attributes=from_attributes, context=context
+            ),
+        )
+
+    @classmethod
+    def parse_yaml(cls, path: str) -> "GoodmapConfig":
+        """Parse YAML configuration file and return GoodmapConfig instance."""
+        try:
+            with open(path, "r") as f:
+                return cls.model_validate(yaml.safe_load(f))
+        except FileNotFoundError:
+            print(f"Config file not found: {path}", file=sys.stderr)
+            raise SystemExit(1)

goodmap-1.1.12/goodmap/core.py

@@ -0,0 +1,46 @@
+from typing import Any, Dict, List
+
+# TODO move filtering to db site
+
+
+def does_fulfill_requirement(entry, requirements):
+    matches = []
+    for category, values in requirements:
+        if not values:
+            continue
+        matches.append(all(entry_value in entry[category] for entry_value in values))
+    return all(matches)
+
+
+def sort_by_distance(data: List[Dict[str, Any]], query_params: Dict[str, List[str]]):
+    try:
+        if "lat" in query_params and "lon" in query_params:
+            lat = float(query_params["lat"][0])
+            lon = float(query_params["lon"][0])
+            data.sort(key=lambda x: (x["position"][0] - lat) ** 2 + (x["position"][1] - lon) ** 2)
+            return data
+        return data
+    except (ValueError, KeyError, IndexError):
+        return data
+
+
+def limit(data, query_params):
+    try:
+        if "limit" in query_params:
+            limit = int(query_params["limit"][0])
+            data = data[:limit]
+            return data
+        return data
+    except (ValueError, KeyError, IndexError):
+        return data
+
+
+def get_queried_data(all_data, categories, query_params):
+    requirements = []
+    for key in categories.keys():
+        requirements.append((key, query_params.get(key)))
+
+    filtered_data = [x for x in all_data if does_fulfill_requirement(x, requirements)]
+    final_data = sort_by_distance(filtered_data, query_params)
+    final_data = limit(final_data, query_params)
+    return final_data