BERATools 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

beratools/third_party/pyqtlet2/leaflet/layer/layergroup.py

@@ -1,45 +0,0 @@
-from .layer import Layer
-
-class LayerGroup(Layer):
-    """
-    Used to group several layers and handle them as one. If you add it to the map, any layers added or removed from the group will be added/removed on the map as well. 
-    """
-
-    @property
-    def layers(self):
-        return self._layers
-
-    def __init__(self):
-        super().__init__()
-        self._layers = []
-        if self._map:
-            self._initJs()
-
-    def _initJs(self):
-        leafletJsObject = 'new L.layerGroup()'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)
-
-    def addLayer(self, layer):
-        self._layers.append(layer)
-        layer.map = self._map
-        layer._initJs()
-        js = '{layerGroup}.addLayer({layerName})'.format(layerGroup=self._layerName,
-                layerName=layer._layerName)
-        self.runJavaScriptForMapIndex(js)
-
-    def removeLayer(self, layer):
-        if not layer in self._layers:
-            # TODO Raise ValueError?
-            return
-        self._layers.remove(layer)
-        js = '{layerGroup}.removeLayer({layerName})'.format(layerGroup=self._layerName,
-                layerName=layer._layerName)
-        self.runJavaScriptForMapIndex(js)
-    
-    def clearLayers(self):
-        js = '{layerGroup}.clearLayers()'.format(layerGroup=self._layerName)
-        self.runJavaScriptForMapIndex(js)
-    
-    def toGeoJSON(self, callback):
-        self.getJsResponseForMapIndex(f'{self.jsName}.toGeoJSON()', callback)
-

beratools/third_party/pyqtlet2/leaflet/layer/marker/__init__.py

@@ -1 +0,0 @@
-from .marker import Marker

beratools/third_party/pyqtlet2/leaflet/layer/marker/marker.py

@@ -1,91 +0,0 @@
-from ..layer import Layer
-from ..icon import Icon
-from ...core.Parser import Parser
-
-from qtpy.QtCore import Slot, Signal, QJsonValue
-
-from typing import List
-
-
-class Marker(Layer):
-    moveend = Signal(dict)
-    move = Signal(dict)
-    click = Signal(dict)
-
-    def __init__(self, latLng: List[float], options=None):
-        super().__init__()
-        if isinstance(options, type(None)):
-            options = {}
-        self.latLng = latLng
-        self.options = options
-        self.opacity = options.get('opacity', 1)
-        self.draggable = options.get('draggable', False)
-        if self._map:
-            self._initJs()
-
-    @Slot(QJsonValue)
-    def _onMove(self, event):
-        self._logger.debug('marker moved. event: {event}'.format(event=event))
-        event = self._qJsonValueToDict(event)
-        self.latLng = [event["latlng"]["lat"], event["latlng"]["lng"]]
-        self.move.emit({**self._qJsonValueToDict(event), "latLng": self.latLng, "sender": self})
-
-    @Slot(QJsonValue)
-    def _onMoveend(self, event):
-        self._logger.debug('marker moved. event: {event}'.format(event=event))
-        if self.opacity == 0:
-            return
-        self.moveend.emit({**self._qJsonValueToDict(event), "latLng": self.latLng, "sender": self})
-
-    @Slot(QJsonValue)
-    def _click(self, event):
-        self._logger.debug('marker clicked. event: {event}'.format(event=event))
-        if self.opacity == 0:
-            return
-        self.click.emit({**self._qJsonValueToDict(event), "sender": self})
-
-    def _initJs(self):
-        leafletJsObject = 'L.marker({latLng}'.format(latLng=self.latLng)
-        if self.options:
-            leafletJsObject += ', {options}'.format(options=Parser.dict_for_js(self.options))
-        leafletJsObject += ')'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)
-        self._connectEventToSignal('move', '_onMove', self._map.mapWidgetIndex)
-        self._connectEventToSignal('moveend', '_onMoveend', self._map.mapWidgetIndex)
-        self._connectEventToSignal('click', '_click', self._map.mapWidgetIndex)
-
-    def setLatLng(self, latLng):
-        self.latLng = latLng
-        js = '{layerName}.setLatLng({latLng})'.format(
-                layerName=self._layerName, latLng=latLng)
-        self.runJavaScriptForMapIndex(js)
-        return self
-
-    def setOpacity(self, opacity):
-        self.opacity = opacity
-        js = '{layerName}.setOpacity({opacity})'.format(
-                layerName=self._layerName, opacity=self.opacity)
-        self.runJavaScriptForMapIndex(js)
-        return self
-
-    def setDragging(self, draggable):
-        self.draggable = draggable
-        option = 'enable' if self.draggable else 'disable'
-        js = '{layerName}.dragging.{option}();'.format(layerName=self._layerName, option=option)
-        self.runJavaScriptForMapIndex(js)
-        return self
-
-    def setIcon(self, icon: Icon):
-        js = '{layerName}.setIcon({markerIcon});'.format(layerName=self._layerName, markerIcon=icon._layerName)
-        self.runJavaScriptForMapIndex(js)
-        return self
-
-    def setRotationAngle(self, angle_deg: float):
-        js = '{layerName}.setRotationAngle({angle_deg});'.format(layerName=self._layerName, angle_deg=angle_deg)
-        self.runJavaScriptForMapIndex(js)
-        return self
-
-    def setRotationOrigin(self, origin: str):
-        js = '{layerName}.setRotationOrigin({origin});'.format(layerName=self._layerName, origin=origin)
-        self.runJavaScriptForMapIndex(js)
-        return self

beratools/third_party/pyqtlet2/leaflet/layer/tile/__init__.py

@@ -1,2 +0,0 @@
-from .gridlayer import GridLayer
-from .tilelayer import TileLayer

beratools/third_party/pyqtlet2/leaflet/layer/tile/gridlayer.py

@@ -1,4 +0,0 @@
-from .. import Layer
-
-class GridLayer(Layer):
-    pass

beratools/third_party/pyqtlet2/leaflet/layer/tile/tilelayer.py

@@ -1,16 +0,0 @@
-from . import GridLayer
-
-class TileLayer(GridLayer):
-    def __init__(self, urlTemplate, options=None):
-        super().__init__()
-        self.urlTemplate = urlTemplate
-        self.options = options
-        if self._map:
-            self._initJs()
-        
-    def _initJs(self):
-        leafletJsObject = 'L.tileLayer("{urlTemplate}"'.format(urlTemplate=self.urlTemplate)
-        if self.options:
-            leafletJsObject += ', {options}'.format(options=self.options)
-        leafletJsObject += ')'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)

beratools/third_party/pyqtlet2/leaflet/layer/vector/__init__.py

@@ -1,5 +0,0 @@
-from .circle import Circle
-from .circlemarker import CircleMarker
-from .polygon import Polygon
-from .polyline import Polyline
-from .rectangle import Rectangle

beratools/third_party/pyqtlet2/leaflet/layer/vector/circle.py

@@ -1,15 +0,0 @@
-from .circlemarker import CircleMarker
-
-
-class Circle(CircleMarker):
-    def __init__(self, latLng, radius, options=None):
-        self.radius = radius
-        super().__init__(latLng, options)
-
-    def _initJs(self):
-        leafletJsObject = 'L.circle({latLng},{radius}'.format(latLng=self.latLng,
-                radius=self.radius)
-        if self.options:
-            leafletJsObject += ', {options}'.format(options=self.options)
-        leafletJsObject += ')'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)

beratools/third_party/pyqtlet2/leaflet/layer/vector/circlemarker.py

@@ -1,18 +0,0 @@
-from .path import Path
-
-
-class CircleMarker(Path):
-    def __init__(self, latLng, options=None):
-        super().__init__()
-        self.latLng = latLng
-        self.options = options
-        if self._map:
-            self._initJs()
-
-    def _initJs(self):
-        leafletJsObject = 'L.circleMarker({latLng}'.format(latLng=self.latLng)
-        if self.options:
-            leafletJsObject += ', {options}'.format(options=self.options)
-        leafletJsObject += ')'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)
-

beratools/third_party/pyqtlet2/leaflet/layer/vector/path.py

@@ -1,5 +0,0 @@
-from ..layer import Layer
-
-
-class Path(Layer):
-    pass

beratools/third_party/pyqtlet2/leaflet/layer/vector/polygon.py

@@ -1,14 +0,0 @@
-from .polyline import Polyline
-
-
-class Polygon(Polyline):
-    def __init__(self, latLngs, options=None):
-        super().__init__(latLngs, options)
-
-    def _initJs(self):
-        leafletJsObject = 'L.polygon({latLngs}'.format(latLngs=self.latLngs)
-        if self.options:
-            leafletJsObject += ', {options}'.format(options=self.options)
-        leafletJsObject += ')'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)
-

beratools/third_party/pyqtlet2/leaflet/layer/vector/polyline.py

@@ -1,18 +0,0 @@
-from .path import Path
-
-
-class Polyline(Path):
-    def __init__(self, latLngs, options=None):
-        super().__init__()
-        self.latLngs = latLngs
-        self.options = options
-        if self._map:
-            self._initJs()
-
-    def _initJs(self):
-        leafletJsObject = 'L.polyline({latLngs}'.format(latLngs=self.latLngs)
-        if self.options:
-            leafletJsObject += ', {options}'.format(options=self.options)
-        leafletJsObject += ')'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)
-

beratools/third_party/pyqtlet2/leaflet/layer/vector/rectangle.py

@@ -1,14 +0,0 @@
-from .polygon import Polygon
-
-
-class Rectangle(Polygon):
-    def __init__(self, latLngs, options=None):
-        super().__init__(latLngs, options)
-
-    def _initJs(self):
-        leafletJsObject = 'L.rectangle({latLngs}'.format(latLngs=self.latLngs)
-        if self.options:
-            leafletJsObject += ', {options}'.format(options=self.options)
-        leafletJsObject += ')'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)
-

beratools/third_party/pyqtlet2/leaflet/map/__init__.py

@@ -1 +0,0 @@
-from .map import Map

beratools/third_party/pyqtlet2/leaflet/map/map.py

@@ -1,220 +0,0 @@
-import json
-import logging
-import os
-import time
-
-from qtpy.QtCore import Slot, Signal, QJsonValue
-
-from ... import mapwidget
-from ..core import Evented
-from ..layer import Layer
-
-
-class Map(Evented):
-    '''
-    .. module:: pyqtlet2
-
-    pyqtlet2 equivalent of L.map
-
-    Map element has to be the first pyqtlet2 object to be initiated.
-
-    .. note::
-        Further documentation can be found at the official leaflet API.
-
-    :param pyqtlet2.MapWidget mapWidget: The mapwidget object
-        Should only be sent once, when the first object is being 
-        initialised.
-
-    :param dict options: Options for initiation (optional)
-    '''
-
-    clicked = Signal(dict)
-    zoom = Signal(dict)
-    drawCreated = Signal(dict)
-    right_mouse_clicked = Signal(dict)
-    mapWidgetCounter = 0
-
-    @property
-    def layers(self):
-        """
-        Instead of L.map.eachLayer
-        """
-        return self._layers
-
-    @property
-    def jsName(self):
-        '''
-        Name of the Leaflet element
-        '''
-        return self._jsName
-
-    @Slot(QJsonValue)
-    def _onClick(self, event):
-        self._logger.debug('map clicked. event: {event}'.format(event=event))
-        self.clicked.emit(self._qJsonValueToDict(event))
-        
-    @Slot(QJsonValue)
-    def _onRightClick(self, event):
-        self._logger.debug('map clicked. event: {event}'.format(event=event))
-        self.right_mouse_clicked.emit(self._qJsonValueToDict(event))
-
-    @Slot(QJsonValue)
-    def _onDrawCreated(self, event):
-        self._logger.debug('draw created. event: {event}'.format(event=event))
-        self.drawCreated.emit(self._qJsonValueToDict(event))
-
-    @Slot(QJsonValue)
-    def _onZoom(self, event):
-        self._logger.debug('map zoom. event: {event}'.format(event=event))
-        self.zoom.emit(self._qJsonValueToDict(event))
-
-    def __init__(self, mapWidget, options=None):
-        '''
-        pyqtlet2 equivalent of L.map
-
-        Map element has to be the first pyqtlet2 object to be initiated.
-
-        :param pyqtlet2.MapWidget mapWidget: The mapwidget object
-            Should only be sent once, when the first object is being
-            initialised.
-
-        :param dict options: Options for initiation (optional)
-
-        .. note
-            Further documentation can be found at the official leaflet API.
-        '''
-
-        super().__init__(mapWidget, Map.mapWidgetCounter)
-        self.mapWidgetIndex = Map.mapWidgetCounter
-        Map.mapWidgetCounter += 1
-        self._logger = logging.getLogger(__name__)
-        self.options = options
-        self._layers = []
-        self._controls = []
-        self._jsName = 'map'
-        self._initJs()
-        self._connectEventToSignal('click', '_onClick', self.mapWidgetIndex)
-        self._connectEventToSignal('contextmenu', '_onRightClick', self.mapWidgetIndex)
-        self._connectEventToSignal('zoom', '_onZoom', self.mapWidgetIndex)
-        self._connectEventToSignal('draw:created', '_onDrawCreated', self.mapWidgetIndex)
-
-    def _initJs(self):
-        jsObject = 'L.map("map"'
-        if self.options:
-            jsObject += ', {options}'.format(options=self._stringifyForJs(self.options))
-        jsObject += ')'
-        self._createJsObject(jsObject, self.mapWidgetIndex)
-
-    def setView(self, latLng, zoom=None, options=None):
-        js = 'map.setView({latLng}'.format(latLng=latLng)
-        if zoom:
-            js += ', {zoom}'.format(zoom=zoom)
-        if options:
-            js += ', {options}'.format(options=options)
-        js += ');'
-        self.runJavaScript(js, self.mapWidgetIndex)
-        return self
-
-    def runJavaScriptForMap(self, js):
-        self.runJavaScript(js, self.mapWidgetIndex)
-
-    def addLayer(self, layer: Layer):
-        self._layers.append(layer)
-        layer.map = self
-        layer._initJs()
-        js = 'map.addLayer({layerName})'.format(layerName=layer.layerName)
-        self.runJavaScriptForMap(js)
-        layer._initPopupAndTooltip()
-        return self
-
-    def removeLayer(self, layer):
-        if layer not in self._layers:
-            # TODO Should we raise a ValueError here? Or just return
-            return
-        self._layers.remove(layer)
-        layer.map = None
-        js = 'map.removeLayer({layerName})'.format(layerName=layer.layerName)
-        self.runJavaScriptForMap(js)
-        return self
-
-    def addControl(self, control):
-        self._controls.append(control)
-        control.map = self
-        control._initJs()
-        js = 'map.addControl({controlName})'.format(controlName=control.controlName)
-        self.runJavaScriptForMap(js)
-        return self
-
-    def removeControl(self, control):
-        if control not in self._controls:
-            # TODO Should we raise a ValueError here? Or just return
-            return
-        self._controls.remove(control)
-        control.map = None
-        js = 'map.removeControl({controlName})'.format(controlName=control.controlName)
-        self.runJavaScriptForMap(js)
-        return self
-
-    def getJsresponseForMap(self, js, callback):
-        return self.getJsResponse(js, self.mapWidgetIndex, callback)
-
-    def getBounds(self, callback):
-        return self.getJsresponseForMap('map.getBounds()', callback)
-
-    def getCenter(self, callback):
-        return self.getJsresponseForMap('map.getCenter()', callback)
-
-    def getZoom(self, callback):
-        return self.getJsresponseForMap('map.getZoom()', callback)
-
-    def getState(self, callback):
-        return self.getJsresponseForMap('getMapState()', callback)
-
-    def hasLayer(self, layer):
-        return layer in self._layers
-
-    def setZoom(self, zoom, options=None):
-        js = 'map.setZoom({zoom}'.format(zoom=zoom)
-        if options:
-            js += ', {options}'.format(options=options)
-        js += ');'
-        self.runJavaScriptForMap(js)
-        return self
-
-    def setMaxBounds(self, bounds):
-        js = 'map.setMaxBounds({bounds})'.format(bounds=bounds)
-        self.runJavaScriptForMap(js)
-        return self
-
-    def fitBounds(self, bounds):
-        js = 'map.fitBounds({bounds})'.format(bounds=bounds)
-        self.runJavaScriptForMap(js)
-        return self
-
-    def setMaxZoom(self, zoom):
-        js = 'map.setMaxZoom({zoom})'.format(zoom=zoom)
-        self.runJavaScriptForMap(js)
-        return self
-
-    def setMinZoom(self, zoom):
-        js = 'map.setMinZoom({zoom})'.format(zoom=zoom)
-        self.runJavaScriptForMap(js)
-        return self
-
-    def panTo(self, latLng, options=None):
-        js = 'map.panTo({latLng}'.format(latLng=latLng)
-        if options:
-            js += ', {options}'.format(options=options)
-        js += ');'
-        self.runJavaScriptForMap(js)
-        return self
-
-    def flyTo(self, latLng, zoom=None, options=None):
-        js = 'map.flyTo({latLng}'.format(latLng=latLng)
-        if zoom:
-            js += ', {zoom}'.format(zoom=zoom)
-        if options:
-            js += ', {options}'.format(options=options)
-        js += ');'
-        self.runJavaScriptForMap(js)
-        return self

beratools/third_party/pyqtlet2/mapwidget.py

@@ -1,45 +0,0 @@
-import os
-
-from qtpy.QtCore import QEventLoop, Qt, QUrl
-from qtpy.QtWebChannel import QWebChannel
-from qtpy.QtWebEngineWidgets import QWebEngineView, QWebEnginePage
-
-
-class MapWidget(QWebEngineView):
-    """
-    The MapWidget class is a QWebEngineView that houses the leaflet map.
-    Since it is a QWidget, it can be added to any QLayout.
-    """
-
-    @property
-    def page(self):
-        return self._page
-
-    @property
-    def channel(self):
-        return self._channel
-
-    def __init__(self, use_file_absolute_path: bool = True, alternative_base_path: str=""):
-        super().__init__()
-        if use_file_absolute_path or len(alternative_base_path) == 0:
-            self.base_path = os.path.dirname(os.path.abspath(__file__))
-        else:
-            self.base_path = alternative_base_path
-        self._page = QWebEnginePage()
-        self.setPage(self._page)
-        self._channel = QWebChannel()
-        self._page.setWebChannel(self._channel)
-        self._loadPage()
-        self.setContextMenuPolicy(Qt.NoContextMenu)
-
-    def _get_page_path(self):
-        return os.path.join(self.base_path, 'web', 'map.html')
-
-    def _loadPage(self):
-        html_path = self._get_page_path()
-        # QEventLoop is used to make the page loading behave syncronously
-        init_loop = QEventLoop()
-        self._page.loadFinished.connect(init_loop.quit)
-        self._page.load(QUrl().fromLocalFile(html_path))
-        init_loop.exec_()
-

beratools/third_party/pyqtlet2/web/custom.js

@@ -1,43 +0,0 @@
-function copyWithoutCircularReferences(references, object) {
-    var cleanObject = {};
-    Object.keys(object).forEach(function(key) {
-        var value = object[key];
-        if (value && typeof value === 'object') {
-            if (references.indexOf(value) < 0) {
-                references.push(value);
-                cleanObject[key] = copyWithoutCircularReferences(references, value);
-                references.pop();
-            } else {
-                cleanObject[key] = '###_Circular_###';
-            }
-        } else if (typeof value !== 'function') {
-            cleanObject[key] = value;
-        }
-    });
-    return cleanObject;
-}
-
-// NOTE: There is an assumption here that the map var will be called map
-// Might not be the case if there are multiple maps.
-function getMapState() {
-    var center = map.getCenter();
-    var zoom = map.getZoom();
-    var bounds = map.getBounds();
-    var minZoom = map.getMinZoom();
-    var maxZoom = map.getMaxZoom();
-    var size = map.getSize();
-    var pixelBounds = map.getPixelBounds();
-    var pixelOrigin = map.getPixelOrigin();
-    var pixelWorldBounds = map.getPixelWorldBounds();
-    return {
-        center: center,
-        zoom: zoom,
-        bounds: bounds,
-        minZoom: minZoom,
-        maxZoom: maxZoom,
-        size: size,
-        pixelBounds: pixelBounds,
-        pixelOrigin: pixelOrigin,
-        pixelWorldBounds: pixelWorldBounds
-    }
-}

beratools/third_party/pyqtlet2/web/map.html

@@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<html>
-    <head>
-        <title>Map</title>
-        <meta charset="utf-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <!-- Leaflet CSS -->
-        <link rel="stylesheet" href="modules/leaflet_193/leaflet.css"/>
-        <link rel="stylesheet" href="modules/leaflet_draw_414/leaflet.draw.css"/>
-        <!-- QWebChannel -->
-        <script src="qrc:///qtwebchannel/qwebchannel.js"></script>
-    </head>
-    <body style="margin: 0px">
-        <div id="map" style="width: 100vw; height: 100vh;"></div>
-        <!-- Leaflet JS -->
-        <script src='modules/leaflet_193/leaflet.js'></script>
-        <script src='modules/leaflet_draw_414/leaflet.draw.js'></script>
-        <script src='modules/leaflet_rotatedMarker_020/leaflet.rotatedMarker.js'></script>
-        <!-- Custom JS -->
-        <script src='custom.js'></script>
-    </body>
-</html>
-