bracket-lang 0.2.0__tar.gz → 0.4.0__tar.gz

bracket_lang-0.4.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include TKGUI_helloworld.jpg

bracket_lang-0.4.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: bracket-lang
+Version: 0.4.0
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pyinstaller>=6.0.0
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# bracket
+python制作的转译型简单编程语言
+
+## 1 安装
+```bash
+pip install bracket-lang
+```
+
+## 2 Hello world
+```bracket
+[INFO] ["Hello world!"]
+```
+
+## 3 基本语法
+```bracket
+# main.bracket
+
+# 打印
+[INFO] ["这是一段文本"]
+[INFO] ["Loading...", end=" "]
+[INFO] ["complete"]
+
+# 变量
+[VAR] [integer] [2]
+[VAR] [floating_point] [3.0]
+[VAR] [string] ["abc"]
+[VAR] [lst] [[1, 2, 3, 4, 5]]
+[VAR] [t] [(1, 2, 3)]
+[VAR] [dict] [{1: 1, 2: 4, 3: 9}]
+[INFO] [integer, floating_point, string, lst, t, dict]
+
+# 输入
+[VAR] [short] [INPUT] ["单行文本"] [False]
+[VAR] [long] [INPUT] ["多行文本"] [True]
+[INFO] ["您这两次分别输入了: "]
+[INFO] [short]
+[INFO] [long]
+
+# 分支语句
+[VAR] [a] [6]
+[IF] [a>0]
+    [INFO] ["正数"]
+[ELSEIF] [a==0]
+    [INFO] ["零"]
+[ELSE]
+    [INFO] ["负数"]
+
+# 循环
+[VAR] [total] [0]
+[FOR] [i] [1, 101, 1]
+    [VAR] [total] [total+i]
+[INFO] ["1~100的和:", total]
+[VAR] [i] [0]
+[WHILE] [i<10]
+    [INFO] [i]
+    [VAR] [i] [i+1]
+[LOOP]
+    [INFO] [i]
+    [IF] [i==100]
+        [BREAK]
+    [VAR] [i] [i+1]
+
+# 函数
+[FUNC] [longest] [x, y]
+    [IF] [len(x)>len(y)]
+        [RETURN] [x]
+    [RETURN] [y]
+[INFO] [longest("hi", "hello")]
+
+# 类
+[CLASS] [Calculator] [object]
+    [FUNC] [add] [a, b]
+        [RETURN] [a+b]
+    [FUNC] [subtract] [a, b]
+        [RETURN] [a-b]
+    [FUNC] [mul] [a, b]
+        [RETURN] [a*b]
+    [FUNC] [division] [a, b]
+        [IF] [b==0]
+            [ERROR] ["Cannot devide by zero."]
+        [RETURN] [a/b]
+    [FUNC] [percent] [a]
+        [RETURN] [a/100]
+[INFO] [Calculator.add(1, 1)]
+
+# 警告
+[WARN] ["警告信息"]
+
+# GUI
+[USE] [GUI]
+[VAR] [root] [Base()]
+root.title("Hello bracket")
+root.geometry("300x200")
+[VAR] [label] [Tag(root, text="Hello, World!")]
+label.pack()
+root.mainloop()
+```
+输出: 
+```text
+这是一段文本
+Loading... complete
+2 3.0 abc [1, 2, 3, 4, 5] (1, 2, 3) {1: 1, 2: 4, 3: 9}
+单行文本: 1
+多行文本: 2
+3
+您这两次分别输入了
+1
+2
+3
+正数
+5050
+1
+2
+3
+...
+100
+hello
+2
+警告信息[yellow]
+```
+![窗口显示: ](./TKGUI_helloHello.jpg)
+打包:
+```bash
+bracket pack main.bracket
+```
+
+## 4 命令行工具参数
+| 参数 | 用法 |
+| ------ | ------ |
+| `--help` `-h` | 帮助 |
+| `build` | 转译 |
+| `run` | 转译运行 |
+| `pack` | 打包成二进制 |
+
+## 6 注意事项
+1. `INFO`的参数与python的`print`基本相同
+2. `[VAR] [lst] [[1, 2, 3, 4, 5]]`是真正的列表, `[VAR] [t] [1, 2, 3, 4, 5]`是元组
+3. `FOR`必须要写三个参数
+4. `[LOOP]`是无限循环, 与`[WHILE] [True]`等效
+5. 变量名不能与bracket关键字和python关键字重名
+6. bracket语言不兼容python的列表推导式, 三元表达式等
+7. bracket内置轻量编辑器bkted

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/README.md

@@ -13,6 +13,8 @@ pip install bracket-lang
 
 ## 3 基本语法
 ```bracket
+# main.bracket
+
 # 打印
 [INFO] ["这是一段文本"]
 [INFO] ["Loading...", end=" "]
@@ -85,11 +87,11 @@ pip install bracket-lang
 [WARN] ["警告信息"]
 
 # GUI
-[USE] [TKGUI]
-[VAR] [root] [TKGUI.Tk()]
+[USE] [GUI]
+[VAR] [root] [Base()]
 root.title("Hello bracket")
 root.geometry("300x200")
-[VAR] [label] [TKGUI.Label(root, text="Hello, World!")]
+[VAR] [label] [Tag(root, text="Hello, World!")]
 label.pack()
 root.mainloop()
 ```
@@ -117,6 +119,10 @@ hello
 警告信息[yellow]
 ```
 ![窗口显示: ](./TKGUI_helloHello.jpg)
+打包:
+```bash
+bracket pack main.bracket
+```
 
 ## 4 命令行工具参数
 | 参数 | 用法 |
@@ -124,6 +130,7 @@ hello
 | `--help` `-h` | 帮助 |
 | `build` | 转译 |
 | `run` | 转译运行 |
+| `pack` | 打包成二进制 |
 
 ## 6 注意事项
 1. `INFO`的参数与python的`print`基本相同

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/BRANCH.py

@@ -2,12 +2,18 @@
 # bracket/BRANCH.py
 # manage the branch sentences
 
+import sys
+
+import rich
+
 # [IF] [<cond>] → if <cond>:
 def IF_to_if(code: str):
     code = code.lstrip()
     keyword, cond = code.split(" ", 1)
     if keyword!="[IF]":
-        raise SyntaxError(f"Expect `[IF]` got {keyword}")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"error:Expect `[IF]` got {keyword}")
+        sys.exit(1)
     text = cond.removeprefix("[").removesuffix("]")
     return f"if {text}:"
 
@@ -16,7 +22,9 @@ def ELSEIF_to_elif(code: str):
     code = code.lstrip()
     keyword, cond = code.split(" ", 1)
     if keyword!="[ELSEIF]":
-        raise SyntaxError(f"Expect `[ELSEIF]` got {keyword}")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"error:Expect `[ELSEIF]` got {keyword}")
+        sys.exit(1)
     text = cond.removeprefix("[").removesuffix("]")
     return f"elif {text}:"
 
@@ -24,7 +32,9 @@ def ELSEIF_to_elif(code: str):
 def ELSE_to_else(code: str):
     code = code.lstrip()
     if code!="[ELSE]":
-        raise SyntaxError(f"Expect `[ELSE]` got {code}")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"error:Expect `[ELSE]` got {keyword}")
+        sys.exit(1)
     return "else:"
 
 def transpile_line(line: str):

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/CLASS.py

@@ -2,27 +2,41 @@
 # bracket/CLASS.py
 # manage classes defining
 
+import sys
 from keyword import kwlist
 
+import rich
+
 # [CLASS] [<class name>] [<parent class>] → class <class name>(<parent class>):
 def CLASS_to_class(code: str):
     code = code.lstrip()
     keyword, rest = code.split(" ", 1)
     if keyword!="[CLASS]":
-        raise SyntaxError(f"Expected `CLASS` got `{keyword}`.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]Expected `CLASS` got `{keyword}`.[/red]")
+        sys.exit(1)
     inner = rest.removeprefix("[").removesuffix("]")
     parts = inner.split("] [")
     if len(parts) != 2:
-        raise SyntaxError("Usage: [CLASS] [<class name>] [<parent class>]")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[red]error:Something wrong in your code")
+        rich.print("[red]The usage of `[CLASS]` sentences is `[CLASS] [<class name>] [<parent class>]`[/red]")
+        sys.exit(1)
     class_name = parts[0].strip()
     parent_class = parts[1].strip()
     if not class_name:
-        raise SyntaxError("Class name cannot be empty.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[red]error:Class name cannot be empty.[/red]")
+        sys.exit(1)
     dangerous_list = kwlist+["INFO", "VAR", "INPUT", "IF", "ELSEIF", "ELSE", "FOR", "WHILE", "LOOP", "FUNC", "CLASS", "ERROR", "WARN", "USE"]
     if not class_name.isidentifier():
-        raise SyntaxError(f"Invalid class name: {class_name}.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Invalid class name: {class_name}.[/red]")
+        sys.exit(1)
     if class_name in dangerous_list:
-        raise SyntaxError(f"Invalid name: {class_name}.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Invalid class name: {class_name}.[/red]")
+        sys.exit(1)
     return f"class {class_name}({parent_class}):"
 
 def transpile_line(line: str) -> str:

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/ERROR.py

@@ -2,12 +2,18 @@
 # bracket/ERROR.py
 # manage errors generating
 
+import sys
+
+import rich
+
 # [ERROR] [<info>] → __import__("rich").print([red]<info>[/red]);__import__("sys").exit(1)
 def ERROR_to_rich_print_and_exit_1(code: str):
     code = code.lstrip()
     keyword, info = code.split(" ", 1)
     if keyword!="[ERROR]":
-        raise SyntaxError(f"Expected `ERROR` got `{keyword}`.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]Expected `ERROR` got `{keyword}`.[/red]")
+        sys.exit(1)
     info = info.removeprefix("[").removesuffix("]")
     return f"__import__('rich').print('[red]{info[1:-1]}[/red]');__import__('sys').exit(1)"
 

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/FUN.py

@@ -3,26 +3,40 @@
 # mamage function defining
 
 from keyword import kwlist
+import sys
+
+import rich
 
 # [FUNC] [<function name>] [<args>] → def <function name>(<args>):
 def FUNC_to_def(code: str):
     code = code.lstrip()
     keyword, rest = code.split(" ", 1)
     if keyword!="[FUNC]":
-        raise SyntaxError(f"Expected `FUNC` got `{keyword}`.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `FUNC` got `{keyword}`.[/red]")
+        sys.exit(1)
     inner = rest.removeprefix("[").removesuffix("]")
     parts = inner.split("] [")
     if len(parts) != 2:
-        raise SyntaxError("Usage: [FUNC] [<function name>] [<args>]")
+        rich.print(f"[red]{code}[red]")
+        rich.print("[red]error:Something wrong in your code[/red]")
+        rich.print("[red]The usage of `[FUNC]` sentences is `[FUNC] [<function name>] [<args>]`[/red]")
+        sys.exit(1)
     function_name = parts[0].strip()
     args = parts[1].strip()
     if not function_name:
-        raise SyntaxError("Function name cannot be empty.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[/red]error:Function name cannot be empty.[/red]")
+        sys.exit(1)
     dangerous_list = kwlist+["INFO", "VAR", "INPUT", "IF", "ELSEIF", "ELSE", "FOR", "WHILE", "LOOP", "FUNC", "CLASS", "ERROR", "WARN", "USE"]
     if not function_name.isidentifier():
-        raise SyntaxError(f"Invalid function name: {function_name}.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Invalid function name: {function_name}.[/red]")
+        sys.exit(1)
     if function_name in dangerous_list:
-        raise SyntaxError(f"Invalid function name: {function_name}.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Invalid function name: {function_name}.[/red]")
+        sys.exit(1)
     return f"def {function_name}({args}):"
 
 # [RETURN] [<val>] → return <val>
@@ -30,7 +44,9 @@ def RETURN_to_return(code: str):
     code = code.lstrip()
     keyword, val = code.split(" ", 1)
     if keyword!="[RETURN]":
-        raise SyntaxError(f"Expected `RETURN` got `{keyword}`.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `FUNC` got `{keyword}`.[/red]")
+        sys.exit(1)
     val = val.removeprefix("[").removesuffix("]")
     if not val:
         return "return"

bracket_lang-0.4.0/bracket/GUI.py

@@ -0,0 +1,16 @@
+# bracket/GUI.py
+# GUI support for bracket
+
+import tkinter as tk
+
+Base = tk.Tk
+Tag = tk.Label
+Button = tk.Button
+InputBox = tk.Entry
+Text = tk.Text
+Checkbutton = tk.Checkbutton
+Radiobutton = tk.Radiobutton
+Int = tk.IntVar
+String = tk.StringVar
+Double = tk.DoubleVar
+Bool = tk.BooleanVar

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/IMPORTLIB.py

@@ -9,6 +9,6 @@ def USE_to_import(code: str):
         raise SyntaxError(f"Expect `[USE]` got {keyword}")
     key = lib.removeprefix("[").removesuffix("]")
     lib_dict = {
-        "TKGUI": "tkinter as TKGUI"
+        "GUI": "bracket.GUI",
     }
-    return f"import {lib_dict[key]}"
+    return f"from {lib_dict[key]} import*"

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/IO.py

@@ -3,37 +3,52 @@
 # manage I/O operation
 
 from keyword import kwlist
+import sys
 
+import rich
 # [INFO] [<text>] → print(<text>)
 def INFO_to_print(code: str):
     code = code.lstrip()
     keyword, text = code.split(" ", 1)
     if keyword!="[INFO]":
-        raise SyntaxError(f"Expected `INFO` got `{keyword}`.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `INFO` got `{keyword}`.[/red]")
+        sys.exit(1)
     text = text.removeprefix("[").removesuffix("]")
     return f"print({text})"
 
 # [VAR] [<var name>] [INPUT] [<tip word>] [<multilines> (bool)] → var = input(<tip word>)
-def INPUT_to_input(code: str) -> str:
+def INPUT_to_input(code: str):
     code = code.lstrip()
     rest = code.split(" ", 1)[1]
     inner = rest.removeprefix("[").removesuffix("]")
     parts = inner.split("] [")
     if len(parts) != 4:
-        raise SyntaxError("Usage: [VAR] [<var name>] [INPUT] [<tip word>] [<multilines> (bool)]")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[red]error:Something wrong in your code.[/red]")
+        rich.print("[red]The true usage of `[INPUT]` sentences is `[VAR] [<var name>] [INPUT] [<tip word>] [<multilines> (bool)]`[/red]")
+        sys.exit(1)
     var_name = parts[0].strip()
     keyword = parts[1]
     tip_word = parts[2].strip()
     multilines = parts[3].lower() in ("true", "1", "yes", "on")
     if not var_name:
-        raise SyntaxError("Var name cannot be empty.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[red]error:Var name cannot be empty.[/red]")
+        sys.exit(1)
     if not var_name.isidentifier():
-        raise SyntaxError(f"Invalid var name: {var_name}.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Invalid var name: {var_name}.[/red]")
+        sys.exit(1)
     dangerous_list = kwlist+["INFO", "VAR", "INPUT", "IF", "ELSEIF", "ELSE", "FOR", "WHILE", "LOOP", "FUNC", "CLASS", "ERROR", "WARN", "USE"]
     if var_name in dangerous_list:
-        raise SyntaxError(f"Invalid var name: {var_name}.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Invalid var name: {var_name}.[/red]")
+        sys.exit(1)
     if keyword != "INPUT":
-        raise SyntaxError(f"Expected `INPUT`, got `{keyword}`.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `INPUT` got `{keyword}`.[/red]")
+        sys.exit(1)
     if multilines:
         return f'''\
 print({tip_word})

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/LOOP.py

@@ -2,18 +2,26 @@
 # bracket/LOOP.py
 # manage the loop sentences
 
+import sys
+
+import rich
+
 # [FOR] [<range var>] [<start>, <end>, <step length>] → for <range var> in range(<start>, <end>, <step length>)
 def FOR_to_for(code: str) -> str:
     code = code.lstrip()
     keyword, rest = code.split(" ", 1)
     if keyword != "[FOR]":
-        raise SyntaxError(f"Expected `[FOR]` got `{keyword}`")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `[FOR]` got `{keyword}`[/red]")
+        sys.exit(1)
     var_part, range_part = rest.split(" ", 1)
     var = var_part.removeprefix("[").removesuffix("]")
     range_args = range_part.removeprefix("[").removesuffix("]")
     parts = [p.strip() for p in range_args.split(",")]
     if len(parts)!=3:
-        raise SyntaxError("[FOR] needs 3 range arguments")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[red]error:[FOR] needs 3 range arguments[/red]")
+        sys.exit(1)
     start, end, step = parts
     return f"for {var} in range({start}, {end}, {step}):"
 
@@ -22,7 +30,9 @@ def WHILE_to_while(code: str):
     code = code.lstrip()
     keyword, cond = code.split(" ", 1)
     if keyword!="[WHILE]":
-        raise SyntaxError(f"Expect `[WHILE]` got {keyword}")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `[WHILE]` got `{keyword}`[/red]")
+        sys.exit(1)
     text = cond.removeprefix("[").removesuffix("]")
     return f"while {text}:"
 
@@ -30,21 +40,27 @@ def WHILE_to_while(code: str):
 def LOOP_to_while_True(code: str):
     code = code.lstrip()
     if code!="[LOOP]":
-        raise SyntaxError(f"Expect `[LOOP]` got {code}")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `[LOOP]` got `{keyword}`[/red]")
+        sys.exit(1)
     return "while True:"
 
 # [CONTINUE] → continue
 def CONTINUE_to_continue(code: str):
     code = code.lstrip()
     if code!="[CONTINUE]":
-        raise SyntaxError(f"Expect `[CONTINUE]` got {code}")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `[CONTINUE]` got `{keyword}`[/red]")
+        sys.exit(1)
     return "continue"
 
 # [BREAK] → break
 def BREAK_to_break(code: str):
     code = code.lstrip()
     if code!="[BREAK]":
-        raise SyntaxError(f"Expect `[BREAK]` got {code}")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `[BREAK]` got `{keyword}`[/red]")
+        sys.exit(1)
     return "break"
 
 def transpile_line(line: str) -> str:

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/VAR.py

@@ -3,31 +3,47 @@
 # manage variables
 
 from keyword import kwlist
+import sys
+
+import rich
 
 # [VAR] [<var name>] [<value>] → <var name> = <value>
 def VAR_to_varname_equal(code: str):
     code = code.lstrip()
     keyword, rest = code.split(" ", 1)
     if keyword!="[VAR]":
-        raise SyntaxError(f"Expected `VAR` got `{keyword}`.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Expected `VAR` got `{keyword}`.[/red]")
+        sys.exit(1)
     inner = rest.removeprefix("[").removesuffix("]")
     parts = inner.split("] [")
     if len(parts) != 2:
-        raise SyntaxError("Usage: [VAR] [<var name>] [<value>]")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[red]error:Something wrong in your code[/red]")
+        rich.print("[red]the true usage of `[VAR]` sentences is `[VAR] [<var name>] [<value>]`[red]")
+        sys.exit(1)
     var_name = parts[0].strip()
     value = parts[1].strip()
     if not var_name:
-        raise SyntaxError("Var name cannot be empty.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[red]error:Var name cannot be empty.[/red]")
+        sys.exit(1)
     dangerous_list = kwlist+["INFO", "VAR", "INPUT", "IF", "ELSEIF", "ELSE", "FOR", "WHILE", "LOOP", "FUNC", "CLASS", "ERROR", "WARN", "USE"]
     if not var_name.isidentifier():
-        raise SyntaxError(f"Invalid var name: {var_name}.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Invalid var name: {var_name}.[/red]")
+        sys.exit(1)
     if var_name in dangerous_list:
-        raise SyntaxError(f"Invalid var name: {var_name}.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]error:Invalid var name: {var_name}.[/red]")
+        sys.exit(1)
     if not value:
-        raise SyntaxError("Value cannot be empty.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print("[red]error:Value cannot be empty.[/red]")
+        sys.exit(1)
     return f"{var_name} = {value}"
 
-def transpile_line(line: str) -> str:
+def transpile_line(line: str):
     """transpile one line of bracket code and operate indents"""
     indent = len(line) - len(line.lstrip())
     stripped = line.lstrip()

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/WARN.py

@@ -2,12 +2,18 @@
 # bracket/WARN.py
 # manage warnings generating
 
+import sys
+
+import rich
+
 # [WARN] [<info>] → __import__("rich").print("[yellow]<info>[/yellow]")
 def WARN_to_rich_print(code: str):
     code = code.lstrip()
     keyword, info = code.split(" ", 1)
     if keyword!="[WARN]":
-        raise SyntaxError(f"Expected `WARN` got `{keyword}`.")
+        rich.print(f"[red]{code}[/red]")
+        rich.print(f"[red]Expected `WARN` got `{keyword}`.[/red]")
+        sys.exit(1)
     info = info.removeprefix("[").removesuffix("]")
     return f"__import__('rich').print('[yellow]{info[1:-1]}[/yellow]')"
 

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/__init__.py

@@ -1,5 +1,6 @@
 # bracket/__init__.py
 import rich
+import PyInstaller
 
 from .transpile import transpile, transpile_line
 from .cli import main

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket/cli.py

@@ -4,6 +4,8 @@
 
 import sys
 import argparse
+import subprocess
+
 from .transpile import transpile
 
 def main():
@@ -20,20 +22,28 @@ def main():
     build_parser = subparsers.add_parser("build", help="transpile .bracket file to .py")
     build_parser.add_argument("file", help="the .bracket file you want to transpile")
     build_parser.add_argument("-o", "--output", help="output file name(default same name .py)")
+    # pack command
+    pack_parser = subparsers.add_parser("pack", help="pack .bracket file to binary")
+    pack_parser.add_argument("file", help="the .bracket file you want to pack")
+    pack_parser.add_argument("-o", "--output", help="output file name(default same name .bracket)")
     args = parser.parse_args()
-    if args.command == "run":
+    if args.command=="run":
         with open(args.file, "r", encoding="utf-8") as f:
             code = f.read()
         py_code = transpile(code)
         exec(py_code)
-    elif args.command == "build":
+    elif args.command=="build":
         with open(args.file, "r", encoding="utf-8") as f:
             code = f.read()
         py_code = transpile(code)
         output = args.output or args.file.replace(".bracket", ".py")
         with open(output, "w", encoding="utf-8") as f:
             f.write(py_code)
-        print(f"✓ transpile finished: {output}")
+    elif args.command=="pack":
+        print(f"Building {args.file}")
+        subprocess.run(["bracket", "build", str(args.file)], check=True)
+        print("Packing with pyinstaller")
+        subprocess.run(["pyinstaller", "--onefile", str(args.file).replace(".bracket", ".py")], check=True)
 
 if __name__ == "__main__":
     main()

bracket_lang-0.4.0/bracket_lang.egg-info/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: bracket-lang
+Version: 0.4.0
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pyinstaller>=6.0.0
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# bracket
+python制作的转译型简单编程语言
+
+## 1 安装
+```bash
+pip install bracket-lang
+```
+
+## 2 Hello world
+```bracket
+[INFO] ["Hello world!"]
+```
+
+## 3 基本语法
+```bracket
+# main.bracket
+
+# 打印
+[INFO] ["这是一段文本"]
+[INFO] ["Loading...", end=" "]
+[INFO] ["complete"]
+
+# 变量
+[VAR] [integer] [2]
+[VAR] [floating_point] [3.0]
+[VAR] [string] ["abc"]
+[VAR] [lst] [[1, 2, 3, 4, 5]]
+[VAR] [t] [(1, 2, 3)]
+[VAR] [dict] [{1: 1, 2: 4, 3: 9}]
+[INFO] [integer, floating_point, string, lst, t, dict]
+
+# 输入
+[VAR] [short] [INPUT] ["单行文本"] [False]
+[VAR] [long] [INPUT] ["多行文本"] [True]
+[INFO] ["您这两次分别输入了: "]
+[INFO] [short]
+[INFO] [long]
+
+# 分支语句
+[VAR] [a] [6]
+[IF] [a>0]
+    [INFO] ["正数"]
+[ELSEIF] [a==0]
+    [INFO] ["零"]
+[ELSE]
+    [INFO] ["负数"]
+
+# 循环
+[VAR] [total] [0]
+[FOR] [i] [1, 101, 1]
+    [VAR] [total] [total+i]
+[INFO] ["1~100的和:", total]
+[VAR] [i] [0]
+[WHILE] [i<10]
+    [INFO] [i]
+    [VAR] [i] [i+1]
+[LOOP]
+    [INFO] [i]
+    [IF] [i==100]
+        [BREAK]
+    [VAR] [i] [i+1]
+
+# 函数
+[FUNC] [longest] [x, y]
+    [IF] [len(x)>len(y)]
+        [RETURN] [x]
+    [RETURN] [y]
+[INFO] [longest("hi", "hello")]
+
+# 类
+[CLASS] [Calculator] [object]
+    [FUNC] [add] [a, b]
+        [RETURN] [a+b]
+    [FUNC] [subtract] [a, b]
+        [RETURN] [a-b]
+    [FUNC] [mul] [a, b]
+        [RETURN] [a*b]
+    [FUNC] [division] [a, b]
+        [IF] [b==0]
+            [ERROR] ["Cannot devide by zero."]
+        [RETURN] [a/b]
+    [FUNC] [percent] [a]
+        [RETURN] [a/100]
+[INFO] [Calculator.add(1, 1)]
+
+# 警告
+[WARN] ["警告信息"]
+
+# GUI
+[USE] [GUI]
+[VAR] [root] [Base()]
+root.title("Hello bracket")
+root.geometry("300x200")
+[VAR] [label] [Tag(root, text="Hello, World!")]
+label.pack()
+root.mainloop()
+```
+输出: 
+```text
+这是一段文本
+Loading... complete
+2 3.0 abc [1, 2, 3, 4, 5] (1, 2, 3) {1: 1, 2: 4, 3: 9}
+单行文本: 1
+多行文本: 2
+3
+您这两次分别输入了
+1
+2
+3
+正数
+5050
+1
+2
+3
+...
+100
+hello
+2
+警告信息[yellow]
+```
+![窗口显示: ](./TKGUI_helloHello.jpg)
+打包:
+```bash
+bracket pack main.bracket
+```
+
+## 4 命令行工具参数
+| 参数 | 用法 |
+| ------ | ------ |
+| `--help` `-h` | 帮助 |
+| `build` | 转译 |
+| `run` | 转译运行 |
+| `pack` | 打包成二进制 |
+
+## 6 注意事项
+1. `INFO`的参数与python的`print`基本相同
+2. `[VAR] [lst] [[1, 2, 3, 4, 5]]`是真正的列表, `[VAR] [t] [1, 2, 3, 4, 5]`是元组
+3. `FOR`必须要写三个参数
+4. `[LOOP]`是无限循环, 与`[WHILE] [True]`等效
+5. 变量名不能与bracket关键字和python关键字重名
+6. bracket语言不兼容python的列表推导式, 三元表达式等
+7. bracket内置轻量编辑器bkted

{bracket_lang-0.2.0 → bracket_lang-0.4.0}/bracket_lang.egg-info/SOURCES.txt

@@ -1,10 +1,13 @@
 LICENSE
+MANIFEST.in
 README.md
+TKGUI_helloworld.jpg
 setup.py
 bracket/BRANCH.py
 bracket/CLASS.py
 bracket/ERROR.py
 bracket/FUN.py
+bracket/GUI.py
 bracket/IMPORTLIB.py
 bracket/IO.py
 bracket/LOOP.py

bracket_lang-0.4.0/bracket_lang.egg-info/requires.txt

@@ -0,0 +1,2 @@
+rich>=13.0.0
+pyinstaller>=6.0.0

bracket_lang-0.4.0/setup.py

@@ -0,0 +1,25 @@
+# setup.py
+from pathlib import Path
+from setuptools import setup, find_packages
+
+# 读取 README
+readme_path = Path(__file__).parent / "README.md"
+long_description = readme_path.read_text(encoding="utf-8") if readme_path.exists() else ""
+
+setup(
+    name="bracket-lang",
+    version="0.4.0",
+    packages=find_packages(),
+    entry_points={
+        "console_scripts": [
+            "bracket = bracket.cli:main",
+        ],
+    },
+    python_requires=">=3.8",
+    install_requires=[
+        "rich>=13.0.0",
+        "pyinstaller>=6.0.0"
+    ],
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+)

bracket_lang-0.2.0/PKG-INFO

@@ -1,9 +0,0 @@
-Metadata-Version: 2.4
-Name: bracket-lang
-Version: 0.2.0
-Requires-Python: >=3.8
-License-File: LICENSE
-Requires-Dist: rich>=13.0.0
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python

bracket_lang-0.2.0/bracket_lang.egg-info/PKG-INFO

@@ -1,9 +0,0 @@
-Metadata-Version: 2.4
-Name: bracket-lang
-Version: 0.2.0
-Requires-Python: >=3.8
-License-File: LICENSE
-Requires-Dist: rich>=13.0.0
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python

bracket_lang-0.2.0/bracket_lang.egg-info/requires.txt

@@ -1 +0,0 @@
-rich>=13.0.0

bracket_lang-0.2.0/setup.py

@@ -1,15 +0,0 @@
-# setup.py
-from setuptools import setup, find_packages
-
-setup(
-    name="bracket-lang",
-    version="0.2.0",
-    packages=find_packages(),
-    entry_points={
-        "console_scripts": [
-            "bracket = bracket.cli:main",
-        ],
-    },
-    python_requires=">=3.8",
-    install_requires=["rich>=13.0.0"]
-)