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

easycoder/ec_core.py

@@ -2,7 +2,7 @@ import json, math, hashlib, threading, os, subprocess, sys, requests, time, numb
 from psutil import Process
 from datetime import datetime, timezone
 from random import randrange
-from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, Condition
+from .ec_classes import FatalError, RuntimeWarning, RuntimeError, AssertionError, Condition, Object
 from .ec_handler import Handler
 from .ec_timestamp import getTimestamp
 
@@ -729,6 +729,12 @@ class Core(Handler):
         target['locked'] = True
         return self.nextPC()
 
+    # Log a message
+    def k_log(self, command):
+        command['log'] = True
+        command['keyword'] = 'print'
+        return self.k_print(command)
+
     # Declare a module variable
     def k_module(self, command):
         return self.compileVariable(command)
@@ -995,11 +1001,11 @@ class Core(Handler):
         value = self.getRuntimeValue(command['value'])
         program = command['program']
         code = program.code[program.pc]
-        lino = code['lino'] + 1
-        if value == None:
-            print(f'{lino}-> <empty>')
-        else:
-            print(f'{lino}-> {value}')
+        lino = str(code['lino'] + 1)
+        while len(lino) < 4: lino = f' {lino}'
+        if value == None: value = '<empty>'
+        if 'log' in command: print(f'{datetime.now().time()}: {lino}-> {value}')
+        else: print(value)
         return self.nextPC()
 
     # Push a value onto a stack
@@ -1147,6 +1153,7 @@ class Core(Handler):
         return self.stack.pop()
 
     # Compile and run a script
+    # run {path} [as {module}] [with {variable} [and {variable}...]]
     def k_run(self, command):
         try:
             command['path'] = self.nextValue()
@@ -1157,20 +1164,24 @@ class Core(Handler):
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
                 if record['keyword'] == 'module':
-                    command['module'] = record['name']
-                    exports = []
-                    if self.nextIs('with'):
-                        while True:
-                            name = self.nextToken()
-                            record = self.getSymbolRecord()
-                            exports.append(name)
-                            if self.peek() != 'and':
-                                break
-                            self.nextToken()
-                    command['exports'] = json.dumps(exports)
-                    self.add(command)
-                    return True
-        return False
+                    name = record['name']
+                    command['module'] = name
+                else: RuntimeError(self.program, f'Symbol \'name\' is not a module')
+            else: RuntimeError(self.program, 'Module name expected after \'as\'')
+        else: RuntimeError(self.program, '\'as {module name}\' expected')
+        exports = []
+        if self.peek() == 'with':
+            self.nextToken()
+            while True:
+                name = self.nextToken()
+                record = self.getSymbolRecord()
+                exports.append(name)
+                if self.peek() != 'and':
+                    break
+                self.nextToken()
+        command['exports'] = json.dumps(exports)
+        self.add(command)
+        return True
 
     def r_run(self, command):
         module = self.getVariable(command['module'])
@@ -1734,10 +1745,7 @@ 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')
+                    FatalError(self.program.compiler, 'Variable does not hold a value')
             return None
 
         if token == 'arg':
@@ -2503,7 +2511,7 @@ class Core(Handler):
         return not comparison if condition.negate else comparison
 
     def c_not(self, condition):
-        return not self.getRuntimeValue(condition.value1)
+        return not self.getRuntimeValue(condition.value)
 
     def c_object(self, condition):
         comparison = type(self.getRuntimeValue(condition.value1)) is dict

easycoder/ec_graphics.py

@@ -57,7 +57,10 @@ class Graphics(Handler):
             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])
+                try:
+                    args = self.utils.decode(self, default, layout[n])
+                except Exception as e:
+                    RuntimeError(self.program, e)
             item = self.utils.createElement(type, param, args)
             target['layout'].append(item)
         else:
@@ -125,7 +128,8 @@ class Graphics(Handler):
         if type == 'window':
             layout = self.getVariable(command['layout'])
             title = self.getRuntimeValue(command['title'])
-            record['window'] = psg.Window(title, layout['layout'], finalize=True)
+            window = psg.Window(title, layout['layout'], finalize=True)
+            record['window'] = window
             record['eventHandlers'] = {}
             self.program.windowRecord = record
             self.program.run(self.nextPC())
@@ -202,38 +206,327 @@ class Graphics(Handler):
         psg.popup(self.getRuntimeValue(command['message']))
         return self.nextPC()
 
+    # set property {property} of {key} in {window} to {value}
     def k_set(self, command):
-        if self.nextIsSymbol():
-            record = self.getSymbolRecord()
-            keyword = record['keyword']
+        if self.nextIs('property'):
+            command['property'] = self.nextValue()
+            if self.nextIs('of'):
+                command['key'] = self.nextValue()
+                if self.nextIs('in'):
+                    if self.nextIsSymbol():
+                        record = self.getSymbolRecord()
+                        if record['keyword'] == 'window':
+                            name = record['name']
+                            command['window'] = name
+                            if self.nextIs('to'):
+                                command['value'] = self.nextValue()
+                                self.add(command)
+                            return True
+                        else: RuntimeError(self.program, f'\'{name}\' is not a window variable')
+                    else: RuntimeError(self.program, 'No window variable given')
+        return False
+
+    def r_set(self, command):
+        property = self.getRuntimeValue(command['property'])
+        key = self.getRuntimeValue(command['key'])
+        window = self.program.windowRecord['window']
+        value = self.getRuntimeValue(command['value'])
+        self.utils.updateProperty(window[key], property, value)
+        return self.nextPC()
+
+    def k_window(self, command):
+        return self.compileVariable(command)
+
+    def r_window(self, command):
+        return self.nextPC()
+
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        value = {}
+        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.getToken() == 'the':
+            self.nextToken()
+
+        token = self.getToken()
+        value['type'] = token
+
+        if token == 'event':
+           return value
+
+        return None
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # 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_event(self, v):
+        v['type'] = 'text'
+        v['content'] = self.eventValues
+        return v
+
+    #############################################################################
+    # Compile a condition
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers
+
+    #############################################################################
+    # The main loop
+    def mainLoop(self):
+        windowRecord = self.program.windowRecord
+        window = windowRecord['window']
+        eventHandlers = windowRecord['eventHandlers']
+        while True:
+            event, values = window.Read(timeout=100)
+            if event == psg.WIN_CLOSED or event == "EXIT":
+                del window
+                break
+            if event == '__TIMEOUT__': self.program.flushCB()
+            else:
+                if event in eventHandlers:
+                    self.eventValues = values
+                    eventHandlers[event]()
+class Graphics(Handler):
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+        self.utils = GUtils()
+
+    def getName(self):
+        return 'graphics'
+
+    #############################################################################
+    # Keyword handlers
+
+    def k_add(self, command):
+        token = self.nextToken()
+        if self.isSymbol():
+            symbolRecord = self.getSymbolRecord()
+            name = symbolRecord['name']
+            keyword = symbolRecord['keyword']
             if keyword == 'layout':
-                command['target'] = record['name']
+                command['args'] = name
+            elif keyword in ['column', 'frame', 'tab']:
+                command['name'] = name
+                command['type'] = token
                 if self.peek() == 'to':
-                    self.nextToken()
-                    command['type'] = self.nextToken()
+                    command['args'] = []
+                else:
                     command['args'] = self.utils.getArgs(self)
-                else: command['args'] = None
-                self.addCommand(command)
-                return True
-            elif keyword == 'event':
-                pass
-            return False
+        else:
+            command['type'] = token
+            command['args'] = self.utils.getArgs(self)
+        if self.nextIs('to'):
+            if self.nextIsSymbol():
+                symbolRecord = self.getSymbolRecord()
+                if symbolRecord['keyword'] in ['column', 'frame', 'layout', 'tab']:
+                    command['target'] = symbolRecord['name']
+                    self.addCommand(command)
+                    return True
+        return False
 
-    def r_set(self, command):
+    def r_add(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'])
+        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)):
+                try:
+                    args = self.utils.decode(self, default, layout[n])
+                except Exception as e:
+                    RuntimeError(self.program, e)
+            item = self.utils.createElement(type, param, args)
+            target['layout'].append(item)
+        else:
+            v = self.getVariable(args)
+            target['layout'].append(v['layout'])
+        return self.nextPC()
+
+    def k_close(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['keyword'] == 'window':
+                command['target'] = symbolRecord['name']
+                self.add(command)
+                return True
+        return False
+
+    def r_close(self, command):
+        target = self.getVariable(command['target'])
+        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):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            type = symbolRecord['keyword']
+            command['type'] = type
+            command['name'] = symbolRecord['name']
+            if type == 'window':
+                command['title'] = self.nextValue()
+                if self.nextIs('layout'):
+                    if self.nextIsSymbol():
+                        symbolRecord = self.getSymbolRecord()
+                        if symbolRecord['keyword'] == 'layout':
+                            command['layout'] = symbolRecord['name']
+                            self.addCommand(command)
+                            return True
+        return False
+
+    def r_create(self, command):
+        type = command['type']
+        record = self.getVariable(command['name'])
+        if type == 'window':
+            title = self.getRuntimeValue(command['title'])
+            layout = self.getVariable(command['layout'])['layout']
+            # keys = {}
+            # self.utils.tagKeys(keys, layout)
+            window = psg.Window(title, layout, finalize=True)
+            # window.keys = keys
+            record['window'] = window
+            record['eventHandlers'] = {}
+            self.program.windowRecord = record
+            self.program.run(self.nextPC())
+            self.mainLoop()
+            # 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)
+
+    def r_layout(self, command):
+        return self.nextPC()
+
+    def k_on(self, command):
+        token = self.nextToken()
+        if token == 'event':
+            command['key'] = self.nextValue()
+            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'])
+        window = self.getVariable(command['window'])
+        window['eventHandlers'][key] = lambda: self.run(command['goto'])
+        return self.nextPC()
+
+    def k_popup(self, command):
+        command['message'] = self.nextValue()
+        self.addCommand(command)
+        return True
+
+    def r_popup(self, command):
+        psg.popup(self.getRuntimeValue(command['message']))
+        return self.nextPC()
+
+    # set property {property} of {key} in {window} to {value}
+    def k_set(self, command):
+        if self.nextIs('property'):
+            command['property'] = self.nextValue()
+            if self.nextIs('of'):
+                command['key'] = self.nextValue()
+                if self.nextIs('in'):
+                    if self.nextIsSymbol():
+                        record = self.getSymbolRecord()
+                        if record['keyword'] == 'window':
+                            name = record['name']
+                            command['window'] = name
+                            if self.nextIs('to'):
+                                command['value'] = self.nextValue()
+                                self.add(command)
+                            return True
+                        else: RuntimeError(self.program, f'\'{name}\' is not a window variable')
+                    else: RuntimeError(self.program, 'No window variable given')
+        return False
+
+    def r_set(self, command):
+        property = self.getRuntimeValue(command['property'])
+        key = self.getRuntimeValue(command['key'])
+        window = self.program.windowRecord['window']
+        value = self.getRuntimeValue(command['value'])
+        self.utils.updateProperty(window[key], property, value)
         return self.nextPC()
 
     def k_window(self, command):
@@ -266,6 +559,21 @@ class Graphics(Handler):
         if token == 'event':
            return value
 
+        if token == 'property':
+            value['key'] = self.nextValue()
+            if self.nextIs('of'):
+                if self.nextToken() == 'the':
+                    if self.nextIs('event'):
+                        value['source'] = '_event_'
+                        return value
+                else:
+                    value['key'] = self.getValue()
+                    if self.nextIs('in'):
+                        if self.nextIsSymbol():
+                            record = self.getSymbolRecord()
+                            if record['keyword'] == 'window':
+                                value['source'] = record['name']
+                                return value
         return None
 
     #############################################################################
@@ -284,10 +592,30 @@ class Graphics(Handler):
             return None
 
     def v_event(self, v):
+        window = self.eventValues['window']
+        values = self.eventValues['values']
+        self.utils.getEventProperties(window, values)
         v['type'] = 'text'
-        v['content'] = self.eventValues
+        v['content'] = values
         return v
 
+    def v_property(self, v):
+        key = self.getRuntimeValue(v['key'])
+        source = v['source']
+        if source == '_event_':
+            window = self.eventValues['window']
+            values = self.eventValues['values']
+            self.utils.getEventProperties(window, values)
+            v['type'] = 'text'
+            v['content'] = values[key]
+            return v
+        else:
+            window = self.getVariable(source)
+            widget = window['window'].key_dict[key]
+            v['type'] = 'text'
+            v['content'] = widget.get()
+            return v
+
     #############################################################################
     # Compile a condition
     def compileCondition(self):
@@ -305,10 +633,13 @@ class Graphics(Handler):
         eventHandlers = windowRecord['eventHandlers']
         while True:
             event, values = window.Read(timeout=100)
-            if event == psg.WINDOW_CLOSED or event == "EXIT":
+            if event == psg.WIN_CLOSED or event == "EXIT":
+                del window
                 break
             if event == '__TIMEOUT__': self.program.flushCB()
             else:
                 if event in eventHandlers:
-                    self.eventValues = values
+                    self.eventValues = {}
+                    self.eventValues['values'] = values
+                    self.eventValues['window'] = window
                     eventHandlers[event]()

easycoder/ec_gutils.py

@@ -8,7 +8,8 @@ class GUtils:
         args = []
         while True:
             key = handler.nextToken()
-            value = json.dumps(handler.nextValue())
+            value = handler.nextValue()
+            value = json.dumps(value)
             args.append(f'{key}={value}')
             if handler.peek() == 'and':
                 handler.nextToken()
@@ -21,64 +22,123 @@ class GUtils:
     # Get the default args for a graphic element
     def getDefaultArgs(self, type):
         args = {}
-        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 == '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
+        if type == 'Button': self.getDefaultButton(args)
+        elif type == 'Checkbox': self.getDefaultCheckbox(args)
+        elif type == 'Column': self.getDefaultColumn(args)
+        elif type == 'Input': self.getDefaultInput(args)
+        elif type == 'Listbox': self.getDefaultListbox(args)
+        elif type == 'Multiline': self.getDefaultMultiline(args)
+        elif type == 'Text': self.getDefaultText(args)
         return args
 
     # Decode an argument at runtime
-    def decode(self, args, text):
+    def decode(self, handler, args, text):
         p = text.find('=')
         if p > 0:
             key = text[0:p]
-            value = json.loads(text[p+1:])['content']
+            value = text[p+1:]
+            value = json.loads(value)
+            if value['type'] == 'symbol':
+                record = handler.program.getSymbolRecord(value['name'])
+                value = handler.getSymbolValue(record)
+            if value != None: value = value['content']
+            else: raise Exception('Variable has no value')
             args[key] = value
             return args
         return None
 
+    # Reduce the event properties to a list of strings
+    def getEventProperties(self, window, values):
+        keys = values.keys()
+        for key in keys:
+            v = values[key]
+            element = window.key_dict[key]
+            if type(element) is psg.Listbox:
+                # Only pick one from those selected
+                v = v[0]
+            values[key] = v
+
     # Create an element
     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 = self.getSize(args)
-            return psg.Input(key=args['key'], size=size)
-        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'])
+        if type == 'Button': return self.createButton(param, args)
+        elif type == 'Checkbox': return self.createCheckbox(param, args)
+        elif type == 'Column': return self.createColumn(param, args)
+        elif type == 'Input': return self.createInput(param, args)
+        elif type == 'Listbox': return self.createListbox(param, args)
+        elif type == 'Multiline': return self.createMultiline(param, args)
+        elif type == 'Text': return self.createText(param, args)
         else: return None
 
+    # Update a property
+    def updateProperty(self, element, property, value):
+        if property == 'disabled':
+            element.update(disabled=value)
+        elif property == 'value':
+            element.update(value=value)
+        elif property == 'values':
+            element.update(values=value)
+
     def getSize(self, args):
         size = args['size']
         if size == (None, None):
             return size
         size = size.split()
         return (size[0], size[1])
+
+    def getDefaultButton(self, args):
+        args['button_text'] = '(empty)'
+        args['disabled'] = False
+        args['size'] = (None, None)
+
+    def createButton(self, param, args):
+        return psg.Button(button_text=args['button_text'], disabled=args['disabled'], size=self.getSize(args))
+
+    def getDefaultCheckbox(self, args):
+        args['text'] = ''
+        args['key'] = None
+        args['size'] = (None, None)
+        args['expand_x'] = False
+
+    def createCheckbox(self, param, args):
+        return psg.Checkbox(args['text'], key=args['key'], expand_x=args['expand_x'], size=self.getSize(args))
+
+    def getDefaultColumn(self, args):
+        args['expand_x'] = False
+        args['pad'] = (0, 0)
+
+    def createColumn(self, param, args):
+        return psg.Column(param, expand_x=args['expand_x'], pad=args['pad'])
+
+    def getDefaultInput(self, args):
+        args['default_text'] = ''
+        args['key'] = None
+        args['size'] = (None, None)
+
+    def createInput(self, param, args):
+        return psg.Input(default_text=args['default_text'], key=args['key'], size=self.getSize(args))
+
+    def getDefaultListbox(self, args):
+        args['list'] = []
+        args['key'] = [None]
+        args['size'] = '10 2'
+        args['select_mode'] = None
+
+    def createListbox(self, param, args):
+        return psg.Listbox([], key=args['key'], size=self.getSize(args))
+
+    def getDefaultMultiline(self, args):
+        args['default_text'] = ''
+        args['key'] = None
+        args['size'] = (None, None)
+
+    def createMultiline(self, param, args):
+        return psg.Multiline(default_text=args['default_text'], key=args['key'], size=self.getSize(args))
+
+    def getDefaultText(self, args):
+        args['text'] = '(empty)'
+        args['size'] = (None, None)
+        args['expand_x'] = False
+
+    def createText(self, param, args):
+        return psg.Text(text=args['text'], expand_x=args['expand_x'], size=self.getSize(args))
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easycoder
-Version: 250118.2
+Version: 250123.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 → easycoder-250123.2.dist-info}/RECORD

@@ -1,17 +1,17 @@
 easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
-easycoder/__init__.py,sha256=4mEv6h3EwPm3vhSmcaK94mJyEK-iZApgf69_QjY8w0k,262
+easycoder/__init__.py,sha256=v90K-BoaxHQG44wkLTa8lNRPz8R1nU2QCQKSuIOpjao,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_core.py,sha256=kbThzsgjgkk3j29XprZ904Uuh_vF6qXHcPecuCYZvuU,87061
+easycoder/ec_graphics.py,sha256=KbLbhNDr-DjKKy8RbkzpBogvz30FXFOsmQUJxFcBg4E,23718
+easycoder/ec_gutils.py,sha256=cREktnAoHd_1t_fDgrnQ1F60n_TzFTGvoXJeWc_LJo4,5068
 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-250123.2.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250123.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250123.2.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+easycoder-250123.2.dist-info/METADATA,sha256=d48Jr5Dj08j1a112uEuw9OvPoEsiYNYqfiAq9dfvtS4,6162
+easycoder-250123.2.dist-info/RECORD,,