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

easycoder/ec_handler.py

@@ -76,4 +76,4 @@ class Handler:
 
 	# Get the value of an unknown item (domain-specific)
 	def getUnknownValue(self, value):
-		return None # Unable to get value
+		return value

easycoder/ec_mqtt.py

@@ -1,7 +1,9 @@
-from easycoder import Handler, ECObject, ECValue, ECDictionary, FatalError, RuntimeError
+from easycoder import Handler, ECObject, ECValue, RuntimeError
 import paho.mqtt.client as mqtt
 import time
-    
+import threading
+import json
+ 
 #############################################################################
 # MQTT client class
 class MQTTClient():
@@ -14,7 +16,14 @@ class MQTTClient():
         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
@@ -25,28 +34,132 @@ class MQTTClient():
         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()}")
+            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):
-        # print(f"Message received on topic {msg.topic}: {msg.payload.decode()}")
-        if self.onMessagePC is not None:
-            self.message = msg
-            self.program.run(self.onMessagePC)
-            self.program.flushCB()
+        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
+        return self.message.topic # type: ignore
     
-    def getMessagePayload(self):
-        return self.message.payload.decode('utf-8')
+    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 sendMessage(self, topic, message, qos):
-        self.client.publish(topic, message, qos=qos)
+    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()
@@ -57,19 +170,31 @@ class ECTopic(ECObject):
     def __init__(self):
         super().__init__()
 
-    def create(self, name, qos=1):
-        super().__init__()
-        self.name = name
-        self.qos = qos
-
     def getName(self):
-        return self.name
-
-    def getQOS(self):
-        return self.qos
+        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 rutime handlers
+###############################################################################
+# The MQTT compiler and runtime handlers
 class MQTT(Handler):
 
     def __init__(self, compiler):
@@ -89,7 +214,8 @@ class MQTT(Handler):
             self.checkObjectType(record, ECTopic)
             command['topic'] = record['name']
             self.skip('name')
-            command['name'] = self.nextValue()
+            name =self.nextValue()
+            command['name'] = name
             self.skip('qos')
             command['qos'] = self.nextValue()
             self.add(command)
@@ -99,7 +225,10 @@ class MQTT(Handler):
     def r_init(self, command):
         record = self.getVariable(command['topic'])
         topic = ECTopic()
-        topic.create(self.textify(command['name']), qos=int(self.textify(command['qos'])))
+        value = {}
+        value['name'] = self.textify(command['name'])
+        value['qos'] = int(self.textify(command['qos']))
+        topic.setValue(value)
         record['object'] = topic
         return self.nextPC()
 
@@ -149,7 +278,9 @@ class MQTT(Handler):
         token = self.peek()
         if token == 'mqtt':
             self.nextToken()
-            if self.nextIs('message'):
+            event = self.nextToken()
+            if event in ['connect', 'message']:
+                command['event'] = event
                 self.nextToken()
                 command['goto'] = 0
                 self.add(command)
@@ -174,23 +305,33 @@ class MQTT(Handler):
         return False
 
     def r_on(self, command):
-        self.program.mqttClient.onMessage(self.nextPC()+1)
+        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('from')
-            if self.nextIsSymbol():
-                record = self.getSymbolRecord()
-                self.checkObjectType(record, MQTTClient)
-                command['from'] = record['name']
             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
@@ -200,7 +341,38 @@ class MQTT(Handler):
             raise RuntimeError(self.program, 'No MQTT client defined')
         topic = self.getObject(self.getVariable(command['to']))
         message = self.textify(command['message'])
-        self.program.mqttClient.sendMessage(topic.getName(), message, topic.getQOS())
+        
+        # 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
@@ -214,15 +386,22 @@ class MQTT(Handler):
     #############################################################################
     # Compile a value in this domain
     def compileValue(self):
-        token = self.nextToken()
-        if token == 'mqtt':
-            value = ECValue(domain=self.getName())
+        token = self.getToken()
+        if token == 'the':
             token = self.nextToken()
-            if token in ['topic', 'message']:
-                value.setType(token)
-                return value
+        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:
-            return self.getValue()
+            if token == 'mqtt':
+                token = self.nextToken()
+                if token == 'message':
+                    return ECValue(domain=self.getName(), type='mqtt', content=token)
+            # else:
+            #     return self.getValue()
         return None
 
     #############################################################################
@@ -234,10 +413,17 @@ class MQTT(Handler):
     # Value handlers
 
     def v_message(self, v):
-        return self.program.mqttClient.getMessagePayload()
+        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):
-        return self.program.mqttClient.getMessageTopic()
+        topic = self.getObject(self.getVariable(self.textify(v.getContent())))
+        return f'{{"name": "{topic.getName()}", "qos": {topic.getQoS()}}}'
 
     #############################################################################
     # Compile a condition

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,12 +121,12 @@ class Program:
 			self.useClass(Graphics)
 		return True
 	
-	# Use the mqtt module
+	# Use the MQTT module
 	def useMQTT(self):
-		if self.psutil == None:
-			print('Loading mqtt module')
+		if self.mqtt == None:
+			print('Loading MQTT module')
 			from .ec_mqtt import MQTT
-			self.psutil = MQTT
+			self.mqtt = MQTT
 			self.useClass(MQTT)
 		return True
 	
@@ -252,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()
@@ -270,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.
@@ -298,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
@@ -325,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
 
@@ -343,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:
@@ -353,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
@@ -372,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
 
@@ -487,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-260108.1.dist-info → easycoder-260118.3.dist-info}/METADATA

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