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

easycoder/ec_program.py

@@ -1,7 +1,16 @@
-import time, json, sys
+import time, sys, json
 from copy import deepcopy
 from collections import deque
-from .ec_classes import Script, Token, FatalError, RuntimeError, Object
+from .ec_classes import (
+	Script,
+	Token,
+	FatalError,
+	RuntimeError, 
+	NoValueRuntimeError, 
+	ECObject,
+	ECValue,
+	normalize_type
+)
 from .ec_compiler import Compiler
 from .ec_core import Core
 import importlib
@@ -16,20 +25,25 @@ def flush():
 
 class Program:
 
-	def __init__(self, argv):
+	def __init__(self, arg):
 		global queue
 		print(f'EasyCoder version {version("easycoder")}')
-		if len(argv) == 0:
+		if len(arg) == 0:
 			print('No script supplied')
 			exit()
-		if argv in ['-v', '--version']: return
-		scriptName = argv
+		if arg in ['-v', '--version']: return
+		if arg[0:6] == 'debug ':
+			print('Debug mode requested')
+			self.scriptName = arg[6:]
+			self.debugging = True
+		else:
+			self.scriptName = arg
+			self.debugging = False
 
-		f = open(scriptName, 'r')
+		f = open(self.scriptName, 'r')
 		source = f.read()
 		f.close()
 		queue = deque()
-		self.argv = argv
 		self.domains = []
 		self.domainIndex = {}
 		self.name = '<anon>'
@@ -38,28 +52,35 @@ class Program:
 		self.symbols = {}
 		self.onError = 0
 		self.debugStep = False
+		self.debugSkip = False
 		self.stack = []
 		self.script = Script(source)
 		self.compiler = Compiler(self)
+		self.object = ECObject()
 		self.value = self.compiler.value
 		self.condition = self.compiler.condition
 		self.graphics = None
+		self.psutil = None
 		self.useClass(Core)
-		self.externalControl = False
 		self.ticker = 0
-		self.usingGraphics = False
-		self.debugging = False
+		self.graphicsRunning = False
 		self.debugger = None
-		self.running = True
+		self.running = False
+		self.parent = None
+		self.message = None
+		self.onMessagePC = 0
+		self.breakpoint = False
 
 	# This is called at 10msec intervals by the GUI code
 	def flushCB(self):
 		self.ticker += 1
+		# if self.ticker % 1000 == 0: print(f'GUI Tick {self.ticker}')
 		flush()
 
 	def start(self, parent=None, module = None, exports=[]):
 		self.parent = parent
 		self.exports = exports
+		if self.debugging: self.useGraphics()
 		if module != None:
 			module['child'] = self
 		startCompile = time.time()
@@ -72,7 +93,7 @@ class Program:
 				f'{round((finishCompile - startCompile) * 1000)} ms')
 			for name in self.symbols.keys():
 				record = self.code[self.symbols[name]]
-				if name[-1] != ':' and not record['used']:
+				if name[-1] != ':' and not 'used' in record:
 					print(f'Variable "{name}" not used')
 			else:
 				print(f'Run {self.name}')
@@ -81,13 +102,44 @@ class Program:
 			self.compiler.showWarnings()
 
 		# If this is the main script and there's no graphics, run a main loop
-		if parent == None and self.externalControl == False:
-			while True:
+		if parent == None:
+			while not self.graphicsRunning:
 				if self.running == True:
 					flush()
 					time.sleep(0.01)
 				else:
 					break
+	
+	# Use the graphics module
+	def useGraphics(self):
+		if self.graphics == None:
+			print('Loading graphics module')
+			from .ec_graphics import Graphics
+			self.graphics = Graphics
+			self.useClass(Graphics)
+		return True
+	
+	# Use the mqtt module
+	def useMQTT(self):
+		if self.psutil == None:
+			print('Loading mqtt module')
+			from .ec_mqtt import MQTT
+			self.psutil = MQTT
+			self.useClass(MQTT)
+		return True
+	
+	# Use the psutil module
+	def usePSUtil(self):
+		if self.psutil == None:
+			print('Loading psutil module')
+			from .ec_psutil import PSUtil
+			self.psutil = PSUtil
+			self.useClass(PSUtil)
+		return True
+
+	# Indicate that graphics are running
+	def startGraphics(self):
+		self.graphicsRunning = True
 
 	# Import a plugin
 	def importPlugin(self, source):
@@ -112,122 +164,225 @@ class Program:
 		self.domains.append(handler)
 		self.domainIndex[handler.getName()] = handler
 
+	# This is the runtime callback for event handlers
+	def callback(self, item, record, goto):
+		object = self.getObject(record)
+		values = object.getValues() # type: ignore
+		for i, v in enumerate(values):
+			if isinstance(v, ECValue): v = v.getContent()
+			if v == item:
+				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):
 		return self.domains
-
-	def getSymbolRecord(self, name):
+	
+	def isSymbol(self, name):
+		return name in self.symbols
+
+	# 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]]
-			if target['import'] != None:
+			if 'import' in target:
 				target = target['import']
 			return target
 		except:
 			RuntimeError(self, f'Unknown symbol \'{name}\'')
+	
+	# Get the object represented by a symbol record
+	def getObject(self, record):
+		if isinstance(record, dict) and 'object' in record:
+			return record['object']
+		return record
+
+	# Check if an object is an instance of a given class
+	# This can either be  variable record (a dict) or an instance of ECObject
+	def isObjectType(self, object, classes):
+		if isinstance(object, dict) and 'object' in object and isinstance(object['object'], ECObject):
+			object = object['object']
+		return isinstance(object, classes)
+
+    # Check if the object is an instance of one of a set of classes. Compile and runtime
+	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, message)
+			else:
+				raise FatalError(self.compiler, message)
+
+	# Get the inner (non-EC) object from a name, record or object
+	def getInnerObject(self, object):
+		if isinstance(object, dict): object = object['object']
+		elif isinstance(object, str):
+			record = self.getVariable(object) # type: ignore
+			object = self.getObject(record) # type: ignore
+		value = object.getValue() # type: ignore
+		if isinstance(value, ECValue) and value.getType() == 'object':
+			return value.getContent()
+		else: return value
 
-	def doValue(self, value):
-		if value == None:
-			RuntimeError(self, f'Undefined value (variable not initialized?)')
-
+	def constant(self, content, numeric):
 		result = {}
-		valType = value['type']
-		if valType in ['boolean', 'int', 'text', 'object']:
-			result = value
+		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
+	
+	# Get the value of an item that may be an ECValue or a raw value. Return as an ECValue
+	def getValueOf(self, item):
+		value = ECValue()
+		if isinstance(item, ECValue):
+			if item.getType() == 'object':
+				return item.getContent()
+			else: value = item
+		else:
+			varType = type(item).__name__
+			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 = 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', 'bool', 'list', 'dict', None):
+			# Simple value - just return the content
+			result.setContent(value.getContent()) # type: ignore
+		
+		elif valType == 'object':
+			# Object other than ECVariable
+			record = self.getVariable(value.getName())
+			object = self.getObject(record) # type: ignore
+			result = object.getContent() # type: ignore
+
+		elif valType == 'symbol': # type: ignore
+			# If it's a symbol, get its value
+			record = self.getVariable(value.getContent()) # type: ignore
+			if not 'object' in record: return None # type: ignore
+			variable = self.getObject(record) # type: ignore
+			result = variable.getValue() # type: ignore
+			if isinstance(result, ECValue): return self.evaluate(result)
+			if isinstance(result, ECObject): return result.getValue()
+			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
 			content = ''
-			for part in value['value']:
-				val = self.doValue(part)
-				if val == None:
-					val = ''
-				if val != '':
-					val = str(val['content'])
-					if val == None:
-						val = ''
-					content += val
-			result['type'] = 'text'
-			result['content'] = content
-		elif valType == 'symbol':
-			name = value['name']
-			symbolRecord = self.getSymbolRecord(name)
-			# if symbolRecord['hasValue']:
-			if symbolRecord:
-				handler = self.domainIndex[symbolRecord['domain']].valueHandler('symbol')
-				result = handler(symbolRecord)
-		# 	else:
-		# 		# Call the given domain to handle a value
-		# 		# domain = self.domainIndex[value['domain']]
-		# 		handler = domain.valueHandler(value['type'])
-		# 		if handler: result = handler(value)
+			for part in value.getContent():  # pyright: ignore[reportOptionalMemberAccess]
+				val = self.evaluate(part) # pyright: ignore[reportAttributeAccessIssue]
+				if val != None:
+					if isinstance(val, ECValue): val = str(val.getContent())
+					if val == None: val = ''
+					else: content += str(val)
+			result.setValue(type=str, content=content)
+	
 		else:
 			# Call the given domain to handle a value
-			domain = self.domainIndex[value['domain']]
-			handler = domain.valueHandler(value['type'])
+			domainName = value.getDomain()  # type: ignore
+			if domainName == None: domainName = 'core'
+			domain = self.domainIndex[domainName]
+			handler = domain.valueHandler(value.getType()) # type: ignore
 			if handler: result = handler(value)
 
 		return result
 
-	def constant(self, content, numeric):
-		result = {}
-		result['type'] = 'int' if numeric else 'text'
-		result['content'] = content
-		return result
-
-	def evaluate(self, value):
-		if value == None:
-			result = {}
-			result['type'] = 'text'
-			result['content'] = ''
-			return result
-
-		result = self.doValue(value)
-		if result:
-			return result
-		return None
-
-	def getValue(self, value):
-		result = self.evaluate(value)
-		if result:
-			return result.get('content')  # type: ignore[union-attr]
-		return None
-
-	def getRuntimeValue(self, value):
+	# 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
-		v = self.evaluate(value)
-		if v != None:
-			content = v['content']
-			if v['type'] == 'boolean':
-				return True if content else False
-			if v['type'] in ['int', 'float', 'text', 'object']:
-				return content
-			return ''
-		return None
-
-	def getSymbolContent(self, symbolRecord):
-		if len(symbolRecord['value']) == 0:
-			return None
-		try: return symbolRecord['value'][symbolRecord['index']]
-		except:  RuntimeError(self, f'Cannot get content of symbol "{symbolRecord["name"]}"')
-
-	def getSymbolValue(self, symbolRecord):
-		if len(symbolRecord['value']) == 0:
+		
+		if isinstance(value, dict):
+			value = value['object']
+		if isinstance(value, ECObject):
+			value = value.getValue()
+		if isinstance(value, ECValue): # type: ignore
+			v = self.evaluate(value) # type: ignore
+		else:
+			v = value
+		if v is None: return None
+		if isinstance(v, ECValue):
+			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
+	def getSymbolContent(self, record):
+		if len(record['value']) == 0:
 			return None
-		try: value = symbolRecord['value'][symbolRecord['index']]
-		except:  RuntimeError(self, f'Cannot get value of symbol "{symbolRecord["name"]}"')
-		copy = deepcopy(value)
+		try: return record['value'][record['index']]
+		except: raise RuntimeError(self, f'Cannot get content of symbol "{record["name"]}"')
+
+	# 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
+		if value is None:
+			raise NoValueRuntimeError(self, f'Symbol "{record["name"]}" has no value')
+		# copy = deepcopy(value)
+		copy = ECValue(domain=value.getDomain(),type=value.getType(),content=deepcopy(value.getContent()))
 		return copy
 
-	def putSymbolValue(self, symbolRecord, value):
-		if symbolRecord['locked']:
-			name = symbolRecord['name']
-			RuntimeError(self, f'Symbol "{name}" is locked')
-		if symbolRecord['value'] == None or symbolRecord['value'] == []:
-			symbolRecord['value'] = [value]
-		else:
-			index = symbolRecord['index']
-			if index == None:
-				index = 0
-			symbolRecord['value'][index] = value
+	# Set the value of a symbol to either an ECValue or a raw value
+	def putSymbolValue(self, record, value):
+		variable = self.getObject(record)
+		if variable.isLocked(): # type: ignore
+			name = record['name']
+			raise RuntimeError(self, f'Symbol "{name}" is locked')
+		variable.setValue(self.getValueOf(value)) # type: ignore
 
 	def encode(self, value):
 		return value
@@ -304,23 +459,35 @@ class Program:
 		self.pc = pc
 		while self.running:
 			command = self.code[self.pc]
+			
+			# Check if debugger wants to halt before executing this command
+			if self.debugger != None:
+				# pc==1 is the first real command (pc==0 is the debug loader)
+				is_first = (self.pc == 1)
+				if self.debugger.checkIfHalt(is_first):
+					# Debugger says halt - break out and wait for user
+					break
+			
 			domainName = command['domain']
 			if domainName == None:
 				self.pc += 1
 			else:
 				keyword = command['keyword']
-				if self.debugStep and command['debug']:
+				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}')
-				if self.debugger != None:
-					self.debugger.step()
 				domain = self.domainIndex[domainName]
 				handler = domain.runHandler(keyword)
 				if handler:
 					command = self.code[self.pc]
 					command['program'] = self
-					self.pc = handler(command)
+					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)}')
 					# Deal with 'exit'
 					if self.pc == -1:
 						queue = deque()
@@ -334,63 +501,48 @@ class Program:
 	# Run the script at a given PC value
 	def run(self, pc):
 		global queue
-		item = Object()
-		item.program = self
-		item.pc = pc
+		item = ECValue()
+		item.program = self # type: ignore
+		item.pc = pc # type: ignore
 		queue.append(item)
+		self.running = True
 
 	def kill(self):
 		self.running = False
 		if self.parent != None: self.parent.program.kill()
 
-	def setExternalControl(self):
-		self.externalControl = True
-
 	def nonNumericValueError(self):
 		FatalError(self.compiler, 'Non-numeric value')
 
-	def variableDoesNotHoldAValueError(self, name):
-		raise FatalError(self.compiler, f'Variable "{name}" does not hold a value')
-
-	def noneValueError(self, name):
-		raise FatalError(self.compiler, f'Value is None')
-
 	def compare(self, value1, value2):
-		val1 = self.evaluate(value1)
-		val2 = self.evaluate(value2)
-		if val1 == None or val2 == None:
+		if value1 == None or value2 == None:
+			RuntimeError(self, 'Cannot compare a value with None')
+		v1 = self.textify(value1)
+		v2 = self.textify(value2)
+		if v1 == None or v2 == None:
+			raise RuntimeError(self, 'Both items must have a value for comparison')
+		if type(v1) == str and type(v2) == str:
+			# String comparison
+			if v1 < v2: return -1
+			if v1 > v2: return 1
 			return 0
-		v1 = val1['content']
-		v2 = val2['content']
-#		if v1 == None and v2 != None or v1 != None and v2 == None:
-#			return 0
-		if v1 == None and v2 != None: return -1
-		elif v2 == None and v1 != None: return 1
-		if v1 != None and val1['type'] == 'int':
-			if not val2['type'] == 'int':
-				if type(v2) is str:
-					try:
-						v2 = int(v2)
-					except:
-						lino = self.code[self.pc]['lino'] + 1
-						RuntimeError(None, f'Line {lino}: \'{v2}\' is not an integer')
-		else:
-			if v2 != None and val2['type'] == 'int':
-				v2 = str(v2)
-			if v1 == None:
-				v1 = ''
-			if v2 == None:
-				v2 = ''
-		if type(v1) == int:
-			if type(v2) != int:
-				v1 = f'{v1}'
-		if type(v2) == int:
-			if type(v1) != int:
-				v2 = f'{v2}'
-		if v1 > v2:  # type: ignore[operator]
-			return 1
+		
+		if type(v1) is str:
+			try:
+				v1 = int(v1)
+			except:
+				print(f'{v1} is not an integer')
+				return None
+		if type(v2) is str:
+			try:
+				v2 = int(v2)
+			except:
+				print(f'{v2} is not an integer')
+				return None
 		if v1 < v2:  # type: ignore[operator]
 			return -1
+		if v1 > v2:  # type: ignore[operator]
+			return 1
 		return 0
 
 	# Set up a message handler
@@ -405,7 +557,7 @@ class Program:
 # This is the program launcher
 def Main():
 	if (len(sys.argv) > 1):
-		Program(sys.argv[1]).start()
+		Program(' '.join(sys.argv[1:])).start()
 	else:
 		Program('-v')
 

easycoder/ec_psutil.py

@@ -0,0 +1,48 @@
+from easycoder import Handler, ECValue
+import os
+from psutil import Process
+
+class PSUtil(Handler):
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+
+    def getName(self):
+        return 'psutil'
+
+    #############################################################################
+    # Keyword handlers
+
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        value = ECValue(domain=self.getName())
+        if self.tokenIs('the'):
+            self.nextToken()
+        token = self.getToken()
+        if token in ['mem', 'memory']:
+            value.setType('memory')
+            return value
+        return None
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # Value handlers
+
+    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)
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers

easycoder/ec_timestamp.py

@@ -5,6 +5,7 @@ def getTimestamp(t):
     tz = pytz.timezone('GB') # Localize this!
     dt = datetime.fromtimestamp(t)
     # print(f'{dt} + {tz.dst(dt).seconds}')
-    return int(t) + tz.dst(dt).seconds
+    dst = tz.dst(dt)
+    return int(t) + (dst.seconds if dst else 0)
 
 # Usage: print(getTimestamp(time.time()))