easycoder 251215.2__py2.py3-none-any.whl → 260111.1__py2.py3-none-any.whl

easycoder/__init__.py

@@ -1,17 +1,18 @@
 '''EasyCoder for Python'''
 
+from .ec_border import *
 from .ec_classes import *
-from .ec_gclasses import *
 from .ec_compiler import *
 from .ec_condition import *
 from .ec_core import *
+from .ec_gclasses import *
 from .ec_graphics import *
 from .ec_handler import *
 from .ec_keyboard import *
-from .ec_border import *
+from .ec_mqtt import *
 from .ec_program import *
 from .ec_psutil import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "251215.2"
+__version__ = "260111.1"

easycoder/debugger/ec_dbg_value_display copy.py

@@ -122,7 +122,7 @@ class ValueDisplay(QWidget):
             else:
                 val_type = val.get('type', '?')
                 content = val.get('content', '')
-                if val_type == 'str':
+                if val_type == str:
                     # keep each element concise
                     s = str(content)
                     if len(s) > 120:

easycoder/debugger/ec_dbg_value_display.py

@@ -1,13 +1,6 @@
 """ValueDisplay widget for displaying variable values in the EasyCoder debugger"""
 
-from PySide6.QtWidgets import (
-    QWidget,
-    QFrame,
-    QVBoxLayout,
-    QLabel,
-    QScrollArea,
-)
-from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QLabel
 
 
 class ValueDisplay(QLabel):
@@ -15,9 +8,17 @@ class ValueDisplay(QLabel):
     
     def __init__(self, parent=None):
         super().__init__(parent)
-    
-    def setValue(self, program, symbol_name):
+
+    @staticmethod
+    def render_text(program, symbol_name):
         record = program.getVariable(symbol_name)
         value = program.textify(record)
-        self.setText(str(value))
+        return None if value is None else str(value)
+
+    def setValue(self, program, symbol_name):
+        try:
+            rendered = self.render_text(program, symbol_name)
+        except Exception as exc:
+            rendered = f"<error: {exc}>"
+        self.setText(rendered if rendered is not None else "")
 

easycoder/debugger/ec_dbg_watchlist.py

@@ -1,6 +1,7 @@
 """WatchListWidget showing variables on a single line with scrollable values."""
 
 import bisect
+import json
 
 from PySide6.QtWidgets import (
     QWidget,
@@ -10,8 +11,12 @@ from PySide6.QtWidgets import (
     QPushButton,
     QSizePolicy,
     QScrollArea,
+    QPlainTextEdit,
+    QFrame,
+    QSplitter,
 )
 from PySide6.QtCore import Qt
+from easycoder.ec_classes import ECVariable, ECDictionary, ECList, ECValue
 from .ec_dbg_value_display import ValueDisplay
 
 
@@ -25,9 +30,20 @@ class WatchListWidget(QWidget):
         self._variable_set: set[str] = set()
         self._order: list[str] = []
         self._placeholder: QLabel | None = None
+        self._expanded_name: str | None = None
 
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(6)
+
+        self.splitter = QSplitter(Qt.Orientation.Vertical, self)
+        self.splitter.setHandleWidth(6)
+        self.splitter.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+        list_container = QWidget(self)
+        list_container.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
         # Outer layout: scrollable labels (left) and fixed button column (right)
-        outer = QHBoxLayout(self)
+        outer = QHBoxLayout(list_container)
         outer.setContentsMargins(0, 0, 0, 0)
         outer.setSpacing(2)
 
@@ -54,8 +70,42 @@ class WatchListWidget(QWidget):
         self.buttons_column.addStretch(1)
         outer.addLayout(self.buttons_column)
 
+        self.splitter.addWidget(list_container)
+
+        self._build_expanded_panel()
+
+        main_layout.addWidget(self.splitter, 1)
+        # Give the list more space by default
+        try:
+            self.splitter.setStretchFactor(0, 3)
+            self.splitter.setStretchFactor(1, 2)
+        except Exception:
+            pass
+
         self._show_placeholder()
 
+    def _build_expanded_panel(self):
+        self.expanded_frame = QFrame(self)
+        self.expanded_frame.setFrameShape(QFrame.Shape.StyledPanel)
+        self.expanded_frame.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+        expanded_layout = QVBoxLayout(self.expanded_frame)
+        expanded_layout.setContentsMargins(6, 6, 6, 6)
+        expanded_layout.setSpacing(4)
+
+        self.expanded_title = QLabel("Expanded view")
+        self.expanded_title.setStyleSheet("font-weight: bold;")
+        expanded_layout.addWidget(self.expanded_title)
+
+        self.expanded_body = QPlainTextEdit(self.expanded_frame)
+        self.expanded_body.setReadOnly(True)
+        self.expanded_body.setLineWrapMode(QPlainTextEdit.LineWrapMode.WidgetWidth)
+        self.expanded_body.setStyleSheet("font-family: monospace; background-color: #fafafa;")
+        expanded_layout.addWidget(self.expanded_body)
+
+        self.splitter.addWidget(self.expanded_frame)
+        self._clear_expanded_panel()
+
     def _show_placeholder(self):
         if self._placeholder is not None:
             return
@@ -90,9 +140,18 @@ class WatchListWidget(QWidget):
         label.setWordWrap(False)
         row_layout.addWidget(label, 1)
 
-        # Remove button in separate column
-        remove_btn = QPushButton("-")
+        # Buttons live in a side container: remove (x) and expand (+)
+        button_container = QWidget(self)
+        button_row = QHBoxLayout(button_container)
+        button_row.setContentsMargins(0, 0, 0, 0)
+        button_row.setSpacing(4)
+
+        remove_btn = QPushButton("x")
         remove_btn.setFixedWidth(22)
+        expand_btn = QPushButton("+")
+        expand_btn.setFixedWidth(22)
+        button_row.addWidget(remove_btn)
+        button_row.addWidget(expand_btn)
 
         def on_remove():
             try:
@@ -104,33 +163,43 @@ class WatchListWidget(QWidget):
                     self._order.remove(name)
                 self.content_layout.removeWidget(row_widget)
                 row_widget.deleteLater()
-                self.buttons_column.removeWidget(remove_btn)
-                remove_btn.deleteLater()
+                self.buttons_column.removeWidget(button_container)
+                button_container.deleteLater()
                 self._rows.pop(name, None)
+                if self._expanded_name == name:
+                    self._clear_expanded_panel()
                 if not self._rows:
+                    self._clear_expanded_panel()
                     self._show_placeholder()
             except Exception:
                 pass
 
         remove_btn.clicked.connect(on_remove)
+        expand_btn.clicked.connect(lambda: self._on_expand(name))
 
         insert_pos = bisect.bisect_left(self._order, name)
         self._order.insert(insert_pos, name)
         # Insert label row above stretch, keeping alphabetical order
         self.content_layout.insertWidget(insert_pos, row_widget)
         # Insert button above stretch on the right, same position
-        self.buttons_column.insertWidget(insert_pos, remove_btn)
+        self.buttons_column.insertWidget(insert_pos, button_container)
 
         # Align button height to row height
         row_widget.adjustSize()
         btn_h = row_widget.sizeHint().height()
         if btn_h > 0:
+            button_container.setFixedHeight(btn_h)
             remove_btn.setFixedHeight(btn_h)
+            expand_btn.setFixedHeight(btn_h)
 
         self._rows[name] = {
             'widget': row_widget,
             'label': label,
-            'button': remove_btn,
+            'buttons': button_container,
+            'remove_btn': remove_btn,
+            'expand_btn': expand_btn,
+            'summary': '',
+            'detail': '',
         }
         self._variable_set.add(name)
 
@@ -143,13 +212,18 @@ class WatchListWidget(QWidget):
         row = self._rows.get(name)
         if not row:
             return
+        detail_text = ''
         try:
-            val_display = ValueDisplay()
-            val_display.setValue(program, name)
-            value_text = val_display.text()
+            summary_text, detail_text = self._get_value_texts(program, name)
+            row['summary'] = summary_text
+            row['detail'] = detail_text
         except Exception as e:
-            value_text = f"<error: {e}>"
-        row['label'].setText(f"{name} = {value_text}")
+            summary_text = f"<error: {e}>"
+            row['summary'] = summary_text
+            row['detail'] = ''
+        row['label'].setText(f"{name} = {summary_text}")
+        if self._expanded_name == name:
+            self._apply_expanded_content(name, summary_text, detail_text)
 
     def refreshVariables(self, program):
         if not self._rows:
@@ -157,3 +231,63 @@ class WatchListWidget(QWidget):
             return
         for name in list(self._rows.keys()):
             self._refresh_one(name, program)
+
+    def _get_value_texts(self, program, name: str):
+        summary = ValueDisplay.render_text(program, name)
+        if summary is None:
+            summary = ''
+
+        try:
+            record = program.getVariable(name)
+            obj = program.getObject(record)
+        except Exception:
+            return summary, ''
+
+        detail = ''
+        try:
+            if isinstance(obj, ECVariable):
+                detail = summary
+            elif isinstance(obj, ECDictionary):
+                raw = obj.getValue()
+                if isinstance(raw, ECValue):
+                    raw = raw.getContent()
+                if isinstance(raw, dict):
+                    detail = json.dumps(raw, indent=2)
+            elif isinstance(obj, ECList):
+                raw = obj.getValue()
+                if isinstance(raw, ECValue):
+                    raw = raw.getContent()
+                if isinstance(raw, list):
+                    detail = json.dumps(raw, indent=2)
+        except Exception:
+            pass
+        return summary, detail
+
+    def _on_expand(self, name: str):
+        if name not in self._rows:
+            return
+        try:
+            if hasattr(self.debugger, 'program'):
+                self._refresh_one(name, self.debugger.program)
+        except Exception:
+            pass
+
+        row = self._rows.get(name)
+        if not row:
+            return
+        self._expanded_name = name
+        self._apply_expanded_content(name, row.get('summary', ''), row.get('detail', ''))
+
+    def _apply_expanded_content(self, name: str, summary: str, detail: str):
+        body = detail if detail else summary
+        if body is None:
+            body = ''
+        if not body:
+            body = 'No content available for this variable.'
+        self.expanded_title.setText(f"Expanded view: {name}")
+        self.expanded_body.setPlainText(body)
+
+    def _clear_expanded_panel(self):
+        self._expanded_name = None
+        self.expanded_title.setText("Expanded view")
+        self.expanded_body.setPlainText("Select a watched variable and click + to view its contents.")

easycoder/debugger/ec_debug.py

@@ -43,6 +43,14 @@ class Debugger(QMainWindow):
             if not text:
                 return
             
+            # Echo all output to original stdout with proper line breaks
+            try:
+                if self.debugger._orig_stdout:
+                    self.debugger._orig_stdout.write(text)
+                    self.debugger._orig_stdout.flush()
+            except Exception:
+                pass
+            
             # Check if this looks like an error message - if so, also write to original stderr
             if any(err_marker in text for err_marker in ['Error', 'Traceback', 'Exception']):
                 try:
@@ -418,6 +426,9 @@ class Debugger(QMainWindow):
         self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowCloseButtonHint)
         self.stopped = True
         self.skip_next_breakpoint = False  # Flag to skip breakpoint check on resume
+        self.saved_queue = []  # Save queue state when stopped to preserve forked threads
+        self._highlighted: set[int] = set()
+        self.step_from_line: int | None = None  # Track source line when stepping
 
         # try to load saved geometry from ~/.ecdebug.conf
         cfg_path = os.path.join(os.path.expanduser("~"), ".ecdebug.conf")
@@ -467,9 +478,10 @@ class Debugger(QMainWindow):
         left.setFrameShape(QFrame.Shape.StyledPanel)
         left_layout = QVBoxLayout(left)
         left_layout.setContentsMargins(8, 8, 8, 8)
+        left_layout.setSpacing(0)
         self.leftColumn = self.MainLeftColumn(self)
-        left_layout.addWidget(self.leftColumn)
-        left_layout.addStretch()
+        self.leftColumn.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        left_layout.addWidget(self.leftColumn, 1)
 
         # Right pane
         right = QFrame()
@@ -794,7 +806,7 @@ class Debugger(QMainWindow):
     ###########################################################################
     # Set the background color of one line of the script
     def setBackground(self, lino, color):
-        # Set the background color of the given line
+        # Set the background color of the given line and track highlighted lines
         if lino < 0 or lino >= len(self.scriptLines):
             return
         lineSpec = self.scriptLines[lino]
@@ -803,8 +815,16 @@ class Debugger(QMainWindow):
             return
         if color == 'none':
             panel.setStyleSheet("")
+            self._highlighted.discard(lino)
         else:
             panel.setStyleSheet(f"background-color: {color};")
+            self._highlighted.add(lino)
+
+    def _clearHighlights(self):
+        # Remove highlighting from all previously highlighted lines
+        for lino in list(self._highlighted):
+            self.setBackground(lino, 'none')
+        self._highlighted.clear()
     
     ###########################################################################
     # Here before each instruction is run
@@ -832,22 +852,32 @@ class Debugger(QMainWindow):
         if is_first_command:
             should_halt = True
             self.stopped = True
+            self.step_from_line = None
             print(f"Program ready at line {lino + 1}")
         # If we're in stopped (step) mode, halt after each command
         elif self.stopped:
-            should_halt = True
+            # If stepping, only halt when we reach a different source line
+            if self.step_from_line is not None:
+                if lino != self.step_from_line:
+                    should_halt = True
+                    self.step_from_line = None
+            else:
+                should_halt = True
         # If there's a breakpoint on this line, halt
         elif bp:
             print(f"Hit breakpoint at line {lino + 1}")
             self.stopped = True
             should_halt = True
         
-        # If halting, update the UI
+        # If halting, update the UI and save queue state
         if should_halt:
             self.scrollTo(lino)
-            self.setBackground(lino, 'LightYellow')
+            self._clearHighlights()
+            self.setBackground(lino, 'Yellow')
             # Refresh variable values when halted
             self.refreshVariables()
+            # Save the current queue state to preserve forked threads
+            self._saveQueueState()
         
         return should_halt
     
@@ -859,6 +889,28 @@ class Debugger(QMainWindow):
         except Exception as ex:
             print(f"Error refreshing variables: {ex}")
     
+    def _saveQueueState(self):
+        """Save the current global queue state (preserves forked threads)"""
+        try:
+            # Import the module to access the global queue
+            from easycoder import ec_program
+            # Save a copy of the queue
+            self.saved_queue = list(ec_program.queue)
+        except Exception as ex:
+            print(f"Error saving queue state: {ex}")
+    
+    def _restoreQueueState(self):
+        """Restore the saved queue state (resume all forked threads)"""
+        try:
+            # Import here to avoid circular dependency
+            from easycoder import ec_program
+            # Restore the queue from saved state
+            if self.saved_queue:
+                ec_program.queue.clear()
+                ec_program.queue.extend(self.saved_queue)
+        except Exception as ex:
+            print(f"Error restoring queue state: {ex}")
+    
     def doRun(self):
         """Resume free-running execution from current PC"""
         command = self.program.code[self.pc]
@@ -870,12 +922,18 @@ class Debugger(QMainWindow):
         
         # Switch to free-running mode
         self.stopped = False
+        self.step_from_line = None
         
         # Skip the breakpoint check for the current instruction (the one we're resuming from)
         self.skip_next_breakpoint = True
         
-        # Resume execution at current PC
+        # Restore the saved queue state to resume all forked threads
+        self._restoreQueueState()
+
+        # Enqueue the current thread, then flush immediately
         self.program.run(self.pc)
+        from easycoder.ec_program import flush
+        flush()
     
     def doStep(self):
         """Execute one instruction and halt again"""
@@ -887,14 +945,33 @@ class Debugger(QMainWindow):
         
         # Stay in stopped mode (will halt after next instruction)
         self.stopped = True
+        # Remember the line we're stepping from - don't halt until we reach a different line
+        self.step_from_line = lino
         
         # Skip the breakpoint check for the current instruction (the one we're stepping from)
         self.skip_next_breakpoint = True
         
-        # Execute the current instruction
+        # Restore the saved queue state to resume all forked threads
+        self._restoreQueueState()
+
+        # Enqueue the current thread, then flush a single cycle
         self.program.run(self.pc)
+        from easycoder.ec_program import flush
+        flush()
     
     def doStop(self):
+        try:
+            lino = self.program.code[self.pc].get('lino', 0) + 1
+            print(f"Stopped by user at line {lino}")
+        except Exception:
+            print("Stopped by user")
+        # Clear all previous highlights and mark the current line
+        try:
+            self._clearHighlights()
+            current_lino = self.program.code[self.pc].get('lino', 0)
+            self.setBackground(current_lino, 'LightYellow')
+        except Exception:
+            pass
         self.stopped = True
     
     def doClose(self):