qmaps 0.0.1__py3-none-any.whl

qmaps/__init__.py

@@ -0,0 +1,3 @@
+"""Map widgets for Qt based on web view"""
+
+__version__ = "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/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/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)

qmaps/openlayers.py

@@ -0,0 +1,118 @@
+from typing import List
+
+from importlib_resources import files
+
+try:
+    from PySide6 import QtCore
+except ImportError:
+    from PySide2 import QtCore
+
+from .base import QMapBase
+
+""" OpenLayers QWebEngineView supporting OSM
+"""
+
+
+class QOpenLayersOSM(QMapBase):
+    """QWidget (QWebEngineView) which renders OpenStreetMap using OpenLayers"""
+
+    HTML = files(__package__).joinpath("resources/openlayers_osm.htm").read_text(encoding="utf-8")
+
+    map_click = QtCore.Signal(float, float)
+    map_dblclick = QtCore.Signal(float, float)
+    map_error = QtCore.Signal()
+    map_loadend = QtCore.Signal()
+    map_loadstart = QtCore.Signal()
+    map_moveend = QtCore.Signal(float, float, float, float)
+    map_movestart = QtCore.Signal(float, float, float, float)
+    map_pointerdrag = QtCore.Signal()
+    map_pointermove = QtCore.Signal()
+    map_postcompose = QtCore.Signal()
+    map_postrender = QtCore.Signal()
+    map_precompose = QtCore.Signal()
+    map_rendercomplete = QtCore.Signal()
+    map_singleclick = QtCore.Signal(float, float)
+
+    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_click(self, lat, lng) -> None:
+        self.map_click.emit(lat, lng)
+
+    @QtCore.Slot(float, float)
+    def on_dblclick(self, lat, lng) -> None:
+        self.map_dblclick.emit(lat, lng)
+
+    @QtCore.Slot()
+    def on_error(self) -> None:
+        self.map_error.emit()
+
+    @QtCore.Slot()
+    def on_loadend(self) -> None:
+        self.map_loadend.emit()
+
+    @QtCore.Slot()
+    def on_loadstart(self) -> None:
+        self.map_loadstart.emit()
+
+    @QtCore.Slot(float, float, float, float)
+    def on_moveend(self, minlat: float, minlon: float, maxlat: float, maxlon: float) -> None:
+        self.map_moveend.emit(minlat, minlon, maxlat, maxlon)
+
+    @QtCore.Slot(float, float, float, float)
+    def on_movestart(self, minlat: float, minlon: float, maxlat: float, maxlon: float) -> None:
+        self.map_movestart.emit(minlat, minlon, maxlat, maxlon)
+
+    @QtCore.Slot()
+    def on_pointerdrag(self) -> None:
+        self.map_pointerdrag.emit()
+
+    @QtCore.Slot()
+    def on_pointermove(self) -> None:
+        self.map_pointermove.emit()
+
+    @QtCore.Slot()
+    def on_postcompose(self) -> None:
+        self.map_postcompose.emit()
+
+    @QtCore.Slot()
+    def on_postrender(self) -> None:
+        self.map_postrender.emit()
+
+    @QtCore.Slot()
+    def on_precompose(self) -> None:
+        self.map_precompose.emit()
+
+    @QtCore.Slot()
+    def on_rendercomplete(self) -> None:
+        self.map_rendercomplete.emit()
+
+    @QtCore.Slot(float, float)
+    def on_singleclick(self, lat, lng) -> None:
+        self.map_singleclick.emit(lat, lng)
+
+    # Python API
+
+    def get_center(self) -> List[float]:
+        return self.run_func_sync("get_center")
+
+    def get_zoom(self) -> float:
+        return self.run_func_sync("get_zoom")
+
+    def add_layer_point(self, latitude: float, longitude: float) -> None:
+        self.run_func_async("add_layer_point", latitude, longitude)
+
+    def add_overlay_text(self, latitude: float, longitude: float, text: str) -> None:
+        self.run_func_async("add_overlay_text", latitude, longitude, text)
+
+    # def pan_to(self, lat: float, lng: float) -> None:
+    #    self.run_func_async("centerOn", coordinate, size, position)