easycoder 251104.1__py2.py3-none-any.whl → 260108.1__py2.py3-none-any.whl

easycoder/ec_value.py

@@ -1,11 +1,9 @@
-from .ec_classes import FatalError
+from typing import Optional, List
+from .ec_classes import ECObject, FatalError, ECValue
 
 # Create a constant
 def getConstant(str):
-	value = {}
-	value['type'] = 'text'
-	value['content'] = str
-	return value
+	return ECValue(type=str, content=str)
 
 class Value:
 
@@ -14,30 +12,28 @@ class Value:
 		self.getToken = compiler.getToken
 		self.nextToken = compiler.nextToken
 		self.peek = compiler.peek
+		self.skip = compiler.skip
 		self.tokenIs = compiler.tokenIs
 
-	def getItem(self):
+	def getItem(self) -> Optional[ECValue]:
 		token = self.getToken()
 		if not token:
 			return None
 
-		value = {}
+		value = ECValue()
 
 		if token == 'true':
-			value['type'] = 'boolean'
-			value['content'] = True
+			value.setValue(bool, True)
 			return value
 
 		if token == 'false':
-			value['type'] = 'boolean'
-			value['content'] = False
+			value.setValue(bool, False)
 			return value
 
 		# Check for a string constant
 		if token[0] == '`':
 			if token[len(token) - 1] == '`':
-				value['type'] = 'text'
-				value['content'] = token[1 : len(token) - 1]
+				value.setValue(type=str, content=token[1 : len(token) - 1])
 				return value
 			FatalError(self.compiler, f'Unterminated string "{token}"')
 			return None
@@ -46,8 +42,7 @@ class Value:
 		if token.isnumeric() or (token[0] == '-' and token[1:].isnumeric):
 			val = eval(token)
 			if isinstance(val, int):
-				value['type'] = 'int'
-				value['content'] = val
+				value.setValue(int, val)
 				return value
 			FatalError(self.compiler, f'{token} is not an integer')
 
@@ -55,51 +50,74 @@ class Value:
 		mark = self.compiler.getIndex()
 		for domain in self.compiler.program.getDomains():
 			item = domain.compileValue()
-			if item != None:
-				return item
+			if item != None: return item
 			self.compiler.rewindTo(mark)
 		# self.compiler.warning(f'I don\'t understand \'{token}\'')
 		return None
 
-	def compileValue(self):
-		token = self.getToken()
+	# Get a list of items following 'the cat of ...'
+	def getCatItems(self) -> Optional[List[ECValue]]:
+		items: List[ECValue] = []
 		item = self.getItem()
+		if item == None: return None
+		items.append(item)
+		while self.peek() in ['cat', 'and']:
+			self.nextToken()
+			self.nextToken()
+			element = self.getItem()
+			if element != None:
+				items.append(element) # pyright: ignore[reportOptionalMemberAccess]
+		return items
+
+	# Check if any domain has something to add to the value
+	def checkDomainAdditions(self, value):
+		for domain in self.compiler.program.getDomains():
+			value = domain.modifyValue(value)
+		return value
+	
+	# Compile a value
+	def compileValue(self) -> Optional[ECValue]:
+		token = self.getToken()
+		# Special-case the plugin-safe full form: "the cat of ..."
+		if token == 'the' and self.peek() == 'cat':
+			self.nextToken()  # move to 'cat'
+			self.skip('of')
+			self.nextToken()
+			items = self.getCatItems()
+			value = ECValue(type='cat', content=items)
+			return self.checkDomainAdditions(value)
+
+		# Otherwise, consume any leading articles before normal parsing
+		self.compiler.skipArticles()
+		token = self.getToken()
+
+		item: ECValue|None = self.getItem()
 		if item == None:
 			self.compiler.warning(f'ec_value.compileValue: Cannot get the value of "{token}"')
 			return None
+		if item.getType() == 'symbol':
+			object = self.compiler.getSymbolRecord(item.getContent())['object']
+			if not object.hasRuntimeValue(): return None
 
-		value = {}
 		if self.peek() == 'cat':
-			value['type'] = 'cat'
-			value['numeric'] = False
-			value['value'] = [item]
-			while self.peek() == 'cat':
-				self.nextToken()
-				self.nextToken()
-				item = self.getItem()
-				if item != None:
-					value['value'].append(item)
+			self.nextToken()  # consume 'cat'
+			self.nextToken()
+			items = self.getCatItems()
+			if items != None: items.insert(0, item)
+			value = ECValue(type='cat', content=items)
 		else:
 			value = item
 
-	# See if any domain has something to add to the value
-		for domain in self.compiler.program.getDomains():
-			value = domain.modifyValue(value)
-
-		return value
+		return self.checkDomainAdditions(value)
 
 	def compileConstant(self, token):
-		value = {}
-		if type(token) == 'str':
-			token = eval(token)
-		if isinstance(token, int):
-			value['type'] = 'int'
-			value['content'] = token
-			return value
-		if isinstance(token, float):
-			value['type'] = 'float'
-			value['content'] = token
-			return value
-		value['type'] = 'text'
-		value['content'] = token
+		value = ECValue()
+		if isinstance(token, str):
+			value.setValue(type=int, content=token)
+		elif isinstance(token, int):
+			value.setValue(type=int, content=token)
+		elif isinstance(token, float):
+			value.setValue(type=float, content=token)
+		else:
+			value.setValue(type=str, content=str(token))
 		return value

easycoder/pre/README.md

@@ -0,0 +1,3 @@
+# 'Pre' version of EasyCoder
+
+The code in this directory is a version of EasyCoder that will run on Python versions lower than 10. It is missing more recent improvements such as the use of annotations.

easycoder/pre/__init__.py

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

easycoder/pre/debugger/__init__.py

@@ -0,0 +1,5 @@
+"""EasyCoder debugger module"""
+
+from .ec_debug import Debugger
+
+__all__ = ['Debugger']

easycoder/pre/debugger/ec_dbg_value_display copy.py

@@ -0,0 +1,195 @@
+"""ValueDisplay widget for displaying variable values in the EasyCoder debugger"""
+
+from PySide6.QtWidgets import (
+    QWidget,
+    QFrame,
+    QVBoxLayout,
+    QLabel,
+    QScrollArea,
+)
+from PySide6.QtCore import Qt
+
+
+class ValueDisplay(QWidget):
+    """Widget to display a variable value with type-appropriate formatting"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        vlayout = QVBoxLayout(self)
+        vlayout.setContentsMargins(0, 0, 0, 0)
+        vlayout.setSpacing(2)
+        
+        # Main value label (always visible)
+        self.value_label = QLabel()
+        self.value_label.setStyleSheet("font-family: mono; padding: 1px 2px;")
+        self.value_label.setWordWrap(False)
+        vlayout.addWidget(self.value_label)
+        
+        # Expanded details inside a scroll area (initially hidden)
+        self.details_scroll = QScrollArea()
+        self.details_scroll.setFrameShape(QFrame.Shape.NoFrame)
+        self.details_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.details_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.details_scroll.setWidgetResizable(True)
+        self.details_content = QWidget()
+        self.details_layout = QVBoxLayout(self.details_content)
+        self.details_layout.setContentsMargins(10, 0, 0, 0)
+        self.details_layout.setSpacing(1)
+        self.details_scroll.setWidget(self.details_content)
+        self.details_scroll.hide()
+        vlayout.addWidget(self.details_scroll)
+        
+        self.is_expanded = False
+        self.current_value = None
+        self.max_detail_rows = 10
+    
+    def setValue(self, symbol_record, program):
+        """Update display with current value from symbol record"""
+        if not symbol_record:
+            self.value_label.setText("<not found>")
+            return
+        
+        # Check if variable has value capability
+        symbol_object = program.getObject(symbol_record)
+        if not symbol_object.hasRuntimeValue():
+            self.value_label.setText(f"<{symbol_record.get('type', 'no-value')}>")
+            return
+        
+        # Get the value array
+        value_array = symbol_object.getValues()
+        
+        if not value_array or len(value_array) == 0:
+            self.value_label.setText("<empty>")
+            return
+        
+        # For arrays, show summary
+        if len(value_array) > 1:
+            index = symbol_record.get('index', 0)
+            self.value_label.setText(f"[{len(value_array)} elements] @{index}")
+            
+            # If expanded, show individual elements
+            if self.is_expanded:
+                self._show_array_elements(value_array, index)
+            else:
+                self._hide_details()
+        else:
+            # Single value - show it directly
+            val = program.textify(symbol_object)
+            self._show_single_value(val)
+    
+    def _show_single_value(self, content):
+        """Display a single value element"""
+        if content is None or content == {}:
+            self.value_label.setText("<none>")
+            return
+        
+        if isinstance(content, bool):
+            self.value_label.setText(str(content))
+        elif isinstance(content, int):
+            self.value_label.setText(str(content))
+        elif isinstance(content, str):
+            # Check if it's JSON
+            if isinstance(content, str) and content.strip().startswith(('{', '[')):
+                # Likely JSON - show truncated with expand option
+                self._set_elided_text(str(content), multiplier=2.0)
+                if self.is_expanded and len(content) > 50:
+                    self._show_text_details(content)
+            else:
+                # Regular string
+                text_s = str(content)
+                self._set_elided_text(text_s, multiplier=2.0)
+                if self.is_expanded:
+                    self._show_text_details(text_s)
+        else:
+            self.value_label.setText(str(content))
+    
+    def _show_array_elements(self, value_array, current_index):
+        """Show expanded array elements"""
+        self.details_scroll.show()
+        # Clear existing
+        while self.details_layout.count():
+            item = self.details_layout.takeAt(0)
+            if item.widget():
+                item.widget().deleteLater()
+
+        # Show all elements with internal vertical scrolling capped to N lines
+        for i in range(len(value_array)):
+            val = value_array[i]
+            marker = '→ ' if i == current_index else '  '
+            
+            if val is None or val == {}:
+                text = f"{marker}[{i}]: <none>"
+            else:
+                val_type = val.get('type', '?')
+                content = val.get('content', '')
+                if val_type == str:
+                    # keep each element concise
+                    s = str(content)
+                    if len(s) > 120:
+                        content = s[:120] + '...'
+                text = f'{marker}[{i}]: {content}'
+            
+            lbl = QLabel(text)
+            lbl.setStyleSheet("font-family: mono; font-size: 9pt;")
+            self.details_layout.addWidget(lbl)
+        # Cap scroll area height to max_detail_rows
+        fm = self.fontMetrics()
+        max_h = int(self.max_detail_rows * fm.height() * 1.2)
+        self.details_scroll.setMaximumHeight(max_h)
+    
+    def _show_text_details(self, text):
+        """Show full text in details area"""
+        self.details_scroll.show()
+        # Clear existing
+        while self.details_layout.count():
+            item = self.details_layout.takeAt(0)
+            if item.widget():
+                item.widget().deleteLater()
+        
+        lbl = QLabel(text)
+        lbl.setStyleSheet("font-family: mono; font-size: 9pt;")
+        lbl.setWordWrap(True)
+        self.details_layout.addWidget(lbl)
+        # Cap to max_detail_rows
+        fm = self.fontMetrics()
+        max_h = int(self.max_detail_rows * fm.height() * 1.2)
+        self.details_scroll.setMaximumHeight(max_h)
+    
+    def _hide_details(self):
+        """Hide expanded details"""
+        self.details_scroll.hide()
+    
+    def toggleExpand(self):
+        """Toggle between expanded and compact view"""
+        self.is_expanded = not self.is_expanded
+        # Caller should call setValue again to refresh display
+
+    def _approx_available_width(self) -> int:
+        try:
+            # Try to find nearest scroll area's viewport width
+            w = self
+            depth = 0
+            while w and depth < 6:
+                if isinstance(w, QScrollArea):
+                    return max(200, w.viewport().width())
+                w = w.parentWidget()
+                depth += 1
+            # Fallback to our own width or a safe default
+            return max(240, self.width())
+        except Exception:
+            return 320
+
+    def _set_elided_text(self, text: str, multiplier: float = 2.0):
+        try:
+            fm = self.value_label.fontMetrics()
+            avail = int(self._approx_available_width() * multiplier)
+            # Apply quotes for display
+            quoted = f'"{text}"'
+            elided = fm.elidedText(quoted, Qt.TextElideMode.ElideRight, max(80, avail))
+            self.value_label.setText(elided)
+        except Exception:
+            # Fallback simple trim
+            s = text
+            if len(s) > 160:
+                s = s[:160] + '...'
+            self.value_label.setText(f'"{s}"')

easycoder/pre/debugger/ec_dbg_value_display.py

@@ -0,0 +1,24 @@
+"""ValueDisplay widget for displaying variable values in the EasyCoder debugger"""
+
+from PySide6.QtWidgets import QLabel
+
+
+class ValueDisplay(QLabel):
+    """Widget to display a variable value with type-appropriate formatting"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+    @staticmethod
+    def render_text(program, symbol_name):
+        record = program.getVariable(symbol_name)
+        value = program.textify(record)
+        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/pre/debugger/ec_dbg_watch_list copy.py

@@ -0,0 +1,219 @@
+"""WatchListWidget for managing the variable watch list in the EasyCoder debugger"""
+
+from PySide6.QtWidgets import (
+    QWidget,
+    QFrame,
+    QHBoxLayout,
+    QVBoxLayout,
+    QGridLayout,
+    QLabel,
+    """WatchListWidget for managing the variable watch list in the EasyCoder debugger
+
+    Simplified to show variables in single-line form: `Name = value`.
+    """
+
+    from PySide6.QtWidgets import (
+        QWidget,
+        QHBoxLayout,
+        QVBoxLayout,
+        QLabel,
+        QPushButton,
+        QSizePolicy,
+    )
+    from .ec_dbg_value_display import ValueDisplay
+
+
+    class WatchListWidget(QWidget):
+        """Simple watch list that renders each variable on a single line."""
+
+        def __init__(self, debugger):
+            super().__init__(debugger)
+            self.debugger = debugger
+            self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+            self._rows: dict[str, dict] = {}
+            self._variable_set: set[str] = set()
+            self._placeholder: QLabel | None = None
+
+            self.layout = QVBoxLayout(self)
+            self.layout.setContentsMargins(0, 0, 0, 0)
+            self.layout.setSpacing(2)
+
+            self._show_placeholder()
+
+        # ------------------------------------------------------------------
+        def _show_placeholder(self):
+            if self._placeholder is not None:
+                return
+            self._placeholder = QLabel("No variables watched. Click + to add.")
+            self._placeholder.setStyleSheet("color: #666; font-style: italic; padding: 4px 2px;")
+            self.layout.addWidget(self._placeholder)
+
+        def _hide_placeholder(self):
+            if self._placeholder is None:
+                return
+            self.layout.removeWidget(self._placeholder)
+            self._placeholder.deleteLater()
+            self._placeholder = None
+
+        # ------------------------------------------------------------------
+        def addVariable(self, name: str):
+            if not name or name in self._variable_set:
+                return
+            if not hasattr(self.debugger, 'watched'):
+                self.debugger.watched = []  # type: ignore[attr-defined]
+            if name not in self.debugger.watched:  # type: ignore[attr-defined]
+                self.debugger.watched.append(name)  # type: ignore[attr-defined]
+
+            # Ensure placeholder hidden
+            self._hide_placeholder()
+
+            # Build a simple row: [ QLabel("Name = value") | remove_btn ]
+            row_widget = QWidget(self)
+            row_layout = QHBoxLayout(row_widget)
+            row_layout.setContentsMargins(4, 0, 4, 0)
+            row_layout.setSpacing(6)
+
+            label = QLabel("")
+            label.setWordWrap(False)
+            row_layout.addWidget(label, 1)
+
+            remove_btn = QPushButton("–")
+            remove_btn.setFixedSize(22, 22)
+
+            def on_remove():
+                try:
+                    if hasattr(self.debugger, 'watched') and name in self.debugger.watched:  # type: ignore[attr-defined]
+                        self.debugger.watched.remove(name)  # type: ignore[attr-defined]
+                    if name in self._variable_set:
+                        self._variable_set.remove(name)
+                    self.layout.removeWidget(row_widget)
+                    row_widget.deleteLater()
+                    self._rows.pop(name, None)
+                    if not self._rows:
+                        """WatchListWidget for managing the variable watch list in the EasyCoder debugger
+
+                        Simplified to show variables in single-line form: `Name = value`.
+                        """
+
+                        from PySide6.QtWidgets import (
+                            QWidget,
+                            QHBoxLayout,
+                            QVBoxLayout,
+                            QLabel,
+                            QPushButton,
+                            QSizePolicy,
+                        )
+                        from .ec_dbg_value_display import ValueDisplay
+
+
+                        class WatchListWidget(QWidget):
+                            """Simple watch list that renders each variable on a single line."""
+
+                            def __init__(self, debugger):
+                                super().__init__(debugger)
+                                self.debugger = debugger
+                                self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+                                self._rows: dict[str, dict] = {}
+                                self._variable_set: set[str] = set()
+                                self._placeholder: QLabel | None = None
+
+                                self.layout = QVBoxLayout(self)
+                                self.layout.setContentsMargins(0, 0, 0, 0)
+                                self.layout.setSpacing(2)
+
+                                self._show_placeholder()
+
+                            # ------------------------------------------------------------------
+                            def _show_placeholder(self):
+                                if self._placeholder is not None:
+                                    return
+                                self._placeholder = QLabel("No variables watched. Click + to add.")
+                                self._placeholder.setStyleSheet("color: #666; font-style: italic; padding: 4px 2px;")
+                                self.layout.addWidget(self._placeholder)
+
+                            def _hide_placeholder(self):
+                                if self._placeholder is None:
+                                    return
+                                self.layout.removeWidget(self._placeholder)
+                                self._placeholder.deleteLater()
+                                self._placeholder = None
+
+                            # ------------------------------------------------------------------
+                            def addVariable(self, name: str):
+                                if not name or name in self._variable_set:
+                                    return
+                                if not hasattr(self.debugger, 'watched'):
+                                    self.debugger.watched = []  # type: ignore[attr-defined]
+                                if name not in self.debugger.watched:  # type: ignore[attr-defined]
+                                    self.debugger.watched.append(name)  # type: ignore[attr-defined]
+
+                                # Ensure placeholder hidden
+                                self._hide_placeholder()
+
+                                # Build a simple row: [ QLabel("Name = value") | remove_btn ]
+                                row_widget = QWidget(self)
+                                row_layout = QHBoxLayout(row_widget)
+                                row_layout.setContentsMargins(4, 0, 4, 0)
+                                row_layout.setSpacing(6)
+
+                                label = QLabel("")
+                                label.setWordWrap(False)
+                                row_layout.addWidget(label, 1)
+
+                                remove_btn = QPushButton("–")
+                                remove_btn.setFixedSize(22, 22)
+
+                                def on_remove():
+                                    try:
+                                        if hasattr(self.debugger, 'watched') and name in self.debugger.watched:  # type: ignore[attr-defined]
+                                            self.debugger.watched.remove(name)  # type: ignore[attr-defined]
+                                        if name in self._variable_set:
+                                            self._variable_set.remove(name)
+                                        self.layout.removeWidget(row_widget)
+                                        row_widget.deleteLater()
+                                        self._rows.pop(name, None)
+                                        if not self._rows:
+                                            self._show_placeholder()
+                                    except Exception:
+                                        pass
+
+                                remove_btn.clicked.connect(on_remove)
+                                row_layout.addWidget(remove_btn, 0)
+
+                                # Track row
+                                self.layout.addWidget(row_widget)
+                                self._rows[name] = {
+                                    'widget': row_widget,
+                                    'label': label,
+                                }
+                                self._variable_set.add(name)
+
+                                # Initial refresh for the new row
+                                try:
+                                    self._refresh_one(name, self.debugger.program)
+                                except Exception:
+                                    pass
+
+                            # ------------------------------------------------------------------
+                            def _refresh_one(self, name: str, program):
+                                row = self._rows.get(name)
+                                if not row:
+                                    return
+                                try:
+                                    # ValueDisplay reduced to textify given symbol name
+                                    val_display = ValueDisplay()
+                                    val_display.setValue(program, name)
+                                    value_text = val_display.text()
+                                except Exception as e:
+                                    value_text = f"<error: {e}>"
+                                row['label'].setText(f"{name} = {value_text}")
+
+                            # ------------------------------------------------------------------
+                            def refreshVariables(self, program):
+                                if not self._rows:
+                                    self._show_placeholder()
+                                    return
+                                for name in list(self._rows.keys()):
+                                    self._refresh_one(name, program)