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

easycoder/ec_program.py

@@ -1,6 +1,7 @@
-import time, sys
+import time, sys, json
 from copy import deepcopy
 from collections import deque
+
 from .ec_classes import (
 	Script,
 	Token,
@@ -8,7 +9,8 @@ from .ec_classes import (
 	RuntimeError, 
 	NoValueRuntimeError, 
 	ECObject,
-	ECValue
+	ECValue,
+	normalize_type
 )
 from .ec_compiler import Compiler
 from .ec_core import Core
@@ -51,6 +53,7 @@ class Program:
 		self.symbols = {}
 		self.onError = 0
 		self.debugStep = False
+		self.debugSkip = False
 		self.stack = []
 		self.script = Script(source)
 		self.compiler = Compiler(self)
@@ -58,6 +61,7 @@ class Program:
 		self.value = self.compiler.value
 		self.condition = self.compiler.condition
 		self.graphics = None
+		self.mqtt = None
 		self.psutil = None
 		self.useClass(Core)
 		self.ticker = 0
@@ -117,6 +121,15 @@ class Program:
 			self.useClass(Graphics)
 		return True
 	
+	# Use the MQTT module
+	def useMQTT(self):
+		if self.mqtt == None:
+			print('Loading MQTT module')
+			from .ec_mqtt import MQTT
+			self.mqtt = MQTT
+			self.useClass(MQTT)
+		return True
+	
 	# Use the psutil module
 	def usePSUtil(self):
 		if self.psutil == None:
@@ -163,6 +176,16 @@ class Program:
 				object.setIndex(i) # type: ignore
 				self.run(goto)
 				return
+	
+	# Ensure the program is running
+	def ensureRunning(self):
+		if not self.running:
+			raise RuntimeError(self, 'Improper use of runtime function')
+	
+	# Ensure the program is not running
+	def ensureNotRunning(self):
+		if self.running:
+			raise RuntimeError(self, 'Improper use of non-runtime function')
 
 	# Get the domain list
 	def getDomains(self):
@@ -173,6 +196,7 @@ class Program:
 
 	# Get the symbol record for a given name
 	def getVariable(self, name):
+		self.ensureRunning()
 		if isinstance(name, dict): name = name['name']
 		try:
 			target = self.code[self.symbols[name]]
@@ -199,10 +223,16 @@ class Program:
 	def checkObjectType(self, object, classes):
 		if isinstance(object, dict): return
 		if not isinstance(object, classes):
+			if isinstance(classes, tuple):
+				class_names = ", ".join([c.__name__ for c in classes])
+				message = f"Variable {object.name} should be one of {class_names}"
+			else:
+				class_names = classes.__name__
+				message = f"Variable {object.name} should be {class_names}"
 			if self.running:
-				raise RuntimeError(self, f"Objects of type {type(object)} are not instances of {classes}")
+				raise RuntimeError(self, message)
 			else:
-				raise FatalError(self.compiler, f"Objects of type {type(object)} are not instances of {classes}")
+				raise FatalError(self.compiler, message)
 
 	# Get the inner (non-EC) object from a name, record or object
 	def getInnerObject(self, object):
@@ -217,13 +247,13 @@ class Program:
 
 	def constant(self, content, numeric):
 		result = {}
-		result['type'] = 'int' if numeric else 'str'
+		result['type'] = int if numeric else str
 		result['content'] = content
 		return result
 	
 	# Test if an item is a string or a number
 	def getItemType(self, value):
-		return 'int' if isinstance(value, int) else 'str'
+		return int if isinstance(value, int) else str
 	
 	# Get the value of an item that may be an ECValue or a raw value. Return as an ECValue
 	def getValueOf(self, item):
@@ -234,31 +264,31 @@ class Program:
 			else: value = item
 		else:
 			varType = type(item).__name__
-			if varType in ['int', 'str', 'bool', 'float', 'list', 'dict']:
-				if varType == 'int': value.setValue(type='int', content=item)
-				elif varType == 'str': value.setValue(type='str', content=item)
-				elif varType == 'bool': value.setValue(type='boolean', content=item)
-				elif varType == 'float': value.setValue(type='str', content=str(item))
-				elif varType == 'list': value.setValue(type='list', content=item)
-				elif varType == 'dict': value.setValue(type='dict', content=item)
-				else: value.setValue(None)
+			if varType == 'int': value.setValue(type=int, content=item)
+			elif varType == 'str': value.setValue(type=str, content=item)
+			elif varType == 'bool': value.setValue(type=bool, content=item)
+			elif varType == 'float': value.setValue(type=str, content=str(item))
+			elif varType == 'list': value.setValue(type=list, content=item)
+			elif varType == 'dict': value.setValue(type=dict, content=item)
+			else: value.setValue(type=None, content=None)
 		return value
 
 	# Runtime function to evaluate an ECObject or ECValue. Returns another ECValue
 	# This function may be called recursively by value handlers.
 	def evaluate(self, item):
+		self.ensureRunning()
 		if isinstance(item, ECObject):
 			value = item.getValue()
 			if value == None:
 				raise RuntimeError(self, f'Symbol {item.getName()} not initialized')
 		else: value = item
 		try:
-			valType = value.getType() # type: ignore
+			valType = normalize_type(value.getType()) # type: ignore
 		except:
 			RuntimeError(self, 'Value does not hold a valid ECValue')
 		result = ECValue(type=valType)
 	
-		if valType in ('str', 'int', 'boolean', 'list', 'dict'):
+		if valType in ('str', 'int', 'bool', 'list', 'dict', None):
 			# Simple value - just return the content
 			result.setContent(value.getContent()) # type: ignore
 		
@@ -276,13 +306,14 @@ class Program:
 			result = variable.getValue() # type: ignore
 			if isinstance(result, ECValue): return self.evaluate(result)
 			if isinstance(result, ECObject): return result.getValue()
-			else:
-				# See if one of the domains can handle this value
-				value = result
-				result = None
-				for domain in self.domains:
-					result = domain.getUnknownValue(value)
-					if result != None: break
+			if isinstance(result, dict) or isinstance(result, list):
+				return result
+			# See if one of the domains can handle this value
+			value = result
+			result = None
+			for domain in self.domains:
+				result = domain.getUnknownValue(value)
+				if result != None: break
 				
 		elif valType == 'cat':
 			# Handle concatenation
@@ -292,8 +323,8 @@ class Program:
 				if val != None:
 					if isinstance(val, ECValue): val = str(val.getContent())
 					if val == None: val = ''
-					else: content += val
-			result.setValue(type='str', content=content)
+					else: content += str(val)
+			result.setValue(type=str, content=content)
 	
 		else:
 			# Call the given domain to handle a value
@@ -307,6 +338,7 @@ class Program:
 
 	# Get the runtime value of a value object (as a string or integer)
 	def textify(self, value):
+		self.ensureRunning()
 		if value is None:
 			return None
 		
@@ -323,6 +355,8 @@ class Program:
 			if v.getType() == 'object':
 				return value.getContent() # type: ignore
 			return v.getContent() 
+		if isinstance(v, (dict, list)): 
+			return json.dumps(v)
 		return v
 
 	# Get the content of a symbol
@@ -334,6 +368,7 @@ class Program:
 
 	# Get the value of a symbol as an ECValue
 	def getSymbolValue(self, record):
+		self.ensureRunning()
 		object = self.getObject(record)
 		self.checkObjectType(object, ECObject)
 		value = object.getValue() # type: ignore
@@ -440,7 +475,7 @@ class Program:
 				self.pc += 1
 			else:
 				keyword = command['keyword']
-				if self.debugStep and 'debug' in command:
+				if self.debugStep and not self.debugSkip and 'debug' in command:
 					lino = command['lino'] + 1
 					line = self.script.lines[command['lino']].strip()
 					print(f'{self.name}: Line {lino}: {domainName}:{keyword}:  {line}')
@@ -449,9 +484,9 @@ class Program:
 				if handler:
 					command = self.code[self.pc]
 					command['program'] = self
-					if self.breakpoint:
-						pass	# Place a breakpoint here for a debugger to catch
 					try:
+						if self.breakpoint:
+							pass	# Place a breakpoint here for a debugger to catch
 						self.pc = handler(command)
 					except Exception as e:
 						raise RuntimeError(self, f'Error during execution of {domainName}:{keyword}: {str(e)}')

easycoder/ec_psutil.py

@@ -36,7 +36,7 @@ class PSUtil(Handler):
     def v_memory(self, v):
         process: Process = Process(os.getpid())
         megabytes: float = process.memory_info().rss / (1024 * 1024)
-        return ECValue(domain=self.getName(), type='float', content=megabytes)
+        return ECValue(domain=self.getName(), type=float, content=megabytes)
 
     #############################################################################
     # Compile a condition

easycoder/ec_value.py

@@ -1,8 +1,9 @@
+from typing import Optional, List
 from .ec_classes import ECObject, FatalError, ECValue
 
 # Create a constant
 def getConstant(str):
-	return ECValue(type='str', content=str)
+	return ECValue(type=str, content=str)
 
 class Value:
 
@@ -11,9 +12,10 @@ 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
@@ -21,17 +23,17 @@ class Value:
 		value = ECValue()
 
 		if token == 'true':
-			value.setValue('boolean', True)
+			value.setValue(bool, True)
 			return value
 
 		if token == 'false':
-			value.setValue('boolean', False)
+			value.setValue(bool, False)
 			return value
 
 		# Check for a string constant
 		if token[0] == '`':
 			if token[len(token) - 1] == '`':
-				value.setValue(type='str', 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
@@ -40,7 +42,7 @@ class Value:
 		if token.isnumeric() or (token[0] == '-' and token[1:].isnumeric):
 			val = eval(token)
 			if isinstance(val, int):
-				value.setValue('int', val)
+				value.setValue(int, val)
 				return value
 			FatalError(self.compiler, f'{token} is not an integer')
 
@@ -53,10 +55,43 @@ class Value:
 		# self.compiler.warning(f'I don\'t understand \'{token}\'')
 		return None
 
+	# 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):
+	def compileValue(self) -> Optional[ECValue]:
 		token = self.getToken()
-		item = self.getItem()
+		# 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
@@ -64,39 +99,25 @@ class Value:
 			object = self.compiler.getSymbolRecord(item.getContent())['object']
 			if not object.hasRuntimeValue(): return None
 
-		value = ECValue()
 		if self.peek() == 'cat':
-			items = None
-			if value.getType() == 'cat': items = value.getContent()
-			else:
-				value.setType('cat')
-				items = [item]
-				value.setContent(items)
-			while self.peek() == 'cat':
-				v = self.nextToken()
-				v= self.nextToken()
-				element = self.getItem()
-				if element != None:
-					items.append(element) # pyright: ignore[reportOptionalMemberAccess]
-			value.setContent(items)
+			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 = ECValue()
-		if type(token) == 'str':
-			token = eval(token)
-		if isinstance(token, int):
-			value.setValue(type='int', content=token)
-			return value
-		if isinstance(token, float):
-			value.setValue(type='float', content=token)
-			return value
-		value.setValue(type='str', content=token)
+		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 "")
+