not1mm 24.3.16__py3-none-any.whl → 24.3.24__py3-none-any.whl

not1mm/bandmap.py

@@ -6,56 +6,27 @@ GPL V3
 """
 
 # pylint: disable=unused-import, c-extension-no-member, no-member, invalid-name, too-many-lines
-# pylint: disable=logging-fstring-interpolation, line-too-long
-
-from datetime import datetime, timezone
-from decimal import Decimal
-from json import loads
-from pathlib import Path
+# pylint: disable=logging-fstring-interpolation, line-too-long, no-name-in-module
 
 import logging
 import os
-
-# import pkgutil
 import platform
-import sys
 import sqlite3
+from datetime import datetime, timezone
+from decimal import Decimal
+from json import loads
 
-from PyQt5 import QtCore, QtGui
-from PyQt5 import QtNetwork
-from PyQt5 import QtWidgets, uic
+from PyQt5 import QtCore, QtGui, QtWidgets, uic, QtNetwork
+from PyQt5.QtCore import Qt
 
+import not1mm.fsutils as fsutils
 from not1mm.lib.multicast import Multicast
 
-os.environ["QT_QPA_PLATFORMTHEME"] = "gnome"
+logger = logging.getLogger(__name__)
 
 PIXELSPERSTEP = 10
 UPDATE_INTERVAL = 2000
 
-# DeprecationWarning: 'pkgutil.get_loader' is deprecated and slated for removal in Python 3.14
-# loader = pkgutil.get_loader("not1mm")
-# WORKING_PATH = os.path.dirname(loader.get_filename())
-WORKING_PATH = os.path.dirname(__loader__.get_filename())
-
-if "XDG_DATA_HOME" in os.environ:
-    DATA_PATH = os.environ.get("XDG_DATA_HOME")
-else:
-    DATA_PATH = str(Path.home() / ".local" / "share")
-DATA_PATH += "/not1mm"
-
-if "XDG_CONFIG_HOME" in os.environ:
-    CONFIG_PATH = os.environ.get("XDG_CONFIG_HOME")
-else:
-    CONFIG_PATH = str(Path.home() / ".config")
-CONFIG_PATH += "/not1mm"
-
-DARK_STYLESHEET = ""
-
-PREF = {}
-if os.path.exists(CONFIG_PATH + "/not1mm.json"):
-    with open(CONFIG_PATH + "/not1mm.json", "rt", encoding="utf-8") as file_descriptor:
-        PREF = loads(file_descriptor.read())
-
 
 class Band:
     """the band"""
@@ -108,16 +79,20 @@ class Database:
         self.db.row_factory = self.row_factory
         self.cursor = self.db.cursor()
         sql_command = (
-            "create table spots("
-            "ts DATETIME NOT NULL, "
+            "create table spots ("
             "callsign VARCHAR(15) NOT NULL, "
+            "ts DATETIME NOT NULL, "
             "freq DOUBLE NOT NULL, "
-            "band VARCHAR(6), "
             "mode VARCHAR(6), "
             "spotter VARCHAR(15) NOT NULL, "
             "comment VARCHAR(45));"
         )
         self.cursor.execute(sql_command)
+
+        self.cursor.execute("CREATE INDEX spot_call_index ON spots (callsign);")
+        self.cursor.execute("CREATE INDEX spot_freq_index ON spots (freq);")
+        self.cursor.execute("CREATE INDEX spot_ts_index ON spots (ts);")
+
         self.db.commit()
 
     @staticmethod
@@ -175,31 +150,27 @@ class Database:
         If False, do not delete any previous spots with the same callsign.
         Default is True.
 
-
         Returns
         -------
         Nothing.
         """
         try:
             if erase:
-                delete_call = (
-                    f"delete from spots where callsign = '{spot.get('callsign')}';"
-                )
-                self.cursor.execute(delete_call)
+                delete_call = "delete from spots where callsign = ?;"
+                self.cursor.execute(delete_call, (spot.get("callsign"),))
                 self.db.commit()
 
-            pre = "INSERT INTO spots("
-            values = []
-            columns = ""
-            placeholders = ""
-            for key in spot.keys():
-                columns += f"{key},"
-                values.append(spot[key])
-                placeholders += "?,"
-            post = f") VALUES({placeholders[:-1]});"
-
-            sql = f"{pre}{columns[:-1]}{post}"
-            self.cursor.execute(sql, tuple(values))
+            self.cursor.execute(
+                "INSERT INTO spots(callsign, ts, freq, mode, spotter, comment) VALUES(?, ?, ?, ?, ?, ?)",
+                (
+                    spot["callsign"],
+                    spot["ts"],
+                    spot["freq"],
+                    spot.get("mode", None),
+                    spot["spotter"],
+                    spot.get("comment", None),
+                ),
+            )
             self.db.commit()
         except sqlite3.IntegrityError:
             ...
@@ -239,7 +210,8 @@ class Database:
         A list of dicts.
         """
         self.cursor.execute(
-            f"select * from spots where freq >= {start} and freq <= {end} order by freq ASC;"
+            "select * from spots where freq >= ? and freq <= ? order by freq ASC;",
+            (start, end),
         )
         return self.cursor.fetchall()
 
@@ -261,7 +233,8 @@ class Database:
         """
 
         self.cursor.execute(
-            f"select * from spots where freq > {current} and freq <= {limit} order by freq ASC;"
+            "select * from spots where freq > ? and freq <= ? order by freq ASC;",
+            ({current}, limit),
         )
         return self.cursor.fetchone()
 
@@ -284,8 +257,8 @@ class Database:
         """
 
         self.cursor.execute(
-            f"select * from spots where freq >= {start} "
-            f"and freq <= {end} and callsign like '%{dx}%';"
+            "select * from spots where freq >= ? and freq <= ? and callsign like ?;",
+            (start, end, f"%{dx}%"),
         )
         return self.cursor.fetchone()
 
@@ -305,7 +278,8 @@ class Database:
         A list of dicts.
         """
         self.cursor.execute(
-            f"select * from spots where freq < {current} and freq >= {limit} order by freq DESC;"
+            "select * from spots where freq < ? and freq >= ? order by freq DESC;",
+            (current, limit),
         )
         return self.cursor.fetchone()
 
@@ -323,14 +297,13 @@ class Database:
         None
         """
         self.cursor.execute(
-            f"delete from spots where ts < datetime('now', '-{minutes} minutes');"
+            "delete from spots where ts < datetime('now', ?);",
+            (f"-{minutes} minutes",),
         )
 
 
-class MainWindow(QtWidgets.QMainWindow):
-    """
-    The main window
-    """
+class BandMapWindow(QtWidgets.QDockWidget):
+    """The BandMapWindow class."""
 
     zoom = 5
     currentBand = Band("20m")
@@ -346,14 +319,14 @@ class MainWindow(QtWidgets.QMainWindow):
     bandwidth_mark = []
     worked_list = {}
     multicast_interface = None
+    text_color = QtGui.QColor(45, 45, 45)
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._udpwatch = None
-        data_path = WORKING_PATH + "/data/bandmap.ui"
-        uic.loadUi(data_path, self)
-        if PREF.get("dark_mode"):
-            self.setStyleSheet(DARK_STYLESHEET)
+
+        uic.loadUi(fsutils.APP_DATA_PATH / "bandmap.ui", self)
+        self.settings = self.get_settings()
         self.agetime = self.clear_spot_olderSpinBox.value()
         self.clear_spot_olderSpinBox.valueChanged.connect(self.spot_aging_changed)
         self.clearButton.clicked.connect(self.clear_spots)
@@ -375,35 +348,75 @@ class MainWindow(QtWidgets.QMainWindow):
         self.update_timer = QtCore.QTimer()
         self.update_timer.timeout.connect(self.update_station_timer)
         self.update_timer.start(UPDATE_INTERVAL)
+        self.setDarkMode(self.settings.get("darkmode", False))
         self.update()
         self.multicast_interface = Multicast(
-            PREF.get("multicast_group", "239.1.1.1"),
-            PREF.get("multicast_port", 2239),
-            PREF.get("interface_ip", "0.0.0.0"),
+            self.settings.get("multicast_group", "239.1.1.1"),
+            self.settings.get("multicast_port", 2239),
+            self.settings.get("interface_ip", "0.0.0.0"),
         )
         self.multicast_interface.ready_read_connect(self.watch_udp)
         self.request_workedlist()
+        self.request_contest()
+
+    def get_settings(self) -> dict:
+        """Get the settings."""
+        if os.path.exists(fsutils.CONFIG_FILE):
+            with open(fsutils.CONFIG_FILE, "rt", encoding="utf-8") as file_descriptor:
+                return loads(file_descriptor.read())
+
+    def setDarkMode(self, setdarkmode=False):
+        """testing"""
+
+        if setdarkmode:
+            darkPalette = QtGui.QPalette()
+            darkColor = QtGui.QColor(45, 45, 45)
+            self.text_color = Qt.white
+            disabledColor = QtGui.QColor(127, 127, 127)
+            darkPalette.setColor(QtGui.QPalette.Window, darkColor)
+            darkPalette.setColor(QtGui.QPalette.WindowText, Qt.white)
+            darkPalette.setColor(QtGui.QPalette.Base, QtGui.QColor(18, 18, 18))
+            darkPalette.setColor(QtGui.QPalette.AlternateBase, darkColor)
+            darkPalette.setColor(QtGui.QPalette.Text, Qt.white)
+            darkPalette.setColor(
+                QtGui.QPalette.Disabled, QtGui.QPalette.Text, disabledColor
+            )
+            darkPalette.setColor(QtGui.QPalette.Button, darkColor)
+            darkPalette.setColor(QtGui.QPalette.ButtonText, Qt.white)
+            darkPalette.setColor(
+                QtGui.QPalette.Disabled, QtGui.QPalette.ButtonText, disabledColor
+            )
+            darkPalette.setColor(QtGui.QPalette.BrightText, Qt.red)
+            darkPalette.setColor(QtGui.QPalette.Link, QtGui.QColor(42, 130, 218))
+            darkPalette.setColor(QtGui.QPalette.Highlight, QtGui.QColor(42, 130, 218))
+            darkPalette.setColor(QtGui.QPalette.HighlightedText, Qt.black)
+            darkPalette.setColor(
+                QtGui.QPalette.Disabled, QtGui.QPalette.HighlightedText, disabledColor
+            )
 
-    def quit_app(self):
-        """doc"""
-        app.quit()
+            self.setPalette(darkPalette)
+            self.callsignField.setPalette(darkPalette)
+            self.update()
+        else:
+            palette = self.style().standardPalette()
+            self.setPalette(palette)
+            self.callsignField.setPalette(palette)
+            self.text_color = Qt.black
+            self.update()
 
     def connect(self):
-        """doc"""
+        """Connect to the cluster."""
+        if not self.callsignField.text():
+            self.callsignField.setFocus()
+            return
         if self.connected is True:
-            self.socket.close()
-            self.connected = False
-            self.connectButton.setStyleSheet("color: red;")
-            self.connectButton.setText("Closed")
+            self.close_cluster()
             return
-        if os.path.exists(CONFIG_PATH + "/not1mm.json"):
-            with open(
-                CONFIG_PATH + "/not1mm.json", "rt", encoding="utf-8"
-            ) as _file_descriptor:
-                globals()["PREF"] = loads(_file_descriptor.read())
-        server = PREF.get("cluster_server", "dxc.nc7j.com")
-        port = PREF.get("cluster_port", 7373)
-        logger.debug("%s", f"{server} {port}")
+        # refresh settings
+        self.settings = self.get_settings()
+        server = self.settings.get("cluster_server", "dxc.nc7j.com")
+        port = self.settings.get("cluster_port", 7373)
+        logger.info(f"connecting to dx cluster {server} {port}")
         self.socket.connectToHost(server, port)
         self.connectButton.setStyleSheet("color: white;")
         self.connectButton.setText("Connecting")
@@ -514,8 +527,13 @@ class MainWindow(QtWidgets.QMainWindow):
                 cmd["spots"] = []
                 self.multicast_interface.send_as_json(cmd)
                 continue
-            if packet.get("cmd", "") == "HALT":
-                self.quit_app()
+            if packet.get("cmd", "") == "CONTESTSTATUS":
+                if not self.callsignField.text():
+                    self.callsignField.setText(packet.get("operator", "").upper())
+                    self.callsignField.selectAll()
+                continue
+            if packet.get("cmd", "") == "DARKMODE":
+                self.setDarkMode(packet.get("state", False))
 
     def spot_clicked(self):
         """dunno"""
@@ -536,13 +554,23 @@ class MainWindow(QtWidgets.QMainWindow):
         cmd["station"] = platform.node()
         self.multicast_interface.send_as_json(cmd)
 
+    def request_contest(self):
+        """Request active contest from logger"""
+        cmd = {}
+        cmd["cmd"] = "GETCONTESTSTATUS"
+        cmd["station"] = platform.node()
+        self.multicast_interface.send_as_json(cmd)
+
     def update_station_timer(self):
         """doc"""
         self.update_stations()
 
     def update(self):
         """doc"""
-        self.update_timer.setInterval(UPDATE_INTERVAL)
+        try:
+            self.update_timer.setInterval(UPDATE_INTERVAL)
+        except AttributeError:
+            ...
         self.clear_all_callsign_from_scene()
         self.clear_freq_mark(self.rxMark)
         self.clear_freq_mark(self.txMark)
@@ -562,12 +590,13 @@ class MainWindow(QtWidgets.QMainWindow):
                 i * PIXELSPERSTEP,
                 length + 10,
                 i * PIXELSPERSTEP,
-                QtGui.QPen(QtGui.QColor(192, 192, 192)),
+                QtGui.QPen(self.text_color),
             )
             if i % 5 == 0:  # Add Frequency
                 freq = self.currentBand.start + step * i
                 text = f"{freq:.3f}"
                 self.something = self.bandmap_scene.addText(text)
+                self.something.setDefaultTextColor(self.text_color)
                 self.something.setPos(
                     -(self.something.boundingRect().width()) + 10,
                     i * PIXELSPERSTEP - (self.something.boundingRect().height() / 2),
@@ -610,7 +639,7 @@ class MainWindow(QtWidgets.QMainWindow):
 
     def Freq2ScenePos(self, freq: float):
         """doc"""
-        if freq < self.currentBand.start or freq > self.currentBand.end:
+        if not freq or freq < self.currentBand.start or freq > self.currentBand.end:
             return QtCore.QPointF()
         step, _digits = self.determine_step_digits()
         ret = QtCore.QPointF(
@@ -641,7 +670,7 @@ class MainWindow(QtWidgets.QMainWindow):
         # anim.setEndValue(int(freq_pos - (self.height() / 2) + 80))
         # anim.start(QtCore.QAbstractAnimation.DeletionPolicy.DeleteWhenStopped)
 
-    def drawfreqmark(self, freq, _step, color, currentPolygon):
+    def drawfreqmark(self, freq, _step, color, currentPolygon) -> None:
         """doc"""
 
         self.clear_freq_mark(currentPolygon)
@@ -660,7 +689,7 @@ class MainWindow(QtWidgets.QMainWindow):
         brush = QtGui.QBrush(color)
         currentPolygon.append(self.bandmap_scene.addPolygon(poly, pen, brush))
 
-    def draw_bandwidth(self, freq, _step, color, currentPolygon):
+    def draw_bandwidth(self, freq, _step, color, currentPolygon) -> None:
         """bandwidth"""
         logger.debug("%s", f"mark:{currentPolygon} f:{freq} b:{self.bandwidth}")
         self.clear_freq_mark(currentPolygon)
@@ -687,16 +716,23 @@ class MainWindow(QtWidgets.QMainWindow):
     def update_stations(self):
         """doc"""
         self.update_timer.setInterval(UPDATE_INTERVAL)
+        if not self.connected:
+            return
+
         self.clear_all_callsign_from_scene()
         self.spot_aging()
         step, _digits = self.determine_step_digits()
 
         result = self.spots.getspotsinband(self.currentBand.start, self.currentBand.end)
+        logger.debug(
+            f"{len(result)} spots in range {self.currentBand.start} - {self.currentBand.end}"
+        )
+
         entity = ""
         if result:
             min_y = 0.0
             for items in result:
-                pen_color = QtGui.QColor(192, 192, 192)
+                pen_color = self.text_color
                 if items.get("comment") == "MARKED":
                     pen_color = QtGui.QColor(47, 47, 255)
                 if items.get("callsign") in self.worked_list:
@@ -754,23 +790,22 @@ class MainWindow(QtWidgets.QMainWindow):
 
         return (step, digits)
 
-    def set_band(self, band: str, savePrevBandZoom: bool):
-        """doc"""
+    def set_band(self, band: str, savePrevBandZoom: bool) -> None:
+        """Change band being shown."""
         logger.debug("%s", f"{band} {savePrevBandZoom}")
         if band != self.currentBand.name:
             if savePrevBandZoom:
                 self.saveCurrentZoom()
             self.currentBand = Band(band)
-            # self.zoom = self.savedZoom(band)
             self.update()
 
-    def spot_aging(self):
-        """doc"""
+    def spot_aging(self) -> None:
+        """Delete spots older than age time."""
         if self.agetime:
             self.spots.delete_spots(self.agetime)
 
-    def clear_all_callsign_from_scene(self):
-        """doc"""
+    def clear_all_callsign_from_scene(self) -> None:
+        """Remove callsigns from the scene."""
         for items in self.textItemList:
             self.bandmap_scene.removeItem(items)
         self.textItemList.clear()
@@ -778,70 +813,69 @@ class MainWindow(QtWidgets.QMainWindow):
             self.bandmap_scene.removeItem(items)
         self.lineitemlist.clear()
 
-    def clear_freq_mark(self, currentPolygon):
-        """doc"""
+    def clear_freq_mark(self, currentPolygon) -> None:
+        """Remove frequency marks from the scene."""
         if currentPolygon:
             for mark in currentPolygon:
                 self.bandmap_scene.removeItem(mark)
         currentPolygon.clear()
 
-    def receive(self):
-        """doc"""
-        data = self.socket.readAll()
-        data = str(data, "utf-8").strip()
-        if "login:" in data:
-            self.send_command(self.callsignField.text())
-            self.send_command(PREF.get("cluster_filter", ""))
-            self.send_command("set dx extension Section")
-            self.send_command("set dx mode " + PREF.get("cluster_mode", "OPEN"))
-            return
-        if "call:" in data or "callsign:" in data:
-            self.send_command(self.callsignField.text())
-            self.send_command(PREF.get("cluster_filter", ""))
-            self.send_command("set dx extension Section")
-            self.send_command("set dx mode " + PREF.get("cluster_mode", "OPEN"))
-            return
-        if "DX de" in data:
-            parts = data.split()
-            spotter = parts[2]
-            freq = parts[3]
-            dx = parts[4]
-            _time = parts[-1]
-            comment = " ".join(parts[5:-1])
-            # spot = DxSpot()
-            spot = {}
-            spot["ts"] = datetime.now(timezone.utc).isoformat(" ")[:19]
-            spot["callsign"] = dx
-            spot["spotter"] = spotter
-            spot["comment"] = comment
-            try:
-                spot["freq"] = float(freq) / 1000
-            except ValueError:
-                logger.debug("%s", f"{data}")
-            self.spots.addspot(spot)
-            return
-        if self.callsignField.text().upper() in data:
-            self.connectButton.setStyleSheet("color: green;")
-            self.connectButton.setText("Connected")
-            logger.debug("%s", f"{data}")
-
-    def maybeconnected(self):
-        """doc"""
+    def receive(self) -> None:
+        """Process waiting bytes"""
+        while self.socket.bytesAvailable():
+            data = self.socket.readLine(1000)
+            data = str(data, "utf-8").strip()
+
+            if "login:" in data or "call:" in data or "callsign:" in data:
+                self.send_command(self.callsignField.text())
+                self.send_command(self.settings.get("cluster_filter", ""))
+                self.send_command("set dx extension Section")
+                self.send_command(
+                    "set dx mode " + self.settings.get("cluster_mode", "OPEN")
+                )
+                return
+            if "DX de" in data:
+                parts = data.split()
+                spotter = parts[2]
+                freq = parts[3]
+                dx = parts[4]
+                _time = parts[-1]
+                comment = " ".join(parts[5:-1])
+                # spot = DxSpot()
+                spot = {}
+                spot["ts"] = datetime.now(timezone.utc).isoformat(" ")[:19]
+                spot["callsign"] = dx
+                spot["spotter"] = spotter
+                spot["comment"] = comment
+                logger.debug(f"{spot}")
+                try:
+                    spot["freq"] = float(freq) / 1000
+                    self.spots.addspot(spot)
+                except ValueError:
+                    logger.debug(f"couldn't parse freq from datablock {data}")
+                return
+            if self.callsignField.text().upper() in data:
+                self.connectButton.setStyleSheet("color: green;")
+                self.connectButton.setText("Connected")
+                logger.debug(f"callsign login acknowledged {data}")
+
+    def maybeconnected(self) -> None:
+        """Update visual state of the connect button."""
         self.connectButton.setStyleSheet("color: yellow;")
         self.connectButton.setText("Connecting")
 
-    def socket_error(self):
-        """doc"""
-        print("An Error occurred.")
+    def socket_error(self) -> None:
+        """Oopsie"""
+        logger.warning("An Error occurred.")
 
-    def disconnected(self):
-        """doc"""
+    def disconnected(self) -> None:
+        """Called when socket is disconnected."""
         self.connected = False
         self.connectButton.setStyleSheet("color: red;")
         self.connectButton.setText("Closed")
 
-    def send_command(self, cmd: str):
-        """doc"""
+    def send_command(self, cmd: str) -> None:
+        """Send a command to the cluster."""
         cmd += "\r\n"
         tosend = bytes(cmd, encoding="ascii")
         logger.debug("%s", f"{tosend}")
@@ -849,44 +883,26 @@ class MainWindow(QtWidgets.QMainWindow):
             if self.socket.isOpen():
                 self.socket.write(tosend)
 
-    def clear_spots(self):
-        """doc"""
+    def clear_spots(self) -> None:
+        """Delete all spots from the database."""
         self.spots.delete_spots(0)
 
-    def spot_aging_changed(self):
-        """doc"""
+    def spot_aging_changed(self) -> None:
+        """Called when spot aging spinbox is changed."""
         self.agetime = self.clear_spot_olderSpinBox.value()
 
-    def showContextMenu(self):
-        """doc"""
-
-
-def run():
-    """doc"""
-    sys.exit(app.exec())
-
-
-logger = logging.getLogger("__main__")
-handler = logging.StreamHandler()
-formatter = logging.Formatter(
-    datefmt="%H:%M:%S",
-    fmt="[%(asctime)s] %(levelname)s %(module)s - %(funcName)s Line %(lineno)d:\n%(message)s",
-)
-handler.setFormatter(formatter)
-logger.addHandler(handler)
-
-if Path("./debug").exists():
-    logger.setLevel(logging.DEBUG)
-    logger.debug("debugging on")
-else:
-    logger.setLevel(logging.WARNING)
-    logger.warning("debugging off")
-
-app = QtWidgets.QApplication(sys.argv)
+    def showContextMenu(self) -> None:
+        """doc string for the linter"""
 
+    def close_cluster(self) -> None:
+        """Close socket connection"""
+        if self.socket and self.socket.isOpen():
+            logger.info("Closing dx cluster connection")
+            self.socket.close()
+            self.connected = False
+            self.connectButton.setStyleSheet("color: red;")
+            self.connectButton.setText("Closed")
 
-app.setStyle("Adwaita-Dark")
-window = MainWindow()
-window.show()
-if __name__ == "__main__":
-    run()
+    def closeEvent(self, _event: QtGui.QCloseEvent) -> None:
+        """Triggered when instance closes."""
+        self.close_cluster()