easycoder 250118.1__py2.py3-none-any.whl → 251103.4__py2.py3-none-any.whl

easycoder/ec_timestamp.py

@@ -2,7 +2,7 @@ import pytz, time
 from datetime import datetime
 
 def getTimestamp(t):
-    tz = pytz.timezone('Europe/London') # Localize this!
+    tz = pytz.timezone('GB') # Localize this!
     dt = datetime.fromtimestamp(t)
     # print(f'{dt} + {tz.dst(dt).seconds}')
     return int(t) + tz.dst(dt).seconds

{easycoder-250118.1.dist-info → easycoder-251103.4.dist-info}/METADATA

@@ -1,16 +1,25 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: easycoder
-Version: 250118.1
+Version: 251103.4
 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>
 Description-Content-Type: text/markdown
 Classifier: License :: OSI Approved :: MIT License
+License-File: LICENSE
 Requires-Dist: pytz
+Requires-Dist: requests
+Requires-Dist: psutil
+Requires-Dist: paramiko
+Requires-Dist: pyside6
 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 it acts as a fairly thin wrapper around Python functions, giving fast compilation and good runtime performance for general applications.
+**_EasyCoder_** is a high-level English-like domain-specific scripting language (DSL) suited for prototyping and rapid testing of ideas. It operates on the command line and a graphics module is under construction. The language is written in Python and it acts as a fairly thin wrapper around standard Python functions, giving fast compilation and good runtime performance for general applications.
+
+**_EasyCoder_** is well suited to building command-line or graphical applications for expressing random logic such as operating procedures and rules, or controlling physical systems, particularly those using wifi devices. It is easy to construct and issue REST commands to local or remote web servers.
+
+For more advanced applications, **_EasyCoder_** is designed to be extensible, by enabling extra language syntax to be added via plugin-in modules. Once these are installed they act as seamless extensions to the basic syntax provided. **_EasyCoder_** derives its power from the use of rich and comprehensive language rather than a complex system of frameworks such as those commonly used in modern programming. This makes it very easy to learn as our brains are wired to operate that way. Having said that, the needs of most control systems are usually served by a fairly modest number of keywords and syntactic variants.
 <hr>
 
 There is also a JavaScript version of **_EasyCoder_**, which provides a full set of graphical features to run in a browser. For this, please visit
@@ -22,15 +31,12 @@ Website: [https://easycoder.github.io](https://easycoder.github.io)
 ## Quick Start
 Install **_EasyCoder_** in your Python environment:
 ```
-pip install requests pytz easycoder
+pip install requests easycoder
 ```
 
 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
-```
+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:
 ```
@@ -41,35 +47,40 @@ fi
 ```
 <hr>
 
-Now write a test script, 'hello.ecs', containing the following:
+Now write a test script, `hello.ecs`, containing the following:
 ```
 print `Hello, world!`
+exit
 ```
 (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):
+The output will look like this (the version number will likely differ):
 ```
-EasyCoder version 250101.1
+EasyCoder version 250403.1
 Compiled <anon>: 1 lines (2 tokens) in 0 ms
 Run <anon>
-1-> Hello, world!
+Hello, world!
 ```
 
+Why the `exit`? Because EasyCoder can't tell that the program is finished. It might contain elements that are waiting for outside events, so without `exit` it just stops and waits. You can kill it by typing Control-C.
+
 It's conventional to add a program title to a script:
 ```
 !   Test script
     script Test
-    print `Hello, world!`
+    log `Hello, world!`
+    exit
 ```
-The first line here is just a comment and has no effect on the running of the script.   The second line gives the script a name, which is useful in debugging as it says which script was running. When run, the output is now
+
+The first line here is just a comment and has no effect on the running of the script.   The second line gives the script a name, which is useful in debugging as it says which script was running. I've also changed `print` to `log` to get more information from the script. When run, the output is now
 ```
-EasyCoder version 250101.1
+EasyCoder version 250403.1
 Compiled Test: 3 lines (4 tokens) in 0 ms
 Run Test
-3-> Hello, world!
+16:37:39.132311:    3-> Hello, world!
 ```
 
-As you might guess from the above, the print command shows the line in the script it was called from. This is very useful in tracking down debugging print commands in large scripts.
+As you might guess from the above, the `log` command shows the time and the line in the script it was called from. This is very useful in tracking down debugging print commands in large scripts.
 
 Here in the repository is a folder called `scripts` containing some sample scripts:
 
@@ -77,19 +88,8 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `tests.ecs` is a test program containing many of the **_EasyCoder_** features  
 `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. 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
-```
-
-Next, install the Python `pySimpleGUI` graphics library; this is done with `pip install pysimplegui`. 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 will included in the `scripts` directory as development proceeds.
-
-`gtest.ecg` contains sample code to demonstrate and test basic features.
+## Graphical programming
+**_EasyCoder_** includes a graphical programming environment based on PySide6, that is in under development. Some demo scripts will be included in the `scripts` directory as development proceeds. Anyone wishing to track progress can do so via this repository. At the time of writing we are transitioning from an early version based on PySimpleGUI to one based on PySide, the latter being an open product that matches the needs of a DSL better than does the former.
 
 ## Significant features
 

easycoder-251103.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+easycoder/__init__.py,sha256=x5eJ0b_BaGw0O88hLzy-pO_ktclTFPZfSD5bmPM85WQ,339
+easycoder/close.png,sha256=3B9ueRNtEu9E4QNmZhdyC4VL6uqKvGmdfeFxIV9aO_Y,9847
+easycoder/ec_border.py,sha256=KpOy0Jq8jI_6DYGo4jaFvoBP_jTIoAYWrmuHhl-FXA4,2355
+easycoder/ec_classes.py,sha256=YGUiKnVN6T5scoeBmmGDQAtE8xJgaTHi0Exh9A7H2Y4,1750
+easycoder/ec_compiler.py,sha256=teu33Y9j0s1kT4R9XvTy6EIXOadpIEz3IVFji5CdBTM,5625
+easycoder/ec_condition.py,sha256=uamZrlW3Ej3R4bPDuduGB2f00M80Z1D0qV8muDx4Qfw,784
+easycoder/ec_core.py,sha256=c51wdwTwppZwGLOhN22SBCdAmnTFQw0eirMJxkOb8vI,100780
+easycoder/ec_handler.py,sha256=zEZ5cPruEVZp3SIQ6ZjdZN5jDyW2gFvHcNmFaet4Sd4,2324
+easycoder/ec_keyboard.py,sha256=H8DhPT8-IvAIGgRxCs4qSaF_AQLaS6lxxtDteejbktM,19010
+easycoder/ec_program.py,sha256=aPuZOYWFqGd1jsLDl5M5YmLu5LfFAewF9EZh6zHIbyM,10308
+easycoder/ec_pyside.py,sha256=ejcSSmGLJZ4mTcRuy2lktM4bG3weH2XhlH22RsT1RlY,58251
+easycoder/ec_timestamp.py,sha256=myQnnF-mT31_1dpQKv2VEAu4BCcbypvMdzq7_DUi1xc,277
+easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
+easycoder/tick.png,sha256=OedASXJJTYvnza4J6Kv5m5lz6DrBfy667zX_WGgtbmM,9127
+easycoder-251103.4.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-251103.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-251103.4.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
+easycoder-251103.4.dist-info/METADATA,sha256=ErcQE05dpxvUuSWSZY_mwvadAf8t4nb_kvqYZhNlL28,6897
+easycoder-251103.4.dist-info/RECORD,,

{easycoder-250118.1.dist-info → easycoder-251103.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: flit 3.9.0
+Generator: flit 3.12.0
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

easycoder/README.md

@@ -1,6 +0,0 @@
-# EasyCode source code
-These are the Python files that comprise **_EasyCoder_**.
-
-**_EasyCoder_** has a small number of third-party dependencies. A minor one is `pytz`, which handles timezones. The biggest one by far is `kivy`, a comprehensive Python graphics library.
-
-If an **_EasyCoder_** script filename ends with `.ecs` it's a command-line script. If it ends with `.ecg` it's a script for a graphical application and will cause `kivy` to be imported. Obviously this will only work on a GUI-based system, whereas command-line scripts will run anywhere there is Python.

easycoder/ec_graphics.py

@@ -1,314 +0,0 @@
-from .ec_classes import FatalError, RuntimeError, Object
-from .ec_handler import Handler
-from .ec_gutils import GUtils
-import PySimpleGUI as psg
-import json
-
-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['args'] = name
-            elif keyword in ['column', 'frame', 'tab']:
-                command['name'] = name
-                command['type'] = token
-                if self.peek() == 'to':
-                    command['args'] = []
-                else:
-                    command['args'] = self.utils.getArgs(self)
-        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_add(self, command):
-        target = self.getVariable(command['target'])
-        type = command['type']
-        args = command['args']
-        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)):
-                args = self.utils.decode(default, layout[n])
-            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_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()
-            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':
-            layout = self.getVariable(command['layout'])
-            title = self.getRuntimeValue(command['title'])
-            record['window'] = psg.Window(title, layout['layout'], finalize=True)
-            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()
-
-    def k_set(self, command):
-        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):
-        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.WINDOW_CLOSED or event == "EXIT":
-                break
-            if event == '__TIMEOUT__': self.program.flushCB()
-            else:
-                if event in eventHandlers:
-                    self.eventValues = values
-                    eventHandlers[event]()

easycoder/ec_gutils.py

@@ -1,84 +0,0 @@
-import PySimpleGUI as psg
-import json
-
-class GUtils:
-
-    # Parse a set of compile-time arguments
-    def getArgs(self, handler):
-        args = []
-        while True:
-            key = handler.nextToken()
-            value = json.dumps(handler.nextValue())
-            args.append(f'{key}={value}')
-            if handler.peek() == 'and':
-                handler.nextToken()
-            else: break
-        v = {}
-        v['type'] = 'text'
-        v['content'] = json.dumps(args)
-        return json.dumps(v)
-
-    # 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
-        return args
-
-    # Decode an argument at runtime
-    def decode(self, args, text):
-        p = text.find('=')
-        if p > 0:
-            key = text[0:p]
-            value = json.loads(text[p+1:])['content']
-            args[key] = value
-            return args
-        return None
-
-    # 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'])
-        else: return None
-
-    def getSize(self, args):
-        size = args['size']
-        if size == (None, None):
-            return size
-        size = size.split()
-        return (size[0], size[1])

easycoder-250118.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-easycoder/README.md,sha256=PYqOc_SkIGiFbyCNs90y7JqoqWe4aO1xYIW-6bOnFKU,573
-easycoder/__init__.py,sha256=eHRjGvRE1Q4gkU7LU7u5U422z1Krs_a2AdY1PHd2sQw,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_handler.py,sha256=IJvxcrJJSR53d6DS_8H5qPHKhp9y5-GV4WXAjhZxu_o,2250
-easycoder/ec_program.py,sha256=wU-vWRWAYK2Ie4EFnp8HeSPUL0bxz-j9HLQSNplObcc,9919
-easycoder/ec_timestamp.py,sha256=_3QFJPzIWZ9Rzk3SQOQJ-gwmvB07pg78k23SPntoZtY,288
-easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
-easycoder-250118.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-250118.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-250118.1.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
-easycoder-250118.1.dist-info/METADATA,sha256=UvUpqmF2I9xQP44f6RKcYtsNPI9Y7eTbd128KE9QMZs,6162
-easycoder-250118.1.dist-info/RECORD,,