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

easycoder/__init__.py

@@ -12,4 +12,4 @@ from .ec_pyside import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "250826.2"
+__version__ = "251104.1"

easycoder/ec_classes.py

@@ -16,7 +16,6 @@ class AssertionError:
 	def __init__(self, program, msg=None):
 		code = program.code[program.pc]
 		lino = code['lino']
-		script = program.script.lines[lino].strip()
 		message = f'Assertion Error in {program.name} at line {lino + 1}'
 		if msg != None:
 			message += f': {msg}'
@@ -58,8 +57,5 @@ class Token:
 		self.lino = lino
 		self.token = token
 	
-class Condition():
-	negate = False
-
 class Object():
     pass

easycoder/ec_compiler.py

@@ -1,4 +1,4 @@
-from .ec_classes import Token, FatalError
+from .ec_classes import FatalError
 from .ec_value import Value
 from .ec_condition import Condition
 
@@ -18,9 +18,11 @@ class Compiler:
 		self.debugCompile = False
 		self.valueTypes = {}
 
-	def getPC(self):
+	# Get the current code size. Used during compilation
+	def getCodeSize(self):
 		return len(self.program.code)
 
+	# Get the current index (the program counter)
 	def getIndex(self):
 		return self.index
 
@@ -39,6 +41,7 @@ class Compiler:
 		self.index += 1
 		return self.getToken()
 
+	# Peek ahead to see the next token without advancing the index
 	def peek(self):
 		try:
 			return self.tokens[self.index + 1].token
@@ -68,19 +71,23 @@ class Compiler:
 		self.index += 1
 		return self.condition.compileCondition()
 
+	# Test if the current token has a specified value
 	def tokenIs(self, value):
 		return self.getToken() == value
 
+	# Test if the next token has the specified value
 	def nextIs(self, value):
 		return self.nextToken() == value
 
+	# Get the command at a given pc in the code list
 	def getCommandAt(self, pc):
 		return self.program.code[pc]
 
 	# Add a command to the code list
-	def add(self, command):
+	def addCommand(self, command):
 		self.code.append(command)
 
+	# Test if the current token is a symbol
 	def isSymbol(self):
 		token = self.getToken()
 		try:
@@ -89,10 +96,12 @@ class Compiler:
 			return False
 		return True
 
+	# Test if the next token is a symbol
 	def nextIsSymbol(self):
 		self.next()
 		return self.isSymbol()
 	
+	# Skip the next token if it matches the value given
 	def skip(self, token):
 		next = self.peek()
 		if type(token) == list:
@@ -102,21 +111,26 @@ class Compiler:
 					return
 		elif next == token: self.nextToken()
 
+	# Rewind to a given position in the code list
 	def rewindTo(self, index):
 		self.index = index
 
+	# Get source line number containing the current token
 	def getLino(self):
 		if self.index >= len(self.tokens):
 			return 0
 		return self.tokens[self.index].lino
 
+	# Issue a warning
 	def warning(self, message):
 		self.warnings.append(f'Warning at line {self.getLino() + 1} of {self.program.name}: {message}')
 
+	# Print all warnings
 	def showWarnings(self):
 		for warning in self.warnings:
 			print(warning)
 
+	# Get the symbol record for the current token (assumes it is a symbol name)
 	def getSymbolRecord(self):
 		token = self.getToken()
 		if not token in self.symbols:
@@ -128,18 +142,23 @@ class Compiler:
 		symbolRecord['used'] = True
 		return symbolRecord
 
+	# Add a value type
 	def addValueType(self):
 		self.valueTypes[self.getToken()] = True
 
+	# Test if a given value is in the value types list
 	def hasValue(self, type):
 		return type in self.valueTypes
 
+	# Compile a program label (a symbol ending with ':')
 	def compileLabel(self, command):
 		return self.compileSymbol(command, self.getToken())
 
+	# Compile a variable
 	def compileVariable(self, command, extra=None):
 		return self.compileSymbol(command, self.nextToken(), extra)
 
+	# Compile a symbol
 	def compileSymbol(self, command, name, extra=None):
 		try:
 			v = self.symbols[name]
@@ -148,7 +167,7 @@ class Compiler:
 		if v:
 			FatalError(self, f'Duplicate symbol name "{name}"')
 			return False
-		self.symbols[name] = self.getPC()
+		self.symbols[name] = self.getCodeSize()
 		command['program'] = self.program
 		command['type'] = 'symbol'
 		command['name'] = name
@@ -161,7 +180,7 @@ class Compiler:
 		command['locked'] = False
 		command['extra'] = extra
 		if 'keyword' in command: command['hasValue'] = self.hasValue(command['keyword'])
-		self.add(command)
+		self.addCommand(command)
 		return True
 
 	# Compile the current token
@@ -171,6 +190,10 @@ class Compiler:
 #		print(f'Compile {token}')
 		if not token:
 			return False
+		if len(self.code) == 0:
+			if self.program.parent == None and hasattr(self.program, 'usingGraphics'):
+				cmd = {'domain': 'graphics', 'keyword': 'init', 'debug': False}
+				self.code.append(cmd)
 		mark = self.getIndex()
 		for domain in self.program.getDomains():
 			handler = domain.keywordHandler(token)
@@ -195,7 +218,7 @@ class Compiler:
 		keyword = self.getToken()
 		if not keyword:
 			return False
-		# print(f'Compile keyword "{keyword}"')
+#		print(f'Compile keyword "{keyword}"')
 		if keyword.endswith(':'):
 			command = {}
 			command['domain'] = None
@@ -209,9 +232,8 @@ class Compiler:
 		self.index = index
 		while True:
 			token = self.tokens[self.index]
-			keyword = token.token
+#			keyword = token.token
 			if self.debugCompile: print(self.script.lines[token.lino])
-#			print(f'{keyword} - {line}')
 #			if keyword != 'else':
 			if self.compileOne() == True:
 				if self.index == len(self.tokens) - 1:
@@ -222,5 +244,10 @@ class Compiler:
 			else:
 				return False
 
+	# Compile fom the current location, stopping on any of a list of tokens
 	def compileFromHere(self, stopOn):
 		return self.compileFrom(self.getIndex(), stopOn)
+
+	# Compile from the start of the script
+	def compileFromStart(self):
+		return self.compileFrom(0, [])

easycoder/ec_condition.py

@@ -19,7 +19,7 @@ class Condition:
 				condition.domain= domain.getName()
 				return condition
 			self.rewindTo(mark)
-			return None
+		return None
 
 	def testCondition(self, condition):
 		handler = self.program.domainIndex[condition.domain]

easycoder/ec_core.py

@@ -1,8 +1,9 @@
 import json, math, hashlib, threading, os, subprocess, time
 import numbers, base64, binascii, random, requests, paramiko
+from copy import deepcopy
 from psutil import Process
 from datetime import datetime
-from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, NoValueError, NoValueRuntimeError, Condition, Object
+from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, NoValueError, NoValueRuntimeError, Object
 from .ec_handler import Handler
 from .ec_timestamp import getTimestamp
 
@@ -30,13 +31,13 @@ class Core(Handler):
             cmd['keyword'] = 'gotoPC'
             cmd['goto'] = 0
             cmd['debug'] = False
-            skip = self.getPC()
+            skip = self.getCodeSize()
             self.add(cmd)
             # Process the 'or'
-            self.getCommandAt(orHere)['or'] = self.getPC()
+            self.getCommandAt(orHere)['or'] = self.getCodeSize()
             self.compileOne()
             # Fixup the skip
-            self.getCommandAt(skip)['goto'] = self.getPC()
+            self.getCommandAt(skip)['goto'] = self.getCodeSize()
 
     #############################################################################
     # Keyword handlers
@@ -159,23 +160,25 @@ class Core(Handler):
         else:
             return self.compileFromHere(['end'])
 
-    # Clear (set false)
     # clear {variable}
     def k_clear(self, command):
         if self.nextIsSymbol():
             target = self.getSymbolRecord()
-            if target['hasValue']:
-                command['target'] = target['name']
+            command['target'] = target['name']
+            if target['hasValue'] or target['keyword'] == 'ssh':
                 self.add(command)
                 return True
         return False
 
     def r_clear(self, command):
         target = self.getVariable(command['target'])
-        val = {}
-        val['type'] = 'boolean'
-        val['content'] = False
-        self.putSymbolValue(target, val)
+        if target['keyword'] == 'ssh':
+            target['ssh'] = None
+        else:
+            val = {}
+            val['type'] = 'boolean'
+            val['content'] = False
+            self.putSymbolValue(target, val)
         return self.nextPC()
 
     # Close a file
@@ -276,7 +279,7 @@ class Core(Handler):
         return self.incdec(command, '-')
 
     # Delete a file or a property
-    # delete {filename}
+    # delete file {filename}
     # delete property {value} of {variable}
     # delete element {name} of {variable}
     def k_delete(self, command):
@@ -305,8 +308,8 @@ class Core(Handler):
         type = command['type']
         if type == 'file':
             filename = self.getRuntimeValue(command['filename'])
-            if os.path.isfile(filename):
-                os.remove(filename)
+            if filename != None:
+                if os.path.isfile(filename): os.remove(filename)
         elif type == 'property':
             key = self.getRuntimeValue(command['key'])
             symbolRecord = self.getVariable(command['var'])
@@ -320,7 +323,8 @@ class Core(Handler):
             symbolRecord = self.getVariable(command['var'])
             value = self.getSymbolValue(symbolRecord)
             content = value['content']
-            content.remove(key)
+            if key >= 0 and key < len(content): del(content[key])
+            else: RuntimeError(self.program, f'Index {key} out of range')
             value['content'] = content
             self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
@@ -464,7 +468,7 @@ class Core(Handler):
                 if url != None:
                     command['url'] = url
                     command['or'] = None
-                    get = self.getPC()
+                    get = self.getCodeSize()
                     if self.peek() == 'timeout':
                         self.nextToken()
                         command['timeout'] = self.nextValue()
@@ -552,7 +556,7 @@ class Core(Handler):
         command['condition'] = self.nextCondition()
         self.add(command)
         self.nextToken()
-        pcElse = self.getPC()
+        pcElse = self.getCodeSize()
         cmd = {}
         cmd['lino'] = command['lino']
         cmd['domain'] = 'core'
@@ -565,7 +569,7 @@ class Core(Handler):
         if self.peek() == 'else':
             self.nextToken()
             # Add a 'goto' to skip the 'else'
-            pcNext = self.getPC()
+            pcNext = self.getCodeSize()
             cmd = {}
             cmd['lino'] = command['lino']
             cmd['domain'] = 'core'
@@ -574,15 +578,15 @@ class Core(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the link to the 'else' branch
-            self.getCommandAt(pcElse)['goto'] = self.getPC()
+            self.getCommandAt(pcElse)['goto'] = self.getCodeSize()
             # Process the 'else' branch
             self.nextToken()
             self.compileOne()
             # Fixup the pcNext 'goto'
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            self.getCommandAt(pcNext)['goto'] = self.getCodeSize()
         else:
             # We're already at the next command
-            self.getCommandAt(pcElse)['goto'] = self.getPC()
+            self.getCommandAt(pcElse)['goto'] = self.getCodeSize()
         return True
 
     def r_if(self, command):
@@ -601,7 +605,7 @@ class Core(Handler):
             name = self.nextToken()
             item = [keyword, name]
             imports.append(item)
-            self.symbols[name] = self.getPC()
+            self.symbols[name] = self.getCodeSize()
             variable = {}
             variable['domain'] = None
             variable['name'] = name
@@ -743,7 +747,7 @@ class Core(Handler):
                     else:
                         command['file'] = self.getValue()
                     command['or'] = None
-                    load = self.getPC()
+                    load = self.getCodeSize()
                     self.processOr(command, load)
                     return True
         else:
@@ -912,7 +916,7 @@ class Core(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the link
-            command['goto'] = self.getPC()
+            command['goto'] = self.getCodeSize()
             return True
         return False
 
@@ -1003,7 +1007,7 @@ class Core(Handler):
         else:
             command['result'] = None
         command['or'] = None
-        post = self.getPC()
+        post = self.getCodeSize()
         self.processOr(command, post)
         return True
 
@@ -1076,7 +1080,7 @@ class Core(Handler):
         return False
 
     def r_push(self, command):
-        value = self.getRuntimeValue(command['value'])
+        value = deepcopy(self.getRuntimeValue(command['value']))
         stackRecord = self.getVariable(command['to'])
         if stackRecord['keyword'] != 'stack':
             RuntimeError(self.program, f'{stackRecord["name"]} is not a stack')
@@ -1102,7 +1106,7 @@ class Core(Handler):
                         FatalError(self.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
                     else:
                         command['or'] = None
-                        self.processOr(command, self.getPC())
+                        self.processOr(command, self.getCodeSize())
                         return True
                 else:
                     FatalError(self.compiler, f'Symbol {self.getToken()} is not a variable')
@@ -1270,7 +1274,7 @@ class Core(Handler):
         else:
             command['file'] = self.getValue()
         command['or'] = None
-        save = self.getPC()
+        save = self.getCodeSize()
         self.processOr(command, save)
         return True
 
@@ -1503,8 +1507,11 @@ class Core(Handler):
             ssh = paramiko.SSHClient()
             target['ssh'] = ssh
             ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-            ssh.connect(host, username=user, password=password)
-            target['sftp'] = ssh.open_sftp()
+            try:
+                ssh.connect(host, username=user, password=password, timeout=10)
+                target['sftp'] = ssh.open_sftp()
+            except:
+                target['error'] = f'Unable to connect to {host} (timeout)'
             return self.nextPC()
 
     # Shuffle a list
@@ -1762,12 +1769,17 @@ class Core(Handler):
                 self.program.importPlugin(f'{source}:{clazz}')
                 return True
             return False
-        elif self.nextIs('graphics'):
-            print('Loading graphics module')
-            from .ec_pyside import Graphics
-            self.program.graphics = Graphics
-            self.program.useClass(Graphics)
-            return True
+        else:
+            token = self.nextToken()
+            if token in ['graphics', 'debugger']:
+                if not hasattr(self.program, 'usingGraphics'):
+                    print('Loading graphics module')
+                    from .ec_pyside import Graphics
+                    self.program.graphics = Graphics
+                    self.program.useClass(Graphics)
+                    self.program.usingGraphics = True
+                if token == 'debugger': self.program.debugging = True
+                return True
         return False
 
     # Declare a general-purpose variable
@@ -1811,10 +1823,10 @@ class Core(Handler):
             return None
         # token = self.getToken()
         command['condition'] = code
-        test = self.getPC()
+        test = self.getCodeSize()
         self.add(command)
         # Set up a goto for when the test fails
-        fail = self.getPC()
+        fail = self.getCodeSize()
         cmd = {}
         cmd['lino'] = command['lino']
         cmd['domain'] = 'core'
@@ -1835,7 +1847,7 @@ class Core(Handler):
         cmd['debug'] = False
         self.add(cmd)
         # Fixup the 'goto' on completion
-        self.getCommandAt(fail)['goto'] = self.getPC()
+        self.getCommandAt(fail)['goto'] = self.getCodeSize()
         return True
 
     def r_while(self, command):
@@ -2108,14 +2120,24 @@ class Core(Handler):
             return value
 
         if token == 'error':
-            if self.peek() == 'code':
+            token = self.peek()
+            if token == 'code':
                 self.nextToken()
                 value['item'] = 'errorCode'
                 return value
-            if self.peek() == 'reason':
+            elif token == 'reason':
                 self.nextToken()
                 value['item'] = 'errorReason'
                 return value
+            elif token in ['in', 'of']:
+                self.nextToken()
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if record['keyword'] == 'ssh':
+                        value['item'] = 'sshError'
+                        value['name'] = record['name']
+                        return value
+            return None
 
         if token == 'type':
             if self.nextIs('of'):
@@ -2279,6 +2301,10 @@ class Core(Handler):
         elif v['item'] == 'errorReason':
             value['type'] = 'text'
             value['content'] = errorReason
+        elif v['item'] == 'sshError':
+            record = self.getVariable(v['name'])
+            value['type'] = 'text'
+            value['content'] = record['error'] if 'error' in record else ''
         return value
 
     def v_files(self, v):
@@ -2430,7 +2456,7 @@ class Core(Handler):
     def v_now(self, v):
         value = {}
         value['type'] = 'int'
-        value['content'] = getTimestamp(time.time())
+        value['content'] = int(time.time())
         return value
 
     def v_position(self, v):
@@ -2510,7 +2536,7 @@ class Core(Handler):
         elif keyword == 'ssh':
             v = {}
             v['type'] = 'boolean'
-            v['content']  = True if 'ssh' in symbolRecord else False
+            v['content']  = True if 'ssh' in symbolRecord and symbolRecord['ssh'] != None else False
             return v
         else:
             return None
@@ -2611,18 +2637,39 @@ class Core(Handler):
     #############################################################################
     # Compile a condition
     def compileCondition(self):
-        condition = Condition()
+        condition = Object()
+        condition.negate = False
+
+        token = self.getToken()
 
-        if self.getToken() == 'not':
+        if token == 'not':
             condition.type = 'not'
             condition.value = self.nextValue()
             return condition
 
-        if self.getToken() == 'file':
+        elif token == 'error':
+            self.nextToken()
+            self.skip('in')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'ssh':
+                    condition.type = 'sshError'
+                    condition.target = record['name']
+                    return condition
+            return None
+
+        elif token == 'file':
             path = self.nextValue()
             condition.path = path
             condition.type = 'exists'
-            token = self.nextToken()
+            self.skip('on')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'ssh':
+                    condition.type = 'sshExists'
+                    condition.target = record['name']
+                    token = self.nextToken()
+            else: token = self.getToken()
             if token == 'exists':
                 return condition
             elif token == 'does':
@@ -2798,6 +2845,24 @@ class Core(Handler):
 
     def c_odd(self, condition):
         return self.getRuntimeValue(condition.value1) % 2 == 1
+    
+    def c_sshError(self, condition):
+        target = self.getVariable(condition.target)
+        errormsg = target['error'] if 'error' in target else None
+        condition.errormsg = errormsg
+        test = errormsg != None
+        return not test if condition.negate else test
+
+    def c_sshExists(self, condition):
+        path = self.getRuntimeValue(condition.path)
+        ssh = self.getVariable(condition.target)
+        sftp = ssh['sftp']
+        try:
+            with sftp.open(path, 'r') as remote_file: remote_file.read().decode()
+            comparison = True
+        except:
+            comparison = False
+        return not comparison if condition.negate else comparison
 
     def c_starts(self, condition):
         value1 = self.getRuntimeValue(condition.value1)

easycoder/ec_handler.py

@@ -22,8 +22,8 @@ class Handler:
 		self.compileVariable = compiler.compileVariable
 		self.rewindTo = compiler.rewindTo
 		self.warning = compiler.warning
-		self.getPC = compiler.getPC
-		self.add = compiler.add
+		self.getCodeSize = compiler.getCodeSize
+		self.add = compiler.addCommand
 		self.getCommandAt = compiler.getCommandAt
 		self.compileOne = compiler.compileOne
 		self.compileFromHere = compiler.compileFromHere

easycoder/ec_keyboard.py

@@ -158,6 +158,8 @@ class KeyboardView(QVBoxLayout):
         for row in rows:
             self.addLayout(row)
 
+###############################################################################
+# VirtualKeyboard Class
 class VirtualKeyboard(QStackedWidget):
     def __init__(self, keyboardType, buttonHeight, receiver, onFinished):
         super().__init__()
@@ -173,6 +175,8 @@ class VirtualKeyboard(QStackedWidget):
         self.addKeyboardLayout2()
         self.addKeyboardLayout3()
 
+    ###########################################################################
+    # Add the first keyboard layout (lowercase letters)
     def addKeyboardLayout0(self):
         rowList = []
 
@@ -214,7 +218,7 @@ class VirtualKeyboard(QStackedWidget):
             KeyboardButton(self.buttonHeight * 1.5, self.buttonHeight, self.onClickNumbers, None, 'img/numbers.png'),
             QSpacerItem(self.buttonHeight * 0.05, 0, QSizePolicy.Fixed, QSizePolicy.Minimum),
             KeyboardButton(self.buttonHeight, self.buttonHeight, self.onClickChar, ","),
-            KeyboardButton(self.buttonHeight * 5, self.buttonHeight, self.onClickSpace, None, 'skeyboard/pace.png'),
+            KeyboardButton(self.buttonHeight * 5, self.buttonHeight, self.onClickSpace, None, 'keyboard/space.png'),
             KeyboardButton(self.buttonHeight, self.buttonHeight, self.onClickChar, "."),
             QSpacerItem(self.buttonHeight * 0.05, 0, QSizePolicy.Fixed, QSizePolicy.Minimum),
             KeyboardButton(self.buttonHeight * 1.5, self.buttonHeight, self.onClickEnter, None, 'img/enter.png'),
@@ -228,6 +232,8 @@ class VirtualKeyboard(QStackedWidget):
         container.setLayout(keyboardView)
         self.addWidget(container)
 
+    ###########################################################################
+    # Add the second keyboard layout (uppercase letters)
     def addKeyboardLayout1(self):
         rowList = []
 
@@ -283,6 +289,8 @@ class VirtualKeyboard(QStackedWidget):
         container.setLayout(keyboardView)
         self.addWidget(container)
 
+    ###########################################################################
+    # Add the third keyboard layout (numbers and symbols)
     def addKeyboardLayout2(self):
         rowList = []
 
@@ -320,11 +328,11 @@ class VirtualKeyboard(QStackedWidget):
             KeyboardButton(self.buttonHeight * 1.5, self.buttonHeight, self.onClickLetters, None, 'img/letters.png'),
             QSpacerItem(self.buttonHeight * 0.05, 0, QSizePolicy.Fixed, QSizePolicy.Minimum),
             KeyboardButton(self.buttonHeight, self.buttonHeight, self.onClickChar, ","),
-            KeyboardButton(self.buttonHeight * 6, self.buttonHeight, self.onClickSpace, None, 'img/space.png'),
+            KeyboardButton(self.buttonHeight * 5.2, self.buttonHeight, self.onClickSpace, None, 'keyboard/space.png'),
             KeyboardButton(self.buttonHeight, self.buttonHeight, self.onClickChar, "."),
             QSpacerItem(self.buttonHeight * 0.05, 0, QSizePolicy.Fixed, QSizePolicy.Minimum),
             KeyboardButton(self.buttonHeight * 1.5, self.buttonHeight, self.onClickEnter, None, 'img/enter.png'),
-            QSpacerItem(20, 40, QSizePolicy.Expanding, QSizePolicy.Minimum)
+            QSpacerItem(10, 40, QSizePolicy.Expanding, QSizePolicy.Minimum)
         ])
         rowList.append(row4)
 
@@ -334,6 +342,8 @@ class VirtualKeyboard(QStackedWidget):
         container.setLayout(keyboardView)
         self.addWidget(container)
 
+    ###########################################################################
+    # Add the fourth keyboard layout (additional symbols)
     def addKeyboardLayout3(self):
         rowList = []