easycoder 250103.1__py2.py3-none-any.whl → 250104.1__py2.py3-none-any.whl

easycoder/__init__.py

@@ -10,4 +10,4 @@ from .ec_program import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "250103.1"
+__version__ = "250104.1"

easycoder/ec_compiler.py

@@ -128,6 +128,7 @@ class Compiler:
 			FatalError(self, f'Duplicate symbol name "{name}"')
 			return False
 		self.symbols[name] = self.getPC()
+		command['program'] = self.program
 		command['type'] = 'symbol'
 		command['valueHolder'] = valueHolder
 		command['name'] = name
@@ -136,6 +137,8 @@ class Compiler:
 		command['value'] = [None]
 		command['used'] = False
 		command['debug'] = False
+		command['import'] = None
+		command['locked'] = False
 		self.addCommand(command)
 		return True
 

easycoder/ec_core.py

@@ -367,8 +367,7 @@ class Core(Handler):
         return True
 
     def r_exit(self, command):
-        sys.exit()
-        return 0
+        return -1
 
     # Declare a file variable
     def k_file(self, command):
@@ -462,7 +461,7 @@ class Core(Handler):
             else:
                 RuntimeError(self.program, f'Error: {errorReason}')
         retval['content'] = response.text
-        self.program.putSymbolValue(target, retval);
+        self.program.putSymbolValue(target, retval)
         return self.nextPC()
 
     # Go to a label
@@ -553,15 +552,45 @@ class Core(Handler):
             self.program.pc += 1
         return self.program.pc
 
-    # Import a plugin. This is done at compile time.
-    # import {class} from {source}
+    # Import one or more variables
     def k_import(self, command):
-        clazz = self.nextToken()
-        if self.nextIs('from'):
-            source = self.nextToken()
-            self.program.importPlugin(f'{source}:{clazz}')
-            return True
-        return False
+        imports = []
+        while True:
+            keyword = self.nextToken()
+            name = self.nextToken()
+            item = [keyword, name]
+            imports.append(item)
+            self.symbols[name] = self.getPC()
+            variable = {}
+            variable['domain'] = None
+            variable['name'] = name
+            variable['keyword'] = keyword
+            variable['import'] = None
+            self.addCommand(variable)
+            if self.peek() != 'and':
+                break
+            self.nextToken()
+        command['imports'] = json.dumps(imports)
+        self.add(command)
+        return True
+
+    def r_import(self, command):
+        exports = self.program.exports
+        imports = json.loads(command['imports'])
+        if len(imports) < len(exports):
+            RuntimeError(self.program, 'Too few imports')
+        elif len(imports) > len(exports):
+            RuntimeError(self.program, 'Too many imports')
+        for n in range(0, len(imports)):
+            exportRecord = exports[n]
+            exportKeyword = exportRecord['keyword']
+            name = imports[n][1]
+            symbolRecord = self.program.getSymbolRecord(name)
+            symbolKeyword = symbolRecord['keyword']
+            if symbolKeyword != exportKeyword:
+                RuntimeError(self.program, f'Import {n} ({symbolKeyword}) does not match export {n} ({exportKeyword})')
+            symbolRecord['import'] = exportRecord
+        return self.nextPC()
 
     # Increment a variable
     def k_increment(self, command):
@@ -646,6 +675,60 @@ class Core(Handler):
         self.putSymbolValue(symbolRecord, value)
         return self.nextPC()
 
+    # 1 Load a plugin. This is done at compile time.
+    # 2 Load text from a file
+    def k_load(self, command):
+        self.nextToken()
+        if self.tokenIs('plugin'):
+            clazz = self.nextToken()
+            if self.nextIs('from'):
+                source = self.nextToken()
+                self.program.importPlugin(f'{source}:{clazz}')
+                return True
+        elif self.isSymbol():
+            command['target'] = self.getToken()
+            if self.nextIs('from'):
+                command['file'] = self.nextValue()
+                self.add(command)
+                return True
+        return False
+
+    def r_load(self, command):
+        print(command)
+        target = self.getVariable(command['target'])
+        print(target)
+        file = self.getRuntimeValue(command['file'])
+        print(file)
+        f = open(file, 'r')
+        content = f.read()
+        f.close()
+        value = {}
+        value['type'] = 'text'
+        value['content'] = content
+        self.putSymbolValue(target, value)
+        return self.nextPC()
+
+    # Lock a variable
+    def k_lock(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            command['target'] = symbolRecord['name']
+            self.add(command)
+            return True
+        return False
+
+    def r_lock(self, command):
+        target = self.getVariable(command['target'])
+        target['locked'] = True
+        return self.nextPC()
+
+    # Declare a module variable
+    def k_module(self, command):
+        return self.compileVariable(command)
+
+    def r_module(self, command):
+        return self.nextPC()
+
     # Arithmetic multiply
     # multiply {variable} by {value}[ giving {variable}]}
     def k_multiply(self, command):
@@ -1008,6 +1091,16 @@ class Core(Handler):
         self.putSymbolValue(templateRecord, value)
         return self.nextPC()
 
+    # Release the parent script
+    def k_release(self, command):
+        if self.nextIs('parent'):
+            self.add(command)
+        return True
+
+    def r_release(self, command):
+        self.program.releaseParent()
+        return self.nextPC()
+
     # Return from subroutine
     def k_return(self, command):
         self.add(command)
@@ -1016,11 +1109,65 @@ class Core(Handler):
     def r_return(self, command):
         return self.stack.pop()
 
+    # Compile and run a script
+    def k_run(self, command):
+        if self.nextIsSymbol():
+            record = self.getSymbolRecord()
+            if record['keyword'] == 'module':
+                command['target'] = record['name']
+                if self.nextIs('as'):
+                    command['path'] = self.nextValue()
+                    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
+
+    def r_run(self, command):
+        target = self.getVariable(command['target'])
+        path = self.getRuntimeValue(command['path'])
+        exports = json.loads(command['exports'])
+        for n in range(0, len(exports)):
+            exports[n] = self.getVariable(exports[n])
+        target['path'] = path
+        parent = Object()
+        parent.program = self.program
+        parent.pc = self.nextPC()
+        parent.waiting = True
+        p = self.program.__class__
+        p(path).start(parent, exports)
+        return 0
+
     # Provide a name for the script
     def k_script(self, command):
         self.program.name = self.nextToken()
         return True
 
+    # Save a value to a file
+    def k_save(self, command):
+        command['content'] = self.nextValue()
+        if self.nextIs('to'):
+            command['file'] = self.nextValue()
+            self.add(command)
+            return True
+        return False
+
+    def r_save(self, command):
+        content = self.getRuntimeValue(command['content'])
+        file = self.getRuntimeValue(command['file'])
+        f = open(file, 'w')
+        f.write(content)
+        f.close()
+        return self.nextPC()
+
     # Set a value
     # set {variable}
     # set the elements of {variable} to {value}
@@ -1325,6 +1472,20 @@ class Core(Handler):
         fileRecord['file'].truncate()
         return self.nextPC()
 
+    # Unlock a variable
+    def k_unlock(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            command['target'] = symbolRecord['name']
+            self.add(command)
+            return True
+        return False
+
+    def r_unlock(self, command):
+        target = self.getVariable(command['target'])
+        target['locked'] = False
+        return self.nextPC()
+
     # Declare a general-purpose variable
     def k_variable(self, command):
         return self.compileVariable(command, True)
@@ -2021,19 +2182,12 @@ class Core(Handler):
         value['content'] = json.dumps(item)
         return value
 
+    # 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
-            # if symbolValue == None:
-            #     return None
-            # result['type'] = symbolValue['type']
-            # content = symbolValue['content']
-            # if content == None:
-            #     return ''
-            # result['content'] = content
-            # return result
         else:
             return None
 

easycoder/ec_graphics.py

@@ -1,7 +1,9 @@
+import sys, threading, json
 from .ec_classes import FatalError, RuntimeError, Object
 from .ec_handler import Handler
 from .ec_screenspec import ScreenSpec
 from .ec_renderer import Renderer
+from .ec_program import flush
 
 class Graphics(Handler):
 
@@ -173,7 +175,7 @@ class Graphics(Handler):
             if type == 'window':
                 self.windowSpec = Object()
                 self.windowSpec.title = command['title']['content']
-                self.windowSpec.flush = self.program.flush
+                self.windowSpec.flush = flush
                 self.windowSpec.finish = self.program.finish
                 self.windowSpec.pos = (self.getRuntimeValue(command['pos'][0]), self.getRuntimeValue(command['pos'][1]))
                 self.windowSpec.size = (self.getRuntimeValue(command['size'][0]), self.getRuntimeValue(command['size'][1]))
@@ -219,7 +221,7 @@ class Graphics(Handler):
         if self.nextIsSymbol():
             record = self.getSymbolRecord()
             type = record['keyword']
-            if type in ['ellipse', 'rectangle']:
+            if self.isGraphicType(type):
                 command['target'] = record['id']
                 token = self.nextToken()
                 if token == 'to':
@@ -283,7 +285,7 @@ class Graphics(Handler):
         if command['type'] == 'tap':
             record = self.getVariable(command['target'])
             keyword = record['keyword']
-            if keyword in ['ellipse', 'rectangle', 'text', 'image']:
+            if self.isGraphicType(keyword):
                 id = record['value'][record['index']]['content']
                 self.ui.setOnClick(id, lambda: self.run(pc))
             else:
@@ -296,12 +298,6 @@ class Graphics(Handler):
     def r_rectangle(self, command):
         return self.nextPC()
 
-    def k_text(self, command):
-        return self.compileVariable(command)
-
-    def r_text(self, command):
-        return self.nextPC()
-
     # render {spec}
     def k_render(self, command):
         command['spec'] = self.nextValue()
@@ -332,6 +328,7 @@ class Graphics(Handler):
     def r_run(self, command):
         self.renderer = Renderer()
         self.renderer.init(self.windowSpec)
+        self.ui = self.renderer.getUI()
         self.program.setExternalControl()
         self.program.run(self.nextPC())
         self.renderer.run()
@@ -343,7 +340,7 @@ class Graphics(Handler):
             if self.nextIs('of'):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
-                    if record['keyword'] in ['ellipse', 'rectangle', 'text', 'image']:
+                    if self.isGraphicType(record['keyword']):
                         command['target'] = record['name']
                         if self.nextIs('to'):
                             command['value'] = self.nextValue()
@@ -363,6 +360,12 @@ class Graphics(Handler):
         self.ui.setAttribute(id, attribute, value)
         return self.nextPC()
 
+    def k_text(self, command):
+        return self.compileVariable(command)
+
+    def r_text(self, command):
+        return self.nextPC()
+
     #############################################################################
     # Modify a value or leave it unchanged.
     def modifyValue(self, value):
@@ -373,6 +376,16 @@ class Graphics(Handler):
     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 == 'graphic':
+                value['type'] = 'symbol'
+                return value
+            return None
+        
         if self.tokenIs('the'):
             self.nextToken()
         kwd = self.getToken()
@@ -382,7 +395,7 @@ class Graphics(Handler):
             if self.nextIs('of'):
                 if self.nextIsSymbol():
                     record = self.getSymbolRecord()
-                    if record['keyword'] in ['ellipse', 'rectangle']:
+                    if self.isGraphicType(record['keyword']):
                         value['attribute'] = attribute
                         value['target'] = record['name']
                         return value
@@ -393,6 +406,12 @@ class Graphics(Handler):
                 return value
         return None
 
+    #############################################################################
+    # Test if a graphic type
+
+    def isGraphicType(self, type):
+        return type in ['ellipse', 'rectangle', 'text', 'image']
+
     #############################################################################
     # Value handlers
 
@@ -409,6 +428,15 @@ class Graphics(Handler):
         except Exception as e:
             RuntimeError(self.program, e)
 
+    # This is used by the expression evaluator to get the value of a symbol
+    def v_symbol(self, symbolRecord):
+        result = {}
+        if symbolRecord['keyword'] == 'graphic':
+            symbolValue = self.getSymbolValue(symbolRecord)
+            return symbolValue
+        else:
+            return None
+
     def v_window(self, v):
         try:
             attribute = v['attribute']

easycoder/ec_program.py

@@ -1,12 +1,21 @@
 import time, json, sys
 from copy import deepcopy
 from collections import deque
-from .ec_classes import Script, Token, FatalError, RuntimeError
+from .ec_classes import Script, Token, FatalError, RuntimeError, Object
 from .ec_compiler import Compiler
 from .ec_core import Core
 import importlib
 from importlib.metadata import version
 
+queue = deque()
+
+# Flush the queue
+def flush():
+	global queue
+	while len(queue):
+		item = queue.popleft()
+		item.program.flush(item.pc)
+
 class Program:
 
 	def __init__(self, argv):
@@ -15,7 +24,7 @@ class Program:
 			print('No script supplied')
 			exit()
 		self.classes=[Core]
-		scriptName = argv[0]
+		scriptName = argv
 		if scriptName.endswith('.ecg'):
 			from .ec_graphics import Graphics
 			self.classes.append(Graphics)
@@ -23,6 +32,7 @@ class Program:
 		f = open(scriptName, 'r')
 		source = f.read()
 		f.close()
+		self.argv = argv
 		self.domains = []
 		self.domainIndex = {}
 		self.name = '<anon>'
@@ -37,11 +47,12 @@ class Program:
 		self.value = self.compiler.value
 		self.condition = self.compiler.condition
 		self.processClasses()
-		self.queue = deque()
 		self.externalControl = False
-		self.quit = False
+		self.finished = False
 
-	def start(self):
+	def start(self, parent=None, exports=[]):
+		self.parent = parent
+		self.exports = exports
 		startCompile = time.time()
 		self.tokenise(self.script)
 		if self.compiler.compileFrom(0, []):
@@ -98,11 +109,11 @@ class Program:
 	def getSymbolRecord(self, name):
 		try:
 			target = self.code[self.symbols[name]]
+			if target['import'] != None:
+				target = target['import']
+			return target
 		except:
-			RuntimeError(self.compiler.program, f'Unknown symbol \'{name}\'')
-			return None
-
-		return target
+			RuntimeError(self, f'Unknown symbol \'{name}\'')
 
 	def doValue(self, value):
 		if value == None:
@@ -184,6 +195,8 @@ class Program:
 		return copy
 
 	def putSymbolValue(self, symbolRecord, value):
+		if symbolRecord['locked']:
+			RuntimeError(self, f'Symbol \'{symbolRecord['name']}\' is locked')
 		if symbolRecord['value'] == None or symbolRecord['value'] == []:
 			symbolRecord['value'] = [value]
 		else:
@@ -192,11 +205,11 @@ class Program:
 				index = 0
 			symbolRecord['value'][index] = value
 
-	def encode(self, value, encoding='UTF-8'):
-		return value.encode(encoding)
+	def encode(self, value):
+		return value
 
-	def decode(self, value, encoding='UTF-8'):
-		return value.decode(encoding)
+	def decode(self, value):
+		return value
 
 	# Tokenise the script
 	def tokenise(self, script):
@@ -256,48 +269,60 @@ class Program:
 					token = ''
 		return
 	
-	def finish(self):
-		self.quit = True
+	def releaseParent(self):
+		if self.parent.waiting and self.parent.program.running:
+			self.parent.waiting = False
+			self.parent.program.run(self.parent.pc)
 
 	# Flush the queue
-	def flush(self):
-		while len(self.queue):
-			self.pc = self.queue.popleft()
-			while True:
-				if self.quit:
-					return
-				command = self.code[self.pc]
-				domainName = command['domain']
-				if domainName == None:
-					self.pc += 1
-				else:
-					keyword = command['keyword']
-					if self.debugStep and command['debug']:
-						lino = command['lino'] + 1
-						line = self.script.lines[command['lino']].strip()
-						print(f'{self.name}: Line {lino}: {domainName}:{keyword}:  {line}')
-					domain = self.domainIndex[domainName]
-					handler = domain.runHandler(keyword)
-					if handler:
-						command = self.code[self.pc]
-						command['program'] = self
-						self.pc = handler(command)
-						try:
-							if self.pc == 0 or self.pc >= len(self.code):
-								break
-						except:
-							break
-
-	def setExternalControl(self):
-		self.externalControl = True
+	def flush(self, pc):
+		global queue
+		self.running = True
+		self.pc = pc
+		while True:
+			command = self.code[self.pc]
+			domainName = command['domain']
+			if domainName == None:
+				self.pc += 1
+			else:
+				keyword = command['keyword']
+				if self.debugStep and command['debug']:
+					lino = command['lino'] + 1
+					line = self.script.lines[command['lino']].strip()
+					print(f'{self.name}: Line {lino}: {domainName}:{keyword}:  {line}')
+				domain = self.domainIndex[domainName]
+				handler = domain.runHandler(keyword)
+				if handler:
+					command = self.code[self.pc]
+					command['program'] = self
+					self.pc = handler(command)
+					# Deal with 'exit'
+					if self.pc == -1:
+						queue = deque()
+						self.running = False
+						if self.parent != None:
+							self.releaseParent()
+							sys.exit()
+					elif self.pc == None or self.pc == 0 or self.pc >= len(self.code):
+						break
 
 	# Run the script
 	def run(self, pc):
-		length = len(self.queue)
-		self.queue.append(pc)
+		global queue
+		length = len(queue)
+		item = Object()
+		item.program = self
+		item.pc = pc
+		queue.append(item)
 		if not self.externalControl:
 			if length == 0:
-				return self.flush()
+				return flush()
+	
+	def finish(self):
+		self.running = False
+
+	def setExternalControl(self):
+		self.externalControl = True
 
 	def nonNumericValueError(self):
 		FatalError(self.compiler, 'Non-numeric value')
@@ -343,3 +368,10 @@ class Program:
 		if v1 < v2:
 			return -1
 		return 0
+
+# This is the program launcher
+def Main():
+	if (len(sys.argv) > 1):
+		Program(sys.argv[1]).start()
+	else:
+		print('Syntax: easycoder <scriptname> [plugins]')

easycoder/ec_renderer.py

@@ -232,10 +232,10 @@ class Renderer(App):
     
     def build(self):
         Clock.schedule_interval(self.flushQueue, 0.01)
-        self.ui = UI()
         return self.ui
 
     def init(self, spec):
+        self.ui = UI()
         self.title = spec.title
         self.flush = spec.flush
         Window.size = spec.size

{easycoder-250103.1.dist-info → easycoder-250104.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 250103.1
+Version: 250104.1
 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>
@@ -10,12 +10,13 @@ Requires-Dist: pytz
 Project-URL: Home, https://github.com/easycoder/easycoder-py
 
 # Introduction
-**_EasyCoder_** is a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line and a graphics module is under construction. This version of the language is written in Python and its runtime acts as a fairly thin wrapper around Python functions, giving good performance for general applications.
-
-The JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, is at
+**_EasyCoder_** is a high-level English-like scripting language suited for prototyping and rapid testing of ideas. It operates on the command line and a graphics module is under construction. This version of the language is written in Python and it acts as a fairly thin wrapper around Python functions, giving fast compilation and good runtime performance for general applications.
+<hr>
+For the JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser, please visit
 
 Repository: [https://github.com/easycoder/easycoder.github.io](https://github.com/easycoder/easycoder.github.io)  
 Website: [https://easycoder.github.io](https://easycoder.github.io)
+<hr>
 
 ## Quick Start
 Install **_EasyCoder_** in your Python environment:
@@ -28,7 +29,7 @@ print `Hello, world!`
 ```
 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 output will look like this (the version number will differ):
 
 ```
 EasyCoder version 250101.1
@@ -72,6 +73,19 @@ A couple of demo graphical scripts are included in the `scripts` directory:
 
 **_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
 
+## Significant features
+
+ - English-like syntax based on vocabulary rather than structure. Scripts can be read as English
+ - Comprehensive feature set
+ - Runs directly from source scripts, using a fast compiler to create efficient intermediate runtime code that is run immediately
+ - Low memory requirements
+ - Minimim dependency on other 3rd-party packages
+ - Built-in co-operative multitasking
+ - Dynamic loading of scripts on demand
+ - The language can be extended seamlessly using plugin function modules
+ - Plays well with any Python code
+ - Fully Open Source
+
 ## Programming reference
 
 **_EasyCoder_** comprises a set of modules to handle tokenisation, compilation and runtime control. Syntax and grammar are defined by [packages](doc/README.md), of which there are currently two; the [core](doc/core/README.md) package, which implements a comprehensive set of command-line programming features, and and the [graphics](doc/graphics/README.md) package, which adds graphical features in a windowing environment.

easycoder-250104.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
+easycoder/__init__.py,sha256=a3GF7mJ6MDX_VMS0m8eVDkxAksYnIfCeb4Rw6KgV2ys,283
+easycoder/ec.py,sha256=Nj5PRl8GsKjfGJKq0FOM1a7FeK3cN68CoIFg8lswQEg,221
+easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
+easycoder/ec_compiler.py,sha256=_xBh2L47mz_WOMYdruMYSHyyz2wfh7Hf28q559AWVSU,4781
+easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
+easycoder/ec_core.py,sha256=VtsjZ0r3OKxgF-nnQoRJItbjhSHRUso84SwSz3EubG4,84152
+easycoder/ec_graphics.py,sha256=JLd5w1_RYVmSVmdWhxltMGfdQuKHroFl0HG7MCZ7E2E,16431
+easycoder/ec_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
+easycoder/ec_program.py,sha256=4I7tICiY9zkigA15-K8zdHkH-H-UOr4W1liy0sfMtu8,9440
+easycoder/ec_renderer.py,sha256=1zdIXqk-Sfnu3ErU193iem0Y-r6GeVc8D1HsTB_G2bU,7981
+easycoder/ec_screenspec.py,sha256=TeXgccfYoE--r7Rf9t9drV1V3fU-p-iBnZwtjHzIh8M,2524
+easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
+easycoder/ec_value.py,sha256=XIBtGhcCgh1abrzAn-Wy4l_xH_3cTWakMVIiSlBAZjM,2386
+easycoder-250104.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250104.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250104.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+easycoder-250104.1.dist-info/METADATA,sha256=MsBtZS8mH5qcs5vLAB4PSdnwIF51g7q0uxiKhCRQgo8,5817
+easycoder-250104.1.dist-info/RECORD,,

easycoder-250103.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
-easycoder/__init__.py,sha256=5hieaJUWovLn09r1Tf2I2hBLjfYGXMKuBb6usyd9sYc,283
-easycoder/ec.py,sha256=Nj5PRl8GsKjfGJKq0FOM1a7FeK3cN68CoIFg8lswQEg,221
-easycoder/ec_classes.py,sha256=xnWBNak8oKydkFoxHLlq9wo3lIsB3aMnTDrqbtCfoWo,1512
-easycoder/ec_compiler.py,sha256=2r6Nk7px9UMYqIpYc6dAbYOAFu-CoWPy-iqlsed49Lo,4690
-easycoder/ec_condition.py,sha256=WSbONo4zs2sX1icOVpscZDFSCAEFmTsquoc2RGcLx_k,763
-easycoder/ec_core.py,sha256=1rYUGd5EXpjJkfYnnvJNjvMD_JfTGZRMEV0lLbYrzAU,78939
-easycoder/ec_graphics.py,sha256=o70BdQ-Y3uIo5nheQYwJUmM3gYVerKD9_5arQ8JTP-Y,15556
-easycoder/ec_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
-easycoder/ec_program.py,sha256=TUKQo56vURtx_UO7avIJZhz0EeOe2lNxQQz8EOOnCZ4,8685
-easycoder/ec_renderer.py,sha256=ejVFemHGuFBwGA__6VfZQZeZMnw4Ilvf_y9I34k04LM,7981
-easycoder/ec_screenspec.py,sha256=TeXgccfYoE--r7Rf9t9drV1V3fU-p-iBnZwtjHzIh8M,2524
-easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
-easycoder/ec_value.py,sha256=XIBtGhcCgh1abrzAn-Wy4l_xH_3cTWakMVIiSlBAZjM,2386
-easycoder-250103.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-250103.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-250103.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
-easycoder-250103.1.dist-info/METADATA,sha256=6X8NoMG3Px2cLNDqWYxoMfki71O06qYk8qILNM_49VI,5178
-easycoder-250103.1.dist-info/RECORD,,