Merge pull request #7 from OpenAstroTech/bugfix/js/misc-minor-fixes

Bugfix/js/misc minor fixes

Author: julianneswinoga

OATFWGUI/external_processes.py

@@ -31,7 +31,8 @@ def start(self, extra_args: List[str], finish_signal: Optional):
 
         all_args = self.base_args + extra_args
         self.qproc.setArguments(all_args)
-        self.qproc.finished.connect(finish_signal)
+        if finish_signal is not None:
+            self.qproc.finished.connect(finish_signal)
         log.info(f'Starting {self.proc_name} with args: {all_args}')
         self.qproc.start()
         # Not sure why, but the process doesn't start without these
@@ -45,6 +46,7 @@ def start(self, extra_args: List[str], finish_signal: Optional):
         self.cleanup()
 
     def cleanup(self):
+        log.debug(f'Cleaning up external process: {self.proc_name}. Exited with {self.qproc.exitCode()}')
         self.stdout_text = ''
         self.stderr_text = ''
         self.qproc.deleteLater()

OATFWGUI/gui_logic.py

@@ -4,7 +4,6 @@
 import zipfile
 import json
 from typing import List, Optional
-from collections import namedtuple
 from pathlib import Path
 
 from PySide6.QtCore import Slot, QThreadPool, QFile, QProcess, Qt
@@ -15,10 +14,9 @@
 from log_utils import LogObject
 from qt_extensions import Worker, QBusyIndicatorGoodBad, BusyIndicatorState
 from external_processes import external_processes, get_install_dir
+from gui_state import LogicState, PioEnv, FWVersion
 
 log = logging.getLogger('')
-FWVersion = namedtuple('FWVersion', ['nice_name', 'url'])
-PioEnv = namedtuple('FWVersion', ['nice_name', 'raw_name'])
 
 
 def get_pio_environments(fw_dir: Path) -> List[PioEnv]:
@@ -45,10 +43,8 @@ def get_pio_environments(fw_dir: Path) -> List[PioEnv]:
     }
     pio_environments = []
     for raw_env in raw_pio_envs:
-        if raw_env in nice_name_lookup:
-            pio_env = PioEnv(nice_name_lookup[raw_env], raw_env)
-        else:
-            pio_env = PioEnv(raw_env, raw_env)
+        # Try to match a raw env to nice name, fallback to raw env
+        pio_env = PioEnv(nice_name_lookup.get(raw_env, raw_env), raw_env)
         pio_environments.append(pio_env)
     return pio_environments
 
@@ -77,22 +73,6 @@ def extract_fw(zipfile_name: Path) -> Path:
     return fw_dir
 
 
-class LogicState:
-    release_list: Optional[List[FWVersion]] = None
-    release_idx: Optional[int] = None
-    fw_dir: Optional[Path] = None
-    pio_envs: List[PioEnv] = []
-    pio_env: Optional[str] = None
-    config_file_path: Optional[str] = None
-    build_success: bool = False
-    serial_ports: List[str] = []
-    upload_port: Optional[str] = None
-
-    def __setattr__(self, key, val):
-        log.debug(f'LogicState updated: {key} {getattr(self, key)} -> {val}')
-        super().__setattr__(key, val)
-
-
 class BusinessLogic:
     def __init__(self, main_app: 'MainWidget'):
         self.logic_state = LogicState()
@@ -184,8 +164,8 @@ def get_fw_versions_result(main_app: 'MainWidget', fw_versions_list: List[FWVers
 
     def download_and_extract_fw(self) -> str:
         self.main_app.wSpn_download.setState(BusyIndicatorState.BUSY)
-        fw_idx = self.main_app.wCombo_fw_version.currentIndex()
-        zip_url = self.logic_state.release_list[fw_idx].url
+        self.logic_state.release_idx = self.main_app.wCombo_fw_version.currentIndex()
+        zip_url = self.logic_state.release_list[self.logic_state.release_idx].url
         zipfile_name = download_fw(zip_url)
 
         self.logic_state.fw_dir = extract_fw(zipfile_name)
@@ -256,8 +236,8 @@ def build_fw(self):
     @Slot()
     def pio_build_finished(self):
         log.info(f'platformio build finished')
-        exit_state = external_processes['platformio'].qproc.exitCode()
-        if exit_state == QProcess.NormalExit:
+        exit_code = external_processes['platformio'].qproc.exitCode()
+        if exit_code == 0:
             log.info('Normal exit')
             self.main_app.wSpn_build.setState(BusyIndicatorState.GOOD)
             self.logic_state.build_success = True
@@ -278,14 +258,21 @@ def refresh_ports(self):
     @Slot()
     def pio_refresh_ports_finished(self):
         log.info(f'platformio refresh ports finished')
-        exit_state = external_processes['platformio'].qproc.exitCode()
-        if exit_state == QProcess.NormalExit:
+        exit_code = external_processes['platformio'].qproc.exitCode()
+        if exit_code == 0:
             log.info('Normal exit')
         else:
             log.error('Did not exit normally')
         stdout_data = external_processes['platformio'].stdout_text
-        all_port_data = json.loads(stdout_data)
-        self.logic_state.serial_ports = [port_data['port'] for port_data in all_port_data]
+        if stdout_data:
+            try:
+                all_port_data = json.loads(stdout_data)
+            except json.decoder.JSONDecodeError as e:
+                log.error(f'JSONDecodeError: {e} with\n{repr(stdout_data)}')
+                all_port_data = []
+            self.logic_state.serial_ports = [port_data['port'] for port_data in all_port_data]
+        else:
+            self.logic_state.serial_ports = []
 
         self.main_app.wCombo_serial_port.clear()
         for serial_port in self.logic_state.serial_ports:
@@ -325,8 +312,8 @@ def upload_fw(self):
     @Slot()
     def pio_upload_finished(self):
         log.info(f'platformio upload finished')
-        exit_state = external_processes['platformio'].qproc.exitCode()
-        if exit_state == QProcess.NormalExit:
+        exit_code = external_processes['platformio'].qproc.exitCode()
+        if exit_code == 0:
             log.info('Normal exit')
             self.main_app.wSpn_upload.setState(BusyIndicatorState.GOOD)
         else:

OATFWGUI/gui_state.py

@@ -0,0 +1,32 @@
+import logging
+from typing import NamedTuple, List, Optional
+from pathlib import Path
+
+
+log = logging.getLogger('')
+
+
+class FWVersion(NamedTuple):
+    nice_name: str
+    url: str
+
+
+class PioEnv(NamedTuple):
+    nice_name: str
+    raw_name: str
+
+
+class LogicState:
+    release_list: Optional[List[FWVersion]] = None
+    release_idx: Optional[int] = None
+    fw_dir: Optional[Path] = None
+    pio_envs: List[PioEnv] = []
+    pio_env: Optional[str] = None
+    config_file_path: Optional[str] = None
+    build_success: bool = False
+    serial_ports: List[str] = []
+    upload_port: Optional[str] = None
+
+    def __setattr__(self, key, val):
+        log.debug(f'LogicState updated: {key} {getattr(self, key)} -> {val}')
+        super().__setattr__(key, val)

OATFWGUI/log_utils.py

@@ -3,14 +3,15 @@
 import os
 import enum
 import html
-import platform
 from pathlib import Path
 from datetime import datetime
 from typing import Tuple
 
 from PySide6.QtCore import Signal, QObject
 
 from external_processes import get_install_dir
+from platform_check import get_platform, PlatformEnum
+
 
 class LogObject(QObject):
     log_signal = Signal(str)
@@ -62,7 +63,7 @@ def _colour_html(self, levelno: int) -> Tuple[str, str]:
         return pre, post
 
     def format(self, record):
-        if self.colour_type == LogColourTypes.terminal and 'windows' not in platform.system().lower():
+        if self.colour_type == LogColourTypes.terminal and get_platform() != PlatformEnum.WINDOWS:
             # only use terminal colors when not in windows, they don't work by default
             pre, post = self._colour_terminal(record.levelno)
             log_str = pre + super().format(record) + post

OATFWGUI/main.py

@@ -48,6 +48,8 @@ def setup_environment():
         add_external_process('platformio', 'platformio', [])
 
     external_processes['platformio'].start(['system', 'info'], None)
+    external_processes['platformio'].start(['settings', 'set', 'check_platformio_interval', '9999'], None)
+    external_processes['platformio'].start(['settings', 'set', 'check_prune_system_threshold', '0'], None)
 
 
 class MainWindow(QMainWindow):

OATFWGUI/platform_check.py

@@ -0,0 +1,37 @@
+import enum
+import platform
+import logging
+
+platform_lookup_cache = None
+log = logging.getLogger('')
+
+
+class PlatformEnum(enum.Enum):
+    LINUX = enum.auto()
+    WINDOWS = enum.auto()
+    UNKNOWN = enum.auto()
+
+
+def get_platform() -> PlatformEnum:
+    global platform_lookup_cache
+    if platform_lookup_cache is not None:
+        # Not really for performance, but so that we can use the logger
+        # without worrying about recursion
+        return platform_lookup_cache
+
+    # No logging just yet!!
+    platform_str = platform.system().lower()
+    if 'windows' in platform_str:
+        platform_lookup = PlatformEnum.WINDOWS
+    elif 'linux' in platform_str:
+        platform_lookup = PlatformEnum.LINUX
+    else:
+        platform_lookup = PlatformEnum.UNKNOWN
+    platform_lookup_cache = platform_lookup  # Cache return
+    # We can now use logging
+
+    log.debug(f'platform_str={platform_str}')
+    if platform_lookup == PlatformEnum.UNKNOWN:
+        log.warning(f'Unknown platform {platform_str}!')
+
+    return platform_lookup