therl 0.1.0__tar.gz

therl-0.1.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: therl
+Version: 0.1.0
+Summary: A human readable programming language
+Author-email: CyzmiX <itzmedigamingx@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Therl
+
+> **T**ruly **H**uman **R**eadaby **L**anguage  
+> _(Yes, the acronym is a little cursed. I know.)_
+
+Therl is a human-readable, instruction-based programming language written entirely in pure Python. Its goal is to make code read almost like plain English while remaining predictable and easy to parse.
+
+```therl
+set greeting to "hello"
+
+func greet <name>
+
+    say greeting + " " + name + "!"
+
+eof
+
+func main
+
+    run greet with <name> as "Jeff"
+
+    set numbers to [1..10]
+
+    say numbers
+
+eof
+
+run main
+```
+
+Output:
+
+```text
+hello Jeff!
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+---
+
+## Features
+
+- 📖 Human-readable syntax
+- 📝 Instruction-based language design
+- 🐍 Written entirely in pure Python
+- 🔄 Strictly dynamically typed variables
+- 📦 Built-in lists
+- 🔢 Integer, float, string and boolean types
+- 🧩 Functions with named parameters
+- 📢 Simple `say` statement for output
+- ✏️ Mutable list elements
+- 🚀 Easy to extend
+
+---
+
+## Example
+
+```therl
+set greeting to "hello"
+
+func greet <name>
+
+    say greeting + " " + name + "!"
+
+eof
+
+func main
+
+    say "Welcome!"
+
+    run greet with <name> as "Jeff"
+
+    set ids to [1..10]
+
+    say ids
+
+    set ids at 0 to 1000
+
+    say ids
+
+    add 10 to ids
+
+    say ids
+
+eof
+
+run main
+```
+
+Output:
+
+```text
+Welcome!
+hello Jeff!
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+[1000, 2, 3, 4, 5, 6, 7, 8, 9]
+[1000, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+---
+
+# Project Status
+
+⚠️ Therl is currently in active development.
+
+Expect missing features, breaking changes, and plenty of experimentation as the language evolves.
+
+---
+
+# Roadmap
+
+- [ ] Arithmetic expressions
+- [ ] Conditional statements
+- [ ] Loops
+- [ ] Dictionaries / Maps
+- [ ] Modules
+- [ ] Classes
+- [ ] Error reporting with line numbers
+- [ ] Standard library
+
+---
+
+# Why?
+
+Because making programming languages is fun.
+
+And because writing
+
+```therl
+set score to 100
+
+add 10 to score
+
+say score
+```
+
+just feels oddly satisfying.
+
+---

therl-0.1.0/README.md

@@ -0,0 +1,137 @@
+# Therl
+
+> **T**ruly **H**uman **R**eadaby **L**anguage  
+> _(Yes, the acronym is a little cursed. I know.)_
+
+Therl is a human-readable, instruction-based programming language written entirely in pure Python. Its goal is to make code read almost like plain English while remaining predictable and easy to parse.
+
+```therl
+set greeting to "hello"
+
+func greet <name>
+
+    say greeting + " " + name + "!"
+
+eof
+
+func main
+
+    run greet with <name> as "Jeff"
+
+    set numbers to [1..10]
+
+    say numbers
+
+eof
+
+run main
+```
+
+Output:
+
+```text
+hello Jeff!
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+---
+
+## Features
+
+- 📖 Human-readable syntax
+- 📝 Instruction-based language design
+- 🐍 Written entirely in pure Python
+- 🔄 Strictly dynamically typed variables
+- 📦 Built-in lists
+- 🔢 Integer, float, string and boolean types
+- 🧩 Functions with named parameters
+- 📢 Simple `say` statement for output
+- ✏️ Mutable list elements
+- 🚀 Easy to extend
+
+---
+
+## Example
+
+```therl
+set greeting to "hello"
+
+func greet <name>
+
+    say greeting + " " + name + "!"
+
+eof
+
+func main
+
+    say "Welcome!"
+
+    run greet with <name> as "Jeff"
+
+    set ids to [1..10]
+
+    say ids
+
+    set ids at 0 to 1000
+
+    say ids
+
+    add 10 to ids
+
+    say ids
+
+eof
+
+run main
+```
+
+Output:
+
+```text
+Welcome!
+hello Jeff!
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+[1000, 2, 3, 4, 5, 6, 7, 8, 9]
+[1000, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+---
+
+# Project Status
+
+⚠️ Therl is currently in active development.
+
+Expect missing features, breaking changes, and plenty of experimentation as the language evolves.
+
+---
+
+# Roadmap
+
+- [ ] Arithmetic expressions
+- [ ] Conditional statements
+- [ ] Loops
+- [ ] Dictionaries / Maps
+- [ ] Modules
+- [ ] Classes
+- [ ] Error reporting with line numbers
+- [ ] Standard library
+
+---
+
+# Why?
+
+Because making programming languages is fun.
+
+And because writing
+
+```therl
+set score to 100
+
+add 10 to score
+
+say score
+```
+
+just feels oddly satisfying.
+
+---

therl-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "therl"
+version = "0.1.0"
+description = "A human readable programming language"
+authors = [
+  { name="CyzmiX", email="itzmedigamingx@gmail.com" },
+]
+readme = "README.md"
+requires-python = ">=3.13"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+run-my-tool = "therl.app:main"

therl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

therl-0.1.0/src/therl/__main__.py

@@ -0,0 +1,4 @@
+from therl.main import main
+
+if __name__ == "__main__":
+    main()

therl-0.1.0/src/therl/consts.py

@@ -0,0 +1,13 @@
+import re
+
+from .instructions import ADD, CAST, RUN, SAY, SET
+
+OPERATORS = ["+", "-", "/", "*", "**"]
+INSTRUCTIONS_KEYWORDS = sorted(
+    ["add", "set", "say", "cast", "func", "eof", "run"],
+    key=len,
+    reverse=True,
+)
+INSTRUCTION_TO_FUNC = {"say": SAY, "set": SET, "cast": CAST, "add": ADD, "run": RUN}
+pattern = f"({'|'.join(map(re.escape, INSTRUCTIONS_KEYWORDS))})"
+params_pattern = f"({'|'.join(map(re.escape, ['<', '>']))})"

therl-0.1.0/src/therl/functions.py

@@ -0,0 +1,40 @@
+import sys
+
+from .consts import INSTRUCTION_TO_FUNC
+from .types import VARIABLES_TYPE
+
+
+class Function:
+    def __init__(
+        self,
+        name: str,
+        params: list[str],
+        instructions: list[str] | None = None,
+    ) -> None:
+        self.instructions = instructions
+        self.name = name
+        self.params = params
+
+    def __name__(self):
+        return "function"
+
+    def run(self, params: VARIABLES_TYPE | None = None):
+        import therl.runtime
+
+        if self.instructions is None:
+            return
+
+        OLD_VARIABLES = therl.runtime.VARIABLES
+
+        if params:
+            therl.runtime.VARIABLES = therl.runtime.VARIABLES | params
+
+        for instruction in self.instructions:
+            action = instruction[0]
+
+            try:
+                INSTRUCTION_TO_FUNC[action](instruction[1])
+                therl.runtime.VARIABLES = OLD_VARIABLES
+            except (KeyError, IndexError):
+                print("invalid instruction:", str(instruction))
+                sys.exit(1)

therl-0.1.0/src/therl/instructions.py

@@ -0,0 +1,205 @@
+import re
+import sys
+
+from .types import VARIABLES_TYPE
+from .utils import _decode_value
+from .variable import Variable
+
+
+def SET(string: str):
+    from .runtime import VARIABLES
+
+    check_slices = string.split(" ")
+
+    if check_slices[1] == "to":
+        slices = string.split(" ", maxsplit=2)
+
+        name = slices[0]
+        value = slices[2]
+        alr_exits = VARIABLES.get(name)
+
+        if alr_exits is not None:
+            alr_exits.set(new_value=_decode_value(value))
+            return
+
+        VARIABLES[name] = Variable(name=name, value=_decode_value(value))
+
+    elif check_slices[1] == "at":
+        slices = string.split(" ", maxsplit=2)
+
+        name = slices[0]
+        alr_exits = VARIABLES.get(name)
+        if alr_exits is None:
+            print(f"Cannot modify unexisisting array named {name}")
+            sys.exit(1)
+
+        if alr_exits.type != list and alr_exits.type != str:
+            print(
+                f"Cannot perform index based modification on {alr_exits.type.__name__}, must list or str"
+            )
+            sys.exit(1)
+
+        index_and_value = [i.strip() for i in slices[2].split("to")]
+        try:
+            index = index_and_value[0]
+            if VARIABLES.get(index) is not None:
+                if VARIABLES.get(index).type != int:
+                    print(
+                        f"Invalid index type, expected int found {VARIABLES.get(index).type.__name__}"
+                    )
+                    sys.exit(1)
+                index = VARIABLES.get(index).value
+            else:
+                index = int(index)
+        except ValueError:
+            print("Invalid index type, expected int found str")
+            sys.exit(1)
+        value = index_and_value[1]
+        try:
+            VARIABLES[name].value[index] = (
+                _decode_value(value) if alr_exits.type == list else str(value)
+            )
+        except IndexError:
+            print("Index out of range!")
+            sys.exit(1)
+
+    else:
+        print("invalid syntax expected 'to' in variable assignment")
+        sys.exit(1)
+
+
+def SAY(string: str):
+    from .runtime import VARIABLES
+
+    alr_exits = VARIABLES.get(string.strip())
+
+    if "at" in string:
+        var_and_index = [s.strip() for s in string.split("at")]
+        name = var_and_index[0]
+
+        if VARIABLES.get(name) is None:
+            print(f"Variable with name {name} doesnt exist")
+            sys.exit(1)
+
+        try:
+            index = var_and_index[1]
+            if VARIABLES.get(index) is not None:
+                if VARIABLES.get(index).type != int:
+                    print(
+                        f"Invalid index type, expected int found {VARIABLES.get(index).type.__name__}"
+                    )
+                    sys.exit(1)
+                index = VARIABLES.get(index).value
+            else:
+                index = int(index)
+        except ValueError:
+            print("Invalid index type, expected int found str")
+            sys.exit(1)
+
+        try:
+            print(VARIABLES[name].value[index])
+            return
+        except IndexError:
+            print("Index out of range")
+            sys.exit(1)
+
+    if alr_exits is not None:
+        print(alr_exits.value)
+        return
+
+    print(_decode_value(string))
+
+
+def CAST(string: str):
+    from .runtime import VARIABLES
+
+    slices = [s.strip() for s in string.split("to") if s]
+    name = slices[0]
+    new_type = slices[1]
+    alr_exits = VARIABLES.get(name)
+
+    if alr_exits is None:
+        print(f"Variable with name {name} doesnt exist")
+        sys.exit(1)
+
+    if new_type == "int":
+        alr_exits.cast(int(alr_exits.value))
+
+    elif new_type == "float":
+        alr_exits.cast(float(alr_exits.value))
+
+    elif new_type == "str":
+        alr_exits.cast(str(alr_exits.value))
+
+    elif new_type == "array":
+        alr_exits.cast(list(alr_exits.value))
+
+    else:
+        print(f"Invalid type {new_type}")
+        sys.exit(1)
+
+
+def ADD(string: str):
+    from .runtime import VARIABLES
+
+    slices = [s.strip() for s in string.split("to") if s]
+    name = slices[1]
+    new_value = _decode_value(slices[0])
+    alr_exits = VARIABLES.get(name)
+
+    if alr_exits is None:
+        print(f"Variable with name {name} doesnt exist")
+        sys.exit(1)
+
+    if alr_exits.type != list:
+        print(f"Variable must be an array not a {alr_exits.type.__name__}")
+        sys.exit(1)
+
+    alr_exits.value.append(new_value)
+
+
+def RUN(string: str):
+    from .functions import Function
+    from .runtime import VARIABLES
+
+    slices = [_.strip() for _ in string.split(" ") if _]
+
+    func_name = slices[0]
+
+    if VARIABLES.get(func_name) is None:
+        print(f"Function named {func_name} doesnt exist!")
+        sys.exit(1)
+
+    if VARIABLES.get(func_name).type != Function:
+        print(
+            f"Cant run variable of type {VARIABLES.get(func_name).type.__name__}, must be a function!"
+        )
+        sys.exit(1)
+
+    if len(slices) == 1:
+        VARIABLES[func_name].value.run()
+        return
+
+    if slices[1] == "with":
+        params: VARIABLES_TYPE = {}
+        params_slices = [_.strip() for _ in " ".join(slices[2:]).split("and")]
+
+        for param in params_slices:
+            s = [_.strip() for _ in re.split(re.escape(" "), param) if _]
+            if s[1] != "as":
+                print(f"Expected as in parameter assignment, found {s[1]}")
+                sys.exit()
+            name = s[0].strip().replace("<", "").replace(">", "")
+
+            if name not in VARIABLES.get(func_name).value.params:
+                print(f"Unknown parameter {name}")
+                sys.exit(1)
+
+            value = s[2].strip()
+
+            if VARIABLES.get(value) is not None:
+                params[name] = VARIABLES.get(value)
+            else:
+                params[name] = Variable(name=name, value=_decode_value(value))
+
+        VARIABLES[func_name].value.run(params=params)

therl-0.1.0/src/therl/main.py

@@ -0,0 +1,81 @@
+import re
+import sys
+
+from therl.consts import INSTRUCTION_TO_FUNC, params_pattern, pattern
+from therl.functions import Function
+from therl.runtime import VARIABLES
+from therl.variable import Variable
+
+
+def main():
+    try:
+        if sys.argv[1].split(".")[-1] != "therl":
+            print("Invalid file type, file must be .therl")
+            sys.exit(1)
+
+        with open(sys.argv[1], "r") as file:
+            instructions = [line.strip() for line in file if line.strip()]
+    except IndexError:
+        print("no file provided!")
+        sys.exit(1)
+    except FileNotFoundError:
+        print("file doesnt exist!")
+        sys.exit(1)
+
+    inside_function = False
+    cur_func_instuctions = []
+    cur_func_name = ""
+    cur_func_params = set()
+
+    for instruction in instructions:
+        tokens = [t.strip() for t in re.split(pattern, instruction, maxsplit=2) if t]
+
+        action = tokens[0]
+
+        arg = "".join(tokens[1:])
+
+        if action == "eof":
+            inside_function = False
+
+            VARIABLES[cur_func_name] = Variable(
+                name=cur_func_name,
+                value=Function(
+                    name=cur_func_name,
+                    instructions=cur_func_instuctions,
+                    params=list(cur_func_params),
+                ),
+            )
+            cur_func_name = ""
+            cur_func_instuctions = []
+            cur_func_params.clear()
+            continue
+
+        if inside_function:
+            cur_func_instuctions.append(tokens)
+            continue
+
+        if action == "func":
+            name_and_params = [l.strip() for l in arg.split(" ") if l]
+            cur_func_name = name_and_params[0]
+
+            if VARIABLES.get(cur_func_name) is not None:
+                print(
+                    f"Cant name function to a variable of the same name, '{cur_func_name}' is already defined!"
+                )
+                sys.exit(1)
+
+            inside_function = True
+            params_split = [
+                t.strip()
+                for t in re.split(params_pattern, "".join(name_and_params[1:]))
+                if t
+            ]
+            for i, param in enumerate(params_split):
+                try:
+                    if param == "<" and params_split[i + 2] == ">":
+                        cur_func_params.add(params_split[i + 1])
+                except IndexError:
+                    break
+
+        if not inside_function:
+            INSTRUCTION_TO_FUNC[action](arg)

therl-0.1.0/src/therl/runtime.py

@@ -0,0 +1,4 @@
+from .types import VARIABLES_TYPE
+
+VARIABLES: VARIABLES_TYPE = {}
+SYNTAX = {"assign_value": "to"}

therl-0.1.0/src/therl/types.py

@@ -0,0 +1,3 @@
+from .variable import Variable
+
+type VARIABLES_TYPE = dict[str, Variable]

therl-0.1.0/src/therl/utils.py

@@ -0,0 +1,83 @@
+import sys
+from typing import Any
+
+import therl.consts
+
+
+def _decode_value(value: str) -> Any:
+    from therl.runtime import VARIABLES
+
+    if value[0] == "[" and value[-1] == "]":
+        return _decode_array(value)
+
+    used_operator = not set(value.split(" ")).isdisjoint(therl.consts.OPERATORS)
+
+    if used_operator:
+        try:
+            return eval(
+                value,
+                None,
+                {
+                    var[0]: var[1].value for var in VARIABLES.items()
+                },  # will it be unsafe in this case ?
+            )
+        except NameError as e:
+            print(f"variable nammed {e.name} doesnt exist!")
+            sys.exit(1)
+
+    if value.strip()[0] == value.strip()[-1] == '"':
+        return str(value[1:-1])
+
+    if value.strip().lower() == "true":
+        return True
+    if value.strip().lower() == "false":
+        return False
+
+    # Try Integer
+    try:
+        return int(value)
+    except ValueError:
+        pass
+
+    # Try Float
+    try:
+        return float(value)
+    except ValueError:
+        pass
+
+    if VARIABLES.get(value) is not None:
+        return VARIABLES.get(value).value
+
+    print("Invalid data value: ", value.strip())
+    sys.exit(1)
+
+
+def _decode_array(array_str: str) -> list:
+    clean_str = array_str[1:-1]  # remove [ ]
+
+    if clean_str.strip() == "":
+        return []
+
+    if ".." in clean_str:
+        try:
+            s_and_f = clean_str.split("..")
+            start = int(s_and_f[0])
+
+            finish = int(s_and_f[-1])
+
+            return list(range(start, finish))
+        except ValueError:
+            print("Array sequence must be made with two ints!")
+            sys.exit(1)
+
+    array = []
+
+    for val in clean_str.split(","):
+        v = _decode_value(val.strip())
+        if len(array) > 0 and type(array[0]) != type(v):
+            print("Cannot mix and match data types in array!")
+            sys.exit(1)
+
+        array.append(v)
+
+    return array

therl-0.1.0/src/therl/variable.py

@@ -0,0 +1,24 @@
+import sys
+from typing import Any, Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class Variable(Generic[T]):
+    def __init__(self, name: str, value: T) -> None:
+        self.name = name
+        self.type: type[T] = type(value)
+        self.value: T = value
+
+    def set(self, new_value: Any):
+        if type(new_value) is not self.type:
+            print(
+                f"Error variable types doesnt match! from {self.type.__name__} to {type(new_value).__name__}"
+            )
+            sys.exit(1)
+
+        self.value = new_value
+
+    def cast(self, new_value: T):
+        self.type: type[T] = type(new_value)
+        self.value: T = new_value

therl-0.1.0/src/therl.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: therl
+Version: 0.1.0
+Summary: A human readable programming language
+Author-email: CyzmiX <itzmedigamingx@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Therl
+
+> **T**ruly **H**uman **R**eadaby **L**anguage  
+> _(Yes, the acronym is a little cursed. I know.)_
+
+Therl is a human-readable, instruction-based programming language written entirely in pure Python. Its goal is to make code read almost like plain English while remaining predictable and easy to parse.
+
+```therl
+set greeting to "hello"
+
+func greet <name>
+
+    say greeting + " " + name + "!"
+
+eof
+
+func main
+
+    run greet with <name> as "Jeff"
+
+    set numbers to [1..10]
+
+    say numbers
+
+eof
+
+run main
+```
+
+Output:
+
+```text
+hello Jeff!
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+---
+
+## Features
+
+- 📖 Human-readable syntax
+- 📝 Instruction-based language design
+- 🐍 Written entirely in pure Python
+- 🔄 Strictly dynamically typed variables
+- 📦 Built-in lists
+- 🔢 Integer, float, string and boolean types
+- 🧩 Functions with named parameters
+- 📢 Simple `say` statement for output
+- ✏️ Mutable list elements
+- 🚀 Easy to extend
+
+---
+
+## Example
+
+```therl
+set greeting to "hello"
+
+func greet <name>
+
+    say greeting + " " + name + "!"
+
+eof
+
+func main
+
+    say "Welcome!"
+
+    run greet with <name> as "Jeff"
+
+    set ids to [1..10]
+
+    say ids
+
+    set ids at 0 to 1000
+
+    say ids
+
+    add 10 to ids
+
+    say ids
+
+eof
+
+run main
+```
+
+Output:
+
+```text
+Welcome!
+hello Jeff!
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+[1000, 2, 3, 4, 5, 6, 7, 8, 9]
+[1000, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+---
+
+# Project Status
+
+⚠️ Therl is currently in active development.
+
+Expect missing features, breaking changes, and plenty of experimentation as the language evolves.
+
+---
+
+# Roadmap
+
+- [ ] Arithmetic expressions
+- [ ] Conditional statements
+- [ ] Loops
+- [ ] Dictionaries / Maps
+- [ ] Modules
+- [ ] Classes
+- [ ] Error reporting with line numbers
+- [ ] Standard library
+
+---
+
+# Why?
+
+Because making programming languages is fun.
+
+And because writing
+
+```therl
+set score to 100
+
+add 10 to score
+
+say score
+```
+
+just feels oddly satisfying.
+
+---

therl-0.1.0/src/therl.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/therl/__init__.py
+src/therl/__main__.py
+src/therl/consts.py
+src/therl/functions.py
+src/therl/instructions.py
+src/therl/main.py
+src/therl/runtime.py
+src/therl/types.py
+src/therl/utils.py
+src/therl/variable.py
+src/therl.egg-info/PKG-INFO
+src/therl.egg-info/SOURCES.txt
+src/therl.egg-info/dependency_links.txt
+src/therl.egg-info/entry_points.txt
+src/therl.egg-info/top_level.txt

therl-0.1.0/src/therl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

therl-0.1.0/src/therl.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+run-my-tool = therl.app:main

therl-0.1.0/src/therl.egg-info/top_level.txt

@@ -0,0 +1 @@
+therl