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

easycoder/ec_mqtt.py

@@ -0,0 +1,435 @@
+from easycoder import Handler, ECObject, ECValue, RuntimeError
+import paho.mqtt.client as mqtt
+import time
+import threading
+import json
+ 
+#############################################################################
+# MQTT client class
+class MQTTClient():
+    def __init__(self):
+        super().__init__()
+
+    def create(self, program, clientID, broker, port, topics):
+        self.program = program
+        self.clientID = clientID
+        self.broker = broker
+        self.port = port
+        self.topics = topics
+        self.onConnectPC = None
+        self.onMessagePC = None
+        self.timeout = False
+        self.messages = {}
+        self.chunked_messages = {}  # Store incoming chunked messages {topic: {part_num: data}}
+        self.confirmation_lock = threading.Lock()
+        self.chunk_size = 1024  # Default chunk size
+        self.last_send_time = None  # Time taken for last message transmission (seconds)
+        self.client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=self.clientID) # type: ignore
+    
+        # Setup callbacks
+        self.client.on_connect = self.on_connect
+        self.client.on_message = self.on_message
+
+    def on_connect(self, client, userdata, flags, reason_code, properties):
+        print(f"Client {self.clientID} connected")
+        for item in self.topics:
+            topic = self.program.getObject(self.program.getVariable(item))
+            self.client.subscribe(topic.getName(), qos=topic.getQoS())
+            print(f"Subscribed to topic: {topic.getName()} with QoS {topic.getQoS()}")
+
+        if self.onConnectPC is not None:
+            self.program.run(self.onConnectPC)
+            self.program.flushCB()
+    
+    def on_message(self, client, userdata, msg):
+        payload = msg.payload.decode('utf-8')
+        topic = msg.topic
+        
+        # Check if this is a chunked message (format: "!part!<n> <total><data>")
+        if payload.startswith('!part!'):
+            # Extract: "!part!<n> <total><data>"
+            header_end = payload.find(' ', 6)  # Find space after part number
+            if header_end > 6:
+                try:
+                    part_num = int(payload[6:header_end])  # Extract part number
+                    # Find next space to get total_chunks
+                    total_end = payload.find(' ', header_end + 1)
+                    if total_end > header_end:
+                        total_chunks = int(payload[header_end + 1:total_end])
+                        data = payload[total_end + 1:]  # Rest is data
+                        
+                        # Initialize chunked message storage if this is part 0
+                        if part_num == 0:
+                            self.chunked_messages[topic] = {}
+                        
+                        # Store this chunk with its part number
+                        if topic in self.chunked_messages:
+                            self.chunked_messages[topic][part_num] = data
+                            print(f"Received chunk {part_num}/{total_chunks - 1} on topic {topic}")
+                except (ValueError, IndexError):
+                    pass
+            return
+            
+        elif payload.startswith('!last!'):
+            # Final chunk: "!last!<total><data>"
+            try:
+                # Find where the total ends and data begins (first space after !last!)
+                space_pos = payload.find(' ', 6)
+                if space_pos > 6:
+                    total_chunks = int(payload[6:space_pos])
+                    data = payload[space_pos + 1:]  # Rest is data
+                    
+                    # Initialize topic storage if not present (single chunk case)
+                    if topic not in self.chunked_messages:
+                        self.chunked_messages[topic] = {}
+                    
+                    # Store the last chunk
+                    self.chunked_messages[topic][total_chunks - 1] = data
+                    
+                    # Verify all chunks are present
+                    expected_parts = set(range(total_chunks))
+                    received_parts = set(self.chunked_messages[topic].keys())
+                    
+                    if expected_parts == received_parts:
+                        # All chunks received - assemble complete message
+                        message_parts = [self.chunked_messages[topic][i] for i in sorted(self.chunked_messages[topic].keys())]
+                        complete_message = ''.join(message_parts)
+                        del self.chunked_messages[topic]
+                        
+                        # Confirmation is now handled at the EasyCoder level
+                        # print(f"All chunks received for topic {topic} ({len(complete_message)} bytes total).")
+                        self.message = {"topic": topic, "payload": complete_message}
+                        
+                        if self.onMessagePC is not None:
+#                            print(f'Run from PC {self.onMessagePC}')
+                            self.program.run(self.onMessagePC)
+                            self.program.flushCB()
+                    else:
+                        missing = expected_parts - received_parts
+                        print(f"Warning: Missing chunks {missing} for topic {topic}")
+            except (ValueError, IndexError):
+                pass
+            return
+    
+    def getMessageTopic(self):
+        return self.message.topic # type: ignore
+    
+    def getReceivedMessage(self):
+        return self.message
+
+    def onMessage(self, pc):
+        self.onMessagePC = pc
+
+    def sendMessage(self, topic, message, qos, chunk_size=0):
+        """Send a message, optionally chunked if chunk_size > 0
+        
+        Stores transmission time in self.last_send_time (seconds)
+        """
+        send_start = time.time()
+        
+        # Send message in chunks using selected strategy
+        message_len = len(message)
+        num_chunks = (message_len + chunk_size - 1) // chunk_size
+        
+        # print(f'Sending message ({message_len} bytes) in {num_chunks} chunks of size {chunk_size} to topic {topic} with QoS {qos}')
+        
+        self._send_rapid_fire(topic, message, qos, chunk_size, num_chunks)
+        
+        self.last_send_time = time.time() - send_start
+        print(f'Message transmission complete in {self.last_send_time:.3f} seconds')
+    
+    def _send_rapid_fire(self, topic, message, qos, chunk_size, num_chunks):
+        """Send all chunks as rapidly as possible, wait for single final confirmation"""
+        # print(f"Sending all {num_chunks} chunks as fast as possible...")
+        
+        # Send all chunks rapidly
+        for i in range(num_chunks):
+            start = i * chunk_size
+            end = min(start + chunk_size, len(message))
+            chunk_data = message[start:end]
+            
+            # Prepare chunk with header: "!part!<n> <total><data>" or "!last!<total><data>"
+            if i == num_chunks - 1:
+                chunk_msg = f"!last!{num_chunks} {chunk_data}"
+            else:
+                chunk_msg = f"!part!{i} {num_chunks} {chunk_data}"
+            
+            # Send without waiting
+            self.client.publish(topic, chunk_msg, qos=qos)
+            # print(f"Sent chunk {i}/{num_chunks - 1} to topic {topic} with QoS {qos}: {chunk_msg}")
+        # No waiting here; confirmations are handled in EasyCoder using sender identity
+    
+    # Start the MQTT client loop
+    def run(self):
+        self.client.connect(self.broker, int(self.port), 60)
+        self.client.loop_start()
+        
+###############################################################################
+# An MQTT topic
+class ECTopic(ECObject):
+    def __init__(self):
+        super().__init__()
+
+    def getName(self):
+        v = self.getValue()
+        if v is None:
+            return ""
+        if v is None:
+            return ""
+        return v['name']
+    
+    def getQoS(self):
+        v = self.getValue()
+        if v is None:
+            return 0
+        if v is None:
+            return 0
+        return int(v['qos'])
+    
+    def textify(self):
+        v = self.getValue()
+        if v is None:
+            return ""
+        return f'{{"name": "{v["name"]}", "qos": {v["qos"]}}}'
+
+###############################################################################
+###############################################################################
+# The MQTT compiler and runtime handlers
+class MQTT(Handler):
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+        self.spoke = None
+
+    def getName(self):
+        return 'mqtt'
+
+    #############################################################################
+    # Keyword handlers
+
+    # init {topic} name {name} qos {qos}
+    def k_init(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            self.checkObjectType(record, ECTopic)
+            command['topic'] = record['name']
+            self.skip('name')
+            name =self.nextValue()
+            command['name'] = name
+            self.skip('qos')
+            command['qos'] = self.nextValue()
+            self.add(command)
+            return True
+        return False
+
+    def r_init(self, command):
+        record = self.getVariable(command['topic'])
+        topic = ECTopic()
+        value = {}
+        value['name'] = self.textify(command['name'])
+        value['qos'] = int(self.textify(command['qos']))
+        topic.setValue(value)
+        record['object'] = topic
+        return self.nextPC()
+
+    # mqtt id {clientID} broker {broker} port {port} topics {topic} [and {topic} ...]
+    def k_mqtt(self, command):
+        while True:
+            token = self.peek()
+            if token == 'id':
+                self.nextToken()
+                command['clientID'] = self.nextValue()
+            elif token == 'broker':
+                self.nextToken()
+                command['broker'] = self.nextValue()
+            elif token == 'port':
+                self.nextToken()
+                command['port'] = self.nextValue()
+            elif token == 'topics':
+                self.nextToken()
+                topics = []
+                while self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    self.checkObjectType(record, ECTopic())
+                    topics.append(record['name'])
+                    if self.peek() == 'and': self.nextToken()
+                    else:break
+                command['topics'] = topics
+            else:
+                self.add(command)
+                return True
+        return False
+
+    def r_mqtt(self, command):
+        if hasattr(self.program, 'mqttClient'):
+            raise RuntimeError(self.program, 'MQQT client already defined')
+        clientID = self.textify(command['clientID'])
+        broker = self.textify(command['broker'])
+        port = self.textify(command['port'])
+        topics = command['topics']
+        client = MQTTClient()
+        client.create(self.program, clientID, broker, port, topics)
+        client.run()
+        self.program.mqttClient = client
+        return self.nextPC()
+
+    # on mqtt message {action}
+    def k_on(self, command):
+        token = self.peek()
+        if token == 'mqtt':
+            self.nextToken()
+            event = self.nextToken()
+            if event in ['connect', 'message']:
+                command['event'] = event
+                self.nextToken()
+                command['goto'] = 0
+                self.add(command)
+                cmd = {}
+                cmd['domain'] = 'core'
+                cmd['lino'] = command['lino']
+                cmd['keyword'] = 'gotoPC'
+                cmd['goto'] = 0
+                cmd['debug'] = False
+                self.add(cmd)
+                # Add the action and a 'stop'
+                self.compileOne()
+                cmd = {}
+                cmd['domain'] = 'core'
+                cmd['lino'] = command['lino']
+                cmd['keyword'] = 'stop'
+                cmd['debug'] = False
+                self.add(cmd)
+                # Fixup the link
+                command['goto'] = self.getCodeSize()
+                return True
+        return False
+
+    def r_on(self, command):
+        event = command['event']
+        if event == 'connect':
+            self.program.mqttClient.onConnectPC = self.nextPC()+1
+        elif event == 'message':
+            self.program.mqttClient.onMessagePC = self.nextPC()+1
+        return command['goto']
+
+    # send {message} to {topic}
+    def k_send(self, command):
+        if self.nextIs('mqtt'):
+            command['message'] = self.nextValue()
+            self.skip('to')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                self.checkObjectType(record, MQTTClient)
+                command['to'] = record['name']
+                token = self.peek()
+                if token == 'with':
+                    self.nextToken()
+                    while True:
+                        token = self.nextToken()
+                        if token == 'qos':
+                            command['qos'] = self.nextValue()
+                        if self.peek() == 'and':
+                            self.nextToken()
+                        else:
+                            break
+            self.add(command)
+            return True
+        return False
+
+    def r_send(self, command):
+        if not hasattr(self.program, 'mqttClient'):
+            raise RuntimeError(self.program, 'No MQTT client defined')
+        topic = self.getObject(self.getVariable(command['to']))
+        message = self.textify(command['message'])
+        
+        # Validate that outgoing message is valid JSON with required 'sender' and 'action' fields
+        try:
+            payload_dict = json.loads(message)
+            if not isinstance(payload_dict, dict):
+                raise RuntimeError(self.program, f'MQTT message must be a JSON object, got {type(payload_dict).__name__}')
+            
+            # sender can be a string (topic name) or a dict with 'name' and 'qos' keys
+            if 'sender' not in payload_dict:
+                raise RuntimeError(self.program, 'MQTT message must contain "sender" field')
+            sender_val = payload_dict.get('sender')
+            if isinstance(sender_val, str):
+                pass  # sender is a string (topic name), valid
+            elif isinstance(sender_val, dict):
+                if 'name' not in sender_val or not isinstance(sender_val.get('name'), str):
+                    raise RuntimeError(self.program, 'MQTT message "sender" dict must contain "name" field as string')
+            else:
+                raise RuntimeError(self.program, f'MQTT message "sender" must be a string or dict, got {type(sender_val).__name__}')
+            
+            # action must be a string
+            if 'action' not in payload_dict or not isinstance(payload_dict.get('action'), str):
+                raise RuntimeError(self.program, 'MQTT message must contain "action" field as string')
+        except json.JSONDecodeError as e:
+            raise RuntimeError(self.program, f'MQTT message must be valid JSON: {e}')
+        
+        if 'qos' in command:
+            qos = int(self.textify(command['qos']))
+        else:
+            qos = topic.qos if hasattr(topic, 'qos') else 1
+        self.program.mqttClient.sendMessage(topic.getName(), message, qos, chunk_size=1024)
+        if self.program.mqttClient.timeout:
+            return 0
+        return self.nextPC()
+
+    # Declare a topic variable
+    def k_topic(self, command):
+        self.compiler.addValueType()
+        return self.compileVariable(command, 'ECTopic')
+
+    def r_topic(self, command):
+        return self.nextPC()
+
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        token = self.getToken()
+        if token == 'the':
+            token = self.nextToken()
+        if self.isSymbol():
+            record = self.getSymbolRecord()
+            object = self.getObject(record)
+            if isinstance(object, ECTopic):
+                return ECValue(domain=self.getName(), type='topic', content=record['name'])
+            else: return None
+        else:
+            if token == 'mqtt':
+                token = self.nextToken()
+                if token == 'message':
+                    return ECValue(domain=self.getName(), type='mqtt', content=token)
+            # else:
+            #     return self.getValue()
+        return None
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # Value handlers
+
+    def v_message(self, v):
+        return self.program.mqttClient.message
+    
+    def v_mqtt(self, v):
+        content = v.getContent()
+        if content == 'message':
+            return self.program.mqttClient.message
+        return None
+
+    def v_topic(self, v):
+        topic = self.getObject(self.getVariable(self.textify(v.getContent())))
+        return f'{{"name": "{topic.getName()}", "qos": {topic.getQoS()}}}'
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers

easycoder/ec_program.py

@@ -1,6 +1,7 @@
-import time, sys, json
+import time, sys, json, traceback
 from copy import deepcopy
 from collections import deque
+
 from .ec_classes import (
 	Script,
 	Token,
@@ -60,6 +61,7 @@ class Program:
 		self.value = self.compiler.value
 		self.condition = self.compiler.condition
 		self.graphics = None
+		self.mqtt = None
 		self.psutil = None
 		self.useClass(Core)
 		self.ticker = 0
@@ -93,7 +95,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 'used' in record:
+				if name[-1] != ':' and not record['used']:
 					print(f'Variable "{name}" not used')
 			else:
 				print(f'Run {self.name}')
@@ -119,6 +121,15 @@ class Program:
 			self.useClass(Graphics)
 		return True
 	
+	# Use the MQTT module
+	def useMQTT(self):
+		if self.mqtt == None:
+			print('Loading MQTT module')
+			from .ec_mqtt import MQTT
+			self.mqtt = MQTT
+			self.useClass(MQTT)
+		return True
+	
 	# Use the psutil module
 	def usePSUtil(self):
 		if self.psutil == None:
@@ -243,7 +254,7 @@ class Program:
 	# 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()
@@ -261,6 +272,15 @@ class Program:
 			elif varType == 'dict': value.setValue(type=dict, content=item)
 			else: value.setValue(type=None, content=None)
 		return value
+	
+	# Get the value of an item from its domain handler
+	def textifyInDomain(self, value):
+		domainName = value.getDomain()  # type: ignore
+		if domainName == None: domainName = 'core'
+		domain = self.domainIndex[domainName]
+		handler = domain.valueHandler(value.getType()) # type: ignore
+		result = handler(value) if handler else None
+		return result
 
 	# Runtime function to evaluate an ECObject or ECValue. Returns another ECValue
 	# This function may be called recursively by value handlers.
@@ -289,7 +309,7 @@ class Program:
 
 		elif valType == 'symbol': # type: ignore
 			# If it's a symbol, get its value
-			record = self.getVariable(value.getContent()) # type: ignore
+			record = self.getVariable(value.getName()) # type: ignore
 			if not 'object' in record: return None # type: ignore
 			variable = self.getObject(record) # type: ignore
 			result = variable.getValue() # type: ignore
@@ -316,12 +336,7 @@ class Program:
 			result.setValue(type=str, content=content)
 	
 		else:
-			# Call the given domain to handle a value
-			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)
+			result = self.textifyInDomain(value)
 
 		return result
 
@@ -334,7 +349,7 @@ class Program:
 		if isinstance(value, dict):
 			value = value['object']
 		if isinstance(value, ECObject):
-			value = value.getValue()
+			value = value.textify() # type: ignore
 		if isinstance(value, ECValue): # type: ignore
 			v = self.evaluate(value) # type: ignore
 		else:
@@ -344,6 +359,8 @@ class Program:
 			if v.getType() == 'object':
 				return value.getContent() # type: ignore
 			return v.getContent() 
+		elif isinstance(v, ECObject):
+			return v.textify() # type: ignore
 		if isinstance(v, (dict, list)): 
 			return json.dumps(v)
 		return v
@@ -363,7 +380,6 @@ class Program:
 		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
 
@@ -478,7 +494,8 @@ class Program:
 							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)}')
+						tb = traceback.format_exc()
+						raise RuntimeError(self, f'Error during execution of {domainName}:{keyword}: {str(e)}\n\nTraceback:\n{tb}')
 					# Deal with 'exit'
 					if self.pc == -1:
 						queue = deque()

easycoder/ec_value.py

@@ -22,11 +22,11 @@ class Value:
 
 		value = ECValue()
 
-		if token == 'true':
+		if token.lower() == 'true':
 			value.setValue(bool, True)
 			return value
 
-		if token == 'false':
+		if token.lower() == 'false':
 			value.setValue(bool, False)
 			return value
 
@@ -96,8 +96,9 @@ class Value:
 			self.compiler.warning(f'ec_value.compileValue: Cannot get the value of "{token}"')
 			return None
 		if item.getType() == 'symbol':
-			object = self.compiler.getSymbolRecord(item.getContent())['object']
+			object = self.compiler.getSymbolRecord(item.getName())['object']
 			if not object.hasRuntimeValue(): return None
+			item.setContent(object.name)
 
 		if self.peek() == 'cat':
 			self.nextToken()  # consume 'cat'

easycoder/pre/ec_core.py

@@ -69,7 +69,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
@@ -1655,8 +1655,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
@@ -1912,7 +1911,7 @@ class Core(Handler):
         value = ECValue()
         token = self.getToken()
         if self.isSymbol():
-            value.setValue(type='symbol', content=token)
+            value.setValue(type='symbol', name=token)
             return value
 
         value.setType(token)
@@ -1946,13 +1945,13 @@ class Core(Handler):
                 value.format = None
             return value
 
-        if token == 'element':
+        if token == 'item':
             value.index = self.nextValue()
             if self.nextToken() == 'of':
                 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
 
@@ -2214,10 +2213,10 @@ class Core(Handler):
             value = v
         return value
 
-    def v_element(self, v):
+    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)
         content = variable.getContent()
@@ -2656,7 +2655,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()

easycoder/pre/ec_program.py

@@ -289,7 +289,7 @@ class Program:
 
 		elif valType == 'symbol': # type: ignore
 			# If it's a symbol, get its value
-			record = self.getVariable(value.getContent()) # type: ignore
+			record = self.getVariable(value.getName()) # type: ignore
 			if not 'object' in record: return None # type: ignore
 			variable = self.getObject(record) # type: ignore
 			result = variable.getValue() # type: ignore

easycoder/pre/ec_value.py

@@ -96,7 +96,7 @@ class Value:
 			self.compiler.warning(f'ec_value.compileValue: Cannot get the value of "{token}"')
 			return None
 		if item.getType() == 'symbol':
-			object = self.compiler.getSymbolRecord(item.getContent())['object']
+			object = self.compiler.getSymbolRecord(item.getName())['object']
 			if not object.hasRuntimeValue(): return None
 
 		if self.peek() == 'cat':

{easycoder-260110.1.dist-info → easycoder-260118.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easycoder
-Version: 260110.1
+Version: 260118.3
 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