changed the 2 listboxes with IPs and data into a table, and fixed all functions using this

cfg_util/func/__init__.py

@@ -1,21 +1,17 @@
+import asyncio
 import ipaddress
 import os
 import re
 import time
-from operator import itemgetter
-import asyncio
 
 import aiofiles
 import toml
 
-from cfg_util.miner_factory import miner_factory
-from cfg_util.layout import window
-from cfg_util.func.data import safe_parse_api_data
-
-from config.bos import bos_config_convert, general_config_convert_bos
-
 from API import APIError
-
+from cfg_util.func.data import safe_parse_api_data
+from cfg_util.layout import window
+from cfg_util.miner_factory import miner_factory
+from config.bos import bos_config_convert, general_config_convert_bos
 from settings import CFG_UTIL_CONFIG_THREADS as CONFIG_THREADS
 
 
@@ -60,7 +56,7 @@ async def scan_network(network):
         progress_bar_len += 1
         asyncio.create_task(update_prog_bar(progress_bar_len))
     all_miners.sort(key=lambda x: x.ip)
-    window["ip_list"].update([str(miner.ip) for miner in all_miners])
+    window["ip_table"].update([[str(miner.ip), "", "", "", ""] for miner in all_miners])
     await update_ui_with_data("ip_count", str(len(all_miners)))
     await update_ui_with_data("status", "")
 
@@ -70,21 +66,24 @@ async def miner_light(ips: list):
 
 
 async def flip_light(ip):
-    listbox = window['ip_list'].Widget
+    ip_list = window['ip_table'].Widget
     miner = await miner_factory.get_miner(ip)
-    if ip in window["ip_list"].Values:
+    index = [item[0] for item in window["ip_table"].Values].index(ip)
-        index = window["ip_list"].Values.index(ip)
+    index_tags = ip_list.item(index)['tags']
-        if listbox.itemcget(index, "background") == 'red':
+    if "light" not in index_tags:
-            listbox.itemconfigure(index, bg='#f0f3f7', fg='#000000')
+        ip_list.item(index, tags=([*index_tags, "light"]))
-            await miner.fault_light_off()
+        window['ip_table'].update(row_colors=[(index, "white", "red")])
-        else:
+        await miner.fault_light_on()
-            listbox.itemconfigure(index, bg='red', fg='white')
+    else:
-            await miner.fault_light_on()
+        index_tags.remove("light")
+        ip_list.item(index, tags=index_tags)
+        window['ip_table'].update(row_colors=[(index, "black", "white")])
+        await miner.fault_light_off()
 
 
-async def import_config(ip):
+async def import_config(idx):
     await update_ui_with_data("status", "Importing")
-    miner = await miner_factory.get_miner(ipaddress.ip_address(*ip))
+    miner = await miner_factory.get_miner(ipaddress.ip_address(window["ip_table"].Values[idx[0]][0]))
     await miner.get_config()
     config = miner.config
     await update_ui_with_data("config", str(config))
@@ -105,7 +104,7 @@ async def import_iplist(file_location):
                     if ip not in ip_list:
                         ip_list.append(ipaddress.ip_address(ip))
     ip_list.sort()
-    window["ip_list"].update([str(ip) for ip in ip_list])
+    window["ip_table"].update([[str(ip), "", "", "", ""] for ip in ip_list])
     await update_ui_with_data("ip_count", str(len(ip_list)))
     await update_ui_with_data("status", "")
 
@@ -121,8 +120,8 @@ async def export_iplist(file_location, ip_list_selected):
                     await file.write(str(item) + "\n")
         else:
             async with aiofiles.open(file_location, mode='w') as file:
-                for item in window['ip_list'].Values:
+                for item in window['ip_table'].Values:
-                    await file.write(str(item) + "\n")
+                    await file.write(str(item[0]) + "\n")
     await update_ui_with_data("status", "")
 
 
@@ -197,14 +196,12 @@ async def get_data(ip_list: list):
 
     total_hr = round(sum(d.get('TH/s', 0) for d in miner_data), 2)
     window["hr_total"].update(f"{total_hr} TH/s")
-    window["hr_list"].update(disabled=False)
+    table_data = [
-    window["hr_list"].update([item['IP'] + " | "
+        [
-                              + item['host'] + " | "
+            item["IP"], item["host"], str(item['TH/s']) + " TH/s", item['user'], str(item['wattage']) + " W"
-                              + str(item['TH/s']) + " TH/s | "
+        ] for item in miner_data
-                              + item['user'] + " | "
+    ]
-                              + str(item['wattage']) + " W"
+    await update_ui_with_data("ip_table", table_data)
-                              for item in miner_data])
-    window["hr_list"].update(disabled=True)
     await update_ui_with_data("status", "")
 
 
@@ -225,7 +222,8 @@ async def get_formatted_data(ip: ipaddress.ip_address):
             th5s = round(await safe_parse_api_data(miner_data, 'summary', 0, 'SUMMARY', 0, 'MHS 5s') / 1000000, 2)
         elif 'GHS 5s' in miner_data['summary'][0]['SUMMARY'][0].keys():
             if not miner_data['summary'][0]['SUMMARY'][0]['GHS 5s'] == "":
-                th5s = round(float(await safe_parse_api_data(miner_data, 'summary', 0, 'SUMMARY', 0, 'GHS 5s')) / 1000, 2)
+                th5s = round(float(await safe_parse_api_data(miner_data, 'summary', 0, 'SUMMARY', 0, 'GHS 5s')) / 1000,
+                             2)
             else:
                 th5s = 0
         else:
@@ -258,7 +256,6 @@ async def generate_config(username, workername, v2_allowed):
         url_2 = 'stratum+tcp://us-east.stratum.slushpool.com:3333'
         url_3 = 'stratum+tcp://stratum.slushpool.com:3333'
 
-
     config = {'group': [{
         'name': 'group',
         'quota': 1,
@@ -297,45 +294,23 @@ async def generate_config(username, workername, v2_allowed):
 
 async def sort_data(index: int or str):
     await update_ui_with_data("status", "Sorting Data")
-    data_list = window['hr_list'].Values
+    data_list = window['ip_table'].Values
-    new_list = []
+
-    indexes = {}
+    # wattage
-    for item in data_list:
+    if re.match("[0-9]* W", data_list[0][index]):
-        item_data = [part.strip() for part in item.split("|")]
+        new_list = sorted(data_list, key=lambda x: int(x[index].replace(" W", "")))
-        for idx, part in enumerate(item_data):
+
-            if re.match("[0-9]* W", part):
+    # hashrate
-                item_data[idx] = item_data[idx].replace(" W", "")
+    elif re.match("[0-9]*\.?[0-9]* TH\/s", data_list[0][index]):
-                indexes['wattage'] = idx
+        new_list = sorted(data_list, key=lambda x: float(x[index].replace(" TH/s", "")))
-            elif re.match("[0-9]*\.?[0-9]* TH\/s", part):
+
-                item_data[idx] = item_data[idx].replace(" TH/s", "")
+    # ip addresses
-                indexes['hr'] = idx
+    elif re.match("^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)",
-            elif re.match("^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)", part):
+                  data_list[0][index]):
-                item_data[idx] = ipaddress.ip_address(item_data[idx])
+        new_list = sorted(data_list, key=lambda x: ipaddress.ip_address(x[index]))
-                indexes['ip'] = idx
+
-        new_list.append(item_data)
+    # everything else, hostname and user
-    if not isinstance(index, str):
-        if index == indexes['hr']:
-            new_data_list = sorted(new_list, key=lambda x: float(x[index]))
-        else:
-            new_data_list = sorted(new_list, key=itemgetter(index))
     else:
-        if index.lower() not in indexes.keys():
+        new_list = sorted(data_list, key=lambda x: x[index])
-            return
+    await update_ui_with_data("ip_table", new_list)
-        elif index.lower() == 'hr':
-            new_data_list = sorted(new_list, key=lambda x: float(x[indexes[index]]))
-        else:
-            new_data_list = sorted(new_list, key=itemgetter(indexes[index]))
-    new_ip_list = []
-    for item in new_data_list:
-        new_ip_list.append(item[indexes['ip']])
-    new_data_list = [str(item[indexes['ip']]) + " | "
-                     + item[1] + " | "
-                     + item[indexes['hr']] + " TH/s | "
-                     + item[3] + " | "
-                     + str(item[indexes['wattage']]) + " W"
-                     for item in new_data_list]
-    window["hr_list"].update(disabled=False)
-    window["hr_list"].update(new_data_list)
-    window['ip_list'].update(new_ip_list)
-    window["hr_list"].update(disabled=True)
     await update_ui_with_data("status", "")

cfg_util/ui.py

@@ -22,37 +22,37 @@ async def ui():
                 miner_network = MinerNetwork(value['miner_network'])
             asyncio.create_task(scan_network(miner_network))
         if event == 'select_all_ips':
-            if value['ip_list'] == window['ip_list'].Values:
+            if len(value["ip_table"]) == len(window["ip_table"].Values):
-                window['ip_list'].set_value([])
+                window["ip_table"].update(select_rows=())
             else:
-                window['ip_list'].set_value(window['ip_list'].Values)
+                window["ip_table"].update(select_rows=([row for row in range(len(window["ip_table"].Values))]))
         if event == 'import_config':
-            if 2 > len(value['ip_list']) > 0:
+            if 2 > len(value['ip_table']) > 0:
-                asyncio.create_task(import_config(value['ip_list']))
+                asyncio.create_task(import_config(value['ip_table']))
         if event == 'light':
-            asyncio.create_task(miner_light(value['ip_list']))
+            asyncio.create_task(miner_light([window['ip_table'].Values[item][0] for item in value['ip_table']]))
         if event == "import_iplist":
             asyncio.create_task(import_iplist(value["file_iplist"]))
         if event == "export_iplist":
-            asyncio.create_task(export_iplist(value["file_iplist"], value['ip_list']))
+            asyncio.create_task(export_iplist(value["file_iplist"], [window['ip_table'].Values[item][0] for item in value['ip_table']]))
         if event == "send_config":
-            asyncio.create_task(send_config(value['ip_list'], value['config']))
+            asyncio.create_task(send_config([window['ip_table'].Values[item][0] for item in value['ip_table']], value['config']))
         if event == "import_file_config":
             asyncio.create_task(import_config_file(value['file_config']))
         if event == "export_file_config":
             asyncio.create_task(export_config_file(value['file_config'], value["config"]))
         if event == "get_data":
-            asyncio.create_task(get_data(value['ip_list']))
+            asyncio.create_task(get_data([window["ip_table"].Values[item][0] for item in value["ip_table"]]))
         if event == "generate_config":
             await generate_config_ui()
         if event == "sort_data_ip":
-            asyncio.create_task(sort_data('ip'))
+            asyncio.create_task(sort_data(0))  # ip index in table
         if event == "sort_data_hr":
-            asyncio.create_task(sort_data('hr'))
+            asyncio.create_task(sort_data(2))  # HR index in table
         if event == "sort_data_user":
-            asyncio.create_task(sort_data(3))
+            asyncio.create_task(sort_data(3))  # user index in table
         if event == "sort_data_w":
-            asyncio.create_task(sort_data('wattage'))
+            asyncio.create_task(sort_data(4))  # wattage index in table
         if event == "__TIMEOUT__":
             await asyncio.sleep(0)
 
@@ -65,7 +65,8 @@ async def generate_config_ui():
             break
         if event == "generate_config_window_generate":
             if values['generate_config_window_username']:
-                await generate_config(values['generate_config_window_username'], values['generate_config_window_workername'], values['generate_config_window_allow_v2'])
+                await generate_config(values['generate_config_window_username'],
+                                      values['generate_config_window_workername'],
+                                      values['generate_config_window_allow_v2'])
                 generate_config_window.close()
                 break
-