rfmetadata 1.0.0__py3-none-any.whl

rfmetadata/__init__.py

@@ -0,0 +1,12 @@
+"""
+
+ **RF Metadata Displayer**
+  
+"""
+
+from rfmetadata.version import version as __version__
+
+__all__ = (
+    "__version__",
+    "main",
+)

rfmetadata/__main__.py

@@ -0,0 +1,4 @@
+from rfmetadata.main import main
+
+if __name__ == "__main__":
+    main()

rfmetadata/main.py

@@ -0,0 +1,31 @@
+'''
+Steps:
+>>> pwd
+>>> python -m venv .venv
+>>> source ./venv/bin/activate
+>>> pip install -e .
+>>> rfmetadata
+
+'''
+import sys
+from PySide6 import QtWidgets
+from rfmetadata.windows.main_window import MainWindow
+import argparse
+from . import __version__ # FIXME dynamic versioning ????? how ????
+
+def main()-> None:
+
+   parser = argparse.ArgumentParser()
+   parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+   args = parser.parse_args()
+
+   app = QtWidgets.QApplication()
+
+   widget = MainWindow()
+   widget.show()
+
+   sys.exit(app.exec())
+
+# this is important so that it does not run from pytest
+if __name__ == "__main__":
+    main()

rfmetadata/readme.md

@@ -0,0 +1,44 @@
+# This is an overview on how rfmetadata is working Alan Check ????
+
+## Folders
+
+The work is separated into folder:
+
+### database folder
+This folder is responsible for the modules that query the database. It contains the files:
+    1- database_query.py: This file contains the databasemanager class which queries the database using the method search_power_frequency() and returns the result.
+
+### widgets folder:
+This folder contains all the different widgets that will be added into the main window later. It contains the files:
+    1- search_layout.py: This module creates the widget for the search box at the top of the main window.
+    2- data_graph_layout.py: This module creates the widget for the 3d graph that draws the searched data.
+
+we create different widgets now here and easily add them to the main window later. 
+
+### windows folder:
+This folder contains the different windows of our application. It contains the files:
+    1- main_window.py: which is the main app gui, it contains the search box currently at the top.
+    2- query_result_window.py: which is the window that pops up when you press search. It will contain your result in a clean table view.
+
+I separated them, and made the result pop up in a different window. This way our main gui is much cleaner and not crammed with results.
+And the user gets a beautiful clean window for the result.
+
+### signal_manager folder:
+This folder contains:
+    1- data_signal_manager.py: This module creates two signal managers objects that i use to send (the result of the query to the data_graph_layout.py to be drawn) and (the type of the type of the graph taken from the mainwindow).
+
+## main
+
+In the main.py, I added an arg parser for the "--version" . This way rfsink --version will give the user the current version of our application.
+And called the main_window class to create our main gui.
+
+## how execute the RF-Sink Desktop application
+* Create and activate a virtual environment 
+* Go to the root folder of the project (rf-surveillance)
+
+```
+$ pip install -e .
+$ rfsink
+```
+
+

rfmetadata/signal_manager/data_signal_manager.py

@@ -0,0 +1,26 @@
+from PySide6.QtCore import QObject, Signal
+
+
+class GraphSignalManager(QObject):
+    data_signal = Signal(list)
+
+    def __init__(self)->None:
+        super().__init__()
+
+signal_manager = GraphSignalManager()
+
+class GraphTypeSignalManager(QObject):
+    data_signal = Signal(str)
+
+    def __init__(self)->None:
+        super().__init__()
+
+graph_type_manager = GraphTypeSignalManager()
+
+class TableTypeSignalManager(QObject):
+    data_signal = Signal(bool)
+
+    def __init__(self)->None:
+        super().__init__()
+
+table_type_manager = TableTypeSignalManager()

rfmetadata/version.py

@@ -0,0 +1 @@
+version = '1.0.0'

rfmetadata/widgets/data_graph_layout.py

@@ -0,0 +1,155 @@
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+from rfmetadata.signal_manager.data_signal_manager import signal_manager, graph_type_manager
+import matplotlib.dates as mdates
+from datetime import datetime
+import numpy as np
+from scipy.interpolate import griddata
+from matplotlib import cm
+from matplotlib.colors import Normalize
+
+
+class DataGraph3D(FigureCanvas):
+    def __init__(self, figure:Figure=None)->None:        
+        self.figure = Figure()
+        super().__init__(figure)
+
+        self.min_power = 20.0
+        self.max_power = 60.0
+
+        self.type = "scatter"
+
+        self.data = []
+        self.freq = []
+        self.pow = []
+        self.time = []
+
+
+        self.ax = self.figure.add_subplot(projection='3d')
+        self.ax.set_title("Data Graph")
+        
+        signal_manager.data_signal.connect(self.receive_data)
+        graph_type_manager.data_signal.connect(self.set_type)
+
+        
+                    
+    def receive_data(self, data):
+        self.data = data
+        self.freq.clear()
+        self.pow.clear()
+        self.time.clear()
+
+        for row_data in self.data:
+            self.freq.append(row_data[1])
+            self.pow.append(row_data[2])
+            dt = datetime.strptime(row_data[3], "%d-%m-%Y %H:%M:%S")
+            self.time.append(mdates.date2num(dt))
+
+        self.draw_graph()
+
+    def set_type(self, type):
+        self.type = type
+        self.draw_graph()
+
+    
+    def draw_graph(self):
+
+        if not (self.freq and self.pow and self.time):
+            return
+
+        
+        if self.type == "scatter":
+            self.figure.clear()
+            self.ax = self.figure.add_subplot(projection='3d')
+
+            self.ax.set_title("Data Graph")
+
+            self.ax.set_title("Data Graph")
+            self.ax.set_xlabel("Frequency")
+            self.ax.set_ylabel("Time")
+            self.ax.set_zlabel("Power")
+            self.ax.yaxis.set_major_formatter(mdates.DateFormatter('%d-%m %H:%M'))
+            self.ax.set_zlim(self.min_power, self.max_power)
+            self.ax.scatter(self.freq, self.time, self.pow)
+            self.draw()
+
+        elif self.type == "meshgrid":
+            self.figure.clear()
+
+            self.ax = self.figure.add_subplot(projection='3d')
+
+            self.ax.set_title("Data Graph")
+
+            # Preparing data as numpy arrays
+            freq = np.array(self.freq)
+            time = np.array(self.time)
+            power = np.array(self.pow)
+
+            # Building a grid
+            freq_lin = np.linspace(freq.min(), freq.max(), 100)
+            time_lin = np.linspace(time.min(), time.max(), 100)
+            FREQ, TIME = np.meshgrid(freq_lin, time_lin)
+
+            # Interpolating power data onto grid
+            POWER = griddata(
+                points=(freq, time),
+                values=power,
+                xi=(FREQ, TIME),
+                method='nearest'
+            )
+
+            POWER = np.nan_to_num(POWER, nan=np.nanmin(power))
+
+
+            surf = self.ax.plot_surface(
+                FREQ, TIME, POWER,
+                cmap='inferno',
+                linewidth=0.5,
+                antialiased=True
+            )
+            
+            self.ax.set_title("Data Graph")
+            self.ax.set_xlabel("Frequency")
+            self.ax.set_ylabel("Time")
+            self.ax.set_zlabel("Power")
+
+            self.ax.yaxis.set_major_formatter(mdates.DateFormatter('%d-%m %H:%M'))
+
+            self.ax.set_zlim(self.min_power, self.max_power)
+
+            self.draw()
+
+        elif self.type == "line":
+            self.figure.clear()
+            self.ax = self.figure.add_subplot(111)
+
+            # Normalizing frequency values for colormap
+            norm = Normalize(vmin=min(self.freq), vmax=max(self.freq))
+            cmap = cm.get_cmap('viridis')
+
+            # Plotting each segment with color based on frequency
+            for i in range(len(self.pow) - 1):
+                x_vals = [self.time[i], self.time[i+1]]
+                y_vals = [self.pow[i], self.pow[i+1]]
+                freq_avg = (self.freq[i] + self.freq[i+1]) / 2
+                color = cmap(norm(freq_avg))
+
+                self.ax.plot(x_vals, y_vals, color=color, linewidth=2)
+
+            # Formatting time axis
+            self.ax.set_xlabel('Time')
+            self.ax.set_ylabel('Power')
+            self.ax.set_title('Power vs Time (Colored by Frequency)')
+
+            # Adding colorbar
+            sm = cm.ScalarMappable(norm=norm, cmap=cmap)
+            sm.set_array([])  # Required to register mappable
+            cbar = self.figure.colorbar(sm, ax=self.ax)
+            cbar.set_label("Frequency")
+
+            self.ax.xaxis.set_major_formatter(mdates.DateFormatter('%d-%m %H:%M'))
+            self.figure.autofmt_xdate()
+
+            self.draw()
+
+

rfmetadata/widgets/query_result_layout.py

@@ -0,0 +1,36 @@
+from PySide6.QtWidgets import QWidget, QTableWidget, QTableWidgetItem, QHBoxLayout
+from PySide6.QtCore import Qt
+from rfmetadata.signal_manager.data_signal_manager import signal_manager
+
+class TableResultsWidget(QTableWidget):
+    def __init__(self):
+        super().__init__()
+        
+        self.result = ""
+        signal_manager.data_signal.connect(self.set_result)
+            # Configure table
+        self.setAlternatingRowColors(True)
+        self.horizontalHeader().setStretchLastSection(True)
+
+        self.setColumnCount(4)
+        self.setRowCount(20)
+        self.setHorizontalHeaderLabels(["ID", "frequency", "power", "datetime"])
+
+    def set_result(self, data):
+       self.result = data
+       self.setup_ui(self.result)
+
+    def setup_ui(self, query):
+        self.setRowCount(len(query))
+        for row, row_data in enumerate(query):
+            for col, data in enumerate(row_data):
+                item = QTableWidgetItem(str(data))
+                item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+                self.setItem(row, col, item)
+
+
+
+        
+        
+
+

rfmetadata/widgets/search_layout.py

@@ -0,0 +1,109 @@
+from PySide6.QtWidgets import QGroupBox, QGridLayout, QLabel, QPushButton, QDoubleSpinBox, QSpacerItem, QSizePolicy
+from PySide6.QtCore import QLocale, Qt
+from rfmetadata.windows.query_result_window import show_query_results
+from rfmetadata.signal_manager.data_signal_manager import signal_manager
+import requests
+
+class SearchGroupBox(QGroupBox):
+    
+    def __init__(self, parent=None):
+
+        self.min_power = 20.0
+        self.max_power = 60.0
+        self.min_frequency = 103.0
+        self.max_frequency = 109.0
+
+        super().__init__(parent)
+        self.setup_ui()
+        
+    def setup_ui(self):
+
+        layout = QGridLayout()
+        self.setLayout(layout)
+        
+        self.min_power_spin = QDoubleSpinBox()
+        self.min_power_spin.setRange(self.min_power,self.max_power)
+        self.min_power_spin.setValue(20.0)
+        self.min_power_spin.setSingleStep(0.01)
+        self.min_power_spin.setDecimals(2) 
+        self.min_power_spin.setLocale(QLocale(QLocale.English))
+
+
+        self.max_power_spin = QDoubleSpinBox()
+        self.max_power_spin.setRange(self.min_power,self.max_power)
+        self.max_power_spin.setValue(self.max_power)
+        self.max_power_spin.setSingleStep(0.01)
+        self.max_power_spin.setDecimals(2) 
+        self.max_power_spin.setLocale(QLocale(QLocale.English))
+
+    
+        self.min_frequency_spin = QDoubleSpinBox()
+        self.min_frequency_spin.setRange(self.min_frequency,self.max_frequency)
+        self.min_frequency_spin.setValue(self.min_frequency)
+        self.min_frequency_spin.setSingleStep(0.01)
+        self.min_frequency_spin.setDecimals(2) 
+        self.min_frequency_spin.setLocale(QLocale(QLocale.English))
+
+
+        self.max_frequency_spin = QDoubleSpinBox()
+        self.max_frequency_spin.setRange(self.min_frequency,self.max_frequency)
+        self.max_frequency_spin.setValue(self.max_frequency)
+        self.max_frequency_spin.setSingleStep(0.01)
+        self.max_frequency_spin.setDecimals(2) 
+        self.max_frequency_spin.setLocale(QLocale(QLocale.English))
+
+
+        self.power_label = QLabel("Power:")
+        self.min_power_label = QLabel("Min:",alignment=(Qt.AlignmentFlag.AlignRight|Qt.AlignmentFlag.AlignCenter))
+        self.max_power_label = QLabel("Max:",alignment=(Qt.AlignmentFlag.AlignRight|Qt.AlignmentFlag.AlignCenter))
+
+        self.frequency_label = QLabel("Frequency:")
+        self.min_frequency_label = QLabel("Min:",alignment=(Qt.AlignmentFlag.AlignRight|Qt.AlignmentFlag.AlignCenter))
+        self.max_frequency_label = QLabel("Max:",alignment=(Qt.AlignmentFlag.AlignRight|Qt.AlignmentFlag.AlignCenter))
+
+        self.error_message = QLabel("")
+        self.error_message.setStyleSheet("QLabel { color : red}")
+
+        self.button = QPushButton("Search")
+        
+        layout.addWidget(self.power_label,0,0)
+        layout.addItem(QSpacerItem(200, 0, QSizePolicy.Fixed, QSizePolicy.Minimum))
+        layout.addWidget(self.min_power_label,0,1)
+        layout.addWidget(self.min_power_spin,0,2)
+        layout.addWidget(self.max_power_label,0,3)
+        layout.addWidget(self.max_power_spin,0,4)        
+        
+        layout.addWidget(self.frequency_label,1,0)
+        layout.addItem(QSpacerItem(200, 0, QSizePolicy.Fixed, QSizePolicy.Minimum))
+        layout.addWidget(self.min_frequency_label,1,1)
+        layout.addWidget(self.min_frequency_spin,1,2)
+        layout.addWidget(self.max_frequency_label,1,3)
+        layout.addWidget(self.max_frequency_spin,1,4)
+
+
+        layout.addWidget(self.error_message)
+        layout.addWidget(self.button,2,0)
+
+
+        self.button.clicked.connect(self.search_database)
+        
+    def search_database(self): 
+        min_power = self.min_power_spin.value()
+        max_power = self.max_power_spin.value()
+        min_frequency = self.min_frequency_spin.value()
+        max_frequency = self.max_frequency_spin.value()
+
+        if min_frequency > max_frequency or min_power > max_power:
+            self.error_message.setText("min values can't be larger than max values !")
+
+        else:
+            self.error_message.setText("")
+            result = requests.get(f'http://127.0.0.1:5000/search/{min_power}/{max_power}/{min_frequency}/{max_frequency}')
+
+            if result:
+                signal_manager.data_signal.emit(result.json())
+                show_query_results(result.json())
+            else:
+                self.error_message.setText("No results !")
+        
+       

rfmetadata/windows/main_window.py

@@ -0,0 +1,135 @@
+from PySide6 import QtWidgets
+from PySide6.QtWidgets import QMainWindow, QVBoxLayout, QHBoxLayout, QWidget
+from rfmetadata.widgets.search_layout import SearchGroupBox
+from rfmetadata.widgets.data_graph_layout import DataGraph3D
+from PySide6.QtGui import QAction, QActionGroup
+from rfmetadata.signal_manager.data_signal_manager import graph_type_manager, table_type_manager
+
+from rfmetadata.widgets.query_result_layout import TableResultsWidget
+
+class MainWindow(QMainWindow):
+   def __init__(self):
+        super().__init__()
+
+        self.result_window= "in_window"
+        
+        self.setup_ui()
+        
+   def setup_ui(self):
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        layout = QVBoxLayout(central_widget)
+
+        self.search = SearchGroupBox("Select minimum and maximum values")
+        self.search.setMaximumHeight(200)
+        layout.addWidget(self.search)
+        
+        self.graph = DataGraph3D()
+        self.graph.setMinimumWidth(410)
+        self.graph.setMinimumHeight(300)
+        
+        self.table = TableResultsWidget()
+        self.table.setMinimumWidth(500)
+
+        result_widget = QWidget()
+        result_widget_layout = QHBoxLayout(result_widget)
+
+        if self.result_window == "in_window":
+           result_widget_layout.addWidget(self.table)
+        
+        result_widget_layout.addWidget(self.graph)
+
+        layout.addWidget(result_widget)
+
+
+        self.setWindowTitle("RF Sink Viewer")
+        self.resize(800, 600)
+        
+        self.create_menu()
+        
+
+   def create_menu(self):
+       global menubar
+       menubar = self.menuBar()
+   
+       file_menu = menubar.addMenu("File")
+   
+       exit_action = QAction("Exit", self)
+       exit_action.triggered.connect(self.close)
+       file_menu.addAction(exit_action)
+   
+       help_menu = menubar.addMenu("Help")
+   
+       about_action = QAction("About", self)
+       about_action.triggered.connect(self._show_about)
+       help_menu.addAction(about_action)
+
+
+       # parrent menu
+       tool_menu = menubar.addMenu("Tools")
+       select_graph_menu = tool_menu.addMenu("Graph")
+
+       graph_group = QActionGroup(self)
+       graph_group.setExclusive(True)
+
+       graph_option_a = QAction("3D Scatter Plot", self, checkable=True)
+       graph_option_a.setChecked(True)
+       graph_option_a.triggered.connect(self.set_scatter)
+       
+       graph_option_b = QAction("3D Mesh Grid", self, checkable=True)
+       graph_option_b.triggered.connect(self.set_meshgrid)
+
+       graph_option_c = QAction("2D Line", self, checkable=True)
+       graph_option_c.triggered.connect(self.set_line)
+
+       graph_group.addAction(graph_option_a)
+       graph_group.addAction(graph_option_b)
+       graph_group.addAction(graph_option_c)
+
+       select_graph_menu.addAction(graph_option_a)
+       select_graph_menu.addAction(graph_option_b)
+       select_graph_menu.addAction(graph_option_c)
+       
+       select_table_menu = tool_menu.addMenu("Table view")
+
+       table_group = QActionGroup(self)       
+       table_group.setExclusive(True)
+
+       table_option_a = QAction("In Window", self, checkable=True)
+       table_option_a.setChecked(True)
+       table_option_a.triggered.connect(self.set_in_window)
+       
+       table_option_b = QAction("New Window", self, checkable=True)
+       table_option_b.triggered.connect(self.set_new_window)
+
+       table_group.addAction(table_option_a)
+       table_group.addAction(table_option_b)
+
+       select_table_menu.addAction(table_option_a)
+       select_table_menu.addAction(table_option_b)
+
+
+   def _show_about(self):
+      QtWidgets.QMessageBox.about(self, "About", "RF Sink Viewer using PySide6\nTips:\n1-")
+
+   def set_scatter(self):
+      graph_type_manager.data_signal.emit("scatter")
+      
+   def set_meshgrid(self):
+      graph_type_manager.data_signal.emit("meshgrid")
+
+   def set_line(self):
+      graph_type_manager.data_signal.emit("line")
+
+   def set_in_window(self):
+      self.result_window = "in_window"
+      table_type_manager.data_signal.emit(False)
+      menubar.clear()
+      self.setup_ui()
+      
+   def set_new_window(self):
+      self.result_window = "new_window"
+      table_type_manager.data_signal.emit(True)
+      menubar.clear()
+      self.setup_ui()

rfmetadata/windows/query_result_window.py

@@ -0,0 +1,56 @@
+from PySide6.QtWidgets import QMainWindow, QTableWidget, QTableWidgetItem
+from PySide6.QtCore import Qt
+from rfmetadata.signal_manager.data_signal_manager import table_type_manager
+
+global window_type
+window_type = False
+
+class TableResultsWindow(QMainWindow):
+    def __init__(self, query):
+        super().__init__()
+        self.setWindowTitle("Query Results")
+        
+        # Create table view
+        self.table = QTableWidget()
+        self.table.setColumnCount(4)
+        self.table.setRowCount(len(query))
+        self.table.setHorizontalHeaderLabels(["ID", "frequency", "power", "datetime"])
+
+
+        for row, row_data in enumerate(query):
+            for col, data in enumerate(row_data):
+                item = QTableWidgetItem(str(data))
+                item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+                self.table.setItem(row, col, item)
+
+
+
+        # Configure table
+        self.table.setAlternatingRowColors(True)
+        self.table.horizontalHeader().setStretchLastSection(True)
+        self.table.resizeColumnsToContents()
+        
+        self.setCentralWidget(self.table)
+        self.resize(800, 600)
+
+        table_type_manager.data_signal.connect(self.set_type)
+
+    def set_type(self, type):
+        global window_type 
+        window_type = type
+
+# Usage:
+def show_query_results(query):
+
+    global window_type
+
+    global result_window
+    result_window = TableResultsWindow(query)
+
+    if window_type:
+
+        result_window.show()
+    else:
+        pass
+
+

rfmetadata-1.0.0.dist-info/AUTHORS.md

@@ -0,0 +1,2 @@
+# Authors
+**Holm Consulting**