easycoder 250116.4__py2.py3-none-any.whl → 250118.2__py2.py3-none-any.whl

easycoder/__init__.py

@@ -9,4 +9,4 @@ from .ec_program import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "250116.4"
+__version__ = "250118.2"

easycoder/ec_core.py

@@ -1427,7 +1427,6 @@ class Core(Handler):
 
     def r_system(self, command):
         value = self.getRuntimeValue(command['value'])
-        background = command['background']
         if value != None:
             if command['background']:
                 subprocess.Popen(["sh",value,"&"])
@@ -1735,6 +1734,9 @@ class Core(Handler):
                     if symbolRecord['valueHolder']:
                         value['target'] = symbolRecord['name']
                         return value
+                else:
+                    value['value'] = self.getValue()
+                    return value
                 self.warning(f'Core.compileValue: Token \'{self.getToken()}\' does not hold a value')
             return None
 
@@ -1900,6 +1902,10 @@ class Core(Handler):
                     return value
             return None
 
+        if token == 'system':
+            value['command'] = self.nextValue()
+            return value
+
         return None
 
     #############################################################################
@@ -2199,13 +2205,16 @@ class Core(Handler):
 
     def v_property(self, v):
         propertyValue = self.getRuntimeValue(v['name'])
-        targetName = v['target']
-        target = self.getVariable(targetName)
-        targetValue = self.getRuntimeValue(target)
+        if 'target' in v:
+            targetName = v['target']
+            target = self.getVariable(targetName)
+            targetValue = self.getRuntimeValue(target)
+        else:
+            targetValue = self.getRuntimeValue(v['value'])
         try:
             val = targetValue[propertyValue]
         except:
-            RuntimeError(self.program, f'{targetName} does not have the property \'{propertyValue}\'')
+            RuntimeError(self.program, f'This value does not have the property \'{propertyValue}\'')
             return None
         value = {}
         value['content'] = val
@@ -2247,13 +2256,19 @@ class Core(Handler):
 
     # This is used by the expression evaluator to get the value of a symbol
     def v_symbol(self, symbolRecord):
-        result = {}
         if symbolRecord['keyword'] == 'variable':
-            symbolValue = self.getSymbolValue(symbolRecord)
-            return symbolValue
+            return self.getSymbolValue(symbolRecord)
         else:
             return None
 
+    def v_system(self, v):
+        command = self.getRuntimeValue(v['command'])
+        result = os.popen(command).read()
+        value = {}
+        value['type'] = 'text'
+        value['content'] = result
+        return value
+
     def v_tab(self, v):
         value = {}
         value['type'] = 'text'

easycoder/ec_graphics.py

@@ -9,7 +9,6 @@ class Graphics(Handler):
     def __init__(self, compiler):
         Handler.__init__(self, compiler)
         self.utils = GUtils()
-        self.eventHandlers = {}
 
     def getName(self):
         return 'graphics'
@@ -18,22 +17,27 @@ class Graphics(Handler):
     # Keyword handlers
 
     def k_add(self, command):
-        elements = []
         token = self.nextToken()
         if self.isSymbol():
             symbolRecord = self.getSymbolRecord()
             name = symbolRecord['name']
-            if symbolRecord['keyword'] == 'layout':
-                elements.append(name)
+            keyword = symbolRecord['keyword']
+            if keyword == 'layout':
                 command['args'] = name
-            else: FatalError(self.compiler.program, f'\'{name}\' is not a layout')
+            elif keyword in ['column', 'frame', 'tab']:
+                command['name'] = name
+                command['type'] = token
+                if self.peek() == 'to':
+                    command['args'] = []
+                else:
+                    command['args'] = self.utils.getArgs(self)
         else:
             command['type'] = token
             command['args'] = self.utils.getArgs(self)
         if self.nextIs('to'):
             if self.nextIsSymbol():
                 symbolRecord = self.getSymbolRecord()
-                if symbolRecord['keyword'] == 'layout':
+                if symbolRecord['keyword'] in ['column', 'frame', 'layout', 'tab']:
                     command['target'] = symbolRecord['name']
                     self.addCommand(command)
                     return True
@@ -43,14 +47,19 @@ class Graphics(Handler):
         target = self.getVariable(command['target'])
         type = command['type']
         args = command['args']
+        param= None
         if not 'layout' in target:
             target['layout'] = []
         if args[0] == '{':
+            if type in ['Column', 'Frame', 'Tab']:
+                record = self.getVariable(command['name'])
+                param = record['layout']
             layout = json.loads(self.getRuntimeValue(json.loads(args)))
             default = self.utils.getDefaultArgs(type)
             for n in range(0, len(layout)):
                 args = self.utils.decode(default, layout[n])
-            target['layout'].append(self.utils.createElement(type, args))
+            item = self.utils.createElement(type, param, args)
+            target['layout'].append(item)
         else:
             v = self.getVariable(args)
             target['layout'].append(v['layout'])
@@ -85,6 +94,12 @@ class Graphics(Handler):
         target['window'].close()
         return self.nextPC()
 
+    def k_column(self, command):
+        return self.compileVariable(command)
+
+    def r_column(self, command):
+        return self.nextPC()
+
     # create {window} layout {layout}
     # create {element} {args...}
     def k_create(self, command):
@@ -110,14 +125,30 @@ class Graphics(Handler):
         if type == 'window':
             layout = self.getVariable(command['layout'])
             title = self.getRuntimeValue(command['title'])
-            self.program.window = psg.Window(title, layout['layout'], finalize=True)
+            record['window'] = psg.Window(title, layout['layout'], finalize=True)
+            record['eventHandlers'] = {}
+            self.program.windowRecord = record
             self.program.run(self.nextPC())
             self.mainLoop()
-            self.program.kill()
+            # self.program.kill()
             return 0
         else:
             RuntimeError(self.program, 'Variable is not a window or an element')
 
+    def k_init(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['keyword'] in ['column', 'frame', 'layout', 'tab']:
+                command['target'] = symbolRecord['name']
+                self.add(command)
+                return True
+        return False
+
+    def r_init(self, command):
+        target = self.getVariable(command['target'])
+        target['layout'] = []
+        return self.nextPC()
+
     def k_layout(self, command):
         return self.compileVariable(command)
 
@@ -128,33 +159,38 @@ class Graphics(Handler):
         token = self.nextToken()
         if token == 'event':
             command['key'] = self.nextValue()
-            command['goto'] = self.getPC() + 2
-            self.add(command)
-            self.nextToken()
-            pcNext = self.getPC()
-            cmd = {}
-            cmd['domain'] = 'core'
-            cmd['lino'] = command['lino']
-            cmd['keyword'] = 'gotoPC'
-            cmd['goto'] = 0
-            cmd['debug'] = False
-            self.addCommand(cmd)
-            self.compileOne()
-            cmd = {}
-            cmd['domain'] = 'core'
-            cmd['lino'] = command['lino']
-            cmd['keyword'] = 'stop'
-            cmd['debug'] = False
-            self.addCommand(cmd)
-            # Fixup the link
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
-            return True
+            if self.nextIs('in'):
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if record['keyword'] == 'window':
+                        command['window'] = record['name']
+                        command['goto'] = self.getPC() + 2
+                        self.add(command)
+                        self.nextToken()
+                        pcNext = self.getPC()
+                        cmd = {}
+                        cmd['domain'] = 'core'
+                        cmd['lino'] = command['lino']
+                        cmd['keyword'] = 'gotoPC'
+                        cmd['goto'] = 0
+                        cmd['debug'] = False
+                        self.addCommand(cmd)
+                        self.compileOne()
+                        cmd = {}
+                        cmd['domain'] = 'core'
+                        cmd['lino'] = command['lino']
+                        cmd['keyword'] = 'stop'
+                        cmd['debug'] = False
+                        self.addCommand(cmd)
+                        # Fixup the link
+                        self.getCommandAt(pcNext)['goto'] = self.getPC()
+                        return True
         return False
 
     def r_on(self, command):
         key = self.getRuntimeValue(command['key'])
-        pc = command['goto']
-        self.eventHandlers[key] = lambda: self.run(pc)
+        window = self.getVariable(command['window'])
+        window['eventHandlers'][key] = lambda: self.run(command['goto'])
         return self.nextPC()
 
     def k_popup(self, command):
@@ -221,13 +257,14 @@ class Graphics(Handler):
                 return value
             return None
 
+        if self.getToken() == 'the':
+            self.nextToken()
+
+        token = self.getToken()
         value['type'] = token
 
-        if token == 'test':
-            value = {}
-            value['type'] = 'text'
-            value['content'] = 'test'
-            return value
+        if token == 'event':
+           return value
 
         return None
 
@@ -246,7 +283,9 @@ class Graphics(Handler):
         else:
             return None
 
-    def v_test(self, v):
+    def v_event(self, v):
+        v['type'] = 'text'
+        v['content'] = self.eventValues
         return v
 
     #############################################################################
@@ -261,13 +300,15 @@ class Graphics(Handler):
     #############################################################################
     # The main loop
     def mainLoop(self):
+        windowRecord = self.program.windowRecord
+        window = windowRecord['window']
+        eventHandlers = windowRecord['eventHandlers']
         while True:
-            event, values = self.program.window.Read(timeout=100)
+            event, values = window.Read(timeout=100)
             if event == psg.WINDOW_CLOSED or event == "EXIT":
                 break
             if event == '__TIMEOUT__': self.program.flushCB()
             else:
-                if event in self.eventHandlers:
+                if event in eventHandlers:
                     self.eventValues = values
-                    self.eventHandlers[event]()
-
+                    eventHandlers[event]()

easycoder/ec_gutils.py

@@ -21,14 +21,28 @@ class GUtils:
     # Get the default args for a graphic element
     def getDefaultArgs(self, type):
         args = {}
-        if type == 'Text':
-            args['text'] = '(empty)'
+        if type == 'Button':
+            args['button_text'] = '(empty)'
+            args['size'] = (None, None)
+        if type == 'Checkbox':
+            args['text'] = ''
+            args['key'] = None
+            args['size'] = (None, None)
+            args['expand_x'] = False
+        elif type == 'Column':
             args['expand_x'] = False
+            args['pad'] = (0, 0)
         elif type == 'Input':
             args['key'] = None
             args['size'] = (None, None)
-        elif type == 'Button':
-            args['button_text'] = '(empty)'
+        elif type == 'Multiline':
+            args['default_text'] = ''
+            args['key'] = None
+            args['size'] = (None, None)
+        elif type == 'Text':
+            args['text'] = '(empty)'
+            args['size'] = (None, None)
+            args['expand_x'] = False
         return args
 
     # Decode an argument at runtime
@@ -42,11 +56,29 @@ class GUtils:
         return None
 
     # Create an element
-    def createElement(self, type, args):
-        if type == 'Text': return psg.Text(text=args['text'], expand_x=args['expand_x'])
+    def createElement(self, type, param, args):
+        if type == 'Button':
+            size = self.getSize(args)
+            return psg.Button(button_text=args['button_text'], size=size)
+        if type == 'Checkbox':
+            size = self.getSize(args)
+            return psg.Checkbox(args['text'], key=args['key'], expand_x=args['expand_x'], size=size)
+        if type == 'Column':
+            return psg.Column(param, expand_x=args['expand_x'], pad=args['pad'])
         elif type == 'Input':
-            size = args['size'].split()
-            size = (size[0], size[1])
+            size = self.getSize(args)
             return psg.Input(key=args['key'], size=size)
-        elif type == 'Button': return psg.Button(button_text=args['button_text'])
+        elif type == 'Multiline':
+            size = self.getSize(args)
+            return psg.Multiline(default_text=args['default_text'], key=args['key'], size=size)
+        elif type == 'Text':
+            size = self.getSize(args)
+            return psg.Text(text=args['text'], size=size, expand_x=args['expand_x'])
         else: return None
+
+    def getSize(self, args):
+        size = args['size']
+        if size == (None, None):
+            return size
+        size = size.split()
+        return (size[0], size[1])

easycoder/ec_program.py

@@ -127,7 +127,7 @@ class Program:
 
 	def doValue(self, value):
 		if value == None:
-			FatalError(self.compiler, f'Undefined value (variable not initialized?)')
+			RuntimeError(self, f'Undefined value (variable not initialized?)')
 
 		result = {}
 		valType = value['type']
@@ -150,7 +150,7 @@ class Program:
 			name = value['name']
 			symbolRecord = self.getSymbolRecord(name)
 			if symbolRecord['value'] == [None]:
-				RuntimeWarning(self.program, f'Variable "{name}" has no value')
+				RuntimeWarning(self, f'Variable "{name}" has no value')
 				return None
 			handler = self.domainIndex[symbolRecord['domain']].valueHandler('symbol')
 			result = handler(symbolRecord)

{easycoder-250116.4.dist-info → easycoder-250118.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easycoder
-Version: 250116.4
+Version: 250118.2
 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>

easycoder-250118.2.dist-info/RECORD

@@ -0,0 +1,17 @@
+easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
+easycoder/__init__.py,sha256=4mEv6h3EwPm3vhSmcaK94mJyEK-iZApgf69_QjY8w0k,262
+easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
+easycoder/ec_compiler.py,sha256=dFJEA_uOhD-HeSiAdBzmmA6q3LHThUVoJpSETanmSHs,4800
+easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
+easycoder/ec_core.py,sha256=t4snx4DPIPvj1sLE7uPCrikGZaLajc5Rsq8M_RJiOIw,86727
+easycoder/ec_graphics.py,sha256=W2IE6vCg5h8HPjxuaJQ4ftqCNnhwAnX5CSaeHi0nEG0,11239
+easycoder/ec_gutils.py,sha256=6vO0yJbWc4sYMp2wR8LAwF4CZc5yqYERFfXUnHnFZxU,2819
+easycoder/ec_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
+easycoder/ec_program.py,sha256=R8zMukA-pfRsOpcy9WqTw7fE_190dQfrMt2la23Yrs4,9904
+easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
+easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
+easycoder-250118.2.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250118.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250118.2.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+easycoder-250118.2.dist-info/METADATA,sha256=8EQtFh11Y7TD_fQnHjjFdazmOK2hoM2UB2DcuATTo7s,6162
+easycoder-250118.2.dist-info/RECORD,,

easycoder-250116.4.dist-info/RECORD

@@ -1,17 +0,0 @@
-easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
-easycoder/__init__.py,sha256=7P--K2LPePX1pCo332aXacQgLD3I3uHKC3Qr56PA15o,262
-easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
-easycoder/ec_compiler.py,sha256=dFJEA_uOhD-HeSiAdBzmmA6q3LHThUVoJpSETanmSHs,4800
-easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
-easycoder/ec_core.py,sha256=yO7d5OyEFHBDGKSaC1Fhf1uGjzsttAl6VCvR1W5X5YE,86279
-easycoder/ec_graphics.py,sha256=sjSB7K66oVB4gn8Byjlfs-qPUFoSNVbvK_0plPHI7dI,9423
-easycoder/ec_gutils.py,sha256=9bjRCTBBSCEy6Z3pSkTaZIn_foWKZ79h6pswkLqCti4,1612
-easycoder/ec_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
-easycoder/ec_program.py,sha256=wU-vWRWAYK2Ie4EFnp8HeSPUL0bxz-j9HLQSNplObcc,9919
-easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
-easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
-easycoder-250116.4.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-250116.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-250116.4.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
-easycoder-250116.4.dist-info/METADATA,sha256=n5ZHkO3yF44XFEsO-x0DpIQBgmAT4XA0nZW7pG3DZ50,6162
-easycoder-250116.4.dist-info/RECORD,,