solpl 2.0.0__tar.gz → 2.1.0__tar.gz

solpl-2.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: solpl
+Version: 2.1.0
+Summary: Sol Programming Language Interpreter
+Requires-Python: >=3.7
+License-File: LICENSE
+Dynamic: license-file

solpl-2.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "solpl"
+version = "2.1.0"
+description = "Sol Programming Language Interpreter"
+requires-python = ">=3.7"
+
+[project.scripts]
+solpl = "sol:main"
+
+[tool.setuptools]
+py-modules = ["sol"]

solpl-2.1.0/solpl.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: solpl
+Version: 2.1.0
+Summary: Sol Programming Language Interpreter
+Requires-Python: >=3.7
+License-File: LICENSE
+Dynamic: license-file

{solpl-2.0.0 → solpl-2.1.0}/solpl.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 README.md
 pyproject.toml
-interpreter/sol.py
 solpl.egg-info/PKG-INFO
 solpl.egg-info/SOURCES.txt
 solpl.egg-info/dependency_links.txt

solpl-2.1.0/solpl.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+solpl = sol:main

solpl-2.1.0/solpl.egg-info/top_level.txt

@@ -0,0 +1 @@
+sol

solpl-2.0.0/PKG-INFO

@@ -1,59 +0,0 @@
-Metadata-Version: 2.4
-Name: solpl
-Version: 2.0.0
-Summary: A lightweight, multi-threaded interpreter for the Sol programming language.
-Author-email: Your Name <your.email@example.com>
-License: Apache-2.0
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# Sol
-Sol is an interpreted language built with Python, originally designed to handle async operations only, but has expanded to a full scripting language.
-
-# Why did I build Sol?
-
-I needed something fast, that handled async natively, and which had very few keywords. Then came my first prototype, which only supported async functions. Sol now supports everything a programming language should need: Functions, variables, I/O, etc.
-
-# How to install Sol?
-
-```bash
-pip install solpl
-```
-
-# How to run a Sol script?
-
-```bash
-solpl FILENAME.sol
-```
-
-# Example:
-
-This demonstrates Sol's capabilities with async:
-
-```lua
-countDown(taskName, maxCount)
-    for i -> 1 to maxCount
-        _out -> taskName
-    end
-end
-
-main()
-    _out -> 111
-    countDown(777, 4) >> _async
-    countDown(999, 4) >> _async
-    _out -> 222
-end
-```
-
-# License
-
-This repository is licensed with Apache License 2.0, see the LICENSE file for more details
-
-# Link to PyPi package:
-
-https://pypi.org/project/solpl/

solpl-2.0.0/interpreter/sol.py

@@ -1,445 +0,0 @@
-import math
-import threading
-import time
-import sys
-import os
-import urllib.request  # Native network calls, zero external dependencies!
-import http.server
-
-class ReturnSignal(Exception):
-    def __init__(self, value):
-        self.value = value
-
-class SolInterpreter:
-    def __init__(self):
-        self.variables = {}
-        self.thread_local = threading.local()
-        self.functions = {}
-        self.struct_blueprints = {} 
-        self.lines = []
-        self.threads = []
-
-    @property
-    def scope_stack(self):
-        if not hasattr(self.thread_local, "stack"):
-            self.thread_local.stack = [self.variables]
-        return self.thread_local.stack
-
-    def _compute(self, expr):
-        expr = str(expr).strip()
-        ops = ['+', '-', '*', ':']
-        for op in ops:
-            if op in expr:
-                left, right = expr.split(op)
-                val1 = float(self._resolve(left))
-                val2 = float(self._resolve(right))
-                if op == '+': return val1 + val2
-                if op == '-': return val1 - val2
-                if op == '*': return val1 * val2
-                if op == ':': return val1 / val2
-        return self._resolve(expr)
-
-    def _lookup(self, name):
-        for scope in reversed(self.scope_stack):
-            if name in scope:
-                return scope[name]
-        return None
-
-    def _assign(self, name, val):
-        self.scope_stack[-1][name] = val
-
-    def _resolve(self, val):
-        val = str(val).strip()
-
-        # Handle built-in native functions
-        if val.startswith("_fetch(") and val.endswith(")"):
-            url_expr = val[7:-1].strip()
-            url = str(self._compute(url_expr))
-            return self._native_fetch(url)
-
-        if "(" in val and val.endswith(")") and not val.startswith("_"):
-            parts = val.split("(", 1)
-            name = parts[0].strip()
-            if name in self.functions:
-                args_str = parts[1][:-1].strip()
-                args = [self._compute(a.strip()) for a in args_str.split(",")] if args_str else []
-                return self._call_function(name, args)
-
-        if "[" in val and "]" in val:
-            try:
-                name, idx_part = val.split("[")
-                idx = int(idx_part.replace("]", "").strip())
-                container = self._lookup(name)
-                if isinstance(container, list):
-                    return container[idx]
-            except (ValueError, IndexError, KeyError): pass
-        if "." in val:
-            obj_name, prop = val.split(".")
-            obj = self._lookup(obj_name)
-            if isinstance(obj, dict):
-                return obj.get(prop, 0)
-
-        existing_val = self._lookup(val)
-        if Carlsbad_val := self._lookup(val): return Carlsbad_val
-        if existing_val is not None: return existing_val
-        try: return float(val) if '.' in val else int(val)
-        except: return val.replace('"', '').replace("'", "")
-
-    def _async_worker(self, expr, action):
-        result = self._compute(expr)
-        if action == "_out":
-            print(f"[ASYNC OUTPUT] {result}")
-
-    def _async_input_worker(self, prompt, var_name):
-        user_val = input(prompt)
-        try:
-            if '.' in user_val: user_val = float(user_val)
-            else: user_val = int(user_val)
-        except ValueError: pass
-        self._assign(var_name, user_val)
-
-    def _native_fetch(self, url):
-        try:
-            with urllib.request.urlopen(url, timeout=5) as response:
-                return response.read().decode('utf-8')
-        except Exception as e:
-            return f"Error fetching URL: {str(e)}"
-
-    def _native_listen(self, port, handler_name):
-        interpreter_instance = self
-        class SolHTTPHandler(http.server.BaseHTTPRequestHandler):
-            def do_GET(self):
-                self.send_response(200)
-                self.send_header("Content-type", "text/html")
-                self.end_headers()
-                response_body = interpreter_instance._call_function(handler_name, [self.path])
-                self.wfile.write(bytes(str(response_body), "utf-8"))
-            def log_message(self, format, *args):
-                pass 
-
-        def server_thread():
-            server = http.server.HTTPServer(("0.0.0.0", int(port)), SolHTTPHandler)
-            server.serve_forever()
-
-        t = threading.Thread(target=server_thread, daemon=True)
-        t.start()
-        self.threads.append(t)
-
-    def _evaluate_condition(self, cond):
-        if "=" in cond:
-            left, right = cond.split("=")
-            return self._compute(left.strip()) == self._compute(right.strip())
-        elif "<" in cond:
-            left, right = cond.split("<")
-            return self._compute(left.strip()) < self._compute(right.strip())
-        elif ">" in cond:
-            left, right = cond.split(">")
-            return self._compute(left.strip()) > self._compute(right.strip())
-        return False
-
-    def _get_block_end(self, start_pc):
-        depth = 1
-        pc = start_pc + 1
-        while pc < len(self.lines):
-            line = self.lines[pc]
-            if line.startswith("if ") or line.startswith("while ") or line.startswith("for "):
-                depth += 1
-            elif line == "end":
-                depth -= 1
-                if depth == 0:
-                    return pc
-            pc += 1
-        return pc
-
-    def execute(self, code):
-        self.lines = []
-        for raw_line in code.split('\n'):
-            if ';' in raw_line:
-                raw_line = raw_line.split(';', 1)[0]
-            trimmed = raw_line.strip()
-            if trimmed:
-                self.lines.append(trimmed)
-
-        self.threads = []
-
-        pc = 0
-        while pc < len(self.lines):
-            line = self.lines[pc]
-            if "(" in line and ")" in line and "main" not in line and "end" not in line and "->" not in line and ">>" not in line and "?" not in line and not line.startswith("if ") and not line.startswith("while ") and not line.startswith("for "):
-                parts = line.split("(")
-                name = parts[0].strip()
-                params_str = parts[1].replace(")", "").strip()
-                params = [p.strip() for p in params_str.split(",")] if params_str else []
-                self.functions[name] = {"start_pc": pc + 1, "params": params}
-            elif "{" in line:
-                pc = self._parse_struct(pc)
-                continue
-            pc += 1
-
-        for i, line in enumerate(self.lines):
-            if line == "main()":
-                try:
-                    self._run_block(i + 1)
-                except ReturnSignal:
-                    pass
-                break
-
-        for t in self.threads:
-            if t.is_alive() and not t.daemon:
-                t.join()
-
-    def _parse_struct(self, pc):
-        line = self.lines[pc]
-        struct_name = line.split("{}")[0].strip()
-        fields = {}
-        pc += 1
-        while pc < len(self.lines) and self.lines[pc] != "end":
-            if "->" in self.lines[pc]:
-                key, val = [x.strip() for x in self.lines[pc].split("->")]
-                fields[key] = self._resolve(val)
-            pc += 1
-        self.struct_blueprints[struct_name] = fields
-        self._assign(struct_name, fields.copy())
-        return pc
-
-    def _call_function(self, name, args):
-        func_info = self.functions[name]
-        start_pc = func_info["start_pc"]
-        params = func_info["params"]
-
-        local_scope = {}
-        for param, arg in zip(params, args):
-            local_scope[param] = arg
-
-        self.scope_stack.append(local_scope)
-
-        return_value = 0
-        try:
-            self._run_block(start_pc)
-        except ReturnSignal as sig:
-            return_value = sig.value
-        finally:
-            self.scope_stack.pop()
-
-        return return_value
-
-    def _execute_line(self, line):
-        # Pipeline Check for Asynchronous Custom Prompts: "Name: " >> _input >> a
-        if ">>" in line and "_input" in line:
-            parts = [p.strip() for p in line.split(">>")]
-            if len(parts) == 3 and parts[1] == "_input":
-                prompt_string = str(self._compute(parts[0]))
-                target_variable = parts[2]
-                
-                t = threading.Thread(target=self._async_input_worker, args=(prompt_string, target_variable))
-                t.start()
-                self.threads.append(t)
-                return
-
-        is_async_func = False
-        if ">>" in line and "_async" in line and "(" in line and not line.startswith("_"):
-            is_async_func = True
-            line = line.split(">>")[0].strip()
-
-        if line.startswith("_return ->"):
-            val_expr = line.split("->", 1)[1].strip()
-            result = self._compute(val_expr)
-            raise ReturnSignal(result)
-
-        elif ">>" in line and "_async" in line and not is_async_func:
-            parts = line.split(">>")
-            t = threading.Thread(target=self._async_worker, args=(parts[0].strip(), parts[2].strip()))
-            t.start()
-            self.threads.append(t)
-
-        elif line.startswith("_in ->"):
-            var_name = line.split("->")[1].strip()
-            user_val = input(f"[INPUT REQUIRED FOR %s]: " % var_name)
-            try:
-                if '.' in user_val: user_val = float(user_val)
-                else: user_val = int(user_val)
-            except ValueError: pass
-            self._assign(var_name, user_val)
-
-        elif "_add(" in line:
-            content = line.replace("_add(", "").replace(")", "")
-            parts = [p.strip() for p in content.split(",")]
-            container = self._lookup(parts[0])
-            if isinstance(container, list):
-                container.insert(int(parts[1]), self._resolve(parts[2]))
-        elif "_remove(" in line:
-            content = line.replace("_remove(", "").replace(")", "")
-            parts = [p.strip() for p in content.split(",")]
-            container = self._lookup(parts[0])
-            if isinstance(container, list):
-                container.pop(int(parts[1]))
-        elif "_listen(" in line:
-            content = line.replace("_listen(", "").replace(")", "")
-            port_expr, handler_expr = [p.strip() for p in content.split(",")]
-            port = self._compute(port_expr)
-            self._native_listen(port, handler_expr)
-        elif "_out" in line:
-            val = line.split("->")[1].strip()
-            print(self._compute(val))
-
-        elif "mylist<" in line and ">" in line:
-            var_name = line.split("<")[1].split(">")[0]
-            self._assign(var_name, [])
-
-        elif "->" in line:
-            var, val = [x.strip() for x in line.split("->")]
-            if "." in var:
-                obj, prop = var.split(".")
-                target_obj = self._lookup(obj)
-                if isinstance(target_obj, dict):
-                    target_obj[prop] = self._compute(val)
-            else:
-                self._assign(var, self._compute(val))
-        else:
-            if "(" in line and line.endswith(")") and not line.startswith("_"):
-                parts = line.split("(")
-                name = parts[0].strip()
-                if name in self.functions:
-                    args_str = parts[1][:-1].strip()
-                    args = [self._compute(a.strip()) for a in args_str.split(",")] if args_str else []
-
-                    if is_async_func:
-                        t = threading.Thread(target=self._call_function, args=(name, args))
-                        t.start()
-                        self.threads.append(t)
-                    else:
-                        self._call_function(name, args)
-
-    def _run_block(self, start_pc):
-        pc = start_pc
-        control_stack = [] 
-
-        while pc < len(self.lines):
-            line = self.lines[pc]
-            is_executing = all(level["executing"] for level in control_stack)
-
-            if line.startswith("if "):
-                cond = line.split("if ", 1)[1].strip()
-                if is_executing:
-                    cond_true = self._evaluate_condition(cond)
-                    control_stack.append({"type": "if", "executing": cond_true, "any_branch_true": cond_true})
-                else:
-                    control_stack.append({"type": "if", "executing": False, "any_branch_true": True})
-                pc += 1
-                continue
-
-            elif line.startswith("elseif "):
-                cond = line.split("elseif ", 1)[1].strip()
-                parent_active = all(level["executing"] for level in control_stack[:-1]) if len(control_stack) > 1 else True
-
-                if control_stack and control_stack[-1]["type"] == "if":
-                    if parent_active and not control_stack[-1]["any_branch_true"]:
-                        cond_true = self._evaluate_condition(cond)
-                        control_stack[-1]["executing"] = cond_true
-                        control_stack[-1]["any_branch_true"] = cond_true
-                    else:
-                        control_stack[-1]["executing"] = False
-                pc += 1
-                continue
-
-            elif line == "else":
-                parent_active = all(level["executing"] for level in control_stack[:-1]) if len(control_stack) > 1 else True
-                if control_stack and control_stack[-1]["type"] == "if":
-                    if parent_active and not control_stack[-1]["any_branch_true"]:
-                        control_stack[-1]["executing"] = True
-                        control_stack[-1]["any_branch_true"] = True
-                    else:
-                        control_stack[-1]["executing"] = False
-                pc += 1
-                continue
-
-            elif line.startswith("while "):
-                cond = line.split("while ", 1)[1].strip()
-                if is_executing:
-                    end_pc = self._get_block_end(pc)
-                    if self._evaluate_condition(cond):
-                        control_stack.append({"type": "while", "executing": True, "start_pc": pc, "end_pc": end_pc})
-                        pc += 1
-                    else:
-                        pc = end_pc + 1
-                else:
-                    control_stack.append({"type": "while", "executing": False})
-                    pc += 1
-                continue
-
-            elif line.startswith("for "):
-                if is_executing:
-                    parts = line.split("for ", 1)[1].split("->")
-                    var_name = parts[0].strip()
-                    range_parts = parts[1].split(" to ")
-                    start_val = int(self._compute(range_parts[0].strip()))
-                    end_val = int(self._compute(range_parts[1].strip()))
-
-                    self._assign(var_name, start_val)
-                    end_pc = self._get_block_end(pc)
-
-                    if start_val <= end_val:
-                        control_stack.append({"type": "for", "executing": True, "var": var_name, "end_val": end_val, "start_pc": pc, "end_pc": end_pc})
-                        pc += 1
-                    else:
-                        pc = end_pc + 1
-                else:
-                    control_stack.append({"type": "for", "executing": False})
-                    pc += 1
-                continue
-
-            elif line == "end":
-                if control_stack:
-                    top = control_stack[-1]
-                    if top.get("type") == "while" and top["executing"]:
-                        pc = top["start_pc"]
-                        control_stack.pop()
-                        continue
-                    elif top.get("type") == "for" and top["executing"]:
-                        var_name = top["var"]
-                        next_val = self._lookup(var_name) + 1
-                        if next_val <= top["end_val"]:
-                            self._assign(var_name, next_val)
-                            pc = top["start_pc"] + 1
-                            continue
-                        else:
-                            control_stack.pop()
-                            pc += 1
-                            continue
-                    else:
-                        control_stack.pop()
-                        pc += 1
-                        continue
-                else:
-                    break 
-
-            if is_executing:
-                if "?" in line:
-                    cond, action = line.split("?", 1)
-                    if self._evaluate_condition(cond.strip()):
-                        self._execute_line(action.strip())
-                else:
-                    self._execute_line(line)
-            pc += 1
-
-def main():
-    if len(sys.argv) < 2:
-        print("Error: No script file provided.\nUsage: solpl <filename.sol>", file=sys.stderr)
-        sys.exit(1)
-
-    filename = sys.argv[1]
-    if not filename.endswith(".sol"):
-        print("Error: File must have a '.sol' extension.", file=sys.stderr)
-        sys.exit(1)
-    if not os.path.exists(filename):
-        print(f"Error: File '{filename}' not found.", file=sys.stderr)
-        sys.exit(1)
-
-    with open(filename, "r") as f:
-        code_content = f.read()
-
-    engine = SolInterpreter()
-    engine.execute(code_content)
-
-if __name__ == "__main__":
-    main()

solpl-2.0.0/pyproject.toml

@@ -1,22 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "solpl"
-version = "2.0.0"
-authors = [
-    { name="Your Name", email="your.email@example.com" }
-]
-description = "A lightweight, multi-threaded interpreter for the Sol programming language."
-readme = "README.md"
-license = {text = "Apache-2.0"}
-requires-python = ">=3.7"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: Apache Software License",
-    "Operating System :: OS Independent",
-]
-
-[project.scripts]
-solpl = "interpreter.sol:main"

solpl-2.0.0/solpl.egg-info/PKG-INFO

@@ -1,59 +0,0 @@
-Metadata-Version: 2.4
-Name: solpl
-Version: 2.0.0
-Summary: A lightweight, multi-threaded interpreter for the Sol programming language.
-Author-email: Your Name <your.email@example.com>
-License: Apache-2.0
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# Sol
-Sol is an interpreted language built with Python, originally designed to handle async operations only, but has expanded to a full scripting language.
-
-# Why did I build Sol?
-
-I needed something fast, that handled async natively, and which had very few keywords. Then came my first prototype, which only supported async functions. Sol now supports everything a programming language should need: Functions, variables, I/O, etc.
-
-# How to install Sol?
-
-```bash
-pip install solpl
-```
-
-# How to run a Sol script?
-
-```bash
-solpl FILENAME.sol
-```
-
-# Example:
-
-This demonstrates Sol's capabilities with async:
-
-```lua
-countDown(taskName, maxCount)
-    for i -> 1 to maxCount
-        _out -> taskName
-    end
-end
-
-main()
-    _out -> 111
-    countDown(777, 4) >> _async
-    countDown(999, 4) >> _async
-    _out -> 222
-end
-```
-
-# License
-
-This repository is licensed with Apache License 2.0, see the LICENSE file for more details
-
-# Link to PyPi package:
-
-https://pypi.org/project/solpl/

solpl-2.0.0/solpl.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-solpl = interpreter.sol:main

solpl-2.0.0/solpl.egg-info/top_level.txt

@@ -1 +0,0 @@
-interpreter