easycoder 250317.3__py2.py3-none-any.whl → 250403.1__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__ = "250317.3"
+__version__ = "250403.1"

easycoder/__init__.sync-conflict-20250331-210244-M3XB3VD.py

@@ -0,0 +1,12 @@
+'''EasyCoder for Python'''
+
+from .ec_classes import *
+from .ec_compiler import *
+from .ec_condition import *
+from .ec_core import *
+from .ec_handler import *
+from .ec_program import *
+from .ec_timestamp import *
+from .ec_value import *
+
+__version__ = "250302.1"

easycoder/ec_core.py

@@ -1,4 +1,4 @@
-import json, math, hashlib, threading, os, subprocess, sys, requests, time, numbers, base64, binascii
+import json, math, hashlib, threading, os, subprocess, sys, requests, time, numbers, base64, binascii, random
 from psutil import Process
 from datetime import datetime, timezone
 from random import randrange
@@ -144,7 +144,7 @@ class Core(Handler):
         else:
             return self.compileFromHere(['end'])
 
-    # Clear (set False)
+    # Clear (set false)
     # clear {variable}
     def k_clear(self, command):
         if self.nextIsSymbol():
@@ -405,36 +405,40 @@ class Core(Handler):
             else:
                 FatalError(self.compiler, f'Variable "{symbolRecord["name"]}" does not hold a value')
         if self.nextIs('from'):
-            command['url'] = self.nextValue()
-        command['or'] = None
-        get = self.getPC()
-        if self.peek() == 'timeout':
-            self.nextToken()
-            command['timeout'] = self.nextValue()
-        else:
-            timeout = {}
-            timeout['type'] = 'int'
-            timeout['content'] = 5
-            command['timeout'] = timeout
-        self.addCommand(command)
-        if self.peek() == 'or':
-            self.nextToken()
-            self.nextToken()
-            # Add a 'goto' to skip the 'or'
-            cmd = {}
-            cmd['lino'] = command['lino']
-            cmd['domain'] = 'core'
-            cmd['keyword'] = 'gotoPC'
-            cmd['goto'] = 0
-            cmd['debug'] = False
-            skip = self.getPC()
-            self.addCommand(cmd)
-            # Process the 'or'
-            self.getCommandAt(get)['or'] = self.getPC()
-            self.compileOne()
-            # Fixup the skip
-            self.getCommandAt(skip)['goto'] = self.getPC()
-        return True
+            if self.nextIs('url'):
+                url = self.nextValue()
+                if url != None:
+                    command['url'] = url
+                    command['or'] = None
+                    get = self.getPC()
+                    if self.peek() == 'timeout':
+                        self.nextToken()
+                        command['timeout'] = self.nextValue()
+                    else:
+                        timeout = {}
+                        timeout['type'] = 'int'
+                        timeout['content'] = 5
+                        command['timeout'] = timeout
+                    self.addCommand(command)
+                    if self.peek() == 'or':
+                        self.nextToken()
+                        self.nextToken()
+                        # Add a 'goto' to skip the 'or'
+                        cmd = {}
+                        cmd['lino'] = command['lino']
+                        cmd['domain'] = 'core'
+                        cmd['keyword'] = 'gotoPC'
+                        cmd['goto'] = 0
+                        cmd['debug'] = False
+                        skip = self.getPC()
+                        self.addCommand(cmd)
+                        # Process the 'or'
+                        self.getCommandAt(get)['or'] = self.getPC()
+                        self.compileOne()
+                        # Fixup the skip
+                        self.getCommandAt(skip)['goto'] = self.getPC()
+                    return True
+        return False
 
     def r_get(self, command):
         global errorCode, errorReason
@@ -1414,6 +1418,33 @@ class Core(Handler):
 
         return self.nextPC()
 
+    # Shuffle a list
+    def k_shuffle(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['valueHolder']:
+                command['target'] = self.getToken()
+                self.add(command)
+                return True
+            self.warning(f'Core.negate: Variable "{symbolRecord["name"]}" does not hold a value')
+        return False
+
+    def r_shuffle(self, command):
+        symbolRecord = self.getVariable(command['target'])
+        if not symbolRecord['valueHolder']:
+            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
+            return None
+        value = self.getSymbolValue(symbolRecord)
+        if value == None:
+            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
+        content = value['content']
+        if isinstance(content, list):
+            random.shuffle(content)
+            value['content'] = content
+            self.putSymbolValue(symbolRecord, value)
+            return self.nextPC()
+        RuntimeError(self.program, f'{symbolRecord["name"]} is not a list')
+
     # Declare a stack variable
     def k_stack(self, command):
         return self.compileVariable(command)
@@ -2389,17 +2420,11 @@ class Core(Handler):
 
         if self.getToken() == 'file':
             path = self.nextValue()
-            if self.nextIs('exists'):
+            if self.peek() == 'exists':
                 condition.type = 'exists'
                 condition.path = path
+                self.nextToken()
                 return condition
-            if self.nextIs('does'):
-                if self.nextIs('not'):
-                    if self.nextIs('exist'):
-                        condition.type = 'exists'
-                        condition.path = path
-                        condition.negate = not condition.negate
-                        return condition
             return None
 
         value = self.getValue()
@@ -2493,13 +2518,10 @@ class Core(Handler):
 
     def c_empty(self, condition):
         value = self.getRuntimeValue(condition.value1)
-        if type(value) == dict:
-            comparison = len(value) == 0
+        if value == None:
+            comparison = True
         else:
-            if value == None:
-                comparison = True
-            else:
-                comparison = len(value) == 0
+            comparison = len(value) == 0
         return not comparison if condition.negate else comparison
 
     def c_ends(self, condition):