easycoder 260110.1__py2.py3-none-any.whl → 260118.3__py2.py3-none-any.whl

easycoder/__init__.py

@@ -9,9 +9,10 @@ from .ec_gclasses import *
 from .ec_graphics import *
 from .ec_handler import *
 from .ec_keyboard import *
+from .ec_mqtt import *
 from .ec_program import *
 from .ec_psutil import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "260110.1"
+__version__ = "260118.3"

easycoder/ec_classes.py

@@ -312,6 +312,12 @@ class ECValueHolder(ECObject):
     # Reset the object to empty state
     def reset(self):
         self.setValue(ECValue(content=None))
+    
+    def textify(self):
+        v = self.getValue()
+        if v is None:
+            return ""
+        return json.dumps(v.getContent())
 
 ###############################################################################
 # A string or int variable
@@ -351,7 +357,7 @@ class ECDictionary(ECValueHolder):
             if types_equal(varType, str):
                 try:
                     if content in ('', {}, None): content = {}
-                    else: content = json.loads(content)
+                    elif content[0] in ('{', '['): content = json.loads(content) # type: ignore
                 except:
                     raise RuntimeError(None, 'ECDictionary string value is not valid JSON') # type: ignore
         elif varType == None:
@@ -387,7 +393,10 @@ class ECDictionary(ECValueHolder):
         content = self.getValue()
         if content is None:
             return None
-        return content.get(key, None)
+        if key in content:
+             return content[key]
+        else:
+             return None
 
     # Delete an entry from the dictionary
     def deleteEntry(self, key):

easycoder/ec_compiler.py

@@ -203,6 +203,7 @@ class Compiler:
 
 	# Compile a symbol
 	def compileSymbol(self, command, name, classname):
+		# January 2026
 		# try:
 		# 	self.symbols[name]
 		# 	raise FatalError(self, f'Duplicate symbol name "{name}"')

easycoder/ec_core.py

@@ -2,6 +2,7 @@ import json, math, hashlib, threading, os, subprocess, time
 import base64, binascii, random, requests, paramiko, uuid
 from copy import deepcopy
 from datetime import datetime
+from pathlib import Path
 from .ec_classes import (
     FatalError,
     RuntimeWarning,
@@ -70,7 +71,7 @@ class Core(Handler):
             if not isinstance(self.getObject(record), ECVariable): return False
             # If 'giving' comes next, this variable is the second value
             if self.peek() == 'giving':
-                v2 = ECValue(type='symbol', content=record['name'])
+                v2 = ECValue(type='symbol', name=record['name'])
                 command['value2'] = v2
                 self.nextToken()
                 # Now get the target variable
@@ -165,12 +166,32 @@ class Core(Handler):
             return self.compileFromHere(['end'])
 
     # clear {variable}
+    # clear entry {name} of {dictionary}
+    # clear item {index} of {list}
     def k_clear(self, command):
         token = self.nextToken()
         if token == 'breakpoint':
             command['breakpoint'] = True
             self.add(command)
             return True
+        elif token == 'entry':
+            command['key'] = self.nextValue()
+            self.skip('of')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                self.checkObjectType(self.getObject(record), ECDictionary)
+                command['target'] = record['name']
+                self.add(command)
+                return True
+        elif token == 'item':
+            command['index'] = self.nextValue()
+            self.skip('of')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                self.checkObjectType(self.getObject(record), ECList)
+                command['target'] = record['name']
+                self.add(command)
+                return True
         elif self.isSymbol():
             record = self.getSymbolRecord()
             command['target'] = record['name']
@@ -186,6 +207,14 @@ class Core(Handler):
     def r_clear(self, command):
         if 'breakpoint' in command:
             self.program.breakpoint = False
+        elif 'key' in command:
+            key = self.textify(command['key'])
+            record = self.getVariable(command['target'])
+            self.getObject(record).setEntry(key, ECValue(type=bool, content=False))
+        elif 'index' in command:
+            index = self.textify(command['index'])
+            record = self.getVariable(command['target'])
+            self.getObject(record).setItem(index, ECValue(type=bool, content=False))
         else:
             target = self.getVariable(command['target'])
             if target['keyword'] == 'ssh':
@@ -199,10 +228,10 @@ class Core(Handler):
     def k_close(self, command):
         if self.nextIsSymbol():
             fileRecord = self.getSymbolRecord()
-            self.checkObjectType
-            command['file'] = fileRecord['name']
-            self.add(command)
-            return True
+            if isinstance(self.getObject(fileRecord), ECFile):
+                command['file'] = fileRecord['name']
+                self.add(command)
+                return True
         return False
 
     def r_close(self, command):
@@ -794,6 +823,7 @@ class Core(Handler):
             ssh = self.getVariable(command['ssh'])
             path = self.textify(command['path'])
             sftp = ssh['sftp']
+            print(f'Loading from path: {Path(path).expanduser()}')
             try:
                 with sftp.open(path, 'r') as remote_file: content = remote_file.read().decode()
             except:
@@ -806,7 +836,7 @@ class Core(Handler):
         else:
             filename = self.textify(command['file'])
             try:
-                with open(filename) as f: content = f.read()
+                with open(Path(filename).expanduser()) as f: content = f.read()
             except:
                 errorReason = f'Unable to read from {filename}'
 
@@ -1335,7 +1365,7 @@ class Core(Handler):
                     content = json.dumps(content)
                 elif not isinstance(content, str):
                     content = self.textify(content)
-                with open(filename, 'w') as f: f.write(content)
+                with open(Path(filename).expanduser(), 'w') as f: f.write(content)
             except Exception as e:
                 errorReason = f'Unable to write to {filename}: {str(e)}'
 
@@ -1371,8 +1401,9 @@ class Core(Handler):
         return self.nextPC()
 
     # Set a value
-    # set {variable}
-    # set {variable} to {value}
+    # set {variable} [to {value}]
+    # set entry {key} of {dictionary} [to {value}]
+    # set item {index} of {list} [to {value}]
     # set {ssh} host {host} user {user} password {password}
     # set the items/elements in/of {variable} to {value}
     # set item/entry/property of {variable} to {value}
@@ -1403,16 +1434,15 @@ class Core(Handler):
                 command['type'] = 'ssh'
                 self.add(command)
                 return True
-            elif isinstance(self.getObject(record), ECVariable):
-                self.skip('to')
-                mark = self.compiler.getIndex()
-                value = self.nextValue()
-                if value != None:
+            elif isinstance(self.getObject(record), (ECVariable, ECDictionary, ECList)):
+                if self.peek() == 'to':
+                    self.nextToken()
+                    value = self.nextValue()
                     command['type'] = 'setValue'
                     command['value'] = value
-                else:
-                    self.rewindTo(mark)
+                elif isinstance(self.getObject(record), ECVariable):
                     command['type'] = 'set'
+                else: return False
                 self.add(command)
                 return True
             return False
@@ -1440,19 +1470,30 @@ class Core(Handler):
                 self.add(command)
                 return True
 
-        elif token in ('entry', 'property'):
+        elif token in ('entry', 'item', 'property'):
             command['key'] = self.nextValue()
             if self.nextIs('of'):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
                     if token == 'entry':
                         self.checkObjectType(self.getObject(record), ECDictionary)
+                    elif token == 'item':
+                        self.checkObjectType(self.getObject(record), ECList)
                     command['target'] = record['name']
-                    if self.nextIs('to'):
-                        value = self.nextValue()
-                        if value == None:
-                            FatalError(self.compiler, 'Unable to get a value')
-                        command['value'] = value
+                    if self.peek() == 'to':
+                        self.nextToken()
+                        if self.nextIsSymbol():
+                            record = self.getSymbolRecord()
+                            command['name'] = record['name']
+                        else:
+                            value = self.getValue()
+                            if value == None:
+                                FatalError(self.compiler, 'Unable to get a value')
+                            command['value'] = value
+                        self.add(command)
+                        return True
+                    else: # Set True
+                        command['value'] = ECValue(type=bool, content=True)
                         self.add(command)
                         return True
 
@@ -1499,6 +1540,18 @@ class Core(Handler):
             object.setElements(elements)
             return self.nextPC()
 
+        elif cmdType == 'entry':
+            key = self.textify(command['key'])
+            if 'name' in command:
+                value = self.textify(self.getVariable(command['name']))
+            elif 'value' in command:
+                value = self.textify(command['value'])
+            record = self.getVariable(command['target'])
+            self.checkObjectType(self.getObject(record), ECDictionary)
+            variable = self.getObject(record)
+            variable.setEntry(key, value)
+            return self.nextPC()
+
         elif cmdType == 'item':
             index = self.textify(command['index'])
             value = self.textify(command['value'])
@@ -1517,15 +1570,6 @@ class Core(Handler):
             os.chdir(path)
             return self.nextPC()
 
-        elif cmdType == 'entry':
-            key = self.textify(command['key'])
-            value = self.textify(command['value'])
-            record = self.getVariable(command['target'])
-            self.checkObjectType(self.getObject(record), ECDictionary)
-            variable = self.getObject(record)
-            variable.setEntry(key, value)
-            return self.nextPC()
-
         elif cmdType == 'property':
             key = self.textify(command['key'])
             value = self.evaluate(command['value'])
@@ -1686,8 +1730,7 @@ class Core(Handler):
             self.checkObjectType(record, ECObject)
             # If 'giving' comes next, this variable is the second value
             if self.peek() == 'giving':
-                v2 = ECValue(type='symbol')
-                v2.setContent(record['name'])
+                v2 = ECValue(type='symbol', name=record['name'])
                 command['value2'] = v2
                 self.nextToken()
                 # Now get the target variable
@@ -1815,7 +1858,7 @@ class Core(Handler):
             token = self.nextToken()
             if token == 'graphics':
                 return self.program.useGraphics()
-            elif token == 'mqtt':
+            if token == 'mqtt':
                 return self.program.useMQTT()
             elif token == 'psutil':
                 return self.program.usePSUtil()
@@ -1950,8 +1993,12 @@ class Core(Handler):
         value = ECValue()
         token = self.getToken()
         if self.isSymbol():
-            value.setValue(type='symbol', content=token)
-            return value
+            record = self.getSymbolRecord()
+            if self.isObjectType(record, (ECVariable, ECDictionary, ECList, ECStack, ECSSH, ECFile, ECModule)):
+                value.setType('symbol')
+                value.name = record['name']
+                return value
+            else: return None
 
         value.setType(token)
 
@@ -1990,7 +2037,7 @@ class Core(Handler):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
                     self.checkObjectType(record['object'], ECList)
-                    value.target = ECValue(type='symbol', content=record['name'])
+                    value.target = ECValue(type='symbol', name=record['name'])
                     return value
             return None
 
@@ -2049,7 +2096,7 @@ class Core(Handler):
                     record = self.getSymbolRecord()
                     object = record['object']
                     if isinstance(object, ECList):
-                        value.setContent(record['name'])
+                        value.setName(record['name'])
                         return value
             return None
 
@@ -2194,6 +2241,13 @@ class Core(Handler):
 
         return value
 
+    #############################################################################
+	# Get the value of an unknown item 
+    def getUnknownValue(self, value):
+        if self.isObjectType(value, (ECVariable, ECDictionary, ECList)):
+            return value.getContent()  # type: ignore
+        return None # Unable to get value
+
     #############################################################################
     # Value handlers
 
@@ -2218,7 +2272,7 @@ class Core(Handler):
         return ECValue(type=int, content=round(math.cos(angle * 0.01745329) * radius))
 
     def v_count(self, v):
-        variable = self.getObject(self.getVariable(v.getContent()))
+        variable = self.getObject(self.getVariable(v.getName()))
         return ECValue(type=int, content=variable.getItemCount())
 
     def v_datime(self, v):
@@ -2352,7 +2406,7 @@ class Core(Handler):
     def v_item(self, v):
         index = self.textify(v.index)
         targetName = v.target
-        target = self.getVariable(targetName.getContent())
+        target = self.getVariable(targetName.getName())
         variable = self.getObject(target)
         self.checkObjectType(variable, ECList)
         if index >= variable.getItemCount():
@@ -2461,14 +2515,10 @@ class Core(Handler):
 
     # This is used by the expression evaluator to get the value of a symbol
     def v_symbol(self, v):
-        name = v.name
-        record = self.program.getSymbolRecord(name)
-        keyword = record['keyword']
-        if keyword == 'object':
-            return record['object'].getValue()
-        elif keyword == 'variable':
+        record = self.program.getSymbolRecord(v.name)
+        if self.isObjectType(record, (ECVariable, ECDictionary, ECList)):
             return self.getSymbolValue(record)
-        elif keyword == 'ssh':
+        elif self.isObjectType(record, ECSSH):
             return ECValue(type=bool, content=True if 'ssh' in record and record['ssh'] != None else False)
         else:
             return None
@@ -2532,7 +2582,7 @@ class Core(Handler):
         return ECValue(type=str, content=content.upper())
     
     def v_uuid(self, v):
-        return ECValue(type=str, content=str(uuid.uuid4())[:8])
+        return ECValue(type=str, content=str(uuid.uuid4()))
 
     def v_valueOf(self, v):
         v = self.textify(v.getContent())
@@ -2712,7 +2762,7 @@ class Core(Handler):
 
     def c_empty(self, condition):
         if condition.value1.getType() == 'symbol':
-            record = self.getVariable(condition.value1.content)
+            record = self.getVariable(condition.value1.name)
             variable = self.getObject(record)
             if isinstance(variable, (ECList, ECDictionary)):
                 comparison = variable.isEmpty()
@@ -2739,7 +2789,7 @@ class Core(Handler):
 
     def c_exists(self, condition):
         path = self.textify(condition.path)
-        comparison = os.path.exists(path)
+        comparison = os.path.exists(Path(path).expanduser())
         return not comparison if condition.negate else comparison
 
     def c_greater(self, condition):

easycoder/ec_gclasses.py

@@ -1,4 +1,4 @@
-from .ec_classes import ECObject
+from .ec_classes import ECValue, ECObject
 
 ###############################################################################
 # A generic graphic element
@@ -75,6 +75,13 @@ class ECLabel(ECTextWidget):
     # This is a core class
     def isCoreClass(self):
         return True
+    
+    def getContent(self):
+        return self.getValue().text() # type: ignore
+    
+    # Get the text of the widget
+    def textify(self):
+        return self.getContent()
 
 ###############################################################################
 # A pushbutton variable
@@ -100,7 +107,7 @@ class ECCheckBox(ECCoreWidget):
     def getContent(self):
         v = self.getValue()
         if v is None: return None
-        return v.getContent().isChecked()
+        return v.isChecked() # type: ignore
 
 ###############################################################################
 # A line input widget
@@ -112,6 +119,32 @@ class ECLineInput(ECTextWidget):
     def hasRuntimeValue(self):
         return True
     
+    # Set the text of the widget
+    def setText(self, text):
+        v = self.getValue()
+        if v is None: return
+        v.getContent().setText(str(text)) # type: ignore
+
+    # Get the content of the value at the current index
+    def getContent(self):
+        content = self.getValue()
+        if content is None: return None
+        return content.text()
+    
+    # Get the text of the widget
+    def textify(self):
+        return self.getContent()
+    
+###############################################################################
+# A multiline widget
+class ECMultiline(ECTextWidget):
+    def __init__(self):
+        super().__init__()
+    
+    # This object has a runtime value
+    def hasRuntimeValue(self):
+        return True
+    
     # Set the text of the widget
     def setText(self, text):
         v = self.getValue()
@@ -120,7 +153,7 @@ class ECLineInput(ECTextWidget):
     
     # Get the text of the widget
     def getText(self):
-        return self.getValue().getContent().text() # type: ignore
+        return self.getValue().getContent().toPlainText() # type: ignore
 
     # Get the content of the value at the current index
     def getContent(self):
@@ -128,12 +161,6 @@ class ECLineInput(ECTextWidget):
         if v is None: return None
         return v.getContent().text()
 
-###############################################################################
-# A multiline widget
-class ECMultiline(ECTextWidget):
-    def __init__(self):
-        super().__init__()
-
 ###############################################################################
 # A listbox variable
 class ECListBox(ECCoreWidget):

easycoder/ec_graphics.py

@@ -337,6 +337,23 @@ class Graphics(Handler):
                         layout.addWidget(widget) # type: ignore
         return self.nextPC()
 
+    # adjust {window}
+    def k_adjust(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if self.isObjectType(record, ECWindow):
+                command['window'] = record['name']
+                self.add(command)
+                return True
+        return False
+    
+    def r_adjust(self, command):
+        object = self.getVariable(command['window'])['object']
+        self.checkObjectType(object, ECWindow)
+        window = self.getInnerObject(object)
+        window.adjustSize()
+        return self.nextPC()
+
     # Center one window on another
     # center {window2} on {window1}
     def k_center(self, command):
@@ -518,6 +535,9 @@ class Graphics(Handler):
             elif token == 'size':
                 self.nextToken()
                 command['size'] = self.nextValue()
+            elif token == 'width':
+                self.nextToken()
+                command['width'] = self.nextValue()
             elif token == 'expand':
                 self.nextToken()
                 command['expand'] = True
@@ -723,6 +743,8 @@ class Graphics(Handler):
             c = label.contentsMargins()
             w = fm.horizontalAdvance('m') * self.textify(command['size']) +c.left()+c.right()
             label.setMaximumWidth(w)
+        if 'width' in command:
+            label.setFixedWidth(self.textify(command['width']))
         if 'align' in command:
             alignment = command['align']
             if alignment == 'left': label.setAlignment(Qt.AlignmentFlag.AlignLeft)
@@ -1514,7 +1536,7 @@ class Graphics(Handler):
         value = ECValue(domain=self.getName())
         token = self.getToken()
         if self.isSymbol():
-            value.setContent(token)
+            value.setName(token)
             record = self.getSymbolRecord()
             object = self.getObject(record)
             if isinstance(object, ECCoreWidget) and object.hasRuntimeValue():
@@ -1536,14 +1558,14 @@ class Graphics(Handler):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
                     if self.isObjectType(record, ECListBox) or self.isObjectType(record, ECComboBox): # type: ignore
-                        value.setContent(ECValue(domain=self.getName(), type='object', content=record['name']))
+                        value.setContent(ECValue(domain=self.getName(), type='object', name=record['name']))
                         return value
             elif token == 'count':
                 self.skip('of')
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
                     if self.isObjectType(record, ECListBox) or self.isObjectType(record, ECComboBox): # type: ignore
-                        value.setContent(ECValue(domain=self.getName(), type='object', content=record['name']))
+                        value.setContent(ECValue(domain=self.getName(), type='object', name=record['name']))
                         return value
             elif token == 'text':
                 self.skip('of')
@@ -1552,7 +1574,7 @@ class Graphics(Handler):
                     if (
                         self.isObjectType(record, (ECLabel, ECPushButton, ECMultiline, ECLineInput))
                     ): # type: ignore
-                        value.setContent(ECValue(domain=self.getName(), type='object', content=record['name']))
+                        value.setContent(ECValue(domain=self.getName(), type='object', name=record['name']))
                         return value
             elif token == 'index':
                 self.skip('of')
@@ -1560,7 +1582,14 @@ class Graphics(Handler):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
                     if self.isObjectType(record, (ECListBox, ECComboBox)): # type: ignore
-                        value.setContent(ECValue(domain=self.getName(), type='object', content=record['name']))
+                        value.setContent(ECValue(domain=self.getName(), type='object', name=record['name']))
+                        return value
+            elif token in ['width', 'height']:
+                self.skip('of')
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if self.isObjectType(record, ECWindow): # type: ignore
+                        value.target = record['name']
                         return value
         return None
 
@@ -1598,7 +1627,7 @@ class Graphics(Handler):
             v = ECValue(domain=self.getName(), type=str, content=content)
             return v
         elif self.isObjectType(record, ECCheckBox):
-            checkbox =self.getInnerObject(record)
+            checkbox = self.getInnerObject(record)
             content = checkbox.isChecked()  # type: ignore
             v = ECValue(domain=self.getName(), type=bool, content=content)
             return v
@@ -1611,7 +1640,7 @@ class Graphics(Handler):
     def v_count(self, v):
         content = v.getContent()
         if isinstance(content, ECValue) and content.getType() == 'object':
-            record = self.getVariable(content.getContent())
+            record = self.getVariable(content.getName())
             object = self.getObject(record)
             if isinstance(object, (ECListBox, ECComboBox)):
                 widget = self.getInnerObject(object)
@@ -1622,7 +1651,7 @@ class Graphics(Handler):
     def v_current(self, v):
         content = v.getContent()
         if isinstance(content, ECValue) and content.getType() == 'object':
-            record = self.getVariable(content.getContent())
+            record = self.getVariable(content.getName())
             object = self.getObject(record)
             option = v.option
             if isinstance(object, (ECListBox)):
@@ -1641,28 +1670,52 @@ class Graphics(Handler):
     
     def v_empty(self, v):
         if v.type == 'object':
-            record = self.getVariable(v.getContent())
+            record = self.getVariable(v.getName())
             object = self.getObject(record)
             value = object.isEmpty()
             return ECValue(domain=self.getName(), type=bool, content=value)  # type: ignore
         return None
+    
+    def v_height(self, v):
+        targetName = v.target
+        record = self.getVariable(targetName)
+        object = self.getObject(record)
+        if isinstance(object, ECWindow):
+            widget = self.getInnerObject(object)
+            value = widget.height()  # type: ignore
+            return ECValue(domain=self.getName(), type=int, content=value)  # type: ignore
+        return None
 
     def v_selected(self, v): return self.v_current(v)
 
     def v_text(self, v):
         content = v.getContent()
         if isinstance(content, ECValue) and content.getType() == 'object':
-            record = self.getVariable(content.getContent())
+            record = self.getVariable(content.getName())
             object = self.getObject(record)
             value = object.getText()
             return ECValue(domain=self.getName(), type=int, content=value)  # type: ignore
+    
+    def v_width(self, v):
+        targetName = v.target
+        record = self.getVariable(targetName)
+        object = self.getObject(record)
+        if isinstance(object, ECWindow):
+            widget = self.getInnerObject(object)
+            value = widget.width()  # type: ignore
+            return ECValue(domain=self.getName(), type=int, content=value)  # type: ignore
+        return None
 
     #############################################################################
-	# Get the value of an unknown item (domain-specific)
+	# Get the value of an unknown item
     def getUnknownValue(self, value):
         if self.isObjectType(value, (ECLabelWidget, ECPushButtonWidget, ECLineEditWidget, ECListBoxWidget, ECComboBoxWidget)):
             return value.text()  # type: ignore
-        if self.isObjectType(value, (ECDialogWindow,)): 
+        if self.isObjectType(value, (ECPlainTextEditWidget)):
+            return value.toPlainText()  # type: ignore
+        if self.isObjectType(value, (ECCheckBoxWidget)):
+            return value.isChecked()  # type: ignore
+        if self.isObjectType(value, (ECDialogWindow)): 
             return value.result()  # type: ignore
         return None # Unable to get value