v1.19.0: Cycle statistics, stop logging fix

Author: eldinmiller

CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.19.0] - 2025-11-26
+
+### Added
+- **Cycle Statistics**: Persistent stats tracking (operations, cycle times, yield) with rolling averages
+- **Stats Display**: "Show Stats" button in operator view, "Cycle Statistics..." in Settings menu
+- **Job Tracking**: Stats tracked per-job with "Last Job" comparison
+
+### Changed
+- **Stop Logging**: No longer errors when no active logging sessions
+- **Menus**: Removed "Operator Views" from Devices menu (use double-click instead)
+
 ## [1.18.0] - 2025-11-26
 
 ### Added

_version.py

@@ -1 +1 @@
-__version__ = "1.18.0"
+__version__ = "1.19.0"

requirements.txt

@@ -1,5 +1,6 @@
 # Runtime dependencies
 pyserial>=3.5  # For USB serial communication
+psutil>=5.9.0  # For system stats (uptime, etc.)
 
 # Note: Barcode/QR scanner support uses keyboard input emulation
 # Most USB/Bluetooth scanners work as HID devices, no extra dependencies needed

src/app.py

@@ -276,6 +276,8 @@ def __init__(self, root, startup_file=None):
 
         # --- Serial Number System ---
         initialize_serial_manager()
+        from .serial_number import get_serial_manager
+        self.shared_gui_refs['serial_manager'] = get_serial_manager()
         print("[SYSTEM] Serial number system initialized")
 
         # --- Populate device-specific shared refs ---
@@ -298,6 +300,39 @@ def __init__(self, root, startup_file=None):
             pass  # Ignore if logger not available
 
         self.load_last_script()
+        self.launch_startup_operator_views()
+
+    def launch_startup_operator_views(self):
+        """Launch operator views that are configured to show on startup."""
+        from src.device.views import get_startup_operator_views, show_operator_view
+        from src.config import load_config
+        
+        def _launch_views():
+            try:
+                config_data = load_config()
+                startup_devices = get_startup_operator_views(config_data)
+                
+                for device_name in startup_devices:
+                    # Check if device exists and is connected
+                    device_data = self.device_manager.devices.get(device_name)
+                    if device_data:
+                        device_state = self.device_manager.get_device_state(device_name)
+                        if device_state and device_state.get('connected'):
+                            print(f"[OPERATOR VIEW] Launching operator view for {device_name}")
+                            script_runner = self.shared_gui_refs.get('script_runner')
+                            show_operator_view(self.root, device_name, device_data, 
+                                             self.shared_gui_refs, script_runner)
+                        else:
+                            print(f"[OPERATOR VIEW] Skipping {device_name} - device not connected")
+                    else:
+                        print(f"[OPERATOR VIEW] Skipping {device_name} - device not found")
+            except Exception as e:
+                print(f"[OPERATOR VIEW] Error launching startup views: {e}")
+                import traceback
+                traceback.print_exc()
+        
+        # Launch after a delay to ensure devices are connected
+        self.root.after(1000, _launch_views)
 
     def initialize_shared_variables(self):
         # This method's logic has been moved into __init__ to resolve a startup dependency issue.

src/device/registry.py

@@ -109,7 +109,7 @@ def discover_devices(self):
 
             if os.path.exists(config_path):
                 try:
-                    with open(config_path, 'r') as f:
+                    with open(config_path, 'r', encoding='utf-8') as f:
                         config = json.load(f)
                         device_name = config.get('device_name') or config.get('name')
                 except Exception as e:
@@ -139,33 +139,41 @@ def _load_device_from_path(self, device_name, definition_path):
             scripting_commands = {}
             json_path = os.path.join(definition_path, 'commands.json')
             if os.path.exists(json_path):
-                with open(json_path, 'r') as f:
+                with open(json_path, 'r', encoding='utf-8') as f:
                     scripting_commands = json.load(f)
 
             # Load telemetry schema
             telemetry_data = {}
             schema_path = os.path.join(definition_path, 'telemetry.json')
             if os.path.exists(schema_path):
-                with open(schema_path, 'r') as f:
+                with open(schema_path, 'r', encoding='utf-8') as f:
                     telemetry_data = json.load(f)
 
             # Load events
             events_data = {}
             events_path = os.path.join(definition_path, 'events.json')
             if os.path.exists(events_path):
-                with open(events_path, 'r') as f:
+                with open(events_path, 'r', encoding='utf-8') as f:
                     events_data = json.load(f)
 
-            # Load Python modules (gui, simulator)
+            # Load views
+            views_data = {}
+            views_path = os.path.join(definition_path, 'views.json')
+            if os.path.exists(views_path):
+                with open(views_path, 'r', encoding='utf-8') as f:
+                    views_data = json.load(f)
+            
+            # Load Python modules (gui, simulator, operator_view, parser)
             gui_module = self._load_module_from_path(device_name, 'gui', definition_path)
             simulator_module = self._load_module_from_path(device_name, 'simulator', definition_path)
+            operator_view_module = self._load_module_from_path(device_name, 'operator_view', definition_path)
             parser_module = self._load_module_from_path(device_name, 'parser', definition_path)
 
             # Load warnings from JSON (always from definition folder)
             warnings_data = {}
             warnings_path = os.path.join(definition_path, 'warnings.json')
             if os.path.exists(warnings_path):
-                with open(warnings_path, 'r') as f:
+                with open(warnings_path, 'r', encoding='utf-8') as f:
                     warnings_data = json.load(f)
 
             # Store device data (use old key names for backward compatibility)
@@ -179,8 +187,15 @@ def _load_device_from_path(self, device_name, definition_path):
                 'telemetry_data': telemetry_data,
                 'events_data': events_data,
                 'warnings': warnings_data,
+                'views_data': views_data,
                 'config': {},  # Keep for consistent structure
                 'status_var': None,  # Will be created during GUI init
+                'modules': {
+                    'gui': gui_module,
+                    'simulator': simulator_module,
+                    'operator_view': operator_view_module,
+                    'parser': parser_module,
+                },
             }
 
             return True
@@ -205,28 +220,28 @@ def reload_single_device(self, device_name):
         # Reload commands.json
         json_path = os.path.join(device_path, 'commands.json')
         if os.path.exists(json_path):
-            with open(json_path, 'r') as f:
+            with open(json_path, 'r', encoding='utf-8') as f:
                 self.devices[device_name]['scripting_commands'] = json.load(f)
                 self.log(f"Reloaded commands.json for {device_name}")
 
         # Reload telemetry.json
         schema_path = os.path.join(device_path, 'telemetry.json')
         if os.path.exists(schema_path):
-            with open(schema_path, 'r') as f:
+            with open(schema_path, 'r', encoding='utf-8') as f:
                 self.devices[device_name]['telemetry_data'] = json.load(f)
                 self.log(f"Reloaded telemetry.json for {device_name}")
 
         # Reload events.json
         events_path = os.path.join(device_path, 'events.json')
         if os.path.exists(events_path):
-            with open(events_path, 'r') as f:
+            with open(events_path, 'r', encoding='utf-8') as f:
                 self.devices[device_name]['events_data'] = json.load(f)
                 self.log(f"Reloaded events.json for {device_name}")
 
         # Reload warnings.json
         warnings_path = os.path.join(device_path, 'warnings.json')
         if os.path.exists(warnings_path):
-            with open(warnings_path, 'r') as f:
+            with open(warnings_path, 'r', encoding='utf-8') as f:
                 self.devices[device_name]['warnings'] = json.load(f)
                 self.log(f"Reloaded warnings.json for {device_name}")
 
@@ -341,7 +356,7 @@ def get_device_config(self, device_name):
         config_path = os.path.join(device_path, 'config.json')
         if os.path.exists(config_path):
             try:
-                with open(config_path, 'r') as f:
+                with open(config_path, 'r', encoding='utf-8') as f:
                     return json.load(f)
             except Exception as e:
                 self.log(f"Failed to read config.json for {device_name}: {e}")