qmaps 0.0.1__tar.gz

qmaps-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021-2024 Dobatymo
+
+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.

qmaps-0.0.1/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: qmaps
+Version: 0.0.1
+Summary: Map widgets for Qt based on web view
+Author-email: Dobatymo <Dobatymo@users.noreply.github.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+License-File: LICENSE
+Requires-Dist: importlib-resources
+Requires-Dist: PySide2>=5.14 ; extra == "qt5"
+Requires-Dist: PySide6>=6.6 ; extra == "qt6"
+Project-URL: Home, https://github.com/Dobatymo/qmaps
+Provides-Extra: qt5
+Provides-Extra: qt6
+
+# QMaps
+
+Qt maps widget implemented using a WebView. Various JavaScript libraries and mapping services are supported. Full Python to Javascript and JavaScript to Python calls supported.
+
+## Install
+
+- Windows older than Windows 10 or Python 3.7: `pip install qmaps[qt5]`
+- Windows 10 and above, Python 3.8 and above: `pip install qmaps[qt6]`
+
+## Examples
+
+- `py examples/googlemaps.py` (GoogleMaps library using GoogleMaps tiles)
+- `py examples/googlemaps_osm.py` (GoogleMaps library using OpenStreetMap tiles)
+- `py examples/leaflet_osm.py` (Leaflet library using OpenStreetMap tiles)
+- `py examples/openlayers_osm.py` (OpenLayers library using OpenStreetMap tiles)
+
+## Others
+
+See <https://ircama.github.io/osm-carto-tutorials/map-client/> for more JavaScript maps implementations.
+

qmaps-0.0.1/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+build-backend = "flit_core.buildapi"
+requires = [
+  "flit_core<4,>=3.2",
+]
+
+[project]
+name = "qmaps"
+readme = "readme.md"
+license = {file = "LICENSE"}
+authors = [{name = "Dobatymo", email = "Dobatymo@users.noreply.github.com"}]
+requires-python = ">=3.8"
+classifiers = [
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+dynamic = [
+  "description",
+  "version",
+]
+dependencies = [
+  "importlib-resources",
+]
+[project.optional-dependencies]
+qt5 = [
+  "PySide2>=5.14",
+]
+qt6 = [
+  "PySide6>=6.6",
+]
+[project.urls]
+Home = "https://github.com/Dobatymo/qmaps"
+
+[tool.black]
+line-length = 120
+
+[tool.ruff]
+line-length = 120
+
+[tool.isort]
+profile = "black"
+line_length = 120
+
+[tool.mypy]
+ignore_missing_imports = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_configs = true
+warn_unused_ignores = true
+warn_unreachable = true
+
+[tool.bandit]
+skips = ["B101"]
+
+[dependency-groups]
+dev = [
+    "genutility[test]>=0.0.100",
+    "pytest>=8",
+]

qmaps-0.0.1/qmaps/__init__.py

@@ -0,0 +1,3 @@
+"""Map widgets for Qt based on web view"""
+
+__version__ = "0.0.1"

qmaps-0.0.1/qmaps/base.py

@@ -0,0 +1,140 @@
+import json
+import logging
+import webbrowser
+from typing import Any, Optional, Sequence
+
+try:
+    from PySide6 import QtCore, QtGui, QtWidgets
+    from PySide6.QtWebChannel import QWebChannel
+    from PySide6.QtWebEngineCore import QWebEnginePage
+    from PySide6.QtWebEngineWidgets import QWebEngineView
+except ImportError:
+    from PySide2 import QtCore, QtGui, QtWidgets
+    from PySide2.QtWebChannel import QWebChannel
+    from PySide2.QtWebEngineWidgets import QWebEnginePage, QWebEngineView
+
+
+logmap = {
+    QWebEnginePage.JavaScriptConsoleMessageLevel.InfoMessageLevel: logging.INFO,
+    QWebEnginePage.JavaScriptConsoleMessageLevel.WarningMessageLevel: logging.WARNING,
+    QWebEnginePage.JavaScriptConsoleMessageLevel.ErrorMessageLevel: logging.ERROR,
+}
+
+jslog = logging.getLogger("javascript")
+
+
+def jsrepr(obj: Any) -> str:
+    if obj is None:
+        return "null"
+    elif isinstance(obj, str):
+        return repr(obj)
+    elif isinstance(obj, bool):  # handle bool before int, since a bool is a int
+        return "true" if obj else "false"
+    elif isinstance(obj, (int, float)):
+        return str(obj)
+    else:
+        raise TypeError(f"Unhandled type: {type(obj)}")
+
+
+def js_func_call(name: str, args: Sequence[Any]) -> str:
+    args = ", ".join(map(jsrepr, args))
+    return f"{name}({args});"
+
+
+class QMapBasePage(QWebEnginePage):
+    accept_language = "en-US,en;q=0.9"
+
+    def __init__(
+        self, channel: QWebChannel, cache_dir: str, persistent_dir: str, parent: Optional[QtWidgets.QWidget] = None
+    ) -> None:
+        QWebEnginePage.__init__(self, parent)
+
+        self.profile().setCachePath(cache_dir)
+        self.profile().setPersistentStoragePath(persistent_dir)
+        self.profile().setHttpAcceptLanguage(self.accept_language)  # important! otherwise OSM requests are blocked
+
+        self.setWebChannel(channel)
+
+    def acceptNavigationRequest(self, url: QtCore.QUrl, type: QWebEnginePage.NavigationType, isMainFrame: bool) -> bool:
+        scheme = url.scheme()
+        if type == QWebEnginePage.NavigationType.NavigationTypeLinkClicked and scheme in ("http", "https"):
+            urlstr = url.toEncoded()
+            logging.warning("Open <%s> in browser", urlstr)
+            webbrowser.open(urlstr)
+            return False
+        return True
+
+    def javaScriptConsoleMessage(
+        self, level: QWebEnginePage.JavaScriptConsoleMessageLevel, message: str, lineNumber: int, sourceID: str
+    ) -> None:
+        sourceID = self.parent().clean_log_url(sourceID)
+
+        if sourceID.startswith("data:"):
+            sourceID = sourceID[:20] + "..."
+
+        extra = {"sourceID": sourceID, "lineNumber": lineNumber}
+        jslog.log(logmap[level], message, extra=extra)
+
+    def run_script_async(self, script: str) -> None:
+        self.runJavaScript(script)
+
+    def run_script_sync(self, script: str) -> Any:
+        loop = QtCore.QEventLoop()
+        result: Optional[str] = None
+
+        def callback(arg: Optional[str]) -> None:
+            nonlocal result
+            result = arg
+            loop.quit()
+
+        self.runJavaScript(script, 0, callback)
+        loop.exec_()
+        if isinstance(result, str):
+            return json.loads(result)
+        else:
+            return None
+
+
+class QMapBase(QWebEngineView):
+    def __init__(
+        self,
+        channel_name: str,
+        cache_dir: str = "cache",
+        persistent_dir: str = "persistent",
+    ) -> None:
+        QWebEngineView.__init__(self)
+        self.initialized = False
+
+        channel = QWebChannel(self)
+        page = QMapBasePage(channel, cache_dir, persistent_dir, self)
+        self.setPage(page)
+        self.loadFinished.connect(self.on_load_finished)
+
+        channel.registerObject(channel_name, self)
+
+    def contextMenuEvent(self, event: QtGui.QContextMenuEvent) -> None:  # disable default QWebEngineView context menu
+        pass
+
+    def clean_log_url(self, url: str) -> str:
+        return url
+
+    def wait_until_ready(self) -> None:
+        if not self.initialized:
+            loop = QtCore.QEventLoop()
+            self.loadFinished.connect(loop.quit)
+            loop.exec_()
+
+    @QtCore.Slot(bool)
+    def on_load_finished(self, ok: bool) -> None:
+        if not ok:
+            raise RuntimeError("Could not initialize map")
+
+        self.initialized = True
+
+    def run_func_async(self, name: str, *args) -> None:
+        script = js_func_call(name, args)
+        self.page().run_script_async(script)
+
+    def run_func_sync(self, name: str, *args) -> Any:
+        script = js_func_call(name, args)
+        return self.page().run_script_sync(script)

qmaps-0.0.1/qmaps/googlemaps.py

@@ -0,0 +1,167 @@
+from typing import Optional, Tuple
+
+from importlib_resources import files
+
+try:
+    from PySide6.QtCore import Signal, Slot
+except ImportError:
+    from PySide2.QtCore import Signal, Slot
+
+
+from .base import QMapBase
+
+""" GoogleMaps QWebEngineView supporting GoogleMaps, OSM
+Google Maps JavaScript API: https://developers.google.com/maps/documentation/javascript/overview
+"""
+
+
+class QGoogleMapsBase(QMapBase):
+    map_click = Signal(float, float)
+    map_contextmenu = Signal(float, float)
+    map_dblclick = Signal(float, float)
+    map_move = Signal(float, float)
+    map_moveend = Signal(float, float)
+    map_movestart = Signal(float, float)
+    map_rightclick = Signal(float, float)
+    map_zoom = Signal(int)
+
+    marker_move = Signal(str, float, float)
+    marker_moveend = Signal(str, float, float)
+    marker_movestart = Signal(str, float, float)
+    marker_click = Signal(str, float, float)
+    marker_dblclick = Signal(str, float, float)
+    marker_rightclick = Signal(str, float, float)
+
+    # JavaScript API
+
+    @Slot(float, float)
+    def on_click(self, lat: float, lng: float) -> None:
+        self.map_click.emit(lat, lng)
+
+    @Slot(float, float)
+    def on_contextmenu(self, lat: float, lng: float) -> None:
+        self.map_contextmenu.emit(lat, lng)
+
+    @Slot(float, float)
+    def on_dblclick(self, lat: float, lng: float) -> None:
+        self.map_dblclick.emit(lat, lng)
+
+    @Slot(float, float)
+    def on_move(self, lat: float, lng: float) -> None:
+        self.map_move.emit(lat, lng)
+
+    @Slot(float, float)
+    def on_moveend(self, lat: float, lng: float) -> None:
+        self.map_moveend.emit(lat, lng)
+
+    @Slot(float, float)
+    def on_movestart(self, lat: float, lng: float) -> None:
+        self.map_movestart.emit(lat, lng)
+
+    @Slot(float, float)
+    def on_rightclick(self, lat: float, lng: float) -> None:
+        self.map_rightclick.emit(lat, lng)
+
+    @Slot(int)
+    def on_zoom(self, zoom: int) -> None:
+        self.map_zoom.emit(zoom)
+
+    @Slot(str, float, float)
+    def on_marker_move(self, key: str, lat: float, lng: float) -> None:
+        self.marker_move.emit(key, lat, lng)
+
+    @Slot(str, float, float)
+    def on_marker_moveend(self, key: str, lat: float, lng: float) -> None:
+        self.marker_moveend.emit(key, lat, lng)
+
+    @Slot(str, float, float)
+    def on_marker_movestart(self, key: str, lat: float, lng: float) -> None:
+        self.marker_movestart.emit(key, lat, lng)
+
+    @Slot(str, float, float)
+    def on_marker_click(self, key: str, lat: float, lng: float) -> None:
+        self.marker_click.emit(key, lat, lng)
+
+    @Slot(str, float, float)
+    def on_marker_dblclick(self, key: str, lat: float, lng: float) -> None:
+        self.marker_dblclick.emit(key, lat, lng)
+
+    @Slot(str, float, float)
+    def on_marker_rightclick(self, key: str, lat: float, lng: float) -> None:
+        self.marker_rightclick.emit(key, lat, lng)
+
+    # Python API
+
+    def get_center(self) -> Tuple[float, float]:
+        lat, lon = self.run_func_sync("get_center")
+        return (lat, lon)
+
+    def set_center(self, latitude: float, longitude: float) -> None:
+        self.run_func_async("set_center", latitude, longitude)
+
+    def set_zoom(self, zoom: int) -> None:
+        self.run_func_async("set_zoom", zoom)
+
+    def move_marker(self, key: str, latitude: float, longitude: float) -> None:
+        self.run_func_async("move_marker", key, latitude, longitude)
+
+    def change_marker(
+        self,
+        key: str,
+        clickable: bool = True,
+        draggable: bool = False,
+        label: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> None:
+        self.run_func_async("change_marker", key, clickable, draggable, label, title)
+
+    def delete_marker(self, key: str) -> None:
+        self.run_func_async("delete_marker", key)
+
+    def add_marker(
+        self,
+        key: str,
+        latitude: float,
+        longitude: float,
+        clickable: bool = True,
+        draggable: bool = False,
+        label: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> None:
+        self.run_func_async("add_marker", key, latitude, longitude, clickable, draggable, label, title)
+
+
+class QGoogleMapsOSM(QGoogleMapsBase):
+    """QWidget (QWebEngineView) which renders OpenStreetMap using GoogleMaps"""
+
+    HTML = files(__package__).joinpath("resources/googlemaps_osm.htm").read_text(encoding="utf-8")
+
+    def __init__(self, latitude: float = 0, longitude: float = 0, zoom: int = 0) -> None:
+        super().__init__("qGoogleMaps")
+
+        html = self.HTML
+        html = html.replace("'<latitude>'", str(latitude))
+        html = html.replace("'<longitude>'", str(longitude))
+        html = html.replace("'<zoom>'", str(zoom))
+        self.page().setHtml(html)
+
+
+class QGoogleMapsGoogleMaps(QGoogleMapsBase):
+    """QWidget (QWebEngineView) which renders GoogleMaps using GoogleMaps"""
+
+    HTML = files(__package__).joinpath("resources/googlemaps_googlemaps.htm").read_text(encoding="utf-8")
+
+    def __init__(self, api_key: str, latitude: float = 0, longitude: float = 0, zoom: int = 0) -> None:
+        super().__init__("qGoogleMaps")
+
+        self.api_key = api_key
+
+        html = self.HTML
+        html = html.replace("<YOUR_API_KEY>", api_key)
+        html = html.replace("'<latitude>'", str(latitude))
+        html = html.replace("'<longitude>'", str(longitude))
+        html = html.replace("'<zoom>'", str(zoom))
+        self.page().setHtml(html)
+
+    def clean_log_url(self, url: str) -> str:
+        return url.replace(self.api_key, "<redacted>")

qmaps-0.0.1/qmaps/leaflet.py

@@ -0,0 +1,173 @@
+import json
+from typing import Optional, Sequence, Tuple, Union
+
+from importlib_resources import files
+
+try:
+    from PySide6 import QtCore
+except ImportError:
+    from PySide2 import QtCore
+
+from .base import QMapBase
+
+""" Leaflet QWebEngineView supporting OSM
+"""
+
+CoordsT = Sequence[Tuple[float, float]]
+NumberT = Union[int, float]
+
+DEFAULT_MARKER_TITLE: str = ""
+DEFAULT_MARKER_OPACITY: NumberT = 1.0
+DEFAULT_PATH_COLOR: str = "#3388ff"
+DEFAULT_PATH_WEIGHT: NumberT = 3
+DEFAULT_PATH_FILL_COLOR: str = "*"
+DEFAULT_PATH_FILL_OPACITY: NumberT = 0.2
+DEFAULT_PATH_OPACITY: NumberT = 1.0
+DEFAULT_IMAGEOVERLAY_OPACITY: NumberT = 1.0
+DEFAULT_IMAGEOVERLAY_INTERACTIVE: bool = False
+
+
+class QLeafletOSM(QMapBase):
+    """QWidget (QWebEngineView) which renders OpenStreetMap using Leaflet"""
+
+    HTML = files(__package__).joinpath("resources/leaflet_osm.htm").read_text(encoding="utf-8")
+
+    map_move = QtCore.Signal(float, float)
+    map_moveend = QtCore.Signal(float, float)
+    map_movestart = QtCore.Signal(float, float)
+    map_click = QtCore.Signal(float, float)
+    map_contextmenu = QtCore.Signal(float, float)
+    map_dblclick = QtCore.Signal(float, float)
+    map_zoom = QtCore.Signal(float, float, int)
+
+    def __init__(self, latitude: float = 0, longitude: float = 0, zoom: int = 0) -> None:
+        super().__init__("qOSM")
+
+        html = self.HTML
+        html = html.replace("'<latitude>'", str(latitude))
+        html = html.replace("'<longitude>'", str(longitude))
+        html = html.replace("'<zoom>'", str(zoom))
+        self.page().setHtml(html)
+
+    # JavaScript API
+
+    @QtCore.Slot(float, float)
+    def on_move(self, lat: float, lng: float) -> None:
+        self.map_move.emit(lat, lng)
+
+    @QtCore.Slot(float, float)
+    def on_moveend(self, lat: float, lng: float) -> None:
+        self.map_moveend.emit(lat, lng)
+
+    @QtCore.Slot(float, float)
+    def on_movestart(self, lat: float, lng: float) -> None:
+        self.map_movestart.emit(lat, lng)
+
+    @QtCore.Slot(float, float)
+    def on_click(self, lat: float, lng: float) -> None:
+        self.map_click.emit(lat, lng)
+
+    @QtCore.Slot(float, float)
+    def on_contextmenu(self, lat: float, lng: float) -> None:
+        self.map_contextmenu.emit(lat, lng)
+
+    @QtCore.Slot(float, float)
+    def on_dblclick(self, lat: float, lng: float) -> None:
+        self.map_dblclick.emit(lat, lng)
+
+    @QtCore.Slot(float, float, int)
+    def on_zoom(self, lat: float, lng: float, zoom: int) -> None:
+        self.map_zoom.emit(lat, lng, zoom)
+
+    # Sync Python API
+
+    def get_center(self) -> dict:
+        return self.run_func_sync("get_center")
+
+    def get_zoom(self) -> int:
+        return self.run_func_sync("get_zoom")
+
+    def get_bounds(self) -> Tuple[dict, dict]:
+        a, b = self.run_func_sync("get_bounds")
+        return a, b
+
+    # Async Python API
+
+    def set_view(self, lat: float, lng: float, zoom: int) -> None:
+        self.run_func_async("set_view", lat, lng, zoom)
+
+    def set_zoom(self, zoom: int) -> None:
+        self.run_func_async("set_zoom", zoom)
+
+    def fit_bounds(self, lat1: float, lng1: float, lat2: float, lng2: float) -> None:
+        self.run_func_async("fit_bounds", lat1, lng1, lat2, lng2)
+
+    def pan_to(self, lat: float, lng: float) -> None:
+        self.run_func_async("pan_to", lat, lng)
+
+    def add_marker(
+        self,
+        key: str,
+        lat: float,
+        lng: float,
+        title: str = DEFAULT_MARKER_TITLE,
+        opacity: NumberT = DEFAULT_MARKER_OPACITY,
+        popup: Optional[str] = None,
+    ) -> None:
+        self.run_func_async("add_marker", key, lat, lng, title, opacity, popup)
+
+    def add_circle(
+        self,
+        key: str,
+        lat: float,
+        lng: float,
+        radius: int,
+        color: str = DEFAULT_PATH_COLOR,
+        fill_color: str = DEFAULT_PATH_FILL_COLOR,
+        fill_opacity: NumberT = DEFAULT_PATH_FILL_OPACITY,
+        popup: Optional[str] = None,
+    ) -> None:
+        self.run_func_async("add_circle", key, lat, lng, radius, color, fill_color, fill_opacity, popup)
+
+    def add_polygon(
+        self,
+        key: str,
+        latlngs: Union[CoordsT, Sequence[CoordsT], Sequence[Sequence[CoordsT]]],
+        smooth_factor: NumberT = 1.0,
+        color: str = DEFAULT_PATH_COLOR,
+        weight: NumberT = DEFAULT_PATH_WEIGHT,
+        popup: Optional[str] = None,
+    ) -> None:
+        latlng_list = json.dumps(latlngs)
+        self.run_func_async("add_polygon", key, latlng_list, smooth_factor, color, weight, popup)
+
+    def add_polyline(
+        self,
+        key: str,
+        latlngs: Union[CoordsT, Sequence[CoordsT]],
+        smooth_factor: NumberT = 1.0,
+        color: str = DEFAULT_PATH_COLOR,
+        weight: NumberT = DEFAULT_PATH_WEIGHT,
+        popup: Optional[str] = None,
+    ) -> None:
+        latlng_list = json.dumps(latlngs)
+        self.run_func_async("add_polyline", key, latlng_list, smooth_factor, color, weight, popup)
+
+    def add_image_url(
+        self,
+        key: str,
+        image_url: str,
+        lat1: float,
+        lng1: float,
+        lat2: float,
+        lng2: float,
+        opacity: NumberT = DEFAULT_IMAGEOVERLAY_OPACITY,
+        interactive: bool = DEFAULT_IMAGEOVERLAY_INTERACTIVE,
+    ) -> None:
+        self.run_func_async("add_image_url", key, image_url, lat1, lng1, lat2, lng2, opacity, interactive)
+
+    def remove_layer(self, key: str) -> None:
+        self.run_func_async("remove_layer", key)
+
+    def open_popup(self, key: str) -> None:
+        self.run_func_async("open_popup", key)