easycoder 260104.1__tar.gz → 260119.1__tar.gz

{easycoder-260104.1 → easycoder-260119.1}/.vscode/easycoder/syntaxes/easycoder.tmLanguage.json

@@ -35,7 +35,7 @@
       "patterns": [
         {
           "name": "keyword.control.easycoder",
-          "match": "\\b(add|append|assert|begin|center|checkbox|clear|close|combobox|create|createCheckBox|createDialog|createGroupBox|createLabel|createLayout|createLineEdit|createMessageBox|createMultiLineEdit|createPushbutton|createWidget|createWindow|debug|decrement|delete|dialog|disable|divide|download|dummy|enable|end|exit|file|fork|get|go|gosub|goto|group|hide|if|import|increment|index|init|input|label|layout|lineinput|listbox|load|lock|log|messagebox|module|multiline|multiply|negate|object|on|open|pop|post|print|push|pushbutton|put|read|release|remove|replace|return|run|save|script|select|send|set|show|shuffle|split|ssh|stack|start|stop|system|take|toggle|trim|truncate|unlock|use|variable|wait|while|widget|window|write)\\b"
+          "match": "\\b(add|append|assert|begin|clear|close|copy|create|debug|decrement|delete|dictionary|divide|download|end|exit|file|fork|get|go|gosub|goto|if|import|increment|index|input|list|load|lock|log|module|multiply|negate|on|open|pass|pop|post|print|push|put|read|release|replace|reset|return|run|save|script|send|set|shuffle|split|ssh|stack|stop|system|take|toggle|trim|truncate|unlock|use|variable|wait|while|write)\\b"
         },
         {
           "name": "keyword.operator.easycoder",

{easycoder-260104.1 → easycoder-260119.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easycoder
-Version: 260104.1
+Version: 260119.1
 Summary: Rapid scripting in English
 Keywords: compiler,scripting,prototyping,programming,coding,python,low code,hypertalk,computer language,learn to code
 Author-email: Graham Trott <gtanyware@gmail.com>
@@ -12,6 +12,7 @@ Requires-Dist: requests
 Requires-Dist: psutil
 Requires-Dist: paramiko
 Requires-Dist: pyside6
+Requires-Dist: paho-mqtt
 Project-URL: Home, https://github.com/easycoder/easycoder-py
 
 # Introduction

{easycoder-260104.1 → easycoder-260119.1}/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__ = "260104.1"
+__version__ = "260119.1"

{easycoder-260104.1 → easycoder-260119.1}/easycoder/ec_classes.py

@@ -312,6 +312,16 @@ 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 ""
+        elif isinstance(v, str):
+            return json.dumps(v)
+        elif isinstance(v, ECValue):
+            return v.getContent()
+        return v
 
 ###############################################################################
 # A string or int variable
@@ -351,7 +361,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 +397,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):
@@ -421,19 +434,13 @@ class ECList(ECValueHolder):
 
     # Set the value to an ECValue
     def setValue(self, value):
-        varType = value.getType()
-        if type_in(varType, (str, 'list')):
-            content = value.getContent()
-            if types_equal(varType, str):
-                try:
-                    if content in ('', [], None): content = []
-                    else: content = json.loads(content)
-                except:
-                    raise RuntimeError(None, 'ECList string value is not valid JSON') # type: ignore
-        elif varType == None:
-             content = []
+        content = value.getContent()
+        if content in ('', None): content = []
         else:
-            raise RuntimeError(None, 'ECList can only hold list values or None') # type: ignore
+            try:
+                content = json.loads(content) # type: ignore
+            except:
+                pass
         super().setValue(content)
     
     def getValue(self):
@@ -498,6 +505,12 @@ class ECFile(ECObject):
     def __init__(self):
         super().__init__()
 
+###############################################################################
+# A module variable
+class ECModule(ECObject):
+    def __init__(self):
+        super().__init__()
+
 ###############################################################################
 # An SSH variable
 class ECSSH(ECObject):

{easycoder-260104.1/easycoder/pre → easycoder-260119.1/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-260104.1 → easycoder-260119.1}/easycoder/ec_core.py

@@ -1,7 +1,8 @@
 import json, math, hashlib, threading, os, subprocess, time
-import base64, binascii, random, requests, paramiko
+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,
@@ -16,7 +17,8 @@ from .ec_classes import (
     ECFile,
     ECStack,
     ECSSH,
-    ECValue
+    ECValue,
+    ECModule
 )
 
 from .ec_handler import Handler
@@ -69,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
@@ -164,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']
@@ -185,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':
@@ -198,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):
@@ -514,7 +544,7 @@ class Core(Handler):
         self.run(label)
         return next
 
-    # get {variable) from {url} [or {command}]
+    # get {variable) from url {url} [or {command}]
     def k_get(self, command):
         if self.nextIsSymbol():
             record = self.getSymbolRecord()
@@ -793,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:
@@ -805,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}'
 
@@ -847,7 +878,7 @@ class Core(Handler):
     # Declare a module variable
     def k_module(self, command):
         self.compiler.addValueType()
-        return self.compileVariable(command, 'ECObject')
+        return self.compileVariable(command, 'ECModule')
 
     def r_module(self, command):
         return self.nextPC()
@@ -929,7 +960,8 @@ class Core(Handler):
 
     # on message {action}
     def k_on(self, command):
-        if self.nextIs('message'):
+        token = self.peek()
+        if token == 'message':
             self.nextToken()
             command['goto'] = 0
             self.add(command)
@@ -1186,7 +1218,8 @@ class Core(Handler):
     def k_release(self, command):
         if self.nextIs('parent'):
             self.add(command)
-        return True
+            return True
+        return False
 
     def r_release(self, command):
         self.program.releaseParent()
@@ -1332,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)}'
 
@@ -1355,7 +1388,7 @@ class Core(Handler):
         if self.nextIs('to'):
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
-                if record['keyword'] == 'module':
+                if self.isObjectType(record, ECModule):
                     command['module'] = record['name']
                     self.add(command)
                     return True
@@ -1368,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}
@@ -1400,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
@@ -1444,12 +1477,23 @@ class Core(Handler):
                     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
 
@@ -1496,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'])
@@ -1514,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'])
@@ -1683,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
@@ -1796,7 +1842,8 @@ class Core(Handler):
 
     # use plugin {class} from {source}
     # use graphics
-    # use psutil.
+    # use mqtt
+    # use psutil
     def k_use(self, command):
         if self.peek() == 'plugin':
             # Import a plugin
@@ -1811,9 +1858,15 @@ class Core(Handler):
             token = self.nextToken()
             if token == 'graphics':
                 return self.program.useGraphics()
+            if token == 'mqtt':
+                return self.program.useMQTT()
             elif token == 'psutil':
                 return self.program.usePSUtil()
         return False
+    
+    # Unused
+    def r_use(self, command):
+        return self.nextPC()
 
     # Declare a general-purpose variable
     def k_variable(self, command):
@@ -1940,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)
 
@@ -1980,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
 
@@ -2016,8 +2073,8 @@ class Core(Handler):
         token = self.getToken()
         value.setType(token)
 
-        if token == 'args':
-           return value
+        if token in ['args', 'message', 'uuid', 'weekday']:
+            return value
 
         if token in ('items', 'elements'):
             if self.nextToken() in ('in', 'of'):
@@ -2039,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
 
@@ -2114,9 +2171,6 @@ class Core(Handler):
             value.haystack = self.nextValue() # type: ignore
             return value
 
-        if token == 'message':
-            return value
-
         if token == 'timestamp':
             value.format = None # type: ignore
             if self.peek() == 'of':
@@ -2134,10 +2188,6 @@ class Core(Handler):
                 return value
             return None
 
-        if token == 'weekday':
-            value.setType('weekday')
-            return value
-
         if token == 'error':
             token = self.peek()
             if token == 'code':
@@ -2191,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
 
@@ -2207,7 +2264,7 @@ class Core(Handler):
         value = ECValue(type=bool, content=v.getContent())
     
     def v_boolean(self, v):
-        return self.v.bool(v)
+        return self.v_bool(v)
 
     def v_cos(self, v):
         angle = self.textify(v['angle'])
@@ -2215,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):
@@ -2349,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():
@@ -2458,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
@@ -2527,6 +2580,9 @@ class Core(Handler):
     def v_uppercase(self, v):
         content = self.textify(v.getContent())
         return ECValue(type=str, content=content.upper())
+    
+    def v_uuid(self, v):
+        return ECValue(type=str, content=str(uuid.uuid4()))
 
     def v_valueOf(self, v):
         v = self.textify(v.getContent())
@@ -2706,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()
@@ -2733,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-260104.1 → easycoder-260119.1}/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
@@ -117,22 +124,46 @@ class ECLineInput(ECTextWidget):
         v = self.getValue()
         if v is None: return
         v.getContent().setText(str(text)) # type: ignore
-    
-    # Get the text of the widget
-    def getText(self):
-        return self.getValue().getContent().text() # type: ignore
 
     # Get the content of the value at the current index
     def getContent(self):
-        v = self.getValue()
-        if v is None: return None
-        return v.getContent().text()
-
+        value = self.getValue()
+        if value is None: return None
+        return value.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()
+        if v is None: return
+        v.getContent().setText(str(text)) # type: ignore
+    
+    # Get the text of the widget
+    def getText(self):
+        return self.getValue().getContent().toPlainText() # type: ignore
+
+    # Get the content of the value at the current index
+    def getContent(self):
+        value = self.getValue()
+        if value is None: return None
+        return value.toPlainText()
+    
+    # Get the text of the widget
+    def textify(self):
+        return self.getContent()
 
 ###############################################################################
 # A listbox variable