patrick/Pegelonline
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

code clean: PEP8 methodennamen

Browse Source
This commit is contained in:
Patrick Haßel 2025-09-27 15:59:38 +02:00
parent 127f9dca7d
commit 51f772b3ac
2 changed files with 151 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pegelonline_dockwidget_base.ui
View File

@ -274,7 +274,7 @@
</widget> </widget>
</item> </item>
<item> <item>
<widget class="QSpinBox" name="inHistoryDays"> <widget class="QSpinBox" name="numHistoryDays">
<property name="sizePolicy"> <property name="sizePolicy">
<sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed"> <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
<horstretch>0</horstretch> <horstretch>0</horstretch>

292
po_runner.py
View File

@ -4,7 +4,6 @@ from typing import Callable
from PyQt5 import QtGui from PyQt5 import QtGui
from qgis._core import QgsVectorLayer, QgsProject, QgsLayerTreeLayer, QgsPalLayerSettings, QgsVectorLayerSimpleLabeling from qgis._core import QgsVectorLayer, QgsProject, QgsLayerTreeLayer, QgsPalLayerSettings, QgsVectorLayerSimpleLabeling
from .pegelonline_dockwidget import PegelonlineDockWidget
from .pomodules.po_history import PoHistory from .pomodules.po_history import PoHistory
from .pomodules.po_stations import PoStations from .pomodules.po_stations import PoStations
from .pomodules.po_stations_qgs import PoStationsQgs from .pomodules.po_stations_qgs import PoStationsQgs
@ -28,17 +27,17 @@ class PoRunner(object):
self.areas = None self.areas = None
# ui Signale verbinden # ui Signale verbinden
self.connect_basemap_signals() self._connect_basemap_signals()
self.connect_stations_signals() self._connect_stations_signals()
self.connect_waterlevels_signals() self._waterlevels_connect_signals()
self.connect_history_signals() self._history_connect_signals()
self._historyLoadStations() self._history_load_stations()
# basemap ----------------------------------------------------------------- # basemap -----------------------------------------------------------------
def _basemapCreate(self, path, name, disconnect: Callable[[], None]) -> None | QgsVectorLayer: def _basemap_create(self, path, name, disconnect: Callable[[], None]) -> None | QgsVectorLayer:
print("_basemapCreate: %s" % (name,)) print("_basemap_create: %s" % (name,))
path = os.path.join(self.local_dir, "basemap", path) path = os.path.join(self.local_dir, "basemap", path)
basemap = QgsVectorLayer(path, name, "ogr") basemap = QgsVectorLayer(path, name, "ogr")
@ -55,108 +54,108 @@ class PoRunner(object):
# zum LayerTree hinzufügen # zum LayerTree hinzufügen
layer_tree = self.iface.layerTreeCanvasBridge().rootGroup() layer_tree = self.iface.layerTreeCanvasBridge().rootGroup()
layer_tree.insertChildNode(-1, QgsLayerTreeLayer(basemap)) # am unteren Ende anhängen → liegt somit unter stations/waterlevels layer_tree.insertChildNode(-1, QgsLayerTreeLayer(basemap)) # am unteren Ende anhängen → liegt somit unter stations/waterlevels
return basemap return basemap
# basemap signals --------------------------------------------------------- # basemap signals ---------------------------------------------------------
def connect_basemap_signals(self): def _connect_basemap_signals(self):
print("connect_basemap_signals") print("_connect_basemap_signals")
self.ui.cbBasemapLines.toggled.connect(self.cbBasemapLinesToggled) self.ui.cbBasemapLines.toggled.connect(self._cbBasemapLines_toggled)
self.ui.cbBasemapAreas.toggled.connect(self.cbBasemapAreasToggled) self.ui.cbBasemapAreas.toggled.connect(self._cbBasemapAreas_toggled)
def cbBasemapLinesToggled(self): def _cbBasemapLines_toggled(self):
checked = self.ui.cbBasemapLines.isChecked() checked = self.ui.cbBasemapLines.isChecked()
print("cbBasemapLinesToggled: %s" % (checked,)) print("_cbBasemapLines_toggled: %s" % (checked,))
if self.lines is None and checked: if self.lines is None and checked:
self.lines = self._basemapCreate("waters.gpkg|layername=water_l", "Flüsse", self.disconnectBasemapLines) self.lines = self._basemap_create("waters.gpkg|layername=water_l", "Flüsse", self._basemap_disconnect_lines)
if self.lines is not None: if self.lines is not None:
self._layerSetVisible(self.lines, checked) self._layer_set_visible(self.lines, checked)
self._layerRefresh(self.lines) self._layer_refresh(self.lines)
def cbBasemapAreasToggled(self): def _cbBasemapAreas_toggled(self):
checked = self.ui.cbBasemapAreas.isChecked() checked = self.ui.cbBasemapAreas.isChecked()
print("cbBasemapAreasToggled: %s" % (checked,)) print("_cbBasemapAreas_toggled: %s" % (checked,))
if self.areas is None and checked: if self.areas is None and checked:
self.areas = self._basemapCreate("waters.gpkg|layername=water_f", "Flächen", self.disconnectBasemapAreas) self.areas = self._basemap_create("waters.gpkg|layername=water_f", "Flächen", self._basemap_disconnect_areas)
if self.areas is not None: if self.areas is not None:
self._layerSetVisible(self.areas, checked) self._layer_set_visible(self.areas, checked)
self._layerRefresh(self.areas) self._layer_refresh(self.areas)
def disconnectBasemapLines(self): def _basemap_disconnect_lines(self):
print("disconnectBasemapLines") print("_basemap_disconnect_lines")
self.lines = None self.lines = None
self.ui.cbBasemapLines.setChecked(False) self.ui.cbBasemapLines.setChecked(False)
def disconnectBasemapAreas(self): def _basemap_disconnect_areas(self):
print("disconnectBasemapAreas") print("_basemap_disconnect_areas")
self.areas = None self.areas = None
self.ui.cbBasemapAreas.setChecked(False) self.ui.cbBasemapAreas.setChecked(False)
# stations ---------------------------------------------------------------- # stations ----------------------------------------------------------------
def connect_stations_signals(self): def _connect_stations_signals(self):
print("connect_stations_signals") print("_connect_stations_signals")
# noinspection DuplicatedCode # noinspection DuplicatedCode
self.ui.cbStationsVisible.toggled.connect(self.cbStationsVisibleToggled) self.ui.cbStationsVisible.toggled.connect(self._cbStationsVisible_toggled)
self.ui.cbStationsName.toggled.connect(self.cbStationsNameToggled) self.ui.cbStationsName.toggled.connect(self._cbStationsName_toggled)
self.ui.cbStationsNumber.toggled.connect(self.cbStationsNumberToggled) self.ui.cbStationsNumber.toggled.connect(self._cbStationsNumber_toggled)
self.ui.cbStationsAgency.toggled.connect(self.cbStationsAgencyToggled) self.ui.cbStationsAgency.toggled.connect(self._cbStationsAgency_toggled)
self.ui.cbStationsKm.toggled.connect(self.cbStationsKmToggled) self.ui.cbStationsKm.toggled.connect(self._cbStationsKm_toggled)
self.ui.cbStationsWater.toggled.connect(self.cbStationsWaterToggled) self.ui.cbStationsWater.toggled.connect(self._cbStationsWater_toggled)
def cbStationsVisibleToggled(self): def _cbStationsVisible_toggled(self):
visible = self.ui.cbStationsVisible.isChecked() visible = self.ui.cbStationsVisible.isChecked()
print("cbStationsVisibleToggled: %s" % (visible,)) print("_cbStationsVisible_toggled: %s" % (visible,))
if self.stations is None and visible: if self.stations is None and visible:
reader = PoStationsQgs() reader = PoStationsQgs()
features = reader.getStationsFeatures() features = reader.getStationsFeatures()
self.stations = self._layerFromReader(reader.fields, reader.crs, features, "Stationen") self.stations = self._layer_create_from_reader(reader.fields, reader.crs, features, "Stationen")
self._layerAdd(self.stations, "styles/label_stations.qml", self.disconnectStations) self._layer_add_to_instance(self.stations, "styles/label_stations.qml", self._stations_disconnect)
if self.stations is not None: if self.stations is not None:
self._layerSetVisible(self.stations, visible) self._layer_set_visible(self.stations, visible)
self._stationsUpdateLabeling() self._stations_update_labels()
def cbStationsNameToggled(self): def _cbStationsName_toggled(self):
checked = self.ui.cbStationsName.isChecked() checked = self.ui.cbStationsName.isChecked()
print("cbStationsNameToggled: %s" % (checked,)) print("_cbStationsName_toggled: %s" % (checked,))
self._stationsUpdateLabeling() self._stations_update_labels()
def cbStationsNumberToggled(self): def _cbStationsNumber_toggled(self):
checked = self.ui.cbStationsNumber.isChecked() checked = self.ui.cbStationsNumber.isChecked()
print("cbStationsNumberToggled: %s" % (checked,)) print("_cbStationsNumber_toggled: %s" % (checked,))
self._stationsUpdateLabeling() self._stations_update_labels()
def cbStationsAgencyToggled(self): def _cbStationsAgency_toggled(self):
checked = self.ui.cbStationsAgency.isChecked() checked = self.ui.cbStationsAgency.isChecked()
print("cbStationsAgencyToggled: %s" % (checked,)) print("_cbStationsAgency_toggled: %s" % (checked,))
self._stationsUpdateLabeling() self._stations_update_labels()
def cbStationsKmToggled(self): def _cbStationsKm_toggled(self):
checked = self.ui.cbStationsKm.isChecked() checked = self.ui.cbStationsKm.isChecked()
print("cbStationsKmToggled: %s" % (checked,)) print("_cbStationsKm_toggled: %s" % (checked,))
self._stationsUpdateLabeling() self._stations_update_labels()
def cbStationsWaterToggled(self): def _cbStationsWater_toggled(self):
checked = self.ui.cbStationsWater.isChecked() checked = self.ui.cbStationsWater.isChecked()
print("cbStationsWaterToggled: %s" % (checked,)) print("_cbStationsWater_toggled: %s" % (checked,))
self._stationsUpdateLabeling() self._stations_update_labels()
def disconnectStations(self): def _stations_disconnect(self):
print("disconnectStations") print("_stations_disconnect")
self.stations = None self.stations = None
self.ui.cbStationsVisible.setChecked(False) self.ui.cbStationsVisible.setChecked(False)
# noinspection DuplicatedCode # noinspection DuplicatedCode
def _stationsUpdateLabeling(self): def _stations_update_labels(self):
print("_stationsUpdateLabeling") print("_stations_update_labels")
if self.stations is None: if self.stations is None:
return return
@ -172,78 +171,79 @@ class PoRunner(object):
if self.ui.cbStationsWater.isChecked(): if self.ui.cbStationsWater.isChecked():
fields.append("water") fields.append("water")
self._layerUpdateLabeling(self.stations, fields) self._layer_update_labels(self.stations, fields)
# waterlevels ------------------------------------------------------------- # waterlevels -------------------------------------------------------------
def connect_waterlevels_signals(self): def _waterlevels_connect_signals(self):
print("connect_waterlevels_signals") print("_waterlevels_connect_signals")
# noinspection DuplicatedCode # noinspection DuplicatedCode
self.ui.cbWaterlevelsVisible.toggled.connect(self.cbWaterlevelsVisibleToggled) self.ui.cbWaterlevelsVisible.toggled.connect(self._cbWaterlevelsVisible_toggled)
self.ui.cbWaterlevelsName.toggled.connect(self.cbWaterlevelsNameToggled) self.ui.cbWaterlevelsName.toggled.connect(self._cbWaterlevelsName_toggled)
self.ui.cbWaterlevelsNumber.toggled.connect(self.cbWaterlevelsNumberToggled) self.ui.cbWaterlevelsNumber.toggled.connect(self._cbWaterlevelsNumber_toggled)
self.ui.cbWaterlevelsAgency.toggled.connect(self.cbWaterlevelsAgencyToggled) self.ui.cbWaterlevelsAgency.toggled.connect(self._cbWaterlevelsAgency_toggled)
self.ui.cbWaterlevelsTimestamp.toggled.connect(self.cbWaterlevelsTimestampToggled) self.ui.cbWaterlevelsTimestamp.toggled.connect(self._cbWaterlevelsTimestamp_toggled)
self.ui.cbWaterlevelsValue.toggled.connect(self.cbWaterlevelsValueToggled) self.ui.cbWaterlevelsValue.toggled.connect(self._cbWaterlevelsValue_toggled)
self.ui.cbWaterlevelsMean.toggled.connect(self.cbWaterlevelsMeanToggled) self.ui.cbWaterlevelsMean.toggled.connect(self._cbWaterlevelsMean_toggled)
self.ui.cbWaterlevelsAbsolute.toggled.connect(self.cbWaterlevelsAbsoluteToggled) self.ui.cbWaterlevelsAbsolute.toggled.connect(self._cbWaterlevelsAbsolute_toggled)
def cbWaterlevelsVisibleToggled(self): def _cbWaterlevelsVisible_toggled(self):
visible = self.ui.cbWaterlevelsVisible.isChecked() visible = self.ui.cbWaterlevelsVisible.isChecked()
print("cbWaterlevelsVisibleToggled: %s" % (visible,)) print("_cbWaterlevelsVisible_toggled: %s" % (visible,))
if self.waterlevels is None and visible: if self.waterlevels is None and visible:
reader = PoWaterlevelsQgs() reader = PoWaterlevelsQgs()
features = reader.getWaterlevelsFeatures() features = reader.getWaterlevelsFeatures()
self.waterlevels = self._layerFromReader(reader.fields, reader.crs, features, "Wasserstandinformationen") self.waterlevels = self._layer_create_from_reader(reader.fields, reader.crs, features, "Wasserstandinformationen")
self._layerAdd(self.waterlevels, "styles/label_currentw.qml", self.disconnectWaterlevels) self._layer_add_to_instance(self.waterlevels, "styles/label_currentw.qml", self.waterlevels_disconnect)
if self.waterlevels is not None: if self.waterlevels is not None:
self._layerSetVisible(self.waterlevels, visible) self._layer_set_visible(self.waterlevels, visible)
self._waterlevelsUpdateLabeling() self._waterlevels_update_labels()
def cbWaterlevelsNameToggled(self): def _cbWaterlevelsName_toggled(self):
checked = self.ui.cbWaterlevelsName.isChecked() checked = self.ui.cbWaterlevelsName.isChecked()
print("cbWaterlevelsNameName: %s" % (checked,)) print("_cbWaterlevelsName_toggled: %s" % (checked,))
self._waterlevelsUpdateLabeling() self._waterlevels_update_labels()
def cbWaterlevelsNumberToggled(self): def _cbWaterlevelsNumber_toggled(self):
checked = self.ui.cbWaterlevelsNumber.isChecked() checked = self.ui.cbWaterlevelsNumber.isChecked()
print("cbWaterlevelsNameNumber: %s" % (checked,)) print("_cbWaterlevelsNumber_toggled: %s" % (checked,))
self._waterlevelsUpdateLabeling() self._waterlevels_update_labels()
def cbWaterlevelsAgencyToggled(self): def _cbWaterlevelsAgency_toggled(self):
checked = self.ui.cbWaterlevelsAgency.isChecked() checked = self.ui.cbWaterlevelsAgency.isChecked()
print("cbWaterlevelsNameAgency: %s" % (checked,)) print("_cbWaterlevelsAgency_toggled: %s" % (checked,))
self._waterlevelsUpdateLabeling() self._waterlevels_update_labels()
def cbWaterlevelsTimestampToggled(self): def _cbWaterlevelsTimestamp_toggled(self):
checked = self.ui.cbWaterlevelsTimestamp.isChecked() checked = self.ui.cbWaterlevelsTimestamp.isChecked()
print("cbWaterlevelsTimestampToggled: %s" % (checked,)) print("_cbWaterlevelsTimestamp_toggled: %s" % (checked,))
self._waterlevelsUpdateLabeling() self._waterlevels_update_labels()
def cbWaterlevelsValueToggled(self): def _cbWaterlevelsValue_toggled(self):
checked = self.ui.cbWaterlevelsValue.isChecked() checked = self.ui.cbWaterlevelsValue.isChecked()
print("cbWaterlevelsValueToggled: %s" % (checked,)) print("_cbWaterlevelsValue_toggled: %s" % (checked,))
self._waterlevelsUpdateLabeling() self._waterlevels_update_labels()
def cbWaterlevelsMeanToggled(self): def _cbWaterlevelsMean_toggled(self):
checked = self.ui.cbWaterlevelsMean.isChecked() checked = self.ui.cbWaterlevelsMean.isChecked()
print("cbWaterlevelsMeanToggled: %s" % (checked,)) print("_cbWaterlevelsMean_toggled: %s" % (checked,))
self._waterlevelsUpdateLabeling() self._waterlevels_update_labels()
def cbWaterlevelsAbsoluteToggled(self): def _cbWaterlevelsAbsolute_toggled(self):
checked = self.ui.cbWaterlevelsAbsolute.isChecked() checked = self.ui.cbWaterlevelsAbsolute.isChecked()
print("cbWaterlevelsAbsoluteToggled: %s" % (checked,)) print("_cbWaterlevelsAbsolute_toggled: %s" % (checked,))
self._waterlevelsUpdateLabeling() self._waterlevels_update_labels()
def disconnectWaterlevels(self): def waterlevels_disconnect(self):
print("disconnectWaterlevels") print("waterlevels_disconnect")
self.waterlevels = None self.waterlevels = None
self.ui.cbWaterlevelsVisible.setChecked(False) self.ui.cbWaterlevelsVisible.setChecked(False)
# noinspection DuplicatedCode # noinspection DuplicatedCode
def _waterlevelsUpdateLabeling(self): def _waterlevels_update_labels(self):
print("_waterlevels_update_labels")
if self.waterlevels is None: if self.waterlevels is None:
return return
@ -262,22 +262,22 @@ class PoRunner(object):
fields.append("stateMnwMhw") fields.append("stateMnwMhw")
if self.ui.cbWaterlevelsAbsolute.isChecked(): if self.ui.cbWaterlevelsAbsolute.isChecked():
fields.append("stateNswHsw") fields.append("stateNswHsw")
self._layerUpdateLabeling(self.waterlevels, fields) self._layer_update_labels(self.waterlevels, fields)
# layers ------------------------------------------------------------------ # layers ------------------------------------------------------------------
def _layerSetVisible(self, basemap: QgsVectorLayer, visible): def _layer_set_visible(self, basemap: QgsVectorLayer, visible):
print("_layerSetVisible: %s => %s" % (basemap.name, visible)) print("_layer_set_visible: %s => %s" % (basemap.name, visible))
layer_tree = QgsProject.instance().layerTreeRoot().findLayer(basemap.id()) layer_tree = QgsProject.instance().layerTreeRoot().findLayer(basemap.id())
layer_tree.setItemVisibilityChecked(visible) layer_tree.setItemVisibilityChecked(visible)
def _layerFromReader(self, fields, crs, features, title) -> None | QgsVectorLayer: def _layer_create_from_reader(self, fields, crs, features, title) -> None | QgsVectorLayer:
print("_layerFromReader") print("_layer_create_from_reader")
if features is None: if features is None:
return None return None
layer_path = "Point?crs=%s" % (crs.authid(),) layer_path = "Point?crs=%s" % (crs.authid(),)
print("layer_path: " + layer_path) print("_layer_create_from_reader: layer_path: " + layer_path)
layer = QgsVectorLayer(layer_path, title, "memory") layer = QgsVectorLayer(layer_path, title, "memory")
provider = layer.dataProvider() provider = layer.dataProvider()
@ -287,7 +287,7 @@ class PoRunner(object):
provider.addFeatures(features) provider.addFeatures(features)
for error in provider.errors(): for error in provider.errors():
print("Fehler beim Hinzufügen von Features: " + error) print("_layer_create_from_reader: Fehler beim Hinzufügen von Features: " + error)
layer.updateExtents() layer.updateExtents()
@ -298,16 +298,16 @@ class PoRunner(object):
return None return None
def _layerAdd(self, layer: QgsVectorLayer, styles_path: str, disconnect: Callable[[], None]): def _layer_add_to_instance(self, layer: QgsVectorLayer, styles_path: str, disconnect: Callable[[], None]):
print("_layerShow") print("_layer_add_to_instance")
if layer is None: if layer is None:
print("_layerShow: Übergebener Layer ist None") print("_layer_add_to_instance: Fehler: Übergebener Layer ist None")
return return
# Styles laden # Styles laden
layer.loadNamedStyle(os.path.join(self.local_dir, styles_path)) layer.loadNamedStyle(os.path.join(self.local_dir, styles_path))
# disconnect setzen # disconnect Signal verbinden
layer.willBeDeleted.connect(disconnect) layer.willBeDeleted.connect(disconnect)
# zur Instanz hinzufügen # zur Instanz hinzufügen
@ -315,9 +315,10 @@ class PoRunner(object):
# zum LayerTree hinzufügen # zum LayerTree hinzufügen
layer_tree = self.iface.layerTreeCanvasBridge().rootGroup() layer_tree = self.iface.layerTreeCanvasBridge().rootGroup()
layer_tree.insertChildNode(0, QgsLayerTreeLayer(layer)) # am oberen Ende anhängen → liegt somit über basemap layer_tree.insertChildNode(0, QgsLayerTreeLayer(layer)) # am oberen Ende anhängen → liegt somit über basemap
def _layerUpdateLabeling(self, layer, fields): def _layer_update_labels(self, layer, fields):
print("_layer_update_labels")
labeling = QgsVectorLayerSimpleLabeling(QgsPalLayerSettings()) labeling = QgsVectorLayerSimpleLabeling(QgsPalLayerSettings())
# Anführungszeichen um Feldnamen anbringen # Anführungszeichen um Feldnamen anbringen
@ -333,9 +334,9 @@ class PoRunner(object):
layer.setLabeling(QgsVectorLayerSimpleLabeling(settings)) layer.setLabeling(QgsVectorLayerSimpleLabeling(settings))
layer.setLabelsEnabled(True) layer.setLabelsEnabled(True)
self._layerRefresh(layer) self._layer_refresh(layer)
def _layerRefresh(self, layer): def _layer_refresh(self, layer):
print("_layerRefresh") print("_layerRefresh")
if self.iface.mapCanvas().isCachingEnabled(): if self.iface.mapCanvas().isCachingEnabled():
layer.triggerRepaint() layer.triggerRepaint()
@ -344,39 +345,40 @@ class PoRunner(object):
# history signals --------------------------------------------------------- # history signals ---------------------------------------------------------
def connect_history_signals(self): def _history_connect_signals(self):
self.ui.slHistoryStation.currentTextChanged.connect(self.slHistoryStationChanged) print("_history_connect_signals")
self.ui.btnHistoryStationsRefresh.clicked.connect(self.btnHistoryStationsRefreshClicked) self.ui.slHistoryStation.currentTextChanged.connect(self._slHistoryStation_changed)
self.ui.inHistoryDays.valueChanged.connect(self.inHistoryDaysChanged) self.ui.btnHistoryStationsRefresh.clicked.connect(self._btnHistoryStationsRefresh_clicked)
self.ui.btnHistoryGo.clicked.connect(self._historyLoadGraph) self.ui.numHistoryDays.valueChanged.connect(self._numHistoryDays_changed)
self.ui.btnHistoryGo.clicked.connect(self._history_load_graph)
def btnHistoryStationsRefreshClicked(self): def _slHistoryStation_changed(self):
print("btnHistoryStationsRefreshClicked") print("_slHistoryStation_changed: %s" % (self.ui.slHistoryStation.currentText(),))
self._historyLoadStations() self._history_load_graph()
def slHistoryStationChanged(self): def _btnHistoryStationsRefresh_clicked(self):
print("slHistoryStationChanged: %s" % (self.ui.slHistoryStation.currentText(),)) print("_btnHistoryStationsRefresh_clicked")
self._historyLoadGraph() self._history_load_stations()
def inHistoryDaysChanged(self): def _numHistoryDays_changed(self):
print("inHistoryDays: %s" % (self.ui.inHistoryDays.value(),)) print("_numHistoryDays_changed: %s" % (self.ui.numHistoryDays.value(),))
def _historyLoadGraph(self): def _history_load_graph(self):
print("_history_load_graph")
station = self.ui.slHistoryStation.currentText() station = self.ui.slHistoryStation.currentText()
days = self.ui.inHistoryDays.value() days = self.ui.numHistoryDays.value()
print("_historyLoad: station=%s days=%s" % (station, days)) print("_history_load_graph: station=%s days=%s" % (station, days))
self.ui.lbHistory.clear() self.ui.lbHistory.clear()
self.ui.lbHistory.setText("Laden...")
if station == '' or station is None: if station == '' or station is None:
print("_historyLoad: Fehler: Ungültige Station: %s" % (station,)) print("_history_load_graph: Fehler: Ungültige Station: %s" % (station,))
self.ui.lbHistory.setText("Bitte Station wählen...") self.ui.lbHistory.setText("Bitte Station wählen...")
return return
if days is None or days < 1 or days > 30: if days is None or days < 1 or days > 30:
print("_historyLoad: Fehler: Ungültige Anzahl von Tagen: %s" % (days,)) print("_history_load_graph: Fehler: Ungültige Anzahl von Tagen: %s" % (days,))
self.ui.lbHistory.setText("Bitte Tage [1, 30] wählen...") self.ui.lbHistory.setText("Bitte Tage [1, 30] wählen...")
return return
@ -384,7 +386,7 @@ class PoRunner(object):
image_data = history.download() image_data = history.download()
if image_data is None or len(image_data) == 0: if image_data is None or len(image_data) == 0:
print("_historyLoad: Fehler: Keine Daten erhalten") print("_history_load_graph: Fehler: Keine Daten erhalten")
self.ui.lbHistory.setText("Fehler beim Download!") self.ui.lbHistory.setText("Fehler beim Download!")
return return
@ -393,29 +395,35 @@ class PoRunner(object):
self.ui.lbHistory.setPixmap(pixmap) self.ui.lbHistory.setPixmap(pixmap)
self.ui.lbHistory.resize(pixmap.width(), pixmap.height()) self.ui.lbHistory.resize(pixmap.width(), pixmap.height())
def _historyLoadStations(self): print("_history_load_graph: Bild erfolgreich geladen")
print("_init_history_signals")
# merke die aktuelle Station, um sie wiederherzustellen def _history_load_stations(self):
bisherige_station = self.ui.slHistoryStation.currentText() print("_history_load_stations")
# behalte die aktuelle Station, um sie (mit eventuell neuem Index) wiederherzustellen
current_station = self.ui.slHistoryStation.currentText()
print("_history_load_stations: bisherige_station=%s" % current_station)
self.ui.slHistoryStation.clear() self.ui.slHistoryStation.clear()
stations = PoStations().getStations() stations = PoStations().getStations()
if stations is None or len(stations) == 0: if stations is None or len(stations) == 0:
print("_init_history_signals: Fehler: Keine Stationen erhalten") print("_history_load_stations: Fehler: Keine Stationen erhalten")
return return
index = 0 index = 0
neuer_index = None neuer_index = None
for station in stations: for station in stations:
shortname = station['attributes']['shortname'] shortname = station['attributes']['shortname']
if shortname == bisherige_station: if shortname == current_station:
neuer_index = index neuer_index = index
self.ui.slHistoryStation.addItem(shortname) self.ui.slHistoryStation.addItem(shortname)
index += 1 index += 1
if neuer_index is not None: if neuer_index is not None:
self.ui.slHistoryStation.setCurrentIndex(neuer_index) self.ui.slHistoryStation.setCurrentIndex(neuer_index)
print("_history_load_stations: Bisherige Station \"%s\" mit neuem index=%d wiederhergestellt" % (current_station, neuer_index))
else: else:
self.ui.slHistoryStation.setCurrentIndex(0) self.ui.slHistoryStation.setCurrentIndex(0)
station = self.ui.slHistoryStation.currentText()
print("_history_load_stations: Bisherige Station \"%s\" nicht wiedergefunden. Nehme erste Station: %s" % (current_station, station))