GridCal 5.3.4__tar.gz → 5.3.5__tar.gz

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Branches/line_location_graphic_item.py

@@ -144,7 +144,7 @@ class LineLocationGraphicItem(QtWidgets.QGraphicsEllipseItem, NodeTemplate):
             x = pos.x() - self.rect().width() / 2
             y = pos.y() - self.rect().height() / 2
             self.setRect(x, y, self.rect().width(), self.rect().height())
-            self.set_callabacks(pos.x(), pos.y())
+            self.set_callbacks(pos.x(), pos.y())
 
             if self.hovered and self.enabled:
                 self.update_position()
@@ -232,13 +232,7 @@ class LineLocationGraphicItem(QtWidgets.QGraphicsEllipseItem, NodeTemplate):
         # Implement the functionality for Action 1 here
         self.editor.remove_line_location_graphic(self)
 
-    def MergeFunction(self):
-        """
 
-        :return:
-        """
-        self.editor.merge_lines()
-        pass
 
     def setNodeColor(self, inner_color: QColor, border_color: QColor = None) -> None:
         """

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Branches/map_line_container.py

@@ -47,7 +47,6 @@ class MapLineContainer(GenericDiagramWidget):
         self.nodes_list: List[LineLocationGraphicItem] = list()
         self.segments_list: List[MapLineSegment] = list()
         self.enabled = True
-        self.original = True  # TODO: Que es esto?
 
     def set_width_scale(self, branch_scale: float, arrow_scale: float):
         """
@@ -469,7 +468,7 @@ class MapLineContainer(GenericDiagramWidget):
         for line in self.segments_list:
             line.set_enable(val=False)
 
-    def set_arrows_with_power(self, Sf: complex, St: complex) -> None:
+    def set_arrows_with_power(self, Sf: complex | None, St: complex | None) -> None:
         """
 
         :param Sf:

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Branches/map_line_segment.py

@@ -63,7 +63,7 @@ class MapLineSegment(QGraphicsLineItem):
         self.first.add_position_change_callback(self.set_from_side_coordinates)
         self.second.add_position_change_callback(self.set_to_side_coordinates)
 
-        self.set_colour(self.color, self.style)
+        self._pen = self.set_colour(self.color, self.style)
         self.update_endings()
         self.needsUpdate = True
         self.setZValue(0)
@@ -93,9 +93,9 @@ class MapLineSegment(QGraphicsLineItem):
         :param width:
         :return:
         """
-        pen = self.pen()
-        pen.setWidthF(width)
-        self.setPen(pen)
+        if self._pen.widthF() != width:  # Only update if width changes
+            self._pen.setWidthF(width)
+            self.setPen(self._pen)
 
     def set_arrow_scale(self, width: float):
         """
@@ -124,6 +124,8 @@ class MapLineSegment(QGraphicsLineItem):
         self.arrow_p_to.set_colour(color, self.arrow_p_to.w, style)
         self.arrow_q_to.set_colour(color, self.arrow_q_to.w, style)
 
+        return pen
+
     def set_from_side_coordinates(self, x: float, y: float):
         """
 
@@ -383,7 +385,7 @@ class MapLineSegment(QGraphicsLineItem):
             self.editor.circuit.delete_branch(obj=self.api_object)
             self.editor.delete_diagram_element(device=self.api_object)
 
-    def set_arrows_with_power(self, Sf: complex, St: complex) -> None:
+    def set_arrows_with_power(self, Sf: complex | None, St: complex | None) -> None:
         """
         Set the arrow directions
         :param Sf: Complex power from

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Substation/node_template.py

@@ -5,7 +5,7 @@
 from __future__ import annotations
 from typing import Union, TYPE_CHECKING, List, Callable
 from PySide6.QtCore import QPointF
-from PySide6.QtGui import QBrush, QColor
+from PySide6.QtGui import QBrush
 
 from GridCal.Gui.Diagrams.generic_graphics import GenericDiagramWidget
 
@@ -24,10 +24,15 @@ class NodeTemplate(GenericDiagramWidget):
                  api_object: ALL_DEV_TYPES = None,
                  editor: Union[GridMapWidget, None] = None,
                  draw_labels: bool = True,
-                 needsUpdate: bool = True,
                  lat: float = 0.0,
                  lon: float = 0.0):
         """
+
+        :param api_object: any GridCal device object
+        :param editor: GridMapWidget
+        :param draw_labels:
+        :param lat:
+        :param lon:
         """
         GenericDiagramWidget.__init__(self,
                                       parent=None,
@@ -35,7 +40,6 @@ class NodeTemplate(GenericDiagramWidget):
                                       editor=editor,
                                       draw_labels=draw_labels)
 
-        self.needs_update: bool = needsUpdate
         self.lat = lat
         self.lon = lon
 
@@ -52,7 +56,7 @@ class NodeTemplate(GenericDiagramWidget):
         """
         self._callbacks.append(fcn)
 
-    def set_callabacks(self, x: float, y: float) -> None:
+    def set_callbacks(self, x: float, y: float) -> None:
         """
         Call all callback functions with x, y
         :param x: x position

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Substation/substation_graphic_item.py

@@ -62,8 +62,14 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
         self.api_object: Substation = api_object  # reassign for the types to be clear
 
         self.radius = r
-        x, y = self.editor.to_x_y(lat=lat, lon=lon)
-        self.setRect(x, y, self.radius, self.radius)
+        r2 = r / 2
+        x, y = self.editor.to_x_y(lat=lat, lon=lon)  # upper left corner
+        self.setRect(
+            x - r2,
+            y - r2,
+            self.radius,
+            self.radius
+        )
 
         # Enable hover events for the item
         self.setAcceptHoverEvents(True)
@@ -113,7 +119,7 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
             r3 = r / 2
             xc = new_x + r3
             yc = new_y + r3
-            self.set_callabacks(xc, yc)
+            self.set_callbacks(xc, yc)
 
             for vl_graphics in self.voltage_level_graphics:
                 vl_graphics.center_on_substation()
@@ -155,8 +161,14 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
         :param lon:
         :return: x, y
         """
-        x, y = self.editor.to_x_y(lat=lat, lon=lon)
-        self.setRect(x, y, self.rect().width(), self.rect().height())
+        x, y = self.editor.to_x_y(lat=lat, lon=lon)  # upper left corner
+
+        self.setRect(
+            x - self.rect().width() / 2,
+            y - self.rect().height() / 2,
+            self.rect().width(),
+            self.rect().height()
+        )
 
         for vl in self.voltage_level_graphics:
             vl.center_on_substation()
@@ -224,13 +236,20 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
             x = pos.x() - self.rect().width() / 2
             y = pos.y() - self.rect().height() / 2
             self.setRect(x, y, self.rect().width(), self.rect().height())
-            self.set_callabacks(pos.x(), pos.y())
+            self.set_callbacks(pos.x(), pos.y())
 
             for vl_graphics in self.voltage_level_graphics:
                 vl_graphics.center_on_substation()
 
             self.update_position_at_the_diagram()  # always update
 
+        # QGraphicsRectItem.mouseMoveEvent(self, event)
+        # pos = self.mapToParent(event.pos())
+        # x = pos.x() + self.rect().width() / 2
+        # y = pos.y() + self.rect().height() / 2
+        # self.set_callbacks(x, y)
+        # self.update_position_at_the_diagram()  # always update
+
     def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
         """
         Event handler for mouse press events.
@@ -369,7 +388,7 @@ class SubstationGraphicItem(QGraphicsRectItem, NodeTemplate):
 
         if ok:
             x, y = self.move_to(lat=self.api_object.latitude, lon=self.api_object.longitude)  # this moves the vl too
-            self.set_callabacks(x, y)
+            self.set_callbacks(x, y)
 
     def new_substation_diagram(self):
         """

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Substation/voltage_level_graphic_item.py

@@ -203,6 +203,8 @@ class VoltageLevelGraphicItem(GenericDiagramWidget, QGraphicsEllipseItem):
                        icon_path="",
                        function_ptr=self.add_bus)
 
+        menu.exec_(event.screenPos())
+
     def set_color(self, inner_color: QColor = None, border_color: QColor = None) -> None:
         """
 
@@ -238,7 +240,7 @@ class VoltageLevelGraphicItem(GenericDiagramWidget, QGraphicsEllipseItem):
         :param width: New pen width.
         """
         pen = self.pen()
-        pen.setWidth(width)
+        pen.setWidth(width)  # keep this and do not change to setWidthF
         self.setPen(pen)
 
     def add_bus(self):

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Tiles/TileProviders/blue_marble.py

@@ -45,9 +45,9 @@ class BlueMarbleTiles(Tiles):
         """
 
         Tiles.__init__(self,
-                       TilesetName=name,
-                       TilesetShortName='BM Tiles',
-                       TilesetVersion='1.0',
+                       tile_set_name=name,
+                       tile_set_short_name='BM Tiles',
+                       tile_set_version='1.0',
                        levels=list(range(10)),
                        tile_width=256,
                        tile_height=256,
@@ -66,7 +66,7 @@ class BlueMarbleTiles(Tiles):
 
         Note that we assume the point *is* on the map!
 
-        Code taken from [http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
         """
 
         lat_rad = math.radians(latitude)
@@ -76,18 +76,18 @@ class BlueMarbleTiles(Tiles):
 
         return xtile, ytile
 
-    def Tile2Geo(self, xtile: float, ytile: float) -> Tuple[float, float]:
+    def Tile2Geo(self, x_tile: float, y_tile: float) -> Tuple[float, float]:
         """Convert tile fractional coordinates to geo for level in use.
 
         tile  a tupl;e (xtile,ytile) of tile fractional coordinates
 
         Note that we assume the point *is* on the map!
 
-        Code taken from [http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
         """
         n = 2.0 ** self.level
-        xgeo = xtile / n * 360.0 - 180.0
-        yrad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n)))
+        xgeo = x_tile / n * 360.0 - 180.0
+        yrad = math.atan(math.sinh(math.pi * (1 - 2 * y_tile / n)))
         ygeo = math.degrees(yrad)
 
         return xgeo, ygeo

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Tiles/TileProviders/cartodb.py

@@ -23,7 +23,6 @@
 """
 A tile source that serves OpenStreetMap tiles from server(s).
 """
-
 import math
 from typing import Tuple
 from GridCal.Gui.Diagrams.MapWidget.Tiles.tiles import Tiles
@@ -46,16 +45,15 @@ class CartoDbTiles(Tiles):
         :param tile_servers:
         """
 
-        super().__init__(TilesetName=name,
-                         TilesetShortName='CartoDb Dark Matter',
-                         TilesetVersion='1.0',
+        super().__init__(tile_set_name=name,
+                         tile_set_short_name='CartoDb Dark Matter',
+                         tile_set_version='1.0',
                          levels=list(range(22)),
                          tile_width=256,
                          tile_height=256,
                          tiles_dir=tiles_dir,
                          servers=[
-                             "http://basemaps.cartocdn.com/dark_all/"
-                             # http://basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png
+                             "https://basemaps.cartocdn.com/dark_all/"
                          ] if tile_servers is None else tile_servers,
                          url_path='/{Z}/{X}/{Y}.png',
                          max_server_requests=2,
@@ -73,28 +71,46 @@ class CartoDbTiles(Tiles):
     def Geo2Tile(self, longitude: float, latitude: float) -> Tuple[float, float]:
         """
         Convert geo to tile fractional coordinates for level in use.
-        geo  tuple of geo coordinates (xgeo, ygeo)
+        geo  tuple of geo coordinates (longitude, latitude)
         Note that we assume the point *is* on the map!
-        Code taken from [http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+
+        Lon./lat. to tile numbers:
+        n = 2 ^ zoom
+        x_tile = n * ((lon_deg + 180) / 360)
+        y_tile = n * (1 - (log(tan(lat_rad) + sec(lat_rad)) / π)) / 2
+
+        :return: This code returns the coordinate of the upper left point of the tile. (x_tile, y_tile)
         """
         lat_rad = math.radians(latitude)
-        n = 2.0 ** self.level
-        xtile = (longitude + 180.0) / 360.0 * n
-        ytile = ((1.0 - math.log(math.tan(lat_rad) + (1.0 / math.cos(lat_rad))) / math.pi) / 2.0) * n
+        n = math.pow(2.0, self.level)
+        x_tile = (longitude + 180.0) / 360.0 * n
+        y_tile = ((1.0 - math.log(math.tan(lat_rad) + (1.0 / math.cos(lat_rad))) / math.pi) / 2.0) * n
 
-        return xtile, ytile
+        return x_tile, y_tile
 
-    def Tile2Geo(self, xtile: float, ytile: float) -> Tuple[float, float]:
+    def Tile2Geo(self, x_tile: float, y_tile: float) -> Tuple[float, float]:
         """
         Convert tile fractional coordinates to geo for level in use.
-        tile  a tuple (xtile,ytile) of tile fractional coordinates
+        tile  a tuple (x_tile, y_tile) of tile fractional coordinates
         Note that we assume the point *is* on the map!
-        Code taken from [http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+
+        n = 2 ^ zoom
+        lon_deg = x_tile / n * 360.0 - 180.0
+        lat_rad = arctan(sinh(π * (1 - 2 * y_tile / n)))
+        lat_deg = lat_rad * 180.0 / π
+
+        This returns the NW-corner of the square.
+        Use the function with x_tile+1 and/or y_tile+1 to get the other corners.
+        With x_tile+0.5 & y_tile+0.5 it will return the center of the tile.
+
+        :return: This code returns the coordinate of the upper left point of the tile. (longitude, latitude)
         """
 
         n = 2.0 ** self.level
-        longitude = xtile / n * 360.0 - 180.0
-        yrad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n)))
-        latitude = math.degrees(yrad)
+        longitude = x_tile / n * 360.0 - 180.0
+        y_rad = math.atan(math.sinh(math.pi * (1 - 2 * y_tile / n)))
+        latitude = math.degrees(y_rad)
 
         return longitude, latitude

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Tiles/base_tiles.py

@@ -72,8 +72,8 @@ class BaseTiles(object):
         self.ppd_y = 0
 
         # TODO: implement map wrap-around
-        #        self.wrap_x = False
-        #        self.wrap_y = False
+        self.wrap_x = False
+        self.wrap_y = False
 
         # setup the tile cache
         self.cache = TilesCache(tiles_dir=tiles_dir, max_lru=max_lru)
@@ -207,13 +207,13 @@ class BaseTiles(object):
         Tile coordinates are measured from map top-left.
         """
 
-        #        # if we are wrapping X or Y, get wrapped tile coords
-        #        if self.wrap_x:
-        #            x = (x + self.num_tiles_x*self.tile_size_x) % self.num_tiles_x
-        #        if self.wrap_y:
-        #            y = (y + self.num_tiles_y*self.tile_size_y) % self.num_tiles_y
+        # if we are wrapping X or Y, get wrapped tile coords
+        if self.wrap_x:
+            x = (x + self.num_tiles_x * self.tile_size_x) % self.num_tiles_x
+        if self.wrap_y:
+            y = (y + self.num_tiles_y * self.tile_size_y) % self.num_tiles_y
 
-        # retrieve the tile
+            # retrieve the tile
         try:
             # get tile from cache
             return self.cache[(self.level, x, y)]
@@ -254,7 +254,6 @@ class BaseTiles(object):
         """
         Return True if tile at (level, x, y) is on-disk.
         """
-
         raise Exception('You must override BaseTiles.tile_on_disk(level, x, y))')
 
     def setCallback(self, callback: Callable[[int, float, float, QPixmap, bool], None]):
@@ -262,9 +261,7 @@ class BaseTiles(object):
         Set the "tile available" callback function.
         Only used with internet tiles.  See "tiles_net.py".
         """
-
-        pass
-        # raise Exception('You must override BaseTiles.setCallback(callback))')
+        raise Exception('You must override BaseTiles.setCallback(callback))')
 
     def Geo2Tile(self, longitude: float, latitude: float) -> Tuple[int, int]:
         """
@@ -277,12 +274,12 @@ class BaseTiles(object):
 
         raise Exception('You must override BaseTiles.Geo2Tile(xgeo, ygeo)')
 
-    def Tile2Geo(self, xtile: float, ytile: float) -> Tuple[float, float]:
+    def Tile2Geo(self, x_tile: float, y_tile: float) -> Tuple[float, float]:
         """
         Convert tile fractional coordinates to geo for level in use.
 
-        xtile  tile fractional X coordinate
-        ytile  tile fractional Y coordinate
+        :param x_tile:  tile fractional X coordinate
+        :param y_tile:  tile fractional Y coordinate
 
         Note that we assume the point *is* on the map!
         """

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Tiles/tile_worker.py

@@ -42,74 +42,6 @@ def log(val: str):
     print(val)
 
 
-
-
-# class OsmHandler(osm.SimpleHandler):
-#     def __init__(self):
-#         super().__init__()
-#         self.nodes = []
-#         self.ways = []
-#
-#     def node(self, n):
-#         self.nodes.append((n.location.lat, n.location.lon))
-#
-#     def way(self, w):
-#         self.ways.append([node.ref for node in w.nodes])
-#
-#
-# def render_pbf_to_pixmap(pbf_file: str, width=800, height=800) -> QPixmap:
-#     """
-#
-#     :param pbf_file:
-#     :param width:
-#     :param height:
-#     :return:
-#     """
-#     # Parse the .pbf file
-#     handler = OsmHandler()
-#     handler.apply_file(pbf_file)
-#
-#     # Setup Mercator projection
-#     mercator_proj = Proj("epsg:3857")
-#
-#     # Create a QPixmap and painter
-#     pixmap = QPixmap(width, height)
-#     pixmap.fill(Qt.GlobalColor.white)
-#     painter = QPainter(pixmap)
-#     painter.setPen(QPen(Qt.GlobalColor.black, 1))
-#
-#     # Scale coordinates to fit the pixmap
-#     bounds = {
-#         'min_x': float('inf'), 'max_x': float('-inf'),
-#         'min_y': float('inf'), 'max_y': float('-inf')
-#     }
-#     transformed_nodes = []
-#
-#     for lat, lon in handler.nodes:
-#         x, y = mercator_proj(lon, lat)
-#         transformed_nodes.append((x, y))
-#         bounds['min_x'] = min(bounds['min_x'], x)
-#         bounds['max_x'] = max(bounds['max_x'], x)
-#         bounds['min_y'] = min(bounds['min_y'], y)
-#         bounds['max_y'] = max(bounds['max_y'], y)
-#
-#     x_range = bounds['max_x'] - bounds['min_x']
-#     y_range = bounds['max_y'] - bounds['min_y']
-#     scale_x = width / x_range if x_range else 1
-#     scale_y = height / y_range if y_range else 1
-#     scale = min(scale_x, scale_y)
-#
-#     # Render nodes as points
-#     for x, y in transformed_nodes:
-#         scaled_x = int((x - bounds['min_x']) * scale)
-#         scaled_y = int((y - bounds['min_y']) * scale)
-#         painter.drawPoint(scaled_x, height - scaled_y)  # Flip y-axis for Qt's coordinate system
-#
-#     # Close the painter
-#     painter.end()
-#     return pixmap
-
-
 class TileWorker(QThread):
     """Thread class that gets request from queue, loads tile, calls callback."""
 

{gridcal-5.3.4 → gridcal-5.3.5}/GridCal/Gui/Diagrams/MapWidget/Tiles/tiles.py

@@ -35,34 +35,20 @@ import urllib
 from urllib import request
 from urllib.error import HTTPError
 import queue
-from PySide6.QtGui import QPixmap, QPainter, QPen, QColor
-
 from typing import List, Union
 from collections.abc import Callable
+from warnings import warn
+from PySide6.QtGui import QPixmap, QColor
+
 from GridCal.Gui.Diagrams.MapWidget.Tiles.base_tiles import BaseTiles
 from GridCal.Gui.Diagrams.MapWidget.Tiles.tile_worker import TileWorker
 
 
-def log(val: str):
-    print(val)
-
-
 # # set how old disk-cache tiles can be before we re-request them from the
 # # server.  this is the number of days old a tile is before we re-request.
 # # if 'None', never re-request tiles after first satisfied request.
 # RefreshTilesAfterDays = 60
 
-# define the error messages for various failures
-StatusError = {401: 'Looks like you need to be authorised for this server.',
-               404: 'You might need to check the tile addressing for this server.',
-               429: 'You are asking for too many tiles.', }
-
-
-
-
-
-
-
 
 class Tiles(BaseTiles):
     """
@@ -70,15 +56,15 @@ class Tiles(BaseTiles):
     """
 
     # allowed file types and associated values
-    AllowedFileTypes = {'png': 'PNG', 'jpg': 'JPG', 'pbf': 'PBF'}
+    AllowedFileTypes = {'png': 'PNG', 'jpg': 'JPG'}
 
     # the number of seconds in a day
     SecondsInADay = 60 * 60 * 24
 
     def __init__(self,
-                 TilesetName: str,
-                 TilesetShortName: str,
-                 TilesetVersion: str,
+                 tile_set_name: str,
+                 tile_set_short_name: str,
+                 tile_set_version: str,
                  levels: List[int],
                  tile_width: int,
                  tile_height: int,
@@ -88,10 +74,13 @@ class Tiles(BaseTiles):
                  url_path: str,
                  max_server_requests: int,
                  http_proxy,
-                 refetch_days: int = 60,
+                 re_fetch_days: int = 60,
                  attribution: str = ""):
         """
         Initialise a Tiles instance.
+        :param tile_set_name: Name of the tile set.
+        :param tile_set_short_name: Short name of the tile set.
+        :param tile_set_version: Version of the tile set.
         :param levels: a list of level numbers that are to be served
         :param tile_width: width of each tile in pixels
         :param tile_height: height of each tile in pixels
@@ -101,11 +90,11 @@ class Tiles(BaseTiles):
         :param url_path: path on server to each tile
         :param max_server_requests: maximum number of requests per server
         :param http_proxy: proxy to use if required
-        :param refetch_days: fetch new server tile if older than this in days (0 means don't ever update tiles)
+        :param re_fetch_days: fetch new server tile if older than this in days (0 means don't ever update tiles)
         """
-        self.TilesetName = TilesetName
-        self.TilesetShortName = TilesetShortName
-        self.TilesetVersion = TilesetVersion
+        self.tile_set_name = tile_set_name
+        self.tile_set_short_name = tile_set_short_name
+        self.tile_set_version = tile_set_version
 
         self.attribution_string = attribution
 
@@ -124,13 +113,13 @@ class Tiles(BaseTiles):
         self.url_path = url_path
         self.max_requests = max_server_requests
         self.http_proxy = http_proxy
-        self.refresh_tiles_after_days = refetch_days
+        self.refresh_tiles_after_days = re_fetch_days
 
-        # callback must be set by higher-level copde
+        # callback must be set by higher-level code
         self.callback: Union[None, Callable[[int, float, float, QPixmap, bool], None]] = None
 
         # calculate a re-request age, if specified
-        self.rerequest_age = (time.time() - self.refresh_tiles_after_days * self.SecondsInADay)
+        self.re_request_age = (time.time() - self.refresh_tiles_after_days * self.SecondsInADay)
 
         # tiles extent for tile data (left, right, top, bottom)
         self.extent = (-180.0, 180.0, -85.0511, 85.0511)
@@ -148,7 +137,7 @@ class Tiles(BaseTiles):
         # determine the file bitmap type
         try:
             self.filetype = self.AllowedFileTypes[tile_extension_lower]
-        except KeyError as e:
+        except KeyError:
             raise TypeError("Bad tile_extension value, got '%s', "
                             "expected one of %s"
                             % (str(tile_extension),
@@ -166,35 +155,33 @@ class Tiles(BaseTiles):
         # prepare the "pending" and "error" images
         self.pending_tile = QPixmap(256, 256)
         self.pending_tile.fill(QColor.fromRgb(50, 50, 50, 255))
-        # self.pending_tile.loadFromData(std.getPendingImage())
 
         self.error_tile = QPixmap(256, 256)
         self.error_tile.fill(QColor.fromRgb(255, 0, 0, 255))
-        # self.error_tile.loadFromData(std.getErrorImage())
 
-        # Usage
-        # pbf_file = "your_file.pbf"
-        # pixmap = render_pbf_to_pixmap(pbf_file)
-        # pixmap.save("output_map.png")
+        # define the error messages for various failures
+        StatusError = {401: 'Looks like you need to be authorised for this server.',
+                       404: 'You might need to check the tile addressing for this server.',
+                       429: 'You are asking for too many tiles.', }
 
         # test for firewall - use proxy (if supplied)
         test_url = self.servers[0] + self.url_path.format(Z=0, X=0, Y=0)
         try:
             r = request.Request(test_url, headers={'User-Agent': 'GridCal 5'})
             response = request.urlopen(r).read()
-            # request.urlopen(test_url)
+
         except HTTPError as e:
             # if it's fatal, log it and die, otherwise try a proxy
             status_code = e.code
-            log('Error: test_url=%s, status_code=%s' % (test_url, str(status_code)))
+            warn('Error: test_url=%s, status_code=%s' % (test_url, str(status_code)))
             error_msg = StatusError.get(status_code, None)
             if status_code:
                 msg = "\nYou got a " + str(status_code) + " (" + str(error_msg) + ") error from: " + str(test_url)
                 print(msg)
                 # raise RuntimeError(msg) from None
 
-            log('%s exception doing simple connection to: %s' % (type(e).__name__, test_url))
-            log(''.join(traceback.format_exc()))
+            warn('%s exception doing simple connection to: %s' % (type(e).__name__, test_url))
+            warn(''.join(traceback.format_exc()))
 
             if http_proxy:
                 proxy = request.ProxyHandler({'http': http_proxy})
@@ -225,7 +212,7 @@ class Tiles(BaseTiles):
                                     callback=self.tile_is_available,
                                     error_tile=self.error_tile,
                                     content_type=self.content_type,
-                                    re_request_age=self.rerequest_age,
+                                    re_request_age=self.re_request_age,
                                     error_image=self.error_tile,
                                     refresh_tiles_after_days=60)
                 self.workers.append(worker)
@@ -282,9 +269,9 @@ class Tiles(BaseTiles):
             tile = self.cache[(self.level, x, y)]
             if self.tile_on_disk(self.level, x, y):
                 tile_date = self.cache.tile_date((self.level, x, y))
-                if self.rerequest_age and (tile_date < self.rerequest_age):
+                if self.re_request_age and (tile_date < self.re_request_age):
                     self.get_server_tile(self.level, x, y)
-        except KeyError as e:
+        except KeyError:
             # not cached, start process of getting tile from 'net, return 'pending' image
             self.get_server_tile(self.level, x, y)
             tile = self.pending_tile
@@ -402,4 +389,4 @@ class Tiles(BaseTiles):
         self.refresh_tiles_after_days = num_days
 
         # recalculate this instance's age threshold in UNIX time
-        self.rerequest_age = time.time() - self.refresh_tiles_after_days * self.SecondsInADay
+        self.re_request_age = time.time() - self.refresh_tiles_after_days * self.SecondsInADay