easycoder 251215.2__py2.py3-none-any.whl → 260111.1__py2.py3-none-any.whl

easycoder/ec_gclasses.py

@@ -112,6 +112,12 @@ class ECLineInput(ECTextWidget):
     def hasRuntimeValue(self):
         return True
     
+    # Set the text of the widget
+    def setText(self, text):
+        v = self.getValue()
+        if v is None: return
+        v.getContent().setText(str(text)) # type: ignore
+    
     # Get the text of the widget
     def getText(self):
         return self.getValue().getContent().text() # type: ignore
@@ -146,21 +152,26 @@ class ECListBox(ECCoreWidget):
     def isClearable(self):
          return True
     
-    # Get the count of items in the list box
-    def getCount(self):
-        v = self.getContent().count() # type: ignore
-        return v
-    
     # Get the selected item in the list box
     def getContent(self):
-        widget = self.getValue().getContent() # type: ignore
-        content = widget.selectedItems()[0].text() if widget.selectedItems() else None
+        widget = self.getValue() # type: ignore
+        content = widget.selectedItems()[0].text() if widget.selectedItems() else None # type: ignore
         return content
     
     # Get the text of the widget
     def getText(self):
-        return self.getValue().getContent().text() # type: ignore
-
+        return self.getContent() # type: ignore
+    
+    # Get the count of items in the list box
+    def getCount(self):
+        v = self.getContent().count() # type: ignore
+        return v
+    
+    # Get the index of the selected item
+    def getIndex(self):
+        widget = self.getValue() # type: ignore
+        index = widget.currentRow() # type: ignore
+        return index
 
 ###############################################################################
 # A combo box variable

easycoder/ec_graphics.py

@@ -198,7 +198,6 @@ class Graphics(Handler):
     # Set a graphic element as the value of a record
     def setGraphicElement(self, record, element):
         object = self.getObject(record)
-        # object.setValue(ECValue(domain=self.getName(), type='object', content=element))
         object.setValue(element)
 
     def dialogTypes(self):
@@ -769,7 +768,8 @@ class Graphics(Handler):
     
     def r_createLineEdit(self, command, record):
         lineinput = ECLineEditWidget()
-        lineinput.setText(self.textify(command['text']))
+        text = self.textify(command['text'])
+        lineinput.setText(str(text))
         fm = lineinput.fontMetrics()
         m = lineinput.textMargins()
         c = lineinput.contentsMargins()
@@ -1128,9 +1128,10 @@ class Graphics(Handler):
         return self.nextPC()
 
     # remove [the] [current/selected] [item] [from/in] {combobox}/{listbox}
+    # Graphics-reserved syntax: optional article pattern is plugin-safe (core-only command)
     def k_remove(self, command):
         command['variant'] = None
-        self.skip('the')
+        self.skipArticles()  # Optional 'the', 'a', 'an' — syntactic sugar
         self.skip(['current', 'selected'])
         self.skip('item')
         self.skip(['from', 'in'])
@@ -1201,7 +1202,10 @@ class Graphics(Handler):
     # set {listbox} to {list}
     # set blocked true/false
     def k_set(self, command):
-        self.skip('the')
+        # Graphics-reserved syntax: optional article pattern with 'of'/'to' prepositions
+        # Forms like 'set the layout of Window to MainPanel' and 'set layout of Window to MainPanel' are equivalent
+        # Plugin-safe: graphics is a core-only module
+        self.skipArticles()  # Optional 'the', 'a', 'an' — syntactic sugar for readability
         token = self.nextToken()
         command['what'] = token
         if token in ['width', 'height']:
@@ -1363,15 +1367,16 @@ class Graphics(Handler):
             keyword = record['keyword']
             setText = getattr(widget, "setText", None)
             if callable(setText):
-                widget.setText(text)  # type: ignore
+                widget.setText(str(text))  # type: ignore
             elif self.isObjectType(record, ECMultiline):
-                widget.setPlainText(text)  # type: ignore
+                widget.setPlainText(str(text))  # type: ignore
             if self.isObjectType(record, ECPushButton):
-                widget.setAccessibleName(text)  # type: ignore
+                widget.setAccessibleName(str(text))  # type: ignore
         elif what == 'state':
             record = self.getVariable(command['name'])
             if self.isObjectType(record, ECCheckBox):
                 state = self.textify(command['value'])
+                state = False if state == None else True
                 self.getInnerObject(record).setChecked(state)  # type: ignore
         elif what == 'alignment':
             widget = self.getVariable(command['name'])['widget']
@@ -1468,7 +1473,7 @@ class Graphics(Handler):
                 if choice == QMessageBox.StandardButton.Ok: result = 'OK'
                 else: result = ''
             else: result = 'Cancel'
-            v = ECValue(domain='graphics', type='str', content=result)
+            v = ECValue(domain='graphics', type=str, content=result)
             self.putSymbolValue(target, v)
         elif 'window' in command:
             window = self.getInnerObject(self.getVariable(command['window'])['object'])
@@ -1525,6 +1530,7 @@ class Graphics(Handler):
                     self.skip('of')
                 elif token in ['current', 'selected']:
                     token = self.nextToken()
+                    value.option = token
                     if token == 'item': self.skip('in')
                     elif token == 'index': self.skip('of')
                 if self.nextIsSymbol():
@@ -1548,6 +1554,14 @@ class Graphics(Handler):
                     ): # type: ignore
                         value.setContent(ECValue(domain=self.getName(), type='object', content=record['name']))
                         return value
+            elif token == 'index':
+                self.skip('of')
+                value.element = self.getValue()
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if self.isObjectType(record, (ECListBox, ECComboBox)): # type: ignore
+                        value.setContent(ECValue(domain=self.getName(), type='object', content=record['name']))
+                        return value
         return None
 
     #############################################################################
@@ -1564,33 +1578,33 @@ class Graphics(Handler):
         keyword = record['keyword']
         if self.isObjectType(record, ECPushButton):
             pushbutton = self.getInnerObject(record)
-            v = ECValue(domain=self.getName(), type='str', content=pushbutton.accessibleName())
+            v = ECValue(domain=self.getName(), type=str, content=pushbutton.accessibleName())
             return v
         elif self.isObjectType(record, ECLineInput):
             lineinput = self.getInnerObject(record)
-            v = ECValue(domain=self.getName(), type='str', content=lineinput.displayText())
+            v = ECValue(domain=self.getName(), type=str, content=lineinput.displayText())
             return v
         elif self.isObjectType(record, ECMultiline):
             multiline = self.getInnerObject(record)
-            v = ECValue(domain=self.getName(), type='str', content=multiline.toPlainText())
+            v = ECValue(domain=self.getName(), type=str, content=multiline.toPlainText())
             return v
         elif self.isObjectType(record, ECComboBox):
             combobox = self.getInnerObject(record)
-            v = ECValue(domain=self.getName(), type='str', content=combobox.currentText())
+            v = ECValue(domain=self.getName(), type=str, content=combobox.currentText())
             return v
         elif self.isObjectType(record, ECListBox):
             listbox = self.getInnerObject(record)
             content = listbox.currentItem().text()  # type: ignore
-            v = ECValue(domain=self.getName(), type='str', content=content)
+            v = ECValue(domain=self.getName(), type=str, content=content)
             return v
         elif self.isObjectType(record, ECCheckBox):
             checkbox =self.getInnerObject(record)
             content = checkbox.isChecked()  # type: ignore
-            v = ECValue(domain=self.getName(), type='boolean', content=content)
+            v = ECValue(domain=self.getName(), type=bool, content=content)
             return v
         elif self.isObjectType(record, ECDialog):
             content = record['result']
-            v = ECValue(domain=self.getName(), type='str', content=content)
+            v = ECValue(domain=self.getName(), type=str, content=content)
             return v
         return None
 
@@ -1602,22 +1616,24 @@ class Graphics(Handler):
             if isinstance(object, (ECListBox, ECComboBox)):
                 widget = self.getInnerObject(object)
                 value = widget.count()  # type: ignore
-                return ECValue(domain=self.getName(), type='int', content=value)  # type: ignore
+                return ECValue(domain=self.getName(), type=int, content=value)  # type: ignore
             else: raise RuntimeError(self.program, f"Object is not a listbox or combobox")
 
     def v_current(self, v):
         content = v.getContent()
         if isinstance(content, ECValue) and content.getType() == 'object':
             record = self.getVariable(content.getContent())
-            keyword = record['keyword']
             object = self.getObject(record)
-            widget = self.getInnerObject(object)
-            if isinstance(widget, (QListWidget)):
-                content = widget.currentItem().text()  # type: ignore
-                return ECValue(domain=self.getName(), type='int', content=content)
-            elif isinstance(widget, (QComboBox)):
-                content = str(widget.currentText())  # type: ignore
-                return ECValue(domain=self.getName(), type='int', content=content)
+            option = v.option
+            if isinstance(object, (ECListBox)):
+                if option == 'item':
+                    content = object.getText()  # type: ignore
+                elif option == 'index':
+                    content = object.getIndex()  # type: ignore
+                return ECValue(domain=self.getName(), type=int, content=content)
+            elif isinstance(object, (ECComboBox)):
+                content = str(object.currentText())  # type: ignore
+                return ECValue(domain=self.getName(), type=int, content=content)
             else: raise RuntimeError(self.program, f"Object is not a listbox or combobox")
     
     def v_element(self, v):
@@ -1628,7 +1644,7 @@ class Graphics(Handler):
             record = self.getVariable(v.getContent())
             object = self.getObject(record)
             value = object.isEmpty()
-            return ECValue(domain=self.getName(), type='boolean', content=value)  # type: ignore
+            return ECValue(domain=self.getName(), type=bool, content=value)  # type: ignore
         return None
 
     def v_selected(self, v): return self.v_current(v)
@@ -1639,7 +1655,7 @@ class Graphics(Handler):
             record = self.getVariable(content.getContent())
             object = self.getObject(record)
             value = object.getText()
-            return ECValue(domain=self.getName(), type='int', content=value)  # type: ignore
+            return ECValue(domain=self.getName(), type=int, content=value)  # type: ignore
 
     #############################################################################
 	# Get the value of an unknown item (domain-specific)

easycoder/ec_handler.py

@@ -1,5 +1,5 @@
 import sys, json
-from .ec_classes import FatalError, ECValue
+from .ec_classes import normalize_type
 
 class Handler:
 
@@ -9,6 +9,7 @@ class Handler:
 		self.getToken = compiler.getToken
 		self.nextToken = compiler.nextToken
 		self.skip = compiler.skip
+		self.skipArticles = compiler.skipArticles
 		self.peek = compiler.peek
 		self.getValue = compiler.getValue
 		self.nextValue = compiler.nextValue
@@ -71,8 +72,8 @@ class Handler:
 
 	# Get a condition handler
 	def conditionHandler(self, name):
-		return getattr(self, f'c_{name}')
+		return getattr(self, f'c_{normalize_type(name)}')
 
 	# 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

@@ -0,0 +1,248 @@
+from easycoder import Handler, ECObject, ECValue, RuntimeError
+import paho.mqtt.client as mqtt
+    
+#############################################################################
+# 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.onMessagePC = None
+        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()}")
+    
+    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()
+    
+    def getMessageTopic(self):
+        return self.message.topic
+    
+    def getMessagePayload(self):
+        return self.message.payload.decode('utf-8')
+
+    def onMessage(self, pc):
+        self.onMessagePC = pc
+    
+    def sendMessage(self, topic, message, qos):
+        self.client.publish(topic, message, qos=qos)
+    
+    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 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
+
+###############################################################################
+# The MQTT compiler and rutime 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')
+            command['name'] = self.nextValue()
+            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()
+        topic.create(self.textify(command['name']), qos=int(self.textify(command['qos'])))
+        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()
+            if self.nextIs('message'):
+                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):
+        self.program.mqttClient.onMessage(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']
+            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'])
+        self.program.mqttClient.sendMessage(topic.getName(), message, topic.getQOS())
+        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.nextToken()
+        if token == 'mqtt':
+            value = ECValue(domain=self.getName())
+            token = self.nextToken()
+            if token in ['topic', 'message']:
+                value.setType(token)
+                return value
+        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.getMessagePayload()
+
+    def v_topic(self, v):
+        return self.program.mqttClient.getMessageTopic()
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers