PyFT8 3.6.5__tar.gz → 3.7.0__tar.gz

{pyft8-3.6.5 → pyft8-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 3.6.5
+Version: 3.7.0
 Summary: FT8 Decoding and Encoding in Python with test/loopback code
 Author-email: G1OJS <g1ojs@yahoo.com>
 License-Expression: GPL-3.0-or-later

{pyft8-3.6.5 → pyft8-3.7.0}/PyFT8/gui.py

@@ -1,6 +1,8 @@
 import numpy as np
 import matplotlib.pyplot as plt
 from matplotlib import rcParams
+import matplotlib.style as mplstyle
+mplstyle.use('fast')
 import queue
 from matplotlib.widgets import Button
 from PyFT8.time_utils import time_utils
@@ -23,24 +25,31 @@ def add_my_axes(fig, pos):
     ax.set_facecolor(TEXT_BACKGROUND_COLOR)
     return ax
 
-MESSAGE_TYPES = {'generic':{'bg':'blue', 'fg':'white', 'alpha':0.5}, 'CQ':{'bg':'green', 'fg':'white', 'alpha':0.8},
-                 'from_me': {'bg':'yellow', 'fg':'black', 'alpha':0.95}, 'to_me':{'bg':'red', 'fg':'white', 'alpha':0.9}} 
+MESSAGE_TYPES = {'generic':{'bg':'blue', 'fg':'white', 'alpha':0.4}, 'CQ':{'bg':'green', 'fg':'white', 'alpha':0.7},
+                 'from_me': {'bg':'yellow', 'fg':'black', 'alpha':0.9}, 'to_me':{'bg':'red', 'fg':'white', 'alpha':0.9}} 
 class Msg_box:
-    def __init__(self, fig, ax, x, y, w, h, message):
+    def __init__(self, fig, ax, w, h):
         from matplotlib.patches import Rectangle
         self.fig, self.ax = fig, ax
-        message_type_params = MESSAGE_TYPES[message['message_type']]
-        rect = Rectangle((x, y), w, h, edgecolor='lime', lw=2)
+        rect = Rectangle((0, 0), w, h, edgecolor='lime', lw=2)
         self.patch = self.ax.add_patch(rect)
         self.patch.set_visible(False)
-        text_inst = self.ax.text(x, y+1, message['display_text'], fontsize='small', fontweight = 'bold' )
-        text_inst.set_visible(False)
-        text_inst.set_color(message_type_params['fg'])
-        self.patch.set_facecolor(message_type_params['bg'])
-        self.patch.set_alpha(message_type_params['alpha'])
+        self.text_inst = self.ax.text(0, 0, '', fontweight = 'bold' )
+        self.text_inst.set_visible(False)
+        self.text_inst.set_fontfamily('monospace')
+        self.artists = [self.patch, self.text_inst]
+
+    def set_props(self, x, y, message):
+        self.xy = (x, y)
         self.message = message
         self.cycle = message['their_tx_cycle']
-        self.artists = [self.patch, text_inst]
+        message_type_params = MESSAGE_TYPES[message['message_type']]
+        self.text_inst.set_text(message['display_text'])
+        self.text_inst.set_color(message_type_params['fg'])
+        self.patch.set_facecolor(message_type_params['bg'])
+        self.patch.set_alpha(message_type_params['alpha'])
+        self.text_inst.set_position((x, y+1))
+        self.patch.set_xy((x, y))
         for a in self.artists:
             a.set_visible(True)
 
@@ -166,34 +175,48 @@ class Gui:
         self.cid = self.fig.canvas.mpl_connect('button_press_event', self._oncanvasclick)
 
     def main_loop(self):
-        last_ptr = 0
         self.plt.show(block = False)
+        target_update_time = 0.15
         while True:
+            self.fig.canvas.flush_events() # for clicks
+            tstart_wf_redraw = time_utils.time()
             self.image.set_data(self.waterfall_data['data'])
             if self.needs_redraw:
                 self.needs_redraw = False
                 plt.pause(0.01)
             else:
                 self.ax_wf.draw_artist(self.image)
+                self.fig.canvas.flush_events() # for clicks
                 for mb in self.msg_boxes:
-                    mb.draw()
-                self.fig.canvas.update()
+                    if mb.patch.get_visible():
+                        mb.draw()
+                    self.fig.canvas.flush_events() # for clicks
+                self.fig.canvas.blit(self.ax_wf.bbox) #self.fig.canvas.update()
                 self.fig.canvas.flush_events()
+                tdelay = target_update_time - (time_utils.time() - tstart_wf_redraw)
+                if tdelay > 0.01:
+                    time_utils.sleep(tdelay)
 
-    def before_search(self, curr_cycle):
-        self._hide_msg_boxes(curr_cycle)
-        
-    def after_search(self,curr_cycle):
-        self._refresh_hearing()
-        self._refresh_band_buttons()
+    def before_search(self, curr_cycle): # would be better with a local trigger
+        #self._hide_msg_boxes(curr_cycle) # hide boxes overlapping new decodes
+        self._hide_msg_boxes(curr_cycle = None) # hide all boxes
         self._refresh_home_panel()
-        self._clear_msg_boxes(curr_cycle)
+        self._refresh_band_buttons()
+        self._refresh_hearing()
 
     def display_message(self, message):
+        mb = self._get_message_box()
         x = int(message['t0'] / self.waterfall_data['dt'] + message['their_tx_cycle'] * self.waterfall_data['pixels_per_cycle'])
         y = int(message['fHz'] / self.waterfall_data['df'])
-        mb = Msg_box(self.fig, self.ax_wf, x, y, self.waterfall_data['sig_w'], self.waterfall_data['sig_h'], message)
+        mb.set_props(x, y, message)
         self.msg_boxes.append(mb)
+
+    def update_message(self, display_text, update_dict):
+        for mb in self.msg_boxes:
+            if mb.patch.get_visible():
+                if mb.message['display_text'] == display_text:
+                    mb.message.update(update_dict)
+                    mb.set_props(mb.xy[0], mb.xy[1], mb.message)
         
     def get_band_info(self):
         return self.band_info
@@ -215,18 +238,34 @@ class Gui:
                                    color = row_text['color'])
         self.needs_redraw = True
 
+    def _get_message_box(self):
+        mb = None
+        for mb1 in self.msg_boxes:
+            if not mb1.patch.get_visible():
+                mb = mb1
+                break
+        if not mb:
+            mb = Msg_box(self.fig, self.ax_wf, self.waterfall_data['sig_w'], self.waterfall_data['sig_h'])
+        return mb
+
     def _set_band(self, band):
         if band in self.configured_bands:
             self.band_info = {'current_band':band, 'fMHz':self.configured_bands[band], 'time_set':time_utils.time()}
             self.console_print(f"[PyFT8] Set band: {self.band_info['current_band']} {self.band_info['fMHz']}")
+            for mb in self.msg_boxes:
+                mb.hide()
+                mb.remove()
+            self.msg_boxes = []
+            self._refresh_home_panel()
+            self._refresh_band_buttons()
+            self._refresh_hearing()
+            self.needs_redraw = True
 
     def _oncanvasclick(self, clickargs):
-        #print(f"Click at {time_utils.cycle_time():6.2f}")
-         
         if clickargs.inaxes is self.ax_wf:
             for mb in self.msg_boxes:
                 if mb.contains(clickargs.x, clickargs.y):
-                    self.console_print(f"[GUI] Clicked on message '{mb.message['msg_text']}'")
+                    self.console_print(f"[GUI] Clicked on message '{mb.message['msg_text']}")
                     self.qso_manager.on_click({'action':"MESSAGE_CLICK", 'message':mb.message})
                     return
         for bb in self.button_boxes:
@@ -235,28 +274,15 @@ class Gui:
                     self.needs_redraw = True
                     self._set_band(bb.id)
                     self.qso_manager.on_click({'action':"SET_BAND", 'fMHz':self.configured_bands[bb.id]})
-                    self.after_search(curr_cycle = None)
                 else:
                     action = ["CQ", "RPT_LAST", "TX_OFF"][['CQ', 'Repeat last', 'Tx off'].index(bb.id)]
                     self.qso_manager.on_click({'action':action})
 
-    def _hide_msg_boxes(self, curr_cycle):
-        to_hide = [mb for mb in self.msg_boxes if mb.cycle == curr_cycle]
+    def _hide_msg_boxes(self, curr_cycle = None):
+        to_hide = [mb for mb in self.msg_boxes if (mb.cycle == curr_cycle) or (curr_cycle is None)]
         for mb in to_hide:
             mb.hide()
         self.needs_redraw = True
-
-    def _clear_msg_boxes(self, curr_cycle = None):
-        to_remove = [mb for mb in self.msg_boxes if mb.cycle == curr_cycle or curr_cycle is None]
-        self.msg_boxes = [mb for mb in self.msg_boxes if mb.cycle != curr_cycle]
-        for mb in to_remove:
-            mb.remove()
-        self.needs_redraw = True
-
-    def _text_row(self, ax, x, y, text = '', color = 'white', **args):
-        art = ax.text(x, y, text, color = color)
-        art.set_fontfamily('monospace')
-        return art
    
     def _refresh_home_panel(self):
         current_band = self.band_info['current_band']

{pyft8-3.6.5 → pyft8-3.7.0}/PyFT8/message_broker.py

@@ -26,20 +26,15 @@ class Broker():
         mtype = ['generic', 'from_me', 'to_me', 'CQ'][mtype_val]        
         message_dict.update( {'message_type':mtype, 'display_text':f"{hail} {their_call} {grid_rpt}",
                               'priority':(mtype == 'to_me' or mtype == 'CQ')} )
-        if self.history:
-            current_band = self.gui.get_band_info()['current_band'] 
-            hearing_me, wb_text, geo_text = self.history.get_message_extra_info(their_call, current_band)
-            display_text = f"{message_dict['hail']} {message_dict['their_call']} {message_dict['grid_rpt']} {hearing_me} {wb_text} {geo_text}"
-            message_dict.update( {'hearing_me':hearing_me, 'wb_text':wb_text, 'geo_text':geo_text, 'display_text':display_text } )            
-
         if message_dict['priority']:
             if self.gui:
                 self.gui.display_message(message_dict)
+
         if self.on_decode:
             self.on_decode(message_dict)
         m = message_dict
         screen_format = f"{cyclestart_string} {their_snr} {m['dt']:4.1f} {m['fHz']:4.0f} ~ {hail} {their_call} {grid_rpt}"
-        print(f"{screen_format:50s} decoded@ {m['decode_completed']:5.1f}s, dec = {m['decode_status']}")
+        print(f"{screen_format:50s} decoded@ {m['decode_completed'] %15:5.1f}s, dec = {m['decode_status']}")
         self.message_queue_non_time_critical.put(message_dict)
 
     def _process_message_ntc(self):
@@ -52,7 +47,14 @@ class Broker():
                 if self.gui:
                     band_info = self.gui.get_band_info()
                     if not m['priority']:
-                        self.gui.display_message(m)                   
+                        self.gui.display_message(m)
+                    else:
+                        if self.history:
+                            current_band = self.gui.get_band_info()['current_band'] 
+                            hearing_me, wb_text, geo_text = self.history.get_message_extra_info(m['their_call'], current_band)
+                            new_display_text = f"{m['display_text']} {hearing_me} {wb_text} {geo_text}"
+                            self.gui.update_message( m['display_text'], {'hearing_me':hearing_me, 'wb_text':wb_text,
+                                                        'geo_text':geo_text, 'display_text':new_display_text } )
                 if band_info:
                     if m['their_call'] != 'not':
                         if self.history:

{pyft8-3.6.5 → pyft8-3.7.0}/PyFT8/pyft8.py

@@ -11,7 +11,7 @@ from PyFT8.databases import ADIF
 from PyFT8.qso_manager import QSO_manager
 from PyFT8.message_broker import Broker
 
-VER = '3.6.5'
+VER = '3.7.0'
 PSKR_REFRESH_MINS = 20
 message_broker = None
 
@@ -136,7 +136,7 @@ def cli():
         qso_manager = QSO_manager(message_broker, rig_control, console_print)
         message_broker.gui.register_qso_manager(qso_manager)
         message_broker.rx.register_before_search(message_broker.gui.before_search)
-        message_broker.rx.register_after_search(message_broker.gui.after_search)
+        #message_broker.rx.register_after_search(message_broker.gui.after_search)
         message_broker.history.incorporate_log_data(qso_manager.adif_logging.cache)
         message_broker.history.start_collect_new()
 

{pyft8-3.6.5 → pyft8-3.7.0}/PyFT8/receiver.py

@@ -592,7 +592,7 @@ class Receiver():
                                         'msg_text':f"{hail} {their_call} {grid_rpt}",
                                         'their_snr':f"{c.snr:+03d}", 'their_tx_cycle':c.origin['odd_even'], 
                                         't0':c.origin['t0'], 'dt':c.origin['t0'] - 0.5, 'fHz':c.origin['f0'],
-                                        'decode_status':c.decode_status, 'decode_completed':time_utils.cycle_time()}
+                                        'decode_status':c.decode_status, 'decode_completed':time_utils.time()}
                         self.process_message(message_dict)
                 
             if len(to_decode):

{pyft8-3.6.5 → pyft8-3.7.0}/PyFT8.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 3.6.5
+Version: 3.7.0
 Summary: FT8 Decoding and Encoding in Python with test/loopback code
 Author-email: G1OJS <g1ojs@yahoo.com>
 License-Expression: GPL-3.0-or-later

{pyft8-3.6.5 → pyft8-3.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PyFT8"
-version = "3.6.5"
+version = "3.7.0"
 license = "GPL-3.0-or-later"
 
 authors = [

pyft8-3.7.0/tests/spare2.py

@@ -0,0 +1,37 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import time
+import threading
+SIZE = 1000
+
+def thread1():
+    dat = np.random.rand(SIZE, SIZE)
+    while True:
+        time.sleep(0.1)
+        dat = ( dat * dat )%1
+
+
+def oncanvasclick(args):
+    t = time.time()
+    print(t %60)
+
+fig, ax = plt.subplots( figsize=(8,8) )
+ax.set_xlim(0,SIZE)
+ax.set_ylim(0,SIZE)
+threading.Thread(target = thread1, daemon = True).start()
+plt.show(block = False)
+
+dat = np.random.rand(SIZE, SIZE)
+img = ax.imshow(dat)
+plt.pause(0.1)
+cid = fig.canvas.mpl_connect('button_press_event', oncanvasclick)
+while True:
+    time.sleep(0.1)
+    img.set_data(np.random.rand(SIZE, SIZE))
+    plt.pause(0.2)
+
+    
+
+

pyft8-3.6.5/tests/spare2.py

@@ -1,28 +0,0 @@
-
-import numpy as np
-import matplotlib.pyplot as plt
-import time
-SIZE = 500
-
-fig, ax = plt.subplots( figsize=(8,8) )
-ax.set_xlim(0,SIZE)
-ax.set_ylim(0,SIZE)
-plt.show(block = False)
-
-arts = []
-
-from matplotlib.patches import Rectangle
-for i in range(10):
-    x, y = SIZE*np.random.rand(1)[0], SIZE*np.random.rand(1)[0]
-    rect = Rectangle((x, y), width=100, height=6, alpha=0.6, edgecolor='lime', lw=2)
-    art = ax.add_patch(rect)
-    arts.append(art)
-    ax.draw_artist(art)
-fig.canvas.update()
-fig.canvas.flush_events()
-    
-time.sleep(1)
-for a in arts:
-    a.remove()
-plt.pause(0.001)
-