easycoder 250116.1__tar.gz → 250116.3__tar.gz

{easycoder-250116.1 → easycoder-250116.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easycoder
-Version: 250116.1
+Version: 250116.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>
@@ -22,15 +22,30 @@ Website: [https://easycoder.github.io](https://easycoder.github.io)
 ## Quick Start
 Install **_EasyCoder_** in your Python environment:
 ```
-pip install easycoder
+pip install requests pytz easycoder
 ```
-You may also need to install `pytz`, as some commands need it.
 
-Write a test script, 'hello.ecs', containing the following:
+Test the install by typing the command `easycoder`.
+<hr>
+On Linux, this will probably fail as the installer places the executable file in the `$HOME/.local/bin` directory. So give the command
+```
+    export PATH=$HOME/.local/bin:$PATH
+```
+
+To make this change permanent, edit your `.profile` file, adding the following:
+```
+# set PATH so it includes user's private .local/bin if it exists
+if [ -d "$HOME/.local/bin" ] ; then
+    PATH="$HOME/.local/bin:$PATH"
+fi
+```
+<hr>
+
+Now write a test script, 'hello.ecs', containing the following:
 ```
 print `Hello, world!`
 ```
-This is traditionally the first program to be written in virtually any language. To run it, use `easycoder hello.ecs`.
+(Note the backticks.) This is traditionally the first program to be written in virtually any language. To run it, use `easycoder hello.ecs`.
 
 The output will look like this (the version number will differ):
 ```
@@ -63,19 +78,18 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `benchmark.ecs` allows the performance of **_EasyCoder_** to be compared to other languages if a similar script is written for each one.
 
 ## Graphical programmming
-**_EasyCoder_** includes a graphical programming environment that is in the early stages of development. A couple of demo scripts are included in the `scripts` directory. To run them, first install the Python `kivy` graphics library if it's not already present on your system. This is done with `pip install kivy`. Then run your **_EasyCoder_** script using `easycoder {scriptname}.ecg`.
-
-Graphical scripts look much like any other script but their file names must use the extension `.ecg` to signal to **_EasyCoder_** that it needs to load the graphics module. Non-graphical applications can use any extension but `.ecs` is recommended. This allows the **_EasyCoder_** application to be used wherever Python is installed, in either a command-line or a graphical environment, but graphics will of course not be available in the former.
-
-Some demo graphical scripts are included in the `scripts` directory:
+**_EasyCoder_** includes a graphical programming environment that is in the early stages of development. Some demo scripts will be included in the `scripts` directory; these can be recognised by the extension`.ecg`. To run them, first install `tkinter`. On Linux this is done with
+```
+    sudo apt install python3-tk
+```
 
-`graphics-demo.ecg` shows some of the elements that can be created, and demonstrates a variety of the graphical features of the language such as detecting when elements are clicked.
+Next, install the Python `pySimpleGUI` graphics library; this is done with `pip install pysimplegui`. Then run your **_EasyCoder_** script using `easycoder {scriptname}.ecg`.
 
-`wave.ecg` is a "Mexican Wave" simulation.
+Graphical scripts look much like any other script but their file names must use the extension `.ecg` to signal to **_EasyCoder_** that it needs to load the graphics module. Non-graphical applications can use any extension but `.ecs` is recommended. This allows the **_EasyCoder_** application to be used wherever Python is installed, in either a command-line or a graphical environment, but graphics will of course not be available in the former.
 
-`keyboard.ecg` creates an on-screen keyboard (currently a 4-function calculator keypad) that responds to clicks on its keys. It uses a plugin module (see below) to add extra vocabulary and syntax to the language. This is currently under development so its features are likely to change. The intention is to support a wide range of keyboard styles with the minimum mount of coding. The plugin (`ec_keyword.py`) can be downloaded from the repository.
+Some demo graphical scripts will included in the `scripts` directory as development proceeds.
 
-**_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs. The renderer works with JSON-formatted specifications of the itens to be displayed.
+`gtest.ecg` contains sample code to demonstrate and test basic features.
 
 ## Significant features
 

{easycoder-250116.1 → easycoder-250116.3}/README.md

@@ -11,15 +11,30 @@ Website: [https://easycoder.github.io](https://easycoder.github.io)
 ## Quick Start
 Install **_EasyCoder_** in your Python environment:
 ```
-pip install easycoder
+pip install requests pytz easycoder
 ```
-You may also need to install `pytz`, as some commands need it.
 
-Write a test script, 'hello.ecs', containing the following:
+Test the install by typing the command `easycoder`.
+<hr>
+On Linux, this will probably fail as the installer places the executable file in the `$HOME/.local/bin` directory. So give the command
+```
+    export PATH=$HOME/.local/bin:$PATH
+```
+
+To make this change permanent, edit your `.profile` file, adding the following:
+```
+# set PATH so it includes user's private .local/bin if it exists
+if [ -d "$HOME/.local/bin" ] ; then
+    PATH="$HOME/.local/bin:$PATH"
+fi
+```
+<hr>
+
+Now write a test script, 'hello.ecs', containing the following:
 ```
 print `Hello, world!`
 ```
-This is traditionally the first program to be written in virtually any language. To run it, use `easycoder hello.ecs`.
+(Note the backticks.) This is traditionally the first program to be written in virtually any language. To run it, use `easycoder hello.ecs`.
 
 The output will look like this (the version number will differ):
 ```
@@ -52,19 +67,18 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `benchmark.ecs` allows the performance of **_EasyCoder_** to be compared to other languages if a similar script is written for each one.
 
 ## Graphical programmming
-**_EasyCoder_** includes a graphical programming environment that is in the early stages of development. A couple of demo scripts are included in the `scripts` directory. To run them, first install the Python `kivy` graphics library if it's not already present on your system. This is done with `pip install kivy`. Then run your **_EasyCoder_** script using `easycoder {scriptname}.ecg`.
-
-Graphical scripts look much like any other script but their file names must use the extension `.ecg` to signal to **_EasyCoder_** that it needs to load the graphics module. Non-graphical applications can use any extension but `.ecs` is recommended. This allows the **_EasyCoder_** application to be used wherever Python is installed, in either a command-line or a graphical environment, but graphics will of course not be available in the former.
-
-Some demo graphical scripts are included in the `scripts` directory:
+**_EasyCoder_** includes a graphical programming environment that is in the early stages of development. Some demo scripts will be included in the `scripts` directory; these can be recognised by the extension`.ecg`. To run them, first install `tkinter`. On Linux this is done with
+```
+    sudo apt install python3-tk
+```
 
-`graphics-demo.ecg` shows some of the elements that can be created, and demonstrates a variety of the graphical features of the language such as detecting when elements are clicked.
+Next, install the Python `pySimpleGUI` graphics library; this is done with `pip install pysimplegui`. Then run your **_EasyCoder_** script using `easycoder {scriptname}.ecg`.
 
-`wave.ecg` is a "Mexican Wave" simulation.
+Graphical scripts look much like any other script but their file names must use the extension `.ecg` to signal to **_EasyCoder_** that it needs to load the graphics module. Non-graphical applications can use any extension but `.ecs` is recommended. This allows the **_EasyCoder_** application to be used wherever Python is installed, in either a command-line or a graphical environment, but graphics will of course not be available in the former.
 
-`keyboard.ecg` creates an on-screen keyboard (currently a 4-function calculator keypad) that responds to clicks on its keys. It uses a plugin module (see below) to add extra vocabulary and syntax to the language. This is currently under development so its features are likely to change. The intention is to support a wide range of keyboard styles with the minimum mount of coding. The plugin (`ec_keyword.py`) can be downloaded from the repository.
+Some demo graphical scripts will included in the `scripts` directory as development proceeds.
 
-**_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs. The renderer works with JSON-formatted specifications of the itens to be displayed.
+`gtest.ecg` contains sample code to demonstrate and test basic features.
 
 ## Significant features
 

{easycoder-250116.1 → easycoder-250116.3}/easycoder/__init__.py

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

{easycoder-250116.1 → easycoder-250116.3}/easycoder/ec_compiler.py

@@ -98,11 +98,11 @@ class Compiler:
 		return self.tokens[self.index].lino
 
 	def warning(self, message):
-		self.warnings.append(message)
+		self.warnings.append(f'Warning at line {self.getLino() + 1} of {self.program.name}: {message}')
 
 	def showWarnings(self):
 		for warning in self.warnings:
-			print(f'Warning at line {self.getLino() + 1} of {self.program.name}: {warning}')
+			print(warning)
 
 	def getSymbolRecord(self):
 		token = self.getToken()

{easycoder-250116.1 → easycoder-250116.3}/easycoder/ec_graphics.py

@@ -9,6 +9,7 @@ class Graphics(Handler):
     def __init__(self, compiler):
         Handler.__init__(self, compiler)
         self.utils = GUtils()
+        self.eventHandlers = {}
 
     def getName(self):
         return 'graphics'
@@ -18,17 +19,18 @@ class Graphics(Handler):
 
     def k_add(self, command):
         elements = []
-        while True:
-            if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                name = symbolRecord['name']
-                if 'iselement' in symbolRecord:
-                    elements.append(name)
-                    if self.peek() != 'and': break
-                else: FatalError(self.program.compiler, f'"{name}" is not a graphic element')
-            else: FatalError(self.program.compiler, f'Element expected; got "{self.getToken()}"')
-            self.nextToken()
-        command['elements'] = json.dumps(elements)
+        token = self.nextToken()
+        if self.isSymbol():
+            symbolRecord = self.getSymbolRecord()
+            name = symbolRecord['name']
+            if symbolRecord['keyword'] == 'layout':
+                elements.append(name)
+                command['args'] = name
+            else: FatalError(self.compiler.program, f'\'{name}\' is not a layout')
+        elif token[0:2] == 'g_':
+            command['type'] = token
+            command['args'] = self.utils.getArgs(self)
+        else: return False
         if self.nextIs('to'):
             if self.nextIsSymbol():
                 symbolRecord = self.getSymbolRecord()
@@ -40,14 +42,36 @@ class Graphics(Handler):
 
     def r_add(self, command):
         target = self.getVariable(command['target'])
-        elements = json.loads(command['elements'])
+        type = command['type']
+        args = command['args']
         if not 'layout' in target:
             target['layout'] = []
-        for element in elements:
-            v = self.getVariable(element)
+        if args[0] == '{':
+            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))
+        else:
+            v = self.getVariable(args)
             target['layout'].append(v['layout'])
         return self.nextPC()
 
+    def k_capture(self, command):
+        if self.nextIs('event'):
+            if self.nextIs('as'):
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    command['target'] = record['name']
+                    self.addCommand(command)
+                    return True
+        return False
+
+    def r_capture(self, command):
+        target = self.getVariable(command['target'])
+        self.putSymbolValue(target, self.getConstant(self.eventValues))
+        return self.nextPC()
+
     def k_close(self, command):
         if self.nextIsSymbol():
             symbolRecord = self.getSymbolRecord()
@@ -79,10 +103,6 @@ class Graphics(Handler):
                             command['layout'] = symbolRecord['name']
                             self.addCommand(command)
                             return True
-            elif type[0:2] == 'g_':
-                command['args'] = self.compileConstant(self.utils.getArgs(self))
-                self.addCommand(command)
-                return True
         return False
 
     def r_create(self, command):
@@ -96,79 +116,10 @@ class Graphics(Handler):
             self.mainLoop()
             self.program.kill()
             return 0
-        elif 'iselement' in record:
-            layout = json.loads(self.getRuntimeValue(command['args']))
-            args = self.utils.getDefaultArgs(type)
-            content = json.loads(layout['content'])
-            for n in range(0, len(content)):
-                args = self.utils.decode(args, content[n])
-            element = self.utils.createElement(type, args)
-            record['layout'] = element
-            return self.nextPC()
         else:
             RuntimeError(self.program, 'Variable is not a window or an element')
 
-    def k_g_button(self, command):
-        command['iselement'] = True
-        return self.compileVariable(command)
-
-    def r_g_button(self, command):
-        return self.nextPC()
-
-    def k_g_input(self, command):
-        command['iselement'] = True
-        return self.compileVariable(command)
-
-    def r_g_input(self, command):
-        return self.nextPC()
-
-    def k_g_text(self, command):
-        command['iselement'] = True
-        return self.compileVariable(command)
-
-    def r_g_text(self, command):
-        return self.nextPC()
-
-    def k_init(self, command):
-        if self.nextIsSymbol():
-            record = self.getSymbolRecord()
-            if record['keyword'] == 'layout':
-                command['target'] = record['name']
-                if self.peek() == 'with':
-                    self.nextToken()
-                    if self.nextIsSymbol():
-                        record = self.getSymbolRecord()
-                        name = record['name']
-                        if record['iselement']:
-                            command['args'] = name
-                        else: FatalError(self.program.compiler, f'\'{name}\' is not a graphic element')
-                    else:
-                        command['type'] = self.getToken()
-                        command['args'] = self.utils.getArgs(self)
-                else: command['args'] = None
-                self.addCommand(command)
-                return True
-            return False
-
-    def r_init(self, command):
-        record = self.getVariable(command['target'])
-        record['layout'] = []
-        type = command['type']
-        args = command['args']
-        if args != None:
-            if args[0] == '{':
-                layout = json.loads(self.getRuntimeValue(json.loads(args)))
-                args = self.utils.getDefaultArgs(type)
-                for n in range(0, len(layout)):
-                    args = self.utils.decode(args, layout[n])
-                record['layout'].append(self.utils.createElement(type, args))
-            else:
-                v = self.getVariable(args)
-                record['layout'].append(v['layout'])
-        return self.nextPC()
-
     def k_layout(self, command):
-        command['iselement'] = True
         return self.compileVariable(command)
 
     def r_layout(self, command):
@@ -176,42 +127,8 @@ class Graphics(Handler):
 
     def k_on(self, command):
         token = self.nextToken()
-        command['type'] = token
-        if token == 'click':
-            command['event'] = token
-            if self.peek() == 'in':
-                self.nextToken()
-            if self.nextIs('screen'):
-                command['target'] = None
-            elif self.isSymbol():
-                target = self.getSymbolRecord()
-                command['target'] = target['name']
-            else:
-                FatalError(self.program.compiler, f'{self.getToken()} is not a screen element')
-                return False
-            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
-        elif token == 'tick':
-            command['event'] = token
+        if token == 'event':
+            command['key'] = self.nextValue()
             command['goto'] = self.getPC() + 2
             self.add(command)
             self.nextToken()
@@ -236,17 +153,9 @@ class Graphics(Handler):
         return False
 
     def r_on(self, command):
+        key = self.getRuntimeValue(command['key'])
         pc = command['goto']
-        if command['type'] == 'click':
-            event = command['event']
-            if event == 'click':
-                target = command['target']
-                if target == None:
-                    value = 'screen'
-                else:
-                    widget = self.getVariable(target)
-                value = widget['value'][widget['index']]
-                self.renderer.setOnClick(value['content'], lambda: self.run(pc))
+        self.eventHandlers[key] = lambda: self.run(pc)
         return self.nextPC()
 
     def k_popup(self, command):
@@ -259,9 +168,37 @@ class Graphics(Handler):
         return self.nextPC()
 
     def k_set(self, command):
-        return True
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            keyword = record['keyword']
+            if keyword == 'layout':
+                command['target'] = record['name']
+                if self.peek() == 'to':
+                    self.nextToken()
+                    command['type'] = self.nextToken()
+                    command['args'] = self.utils.getArgs(self)
+                else: command['args'] = None
+                self.addCommand(command)
+                return True
+            elif keyword == 'event':
+                pass
+            return False
 
     def r_set(self, command):
+        target = self.getVariable(command['target'])
+        target['layout'] = []
+        type = command['type']
+        args = command['args']
+        if args != None:
+            if args[0] == '{':
+                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))
+            else:
+                v = self.getVariable(args)
+                target['layout'].append(v['layout'])
         return self.nextPC()
 
     def k_window(self, command):
@@ -274,19 +211,20 @@ class Graphics(Handler):
     # Compile a value in this domain
     def compileValue(self):
         value = {}
-        value['domain'] = 'graphics'
+        value['domain'] = self.getName()
         token = self.getToken()
         if self.isSymbol():
+            value['name'] = token
+            symbolRecord = self.getSymbolRecord()
+            keyword = symbolRecord['keyword']
+            if keyword == 'event':
+                value['type'] = 'symbol'
+                return value
             return None
 
-        if self.tokenIs('the'):
-            self.nextToken()
-        token = self.getToken()
-
         value['type'] = token
 
         if token == 'test':
-            name = self.nextToken()
             value = {}
             value['type'] = 'text'
             value['content'] = 'test'
@@ -302,6 +240,13 @@ class Graphics(Handler):
     #############################################################################
     # Value handlers
 
+    # This is used by the expression evaluator to get the value of a symbol
+    def v_symbol(self, symbolRecord):
+        if symbolRecord['keyword'] == 'event':
+            return self.getSymbolValue(symbolRecord)
+        else:
+            return None
+
     def v_test(self, v):
         return v
 
@@ -323,4 +268,7 @@ class Graphics(Handler):
                 break
             if event == '__TIMEOUT__': self.program.flushCB()
             else:
-                print(event, values)
+                if event in self.eventHandlers:
+                    self.eventValues = values
+                    self.eventHandlers[event]()
+

easycoder-250116.3/scripts/testg.ecg

@@ -0,0 +1,48 @@
+!	A test script
+
+	script Test
+
+    layout Row
+    layout Layout
+    window Window
+    variable Event
+    variable N
+
+    popup `Hello!`
+!    debug step
+
+    set Row to g_text text `Date (YYYY-MM-DD):` and expand_x true
+    add g_input key `-DATE-` and size `20 1` to Row
+    add Row to Layout
+
+    set Row to g_text text `Time (HH:MM):` and expand_x true
+    add g_input key `-TIME-` and size `20 1` to Row
+    add Row to Layout
+
+    set Row to g_text text `Your name:` and expand_x true
+    add g_input key `-NAME-` and size `20 1` to Row
+    add Row to Layout
+
+    set Row to g_button button_text `Click me`
+    add Row to Layout
+
+    create Window `Graphics Test`
+        layout Layout
+
+    on event `Click me`
+    begin
+        capture event as Event
+        print `Date: ` cat property `-DATE-` of Event
+        print `Time: ` cat property `-TIME-` of Event
+        print `Name: ` cat property `-NAME-` of Event
+    end
+
+    put 0 into N
+    while true
+    begin
+        if N modulo 1000 is 0 print `Running ` cat N
+        increment N
+        wait 10 ticks
+    end
+
+    stop

easycoder-250116.1/scripts/testg.ecg

@@ -1,44 +0,0 @@
-!	A test script
-
-	script Test
-
-    layout Row
-    layout Layout
-    window Window
-    g_input Input
-    g_button Button
-    variable N
-
-    init Layout
-
-!    popup `Hello!`
-!    debug step
-
-    init Row with g_text text `Date (YYYY-MM-DD):` and expand_x true
-    create Input key `-DATE-` and size `20 1`
-    add Input to Row
-    add Row to Layout
-    init Row with g_text text `Time (HH:MM):` and expand_x true
-    create Input key `-TIME-` and size `20 1`
-    add Input to Row
-    add Row to Layout
-    init Row with g_text text `Your name:` and expand_x true
-    create Input key `-NAME-` and size `20 1`
-    add Input to Row
-    add Row to Layout
-    create Button button_text `Click me`
-    init Row with Button
-    add Row to Layout
-
-    create Window `Graphics Test`
-        layout Layout
-
-    put 0 into N
-    while true
-    begin
-        if N modulo 1000 is 0 print `Running ` cat N
-        increment N
-        wait 10 ticks
-    end
-
-    stop