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

beratools/gui_tk/tooltip.py

@@ -1,55 +0,0 @@
-# ---------------------------------------------------------------------------
-#
-# Tooltip.py
-# Script Author: SquareRoot17, retrieved at 01/01/2020 from
-# https://stackoverflow.com/questions/20399243/display-message-when-hovering-over-something-with-mouse-cursor-in-python
-# Modified by Gustavo Lopes Queiroz
-# Date: 2020-Jan-22
-#
-# Purpose: Allows for GUI tooltips when user hovers the cursor over elements
-#
-# ---------------------------------------------------------------------------
-try:
-    from tkinter import *
-except ImportError:
-    from Tkinter import *
-    
-class ToolTip(object):
-
-    def __init__(self, widget, wraplength = 0):
-        self.widget = widget
-        self.tipwindow = None
-        self.id = None
-        self.x = self.y = 0
-        self.wraplength = wraplength
-
-    def showtip(self, text):
-        "Display text in tooltip window"
-        self.text = text
-        if self.tipwindow or not self.text:
-            return
-        x, y, cx, cy = self.widget.bbox("insert")
-        x = x + self.widget.winfo_rootx() + 57
-        y = y + cy + self.widget.winfo_rooty() +27
-        self.tipwindow = tw = Toplevel(self.widget)
-        tw.wm_overrideredirect(1)
-        tw.wm_geometry("+%d+%d" % (x, y))
-        label = Label(tw, text=self.text, justify=LEFT,
-                      background="#ffffe0", relief=SOLID, borderwidth=1, wraplength = self.wraplength,
-                      font=("tahoma", "8", "normal"))
-        label.pack(ipadx=1)
-
-    def hidetip(self):
-        tw = self.tipwindow
-        self.tipwindow = None
-        if tw:
-            tw.destroy()
-
-def CreateToolTip(widget, text, wraplength = 500):
-    toolTip = ToolTip(widget, wraplength)
-    def enter(event):
-        toolTip.showtip(text)
-    def leave(event):
-        toolTip.hidetip()
-    widget.bind('<Enter>', enter)
-    widget.bind('<Leave>', leave)

beratools/third_party/pyqtlet2/__init__.py

@@ -1,9 +0,0 @@
-"""
-Bringing Leaflet maps to PyQt.
-"""
-
-__author__ = 'Leon Friedmann <leon.friedmann@tum.de>'
-__version__ = '0.9.3'
-
-from .mapwidget import MapWidget
-from .leaflet import L

beratools/third_party/pyqtlet2/leaflet/__init__.py

@@ -1,26 +0,0 @@
-from .map import Map
-from .layer import LayerGroup, FeatureGroup, imageOverlay
-from .layer.tile import TileLayer
-from .layer.marker import Marker
-from .layer.icon import Icon
-from .layer.vector import Circle, CircleMarker, Polygon, Polyline, Rectangle
-from .control import Control
-
-class L:
-    """
-    Leaflet namespace that holds reference to all the leaflet objects
-    """
-    map = Map
-    tileLayer = TileLayer
-    imageOverlay = imageOverlay
-    marker = Marker
-    icon = Icon
-    circleMarker = CircleMarker
-    polyline = Polyline
-    polygon = Polygon
-    rectangle = Rectangle
-    circle = Circle
-    layerGroup = LayerGroup
-    featureGroup = FeatureGroup
-    control = Control
-

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

@@ -1,6 +0,0 @@
-from .layers import Layers
-from .draw import Draw
-
-class Control:
-    layers = Layers
-    draw = Draw

beratools/third_party/pyqtlet2/leaflet/control/control.py

@@ -1,59 +0,0 @@
-import json
-import logging
-import os
-import time
-
-from qtpy.QtCore import Slot, Signal
-from ..core import Evented
-
-class Control(Evented):
-
-    # controlId is a static variable shared between all controls
-    # It is used to give unique names to controls
-    controlId = 0
-    # addedToMap and removedFromMap are signals for controls to
-    # know when they're added and removed from maps
-    addedToMap = Signal()
-    removedFromMap = Signal()
-
-    @property
-    def map(self):
-        return self._map
-
-    @map.setter
-    def map(self, map_):
-        self._map = map_
-        if map_ is None:
-            self.removedFromMap.emit()
-        else:
-            self.addedToMap.emit()
-
-    @property
-    def jsName(self):
-        return self._controlName
-
-    @property
-    def controlName(self):
-        return self._controlName
-
-    @controlName.setter
-    def controlName(self, name):
-        self._controlName = name
-
-    def __init__(self):
-        super().__init__()
-        self._map = None
-        self._controlName = self._getNewControlName()
-
-    def addTo(self, map_):
-        map_.addControl(self)
-        return self
-
-    def removeFrom(self, map_):
-        map_.removeControl(self)
-
-    def _getNewControlName(self):
-        controlName = 'c{}'.format(self.controlId)
-        Control.controlId += 1
-        return controlName
-

beratools/third_party/pyqtlet2/leaflet/control/draw.py

@@ -1,52 +0,0 @@
-from .control import Control
-# NOTE: Importing FeatureGroup here may not be the best idea
-from ..layer.featuregroup import FeatureGroup
-
-DEFAULT_POSITION = 'topleft'
-DEFAULT_CIRCLE = False
-DEFAULT_RECTANGLE = False
-
-class Draw(Control):
-
-    def __init__(self, options={}, handleFeatureGroup=True):
-        super().__init__()
-        self.options = options
-        self.handleFeatureGroup = handleFeatureGroup
-        self.featureGroup = None
-        self._handleOptions()
-        if self._map:
-            self._initJs()
-        if handleFeatureGroup:
-            self.addedToMap.connect(self.addDrawnToFeatureGroup)
-
-    def _initJs(self):
-        jsObject = 'new L.Control.Draw('
-        if self.options:
-            jsObject += '{options}'.format(options=self._stringifyForJs(self.options))
-        jsObject += ')'
-        self._createJsObject(jsObject, self._map.mapWidgetIndex)
-
-    def _handleOptions(self):
-        # If there are no options, then we want to set the default options
-        self.options['position'] = self.options.get('position', DEFAULT_POSITION)
-        draw = self.options.get('draw', {})
-        if draw is not False:
-            # We want to make sure the user wants draw functionality
-            draw['circle'] = draw.get('circle', DEFAULT_CIRCLE)
-            draw['rectangle'] = draw.get('rectangle', DEFAULT_RECTANGLE)
-            self.options['draw'] = draw
-        edit = self.options.get('edit', {})
-        if edit is not False:
-            # We want to make sure the user wants edit functionality
-            featureGroup = edit.get('featureGroup', None)
-            if featureGroup is None and self.handleFeatureGroup:
-                # If a feature group has not been set, create one and add it
-                featureGroup = FeatureGroup()
-                edit['featureGroup'] = featureGroup
-            self.featureGroup = featureGroup
-            self.options['edit'] = edit
-
-    def addDrawnToFeatureGroup(self):
-        self.map.addLayer(self.featureGroup)
-        self.map.drawCreated.connect(self.featureGroup.createAndAddDrawnLayer)
-

beratools/third_party/pyqtlet2/leaflet/control/layers.py

@@ -1,20 +0,0 @@
-from .control import Control
-
-class Layers(Control):
-
-    def __init__(self, layers=[], overlays={}, options=None):
-        super().__init__()
-        self.layers = layers
-        self.overlays = overlays
-        self.options = options
-        self._initJs()
-
-    def _initJs(self):
-        jsObject = 'L.control.layers({layers}'.format(layers=self._stringifyForJs(self.layers))
-        if self.overlays is not None:
-            jsObject += ', {overlays}'.format(overlays=self._stringifyForJs(self.overlays))
-        if self.options is not None:
-            jsObject += ', {options}'.format(options=self._stringifyForJs(self.options))
-        jsObject += ')'
-        self._createJsObject(jsObject)
-

beratools/third_party/pyqtlet2/leaflet/core/Parser.py

@@ -1,24 +0,0 @@
-class Parser:
-    @staticmethod
-    def dict_for_js(object_to_parse: dict) -> dict:
-        return_dict = {}
-        for key, value in object_to_parse.items():
-            if isinstance(value, bool):
-                return_dict[key] = str(value).lower()
-                continue
-
-            return_dict[key] = value
-        return return_dict
-
-    @staticmethod
-    def js_for_dict(object_to_parse: dict) -> dict:
-        return_dict = {}
-        for key, value in object_to_parse.items():
-            if isinstance(value, str):
-                value: str
-                if value.lower() in ["true", "false"]:
-                    return_dict[key] = True if value.lower() == "true" else False
-                    continue
-
-            return_dict[key] = value
-        return return_dict

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

@@ -1,2 +0,0 @@
-from .evented import Evented
-

beratools/third_party/pyqtlet2/leaflet/core/evented.py

@@ -1,180 +0,0 @@
-import logging
-
-from ... import mapwidget
-
-from qtpy.QtCore import QObject, QJsonValue
-
-
-class Evented(QObject):
-    '''
-    Base class for all pyqtlet2 objects.
-    Handles initiation, as well as all python<->js communication
-    '''
-    mapWidgets = []
-
-    def __init__(self, mapWidget=None, mapWidgetIndex=None):
-        '''
-        Base class for all pyqtlet2 objects
-        Handles initiation, as well as python-Js communication
-        The first pyqtlet2 object to be initiated should be pyqtlet2.L.map
-        This will allow all the pyqtlet2 objects to have access to the
-        widget and thus the ability to implement leaflet via python.
-
-        :param pyqtlet2.MapWidget mapWidget: The mapwidget object
-            Should only be sent once, when the first object is being 
-            initialised.
-        '''
-        super().__init__()
-        self._logger = logging.getLogger(__name__)
-        self.response = None
-
-        if isinstance(mapWidgetIndex, type(None)):
-            return
-
-        if mapWidget is None:
-            raise RuntimeError('L.map must be initialised before other pyqtlet2 objects')
-        if not issubclass(type(mapWidget), mapwidget.MapWidget):
-            raise TypeError(('Expected mapWidget of type pyqtlet2.MapWidget, '
-                            'received {type_}'.format(type_=type(mapWidget))))
-        self.mapWidgets.append(mapWidget)
-        js = ('var channelObjects = null;'
-              'new QWebChannel(qt.webChannelTransport, function(channel) {'
-              '    channelObjects = channel.objects;'
-              '});')
-        self.runJavaScript(js, mapWidgetIndex)
-        if mapWidget := self.getMapWidgetAtIndex(mapWidgetIndex):
-            mapWidget.page.titleChanged.connect(lambda: print('title changed'))
-
-    def getMapWidgetAtIndex(self, mapWidgetIndex):
-        if len(self.mapWidgets) > mapWidgetIndex:
-            return self.mapWidgets[mapWidgetIndex]
-        self._logger.error("No")
-        return None
-
-    def getJsResponse(self, js, mapWidgetIndex, callback):
-        '''
-        Runs javascript code in the mapWidget and triggers callback.
-
-        Can be used for custom use cases where information is required
-        from the mapwidget, and the existing code does not cover the
-        requirement
-        
-        :param str js: The javascript code
-        :param function callback: The function that will consume the 
-            javascript response
-
-        .. note:: 
-            Qt runs runJavaScript function asynchronously. So if we want 
-            to get a response from leaflet, we need to force it to be sync
-            In all that I have tried, I was unable to get the response from
-            the same function, so I am converting it to a method with callback
-        '''
-        self._logger.debug('Running JS with callback: {js}=>{callback}'.format(
-            js=js, callback=callback.__name__))
-        if mapWidget := self.getMapWidgetAtIndex(mapWidgetIndex):
-            mapWidget.page.runJavaScript(js, callback)
-        else:
-            self._logger.error(f"Can't find mapWidget at index: {mapWidgetIndex}")
-
-    def runJavaScript(self, js, mapWidgetIndex: int):
-        '''
-        Runs javascript code in the mapWidget.
-
-        Can be used for custom use cases where the existing code,
-        methods etc. do not cover the requirements.
-
-        :param str js: The javascript code
-        '''
-        self._logger.debug('Running JS: {js}'.format(js=js))
-        if mapWidget := self.getMapWidgetAtIndex(mapWidgetIndex):
-            mapWidget.page.runJavaScript(js)
-        else:
-            self._logger.error(f"Can't find mapWidget at index: {mapWidgetIndex}")
-
-    def _createJsObject(self, leafletJsObject, mapWidgetIndex):
-        '''
-        Function to create variables/objects in leaflet in the
-        javascript "engine", and registers the object so that it can
-        be called in the webchannel.
-
-        :param str leafletJsObject: javascript code that creates the
-            leaflet object
-        '''
-        # Creates the js object on the mapWidget page
-        js = 'var {name} = {jsObject}'.format(name=self.jsName, 
-                jsObject=leafletJsObject)
-        self.runJavaScript(js, mapWidgetIndex)
-        # register the object in the channel
-        if mapWidget := self.getMapWidgetAtIndex(mapWidgetIndex):
-            mapWidget.channel.registerObject(
-                    '{name}Object'.format(name=self.jsName), self)
-        else:
-            self._logger.error(f"Can't find mapWidget at index: {mapWidgetIndex}")
-
-    def _connectEventToSignal(self, event, signalEmitter, mapWidgetIndex):
-        # We need to delete some keys as they are causing circular structures
-        js = '{name}.on("{event}", function(e) {{\
-                  delete e.target;\
-                  delete e.sourceTarget;\
-                  e = copyWithoutCircularReferences([e], e);\
-                  channelObjects.{name}Object.{signalEmitter}(e)}})'.format(
-            name=self.jsName, event=event, signalEmitter=signalEmitter)
-        self.runJavaScript(js, mapWidgetIndex)
-
-    def _stringifyForJs(self, object_):
-        # When passing options to JS, sometimes we need to pass in objects
-        # this method and _handleObject take care of that
-        # Some arguments are strings and some are objects. We also make sure
-        # that the objects are not sent as strings. Similarly, we also convert
-        # python bool to js bool etc.
-        jsString = str(self._handleObject(object_))
-        jsString = jsString.replace('\'__pyqtletObjectStart__', '')
-        jsString = jsString.replace('\"__pyqtletObjectStart__', '')
-        jsString = jsString.replace('__pyqtletObjectEnd__\'', '')
-        jsString = jsString.replace('__pyqtletObjectEnd__\"', '')
-        return jsString
-
-    def _handleObject(self, object_):
-        if type(object_) is list:
-            return [self._handleObject(item) for item in object_]
-        if type(object_) is dict:
-            return {key: self._handleObject(object_[key]) for key in object_}
-        if issubclass(object_.__class__, Evented):
-            return '__pyqtletObjectStart__{name}__pyqtletObjectEnd__'.format(name=object_.jsName)
-        if object_ is True:
-            return '__pyqtletObjectStart__true__pyqtletObjectEnd__'
-        if object_ is False:
-            return '__pyqtletObjectStart__false__pyqtletObjectEnd__'
-        if object_ is None:
-            return '__pyqtletObjectStart__null__pyqtletObjectEnd__'
-        return object_
-
-    def _qJsonValueToDict(self, object_):
-        # Qt returns QJsonValue from within the QChannel. Converting
-        # that into a dict is a small recursive function.
-        if type(object_) is QJsonValue:
-            return self._qJsonValueToDict(self._qJsonToRespectiveType(object_))
-        if type(object_) is list:
-            return [self._qJsonValueToDict(item) for item in object_]
-        if type(object_) is dict:
-            return {key: self._qJsonValueToDict(object_[key]) for key in object_}
-        return object_
-
-    def _qJsonToRespectiveType(self, object_):
-        # A QJsonValue can be one of many types. This function just
-        # converts into the correct type
-        if object_.isArray():
-            return object_.toArray()
-        if object_.isBool():
-            return object_.toBool()
-        if object_.isDouble():
-            return object_.toDouble()
-        if object_.isNull():
-            return None
-        if object_.isObject():
-            return object_.toObject()
-        if object_.isString():
-            return object_.toString()
-        if object_.isUndefined():
-            return None
-

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

@@ -1,5 +0,0 @@
-from .featuregroup import FeatureGroup
-from .layer import Layer
-from .layergroup import LayerGroup
-from .imageoverlay import imageOverlay
-

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

@@ -1,34 +0,0 @@
-from .layergroup import LayerGroup
-from ..layer import marker, vector
-
-class FeatureGroup(LayerGroup):
-    """
-    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. 
-    """
-
-    def _initJs(self):
-        leafletJsObject = 'new L.featureGroup()'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)
-
-    def createAndAddDrawnLayer(self, drawnLayer, options=None):
-        layerType = drawnLayer['layerType']
-        if layerType == 'polygon':
-            coords = drawnLayer['layer']['_latlngs']['0']
-            coords = [coords[p] for p in coords]
-            self.addLayer(vector.Polygon(coords, options))
-        elif layerType == 'marker':
-            coords = drawnLayer['layer']['_latlng']
-            self.addLayer(marker.Marker(coords, options))
-        elif layerType == 'polyline':
-            coords = drawnLayer['layer']['_latlngs']
-            coords = [coords[p] for p in coords]
-            self.addLayer(vector.Polyline(coords, options))
-        elif layerType == 'rectangle':
-            coords = drawnLayer['layer']['_latlngs']['0']
-            coords = [coords[p] for p in coords]
-            self.addLayer(vector.Rectangle(coords, options))
-        elif layerType == 'circle':
-            coords = drawnLayer['layer']['_latlng']
-            radius = drawnLayer['layer']['options']['radius']
-            self.addLayer(vector.Circle([coords['lat'], coords['lng']], radius))
-            

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

@@ -1 +0,0 @@
-from .icon import Icon

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

@@ -1,30 +0,0 @@
-from ..layer import Layer
-from ...core.Parser import Parser
-import os
-
-
-class Icon(Layer):
-    def __init__(self, iconUrl: str, options=None):
-        super().__init__()
-        if isinstance(options, type(None)):
-            options = {}
-        self.iconUrl = iconUrl
-        self.icon_found = False
-        self.options = options
-        self._check_icon_url()
-        if self._map:
-            self._initJs()
-
-    def _check_icon_url(self):
-        if "http" in self.iconUrl:
-            self._log.info("Can't check if icon exists at url!")
-            return
-        if not os.path.isfile(self.iconUrl):
-            self._log.error(f"Can't locate file at path: '{self.iconUrl}'. Current working directory is '{os.getcwd()}'")
-            return
-        self.icon_found = True
-
-    def _initJs(self):
-        leafletJsObject = 'L.icon({options});'.format(options=Parser.dict_for_js({"iconUrl": self.iconUrl,
-                                                                                  **self.options}))
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)

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

@@ -1,18 +0,0 @@
-from .layer import Layer
-
-class imageOverlay(Layer):
-    def __init__(self, imageURL, bounds, options=None):
-        super().__init__()
-        self.imageURL = imageURL
-        self.bounds = bounds
-        self.options = options
-        if self._map:
-            self._initJs()
-        
-    def _initJs(self):
-        leafletJsObject = 'L.imageOverlay("{imageURL}",{bounds}'.format(imageURL=self.imageURL,bounds=self.bounds)
-        if self.options:
-            leafletJsObject += ', {options}'.format(options=self.options)
-        leafletJsObject += ')'
-        self._createJsObject(leafletJsObject, self._map.mapWidgetIndex)
-

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

@@ -1,105 +0,0 @@
-from ..core import Evented
-import logging
-from abc import abstractmethod
-
-class Layer(Evented):
-
-    # layerId is a static variable shared between all layers
-    # It is used to give unique names to layers
-    layerId = 0
-
-    @property
-    def layerName(self):
-        return self._layerName
-
-    @layerName.setter
-    def layerName(self, name):
-        self._layerName = name
-
-    @property
-    def jsName(self):
-        return self._layerName
-
-    @property
-    def map(self):
-        return self._map
-
-    @map.setter
-    def map(self, map_):
-        self._map = map_
-
-    @abstractmethod
-    def _initJs(self):
-        raise NotImplemented
-
-    def runJavaScriptForMapIndex(self, js):
-        if self._map is not None:
-            self.runJavaScript(js, self._map.mapWidgetIndex)
-
-    def getJsResponseForMapIndex(self, js, callback):
-        if self._map is not None:
-            self.getJsResponse(js, self._map.mapWidgetIndex, callback)
-
-    def __init__(self):
-        super().__init__()
-        self._map = None
-        self._layerName = self._getNewLayerName()
-        self._log = logging.getLogger(f"layer_{self._layerName}")
-        self._popup = None
-        self._popupOptions = None
-        self._tooltip = None
-        self._tooltipOptions = None
-
-    def _initPopupAndTooltip(self):
-        if self._popup is not None:
-            self._bindPopupOrTooltip("Popup", self._popup, self._popupOptions)
-        if self._tooltip is not None:
-            self._bindPopupOrTooltip("Tooltip", self._tooltip, self._tooltipOptions)
-
-    def _bindPopupOrTooltip(self, kind, content, options):
-        js = f'{self._layerName}.bind{kind}("{content}"'
-        if options is not None:
-            js += f', {self._stringifyForJs(options)}'
-        js += ')'
-        self.runJavaScriptForMapIndex(js)
-
-    def _getNewLayerName(self):
-        layerName = 'l{}'.format(self.layerId)
-        Layer.layerId += 1
-        return layerName
-
-    def addTo(self, map_):
-        map_.addLayer(self)
-        return self
-
-    def removeFrom(self, map_):
-        map_.removeLayer(self)
-        return self
-
-    def bindPopup(self, content, options=None):
-        self._popup = content
-        self._popupOptions = options
-        self._bindPopupOrTooltip("Popup", self._popup, self._popupOptions)
-        return self
-
-    def unbindPopup(self):
-        self._popup = None
-        self._popupOptions = None
-        js = '{layerName}.unbindPopup()'.format(layerName=self._layerName)
-        self.runJavaScriptForMapIndex(js)
-        return self
-
-    def bindTooltip(self, content, options=None):
-        self._tooltip = content
-        self._tooltipOptions = options
-        self._bindPopupOrTooltip("Tooltip", self._tooltip, self._tooltipOptions)
-        return self
-
-    def unbindTooltip(self):
-        self._tooltip = None
-        self._tooltipOptions = None
-        js = '{layerName}.unbindTooltip()'.format(layerName=self._layerName)
-        self.runJavaScriptForMapIndex(js)
-        return self
-
-