GridCal 5.3.2__tar.gz → 5.3.4__tar.gz

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

@@ -211,6 +211,9 @@ class MapLineContainer(GenericDiagramWidget):
                 connection_elements.append(substation_to_graphics)
                 substation_to_graphics.line_container = self
 
+        br_scale = self.editor.get_branch_width()
+        arrow_scale = self.editor.get_arrow_scale()
+
         # second pass: create the segments
         for i in range(1, len(connection_elements)):
             elm1 = connection_elements[i - 1]
@@ -223,15 +226,19 @@ class MapLineContainer(GenericDiagramWidget):
             elm2.needsUpdate = True
             segment_graphic_object.needsUpdate = True
 
+            segment_graphic_object.set_width(br_scale * segment_graphic_object.width)  # Assign the pen to the line item
+            segment_graphic_object.set_arrow_scale(arrow_scale)
+
             # register the segment in the line
             self.add_segment(segment=segment_graphic_object)
 
             # draw the segment in the scene
             self.editor.add_to_scene(graphic_object=segment_graphic_object)
 
+
         self.update_connectors()
 
-        self.editor.update_device_sizes()
+        # self.editor.update_device_sizes()
 
     def substation_to(self):
         """

gridcal-5.3.4/GridCal/Gui/Diagrams/MapWidget/Tiles/TileProviders/open_infra_map.py

@@ -0,0 +1,102 @@
+# MIT License
+#
+# Copyright (c) 2018 Ross Wilson
+# Copyright (c) 2024, Santiago Peñate Vera
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+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
+
+
+class OimTiles(Tiles):
+    """An object to source server tiles for pySlipQt."""
+
+    def __init__(self, name: str = 'OpenInfraMap Tiles', tiles_dir='open_infra_map_tiles',
+                 http_proxy=None, tile_servers=None):
+        """
+
+        :param name:
+        :param tiles_dir:
+        :param http_proxy:
+        :param tile_servers:
+        """
+        """Override the base class for these tiles.
+
+        Basically, just fill in the BaseTiles class with values from above
+        and provide the Geo2Tile() and Tile2Geo() methods.
+        """
+        # https://openinframap.org/tiles/{z}/{x}/{y}.pbf
+        super().__init__(
+            TilesetName=name,
+            TilesetShortName='OSM Tiles',
+            TilesetVersion='1.0',
+            levels=list(range(20)),
+            tile_width=256,
+            tile_height=256,
+            tiles_dir=tiles_dir,
+            servers=[
+                'https://openinframap.org/tiles',
+            ] if tile_servers is None else tile_servers,
+            url_path='/{Z}/{X}/{Y}.pbf',
+            max_server_requests=2,
+            max_lru=10000,
+            http_proxy=http_proxy,
+            attribution="© OpenStreetMap contributors, OpenInfraMap"
+        )
+        # TODO: implement map wrap-around
+        #        self.wrap_x = True
+        #        self.wrap_y = False
+
+        # get tile information into instance
+        self.level = min(self.levels)
+        self.num_tiles_x, self.num_tiles_y, self.ppd_x, self.ppd_y = self.GetInfo(self.level)
+
+    def Geo2Tile(self, longitude: float, latitude: float) -> Tuple[int, int]:
+        """
+        Convert geo to tile fractional coordinates for level in use.
+        geo  tuple of geo coordinates (xgeo, ygeo)
+        Note that we assume the point *is* on the map!
+        Code taken from [https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames]
+        """
+        lat_rad = math.radians(latitude)
+        n = 2.0 ** self.level
+        xtile = int((longitude + 180.0) / 360.0 * n)
+        ytile = int(((1.0 - math.log(math.tan(lat_rad) + (1.0 / math.cos(lat_rad))) / math.pi) / 2.0) * n)
+
+        return xtile, ytile
+
+    def Tile2Geo(self, xtile: float, ytile: float) -> Tuple[float, float]:
+        """
+        Convert tile fractional coordinates to geo for level in use.
+        tile  a tuple (xtile,ytile) of tile fractional coordinates
+        Note that we assume the point *is* on the map!
+        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)))
+        ygeo = math.degrees(yrad)
+
+        return xgeo, ygeo

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

@@ -28,11 +28,10 @@ For example, see osm_tiles.py.
 """
 import queue
 import ssl
-# from urllib import request
 from urllib.request import Request, urlopen
 from collections.abc import Callable
-from PySide6.QtGui import QPixmap
 from PySide6.QtCore import QThread
+from PySide6.QtGui import QPixmap
 
 # SSL magic to solve the certificates hell
 # https://stackoverflow.com/questions/68275857/urllib-error-urlerror-urlopen-error-ssl-certificate-verify-failed-certifica
@@ -43,18 +42,86 @@ 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."""
 
     def __init__(self,
                  id_num: int,
                  server: str,
-                 tilepath: str,
+                 tile_path: str,
                  requests_cue: queue.Queue,
                  callback: Callable[[int, float, float, QPixmap, bool], None],  # level, x, y, pixmap, error
                  error_tile: QPixmap,
                  content_type: str,
-                 rerequest_age: float,
+                 re_request_age: float,
                  error_image: QPixmap,
                  refresh_tiles_after_days=60):
         """
@@ -62,12 +129,12 @@ class TileWorker(QThread):
         Results are returned in the callback() params.
         :param id_num: a unique numer identifying the worker instance
         :param server: server URL
-        :param tilepath: path to tile on server
+        :param tile_path: path to tile on server
         :param requests_cue: the request queue
         :param callback: function to call after tile available
         :param error_tile: image of error tile
         :param content_type: expected Content-Type string
-        :param rerequest_age: number of days in tile age before re-requesting (0 means don't update tiles)
+        :param re_request_age: number of days in tile age before re-requesting (0 means don't update tiles)
         :param error_image: the image to return on some error
         :param refresh_tiles_after_days:
         """
@@ -76,12 +143,12 @@ class TileWorker(QThread):
 
         self.id_num = id_num
         self.server = server
-        self.tilepath = tilepath
+        self.tile_path = tile_path
         self.requests_cue = requests_cue
         self.callback: Callable[[int, float, float, QPixmap, bool], None] = callback
         self.error_tile_image = error_tile
         self.content_type = content_type
-        self.rerequest_age = rerequest_age
+        self.re_request_age = re_request_age
         self.error_image = error_image
         self.daemon = True
         self.refresh_tiles_after_days = refresh_tiles_after_days
@@ -98,7 +165,7 @@ class TileWorker(QThread):
             # try to retrieve the image
             error = False
             pixmap = self.error_image
-            tile_url = self.server + self.tilepath.format(Z=level, X=x, Y=y)
+            tile_url = self.server + self.tile_path.format(Z=level, X=x, Y=y)
             try:
 
                 # Create a Request object with the desired headers

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

@@ -35,7 +35,8 @@ import urllib
 from urllib import request
 from urllib.error import HTTPError
 import queue
-from PySide6.QtGui import QPixmap, QColor
+from PySide6.QtGui import QPixmap, QPainter, QPen, QColor
+
 from typing import List, Union
 from collections.abc import Callable
 from GridCal.Gui.Diagrams.MapWidget.Tiles.base_tiles import BaseTiles
@@ -57,13 +58,19 @@ StatusError = {401: 'Looks like you need to be authorised for this server.',
                429: 'You are asking for too many tiles.', }
 
 
+
+
+
+
+
+
 class Tiles(BaseTiles):
     """
     A tile object to source server tiles for the widget.
     """
 
     # allowed file types and associated values
-    AllowedFileTypes = {'png': 'PNG', 'jpg': 'JPG'}
+    AllowedFileTypes = {'png': 'PNG', 'jpg': 'JPG', 'pbf': 'PBF'}
 
     # the number of seconds in a day
     SecondsInADay = 60 * 60 * 24
@@ -149,10 +156,9 @@ class Tiles(BaseTiles):
 
         # compose the expected 'Content-Type' string on request result
         # if we get here we know the extension is in self.AllowedFileTypes
-        if tile_extension_lower == 'jpg':
-            self.content_type = 'image/jpeg'
-        elif tile_extension_lower == 'png':
-            self.content_type = 'image/png'
+        # if tile_extension_lower in ['png', 'jpg']:
+
+        self.content_type = 'image/png'
 
         # set the list of queued unsatisfied requests to 'empty'
         self.queued_requests = {}
@@ -166,6 +172,11 @@ class Tiles(BaseTiles):
         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")
+
         # test for firewall - use proxy (if supplied)
         test_url = self.servers[0] + self.url_path.format(Z=0, X=0, Y=0)
         try:
@@ -209,12 +220,12 @@ class Tiles(BaseTiles):
             for num_thread in range(self.max_requests):
                 worker = TileWorker(id_num=num_thread,
                                     server=server,
-                                    tilepath=self.url_path,
+                                    tile_path=self.url_path,
                                     requests_cue=self.request_queue,
                                     callback=self.tile_is_available,
                                     error_tile=self.error_tile,
                                     content_type=self.content_type,
-                                    rerequest_age=self.rerequest_age,
+                                    re_request_age=self.rerequest_age,
                                     error_image=self.error_tile,
                                     refresh_tiles_after_days=60)
                 self.workers.append(worker)

{gridcal-5.3.2 → gridcal-5.3.4}/GridCal/Gui/Diagrams/MapWidget/grid_map_widget.py

@@ -4,17 +4,19 @@
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
 import os
-from typing import Union, List, Tuple, Dict, TYPE_CHECKING
+from typing import Union, List, Tuple, Dict, TYPE_CHECKING, Any
 import json
 import numpy as np
 import math
 import pandas as pd
+import asyncio
 from matplotlib import pyplot as plt
 
 from PySide6.QtWidgets import QGraphicsItem
 from collections.abc import Callable
 from PySide6.QtSvg import QSvgGenerator
-from PySide6.QtCore import (Qt, QSize, QRect, QMimeData, QIODevice, QByteArray, QDataStream, QModelIndex)
+from PySide6.QtCore import (Qt, QSize, QRect, QMimeData, QIODevice, QByteArray, QDataStream, QModelIndex,
+                            QRunnable, QThreadPool, Slot)
 from PySide6.QtGui import (QIcon, QPixmap, QImage, QPainter, QStandardItemModel, QStandardItem, QColor,
                            QDropEvent, QWheelEvent)
 
@@ -258,6 +260,10 @@ class GridMapWidget(BaseDiagramWidget):
         self.startWi = self.map.view.width()
         self.constantLineWidth = True
 
+        # pool of runnable tasks that work best done asynch with a runnable
+        self.thread_pool = QThreadPool()
+        self.wheel_move_task: QRunnable | None = None
+
         # draw
         self.draw()
 
@@ -897,6 +903,7 @@ class GridMapWidget(BaseDiagramWidget):
         # SANTIAGO: DO NOT TOUCH, THIS IS THE DESIRED BEHAVIOUR
         self.update_device_sizes()
 
+
     def get_branch_width(self) -> float:
         """
         Get the desired branch width
@@ -930,12 +937,27 @@ class GridMapWidget(BaseDiagramWidget):
         scale = self.diagram.min_bus_width + (zoom - min_zoom) / (max_zoom - min_zoom)
         return scale
 
-    def update_device_sizes(self) -> None:
+    def update_device_sizes(self, asynchronously: bool = True) -> None:
         """
-        Updat ethe devices' sizes
+        Caller to the asynchronous device update sizes
         :return:
         """
+        if asynchronously:
+            try:
+                loop = asyncio.get_event_loop()
+                self.wheel_move_task = loop.create_task(self.__update_device_sizes())
+            except RuntimeError:
+                pass
+        else:
+            # do it now
+            asyncio.run(self.__update_device_sizes())
 
+    async def __update_device_sizes(self) -> None:
+        """
+        Update the devices' sizes
+        :return:
+        """
+        print('Updating device sizes!')
         br_scale = self.get_branch_width()
         arrow_scale = self.get_arrow_scale()
         se_scale = self.get_substation_scale()

{gridcal-5.3.2 → gridcal-5.3.4}/GridCal/Gui/Diagrams/MapWidget/map_widget.py

@@ -49,7 +49,7 @@ ygeo: latitude
 from __future__ import annotations
 from typing import List, Union, Tuple, Callable, TYPE_CHECKING
 from enum import Enum
-from PySide6.QtCore import Qt, QTimer, QEvent, QPointF
+from PySide6.QtCore import Qt, QEvent, QPointF
 from PySide6.QtGui import (QPainter, QColor, QPixmap, QCursor,
                            QMouseEvent, QKeyEvent, QWheelEvent,
                            QResizeEvent, QEnterEvent, QPaintEvent, QDragEnterEvent, QDragMoveEvent, QDropEvent)
@@ -510,13 +510,13 @@ class MapWidget(QWidget):
         self.setCursor(self.standard_cursor)
 
         # do a "resize" after this function
-        QTimer.singleShot(10, self.resizeEvent)
+        # QTimer.singleShot(10, self.resizeEvent)
 
         self.GotoLevelAndPosition(level=6,
                                   longitude=0,
                                   latitude=40)
 
-        # add the widgets in a leyered manner
+        # add the widgets in a layered manner
         # self.layout.addWidget(self.notice_widget)
         self.layout.addWidget(self.view)  # Add the QGraphicsView to the layout
 

{gridcal-5.3.2 → gridcal-5.3.4}/GridCal/Gui/Main/SubClasses/Model/diagrams.py

@@ -41,6 +41,7 @@ from GridCal.Gui.Main.object_select_window import ObjectSelectWindow
 from GridCal.Gui.Diagrams.MapWidget.Tiles.TileProviders.blue_marble import BlueMarbleTiles
 from GridCal.Gui.Diagrams.MapWidget.Tiles.TileProviders.cartodb import CartoDbTiles
 from GridCal.Gui.Diagrams.MapWidget.Tiles.TileProviders.open_street_map import OsmTiles
+from GridCal.Gui.Diagrams.MapWidget.Tiles.TileProviders.open_infra_map import OimTiles
 
 ALL_EDITORS = Union[SchematicWidget, GridMapWidget]
 ALL_EDITORS_NONE = Union[None, SchematicWidget, GridMapWidget]
@@ -160,23 +161,28 @@ class DiagramsMain(CompiledArraysMain):
             CartoDbTiles(
                 name='Carto voyager',
                 tiles_dir=os.path.join(tiles_path(), 'carto_db_voyager'),
-                tile_servers=["http://basemaps.cartocdn.com/rastertiles/voyager/"]
+                tile_servers=["https://basemaps.cartocdn.com/rastertiles/voyager/"]
             ),
             CartoDbTiles(
                 name='Carto positron',
                 tiles_dir=os.path.join(tiles_path(), 'carto_db_positron'),
-                tile_servers=['http://basemaps.cartocdn.com/light_all/']
+                tile_servers=['https://basemaps.cartocdn.com/light_all/']
             ),
             CartoDbTiles(
                 name='Carto dark matter',
                 tiles_dir=os.path.join(tiles_path(), 'carto_db_dark_matter'),
-                tile_servers=["http://basemaps.cartocdn.com/dark_all/"]
+                tile_servers=["https://basemaps.cartocdn.com/dark_all/"]
             ),
             OsmTiles(
                 name='Open Street Map',
                 tiles_dir=os.path.join(tiles_path(), 'osm'),
                 tile_servers=["https://tile.openstreetmap.org"]
-            )
+            ),
+            # OimTiles(
+            #     name='Open infra Map',
+            #     tiles_dir=os.path.join(tiles_path(), 'osm'),
+            #     tile_servers=["https://openinframap.org/tiles"]
+            # )
         ]
         tile_names = [tile.TilesetName for tile in self.tile_sources]
         self.tile_index_dict = {tile.TilesetName: i for i, tile in enumerate(self.tile_sources)}
@@ -1526,7 +1532,7 @@ class DiagramsMain(CompiledArraysMain):
                 diagram_widget.set_data(circuit=self.circuit, diagram=diagram)
 
             elif isinstance(diagram_widget, GridMapWidget):
-                diagram_widget.update_device_sizes()
+                diagram_widget.update_device_sizes(asynchronously=False)
 
     def set_selected_diagram_on_click(self):
         """
@@ -1795,6 +1801,10 @@ class DiagramsMain(CompiledArraysMain):
 
         self.set_diagrams_list_view()
 
+        if len(self.diagram_widgets_list) > 0:
+            diagram = self.diagram_widgets_list[0]
+            self.set_diagram_widget(diagram)
+
     def add_map_diagram(self, ask: bool = True) -> None:
         """
         Adds a Map diagram

{gridcal-5.3.2 → gridcal-5.3.4}/GridCal/Gui/Main/SubClasses/base_gui.py

@@ -149,6 +149,8 @@ class BaseMainGui(QMainWindow):
         self.find_node_groups_driver: Union[sim.NodeGroupsDriver, None] = None
         self.file_sync_thread = syncdrv.FileSyncThread(self.circuit, None, None)
 
+        self.task_pool = QtCore.QThreadPool()
+
         # simulation start end
         self.simulation_start_index: int = -1
         self.simulation_end_index: int = -1
@@ -229,7 +231,7 @@ class BaseMainGui(QMainWindow):
 
         self.ui.grid_name_line_edit.textChanged.connect(self.change_circuit_name)
 
-        # comboboxes
+        # combo-boxes
         self.ui.fromComboBox.currentTextChanged.connect(self.update_from_to_list_views)
         self.ui.toComboBox.currentTextChanged.connect(self.update_from_to_list_views)
 

{gridcal-5.3.2 → gridcal-5.3.4}/GridCal/Gui/Main/SubClasses/io.py

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MPL-2.0
 
 import os
+import asyncio
 from typing import Union, List, Callable
 import pandas as pd
 from PySide6 import QtWidgets
@@ -51,7 +52,7 @@ class IoMain(ConfigurationMain):
         self.rosetta_gui: Union[RosetaExplorerGUI, None] = None
 
         self.accepted_extensions = ['.gridcal', '.dgridcal', '.xlsx', '.xls', '.sqlite', '.gch5',
-                                    '.dgs', '.m', '.raw', '.RAW', '.json',
+                                    '.dgs', '.m', '.raw', '.RAW', '.json', '.uct',
                                     '.ejson2', '.ejson3', '.p', '.nc', '.hdf5',
                                     '.xml', '.rawx', '.zip', '.dpx', '.epc', '.EPC',
                                     '.gcplugin']
@@ -261,7 +262,7 @@ class IoMain(ConfigurationMain):
             files_types += "*.dgridcal "
 
         files_types += "*.gch5 *.xlsx *.xls *.sqlite *.dgs "
-        files_types += "*.m *.raw *.RAW *.rawx *.json *.ejson2 *.ejson3 *.xml "
+        files_types += "*.m *.raw *.RAW *.rawx *.uct *.json *.ejson2 *.ejson3 *.xml "
         files_types += "*.zip *.dpx *.epc *.EPC *.nc *.hdf5 *.p"
 
         dialogue = QtWidgets.QFileDialog(None,
@@ -343,12 +344,10 @@ class IoMain(ConfigurationMain):
 
                 if self.circuit.has_diagrams():
                     # create the diagrams that came with the file
+                    # task = gf.AsyncTask(self.create_circuit_stored_diagrams)
+                    # self.task_pool.start(task)
                     self.create_circuit_stored_diagrams()
 
-                    if len(self.diagram_widgets_list) > 0:
-                        diagram = self.diagram_widgets_list[0]
-                        self.set_diagram_widget(diagram)
-
                 else:
                     if self.circuit.get_bus_number() > 300:
                         quit_msg = ("The grid is quite large, hence the schematic might be slow.\n"

{gridcal-5.3.2 → gridcal-5.3.4}/GridCal/Gui/gui_functions.py

@@ -1001,3 +1001,13 @@ def create_int_spinbox(value: int, minimum: int, maximum: int) -> QtWidgets.QSpi
     sn_spinner.setMaximum(maximum)
     sn_spinner.setValue(value)
     return sn_spinner
+
+
+class AsyncTask(QtCore.QRunnable):
+    def __init__(self, task):
+        super().__init__()
+        self.task = task
+
+    @QtCore.Slot()
+    def run(self):
+        self.task()

{gridcal-5.3.2 → gridcal-5.3.4}/GridCal/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # do not forget to keep a three-number version!!!
-__GridCal_VERSION__ = "5.3.2"
+__GridCal_VERSION__ = "5.3.4"
 
 url = 'https://github.com/SanPen/GridCal'
 

{gridcal-5.3.2 → gridcal-5.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GridCal
-Version: 5.3.2
+Version: 5.3.4
 Summary: GridCal is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/GridCal
 Author: Santiago Peñate Vera et. Al.