easycoder 251022.1__tar.gz → 251103.2__tar.gz

easycoder-251103.2/.github/copilot-instructions.md

@@ -0,0 +1,112 @@
+# EasyCoder-py AI Assistant Instructions
+
+This guide helps AI coding assistants understand and work effectively with the EasyCoder-py codebase.
+
+## Project Overview
+
+EasyCoder-py is a high-level English-like domain-specific scripting language (DSL) implemented in Python. Key characteristics:
+
+- English-like syntax focused on vocabulary rather than structure
+- Command-line based with an emerging graphics module using PySide6
+- Acts as a wrapper around standard Python functions
+- Extensible through plugin modules
+- Suitable for prototyping, rapid testing, and control systems
+
+## Core Architecture
+
+### Main Components:
+
+1. Core Language (`easycoder/`)
+   - `ec_compiler.py`: Handles script compilation
+   - `ec_program.py`: Manages program execution
+   - `ec_core.py`: Core language features
+   - `ec_value.py`: Value handling
+   - `ec_condition.py`: Condition processing
+
+2. Plugin System (`plugins/`)
+   - Seamlessly extends language functionality
+   - Example: `points.py` demonstrates coordinate handling
+
+3. Documentation (`doc/`)
+   - Core features in `doc/core/`
+   - Graphics features in `doc/graphics/`
+   - Each keyword/value/condition documented separately
+
+## Development Workflows
+
+### Testing
+
+1. Run the comprehensive test suite:
+```bash
+easycoder scripts/tests.ecs
+```
+
+2. Performance benchmarking:
+```bash
+easycoder scripts/benchmark.ecs
+```
+
+### Script Development
+
+1. Basic script structure:
+```
+script ScriptName
+    ! Your code here
+    exit
+```
+
+2. Debugging:
+- Use `log` instead of `print` for timestamped debug output
+- Example: `log 'Debug message'` outputs with timestamp and line number
+
+## Project Conventions
+
+1. Script Files
+- Extension: `.ecs`
+- Always include `exit` command to properly terminate
+- Use `script Name` to identify scripts for debugging
+
+2. Plugin Development
+- Place new plugins in `plugins/` directory
+- Must provide both compiler and runtime modules
+- See `plugins/points.py` for reference implementation
+
+3. Documentation
+- Place in `doc/` with appropriate subdirectory
+- One markdown file per language feature
+- Include syntax, parameters, and examples
+
+## Common Patterns
+
+1. Error Handling
+```
+on error
+    log error
+    exit
+```
+
+2. Variable Declaration
+```
+variable Name
+set Name to Value
+```
+
+3. Plugin Integration
+```
+use plugin-name
+! Plugin-specific commands
+```
+
+## Key Integration Points
+
+1. Python Integration
+- EasyCoder wraps Python functionality
+- Custom plugins can wrap any Python library with suitable API
+- Direct Python integration via `system` command
+
+2. Graphics (PySide6)
+- Graphics module under active development
+- See `doc/graphics/` for current features
+- Uses plugin system for seamless integration
+
+Remember: Focus on English-like syntax and readability when writing or modifying code. Keep scripts as readable as natural language where possible.

{easycoder-251022.1 → easycoder-251103.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easycoder
-Version: 251022.1
+Version: 251103.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-251022.1 → easycoder-251103.2}/easycoder/__init__.py

@@ -12,4 +12,4 @@ from .ec_pyside import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "251022.1"
+__version__ = "251103.2"

{easycoder-251022.1 → easycoder-251103.2}/easycoder/ec_compiler.py

@@ -78,7 +78,10 @@ class Compiler:
 		return self.program.code[pc]
 
 	# Add a command to the code list
-	def add(self, command):
+	def addCommand(self, command):
+		if len(self.code) == 0:
+			if self.program.usingGraphics:
+				pass
 		self.code.append(command)
 
 	def isSymbol(self):
@@ -161,7 +164,7 @@ class Compiler:
 		command['locked'] = False
 		command['extra'] = extra
 		if 'keyword' in command: command['hasValue'] = self.hasValue(command['keyword'])
-		self.add(command)
+		self.addCommand(command)
 		return True
 
 	# Compile the current token
@@ -209,7 +212,7 @@ class Compiler:
 		self.index = index
 		while True:
 			token = self.tokens[self.index]
-			keyword = token.token
+#			keyword = token.token
 			if self.debugCompile: print(self.script.lines[token.lino])
 #			if keyword != 'else':
 			if self.compileOne() == True:
@@ -223,3 +226,6 @@ class Compiler:
 
 	def compileFromHere(self, stopOn):
 		return self.compileFrom(self.getIndex(), stopOn)
+
+	def compileFromStart(self):
+		return self.compileFrom(0, [])

{easycoder-251022.1 → easycoder-251103.2}/easycoder/ec_core.py

@@ -1769,12 +1769,17 @@ class Core(Handler):
                 self.program.importPlugin(f'{source}:{clazz}')
                 return True
             return False
-        elif self.nextIs('graphics'):
-            print('Loading graphics module')
-            from .ec_pyside import Graphics
-            self.program.graphics = Graphics
-            self.program.useClass(Graphics)
-            return True
+        else:
+            token = self.nextToken()
+            if token in ['graphics', 'debugger']:
+                if not hasattr(self.program, 'usingGraphics'):
+                    print('Loading graphics module')
+                    from .ec_pyside import Graphics
+                    self.program.graphics = Graphics
+                    self.program.useClass(Graphics)
+                    self.program.usingGraphics = True
+                if token == 'debugger': self.program.debugging = True
+                return True
         return False
 
     # Declare a general-purpose variable
@@ -2657,7 +2662,14 @@ class Core(Handler):
             path = self.nextValue()
             condition.path = path
             condition.type = 'exists'
-            token = self.nextToken()
+            self.skip('on')
+            if self.nextIsSymbol():
+                record = self.getSymbolRecord()
+                if record['keyword'] == 'ssh':
+                    condition.type = 'sshExists'
+                    condition.target = record['name']
+                    token = self.nextToken()
+            else: token = self.getToken()
             if token == 'exists':
                 return condition
             elif token == 'does':
@@ -2841,6 +2853,17 @@ class Core(Handler):
         test = errormsg != None
         return not test if condition.negate else test
 
+    def c_sshExists(self, condition):
+        path = self.getRuntimeValue(condition.path)
+        ssh = self.getVariable(condition.target)
+        sftp = ssh['sftp']
+        try:
+            with sftp.open(path, 'r') as remote_file: remote_file.read().decode()
+            comparison = True
+        except:
+            comparison = False
+        return not comparison if condition.negate else comparison
+
     def c_starts(self, condition):
         value1 = self.getRuntimeValue(condition.value1)
         value2 = self.getRuntimeValue(condition.value2)

{easycoder-251022.1 → easycoder-251103.2}/easycoder/ec_handler.py

@@ -23,7 +23,7 @@ class Handler:
 		self.rewindTo = compiler.rewindTo
 		self.warning = compiler.warning
 		self.getPC = compiler.getPC
-		self.add = compiler.add
+		self.add = compiler.addCommand
 		self.getCommandAt = compiler.getCommandAt
 		self.compileOne = compiler.compileOne
 		self.compileFromHere = compiler.compileFromHere

{easycoder-251022.1 → easycoder-251103.2}/easycoder/ec_program.py

@@ -34,9 +34,9 @@ class Program:
 		self.domainIndex = {}
 		self.name = '<anon>'
 		self.code = []
+		self.pc = 0
 		self.symbols = {}
 		self.onError = 0
-		self.pc = 0
 		self.debugStep = False
 		self.stack = []
 		self.script = Script(source)
@@ -48,7 +48,6 @@ class Program:
 		self.externalControl = False
 		self.ticker = 0
 		self.running = True
-#		self.start()
 
 	# This is called at 10msec intervals by the GUI code
 	def flushCB(self):
@@ -62,7 +61,7 @@ class Program:
 			module['child'] = self
 		startCompile = time.time()
 		self.tokenise(self.script)
-		if self.compiler.compileFrom(0, []):
+		if self.compiler.compileFromStart():
 			finishCompile = time.time()
 			s = len(self.script.lines)
 			t = len(self.script.tokens)

{easycoder-251022.1 → easycoder-251103.2}/easycoder/ec_pyside.py

@@ -70,8 +70,12 @@ class Graphics(Handler):
             ]
     
     def setWidget(self, record, widget):
+        if record['index'] >= record['elements']:
+            RuntimeError(self.program, f'Index out of range for widget {record["name"]}')
         if not 'widget' in record:
             record['widget'] = [None] * record['elements']
+        while len(record['widget']) < record['elements']:
+            record['widget'].append(None)
         record['widget'][record['index']] = widget
     
     def getWidget(self, record):
@@ -832,6 +836,7 @@ class Graphics(Handler):
 
     # Initialize the graphics environment
     def k_init(self, command):
+        # return True
         if self.nextIs('graphics'):
             self.add(command)
             return True
@@ -843,7 +848,22 @@ class Graphics(Handler):
         self.program.screenWidth = screen[0]
         self.program.screenHeight = screen[1]
         print(f'Screen: {self.program.screenWidth}x{self.program.screenHeight}')
-        return self.nextPC()
+        # return self.nextPC()
+        def on_last_window_closed():
+            self.program.kill()
+        def init():
+            self.program.flush(self.nextPC())
+        def flush():
+            if not self.blocked:
+                if self.runOnTick != 0:
+                    self.program.run(self.runOnTick)
+                self.program.flushCB()
+        timer = QTimer()
+        timer.timeout.connect(flush)
+        timer.start(10)
+        QTimer.singleShot(500, init)
+        self.app.lastWindowClosed.connect(on_last_window_closed)
+        self.app.exec()
 
     # Declare a label variable
     def k_label(self, command):
@@ -1363,21 +1383,22 @@ class Graphics(Handler):
         return False
         
     def r_start(self, command):
-        def on_last_window_closed():
-            self.program.kill()
-        def init():
-            self.program.flush(self.nextPC())
-        def flush():
-            if not self.blocked:
-                if self.runOnTick != 0:
-                    self.program.run(self.runOnTick)
-                self.program.flushCB()
-        timer = QTimer()
-        timer.timeout.connect(flush)
-        timer.start(10)
-        QTimer.singleShot(500, init)
-        self.app.lastWindowClosed.connect(on_last_window_closed)
-        self.app.exec()
+        return self.nextPC()
+        # def on_last_window_closed():
+        #     self.program.kill()
+        # def init():
+        #     self.program.flush(self.nextPC())
+        # def flush():
+        #     if not self.blocked:
+        #         if self.runOnTick != 0:
+        #             self.program.run(self.runOnTick)
+        #         self.program.flushCB()
+        # timer = QTimer()
+        # timer.timeout.connect(flush)
+        # timer.start(10)
+        # QTimer.singleShot(500, init)
+        # self.app.lastWindowClosed.connect(on_last_window_closed)
+        # self.app.exec()
 
     # Declare a widget variable
     def k_widget(self, command):