RustPython · youknowone · May 15, 2025 · May 8, 2025
diff --git a/crawl_sourcecode.py b/crawl_sourcecode.py
@@ -1,4 +1,4 @@
-""" This script can be used to test the equivalence in parsing between
+"""This script can be used to test the equivalence in parsing between
 rustpython and cpython.
 
 Usage example:
@@ -8,76 +8,80 @@
 $ diff cpython.txt rustpython.txt
 """
 
-
 import ast
 import sys
 import symtable
 import dis
 
 filename = sys.argv[1]
-print('Crawling file:', filename)
+print("Crawling file:", filename)
 
 
-with open(filename, 'r') as f:
+with open(filename, "r") as f:
     source = f.read()
 
 t = ast.parse(source)
 print(t)
 
 shift = 3
+
+
 def print_node(node, indent=0):
-    indents = ' ' * indent
+    indents = " " * indent
     if isinstance(node, ast.AST):
-        lineno = 'row={}'.format(node.lineno) if hasattr(node, 'lineno') else ''
+        lineno = "row={}".format(node.lineno) if hasattr(node, "lineno") else ""
         print(indents, "NODE", node.__class__.__name__, lineno)
         for field in node._fields:
-            print(indents,'-', field)
+            print(indents, "-", field)
             f = getattr(node, field)
             if isinstance(f, list):
                 for f2 in f:
-                    print_node(f2, indent=indent+shift)
+                    print_node(f2, indent=indent + shift)
             else:
-                print_node(f, indent=indent+shift)
+                print_node(f, indent=indent + shift)
     else:
-        print(indents, 'OBJ', node)
+        print(indents, "OBJ", node)
+
 
 print_node(t)
 
 # print(ast.dump(t))
 flag_names = [
-    'is_referenced',
-    'is_assigned',
-    'is_global',
-    'is_local',
-    'is_parameter',
-    'is_free',
+    "is_referenced",
+    "is_assigned",
+    "is_global",
+    "is_local",
+    "is_parameter",
+    "is_free",
 ]
 
+
 def print_table(table, indent=0):
-    indents = ' ' * indent
-    print(indents, 'table:', table.get_name())
-    print(indents, ' ', 'name:', table.get_name())
-    print(indents, ' ', 'type:', table.get_type())
-    print(indents, ' ', 'line:', table.get_lineno())
-    print(indents, ' ', 'identifiers:', table.get_identifiers())
-    print(indents, ' ', 'Syms:')
+    indents = " " * indent
+    print(indents, "table:", table.get_name())
+    print(indents, " ", "name:", table.get_name())
+    print(indents, " ", "type:", table.get_type())
+    print(indents, " ", "line:", table.get_lineno())
+    print(indents, " ", "identifiers:", table.get_identifiers())
+    print(indents, " ", "Syms:")
     for sym in table.get_symbols():
         flags = []
         for flag_name in flag_names:
             func = getattr(sym, flag_name)
             if func():
                 flags.append(flag_name)
-        print(indents, '   sym:', sym.get_name(), 'flags:', ' '.join(flags))
+        print(indents, "   sym:", sym.get_name(), "flags:", " ".join(flags))
     if table.has_children():
-        print(indents, ' ', 'Child tables:')
+        print(indents, " ", "Child tables:")
         for child in table.get_children():
-            print_table(child, indent=indent+shift)
+            print_table(child, indent=indent + shift)
+
 
-table = symtable.symtable(source, 'a', 'exec')
+table = symtable.symtable(source, "a", "exec")
 print_table(table)
 
 print()
-print('======== dis.dis ========')
+print("======== dis.dis ========")
 print()
-co = compile(source, filename, 'exec')
+co = compile(source, filename, "exec")
 dis.dis(co)
diff --git a/demo_closures.py b/demo_closures.py
@@ -1,13 +1,12 @@
-
-
 def foo(x):
     def bar(z):
         return z + x
+
     return bar
 
+
 f = foo(9)
 g = foo(10)
 
 print(f(2))
 print(g(2))
-
diff --git a/ruff.toml b/ruff.toml
@@ -1,11 +1,4 @@
-include = [
-    "examples/**/*.py",
-    "extra_tests/**/*.py",
-    "wasm/**/*.py",
-]
-
 exclude = [
-    ".*",
     "Lib",
     "vm/Lib",
     "benches",

diff --git a/scripts/cargo-llvm-cov.py b/scripts/cargo-llvm-cov.py
@@ -3,18 +3,21 @@
 
 TARGET = "extra_tests/snippets"
 
+
 def run_llvm_cov(file_path: str):
-    """ Run cargo llvm-cov on a file. """
+    """Run cargo llvm-cov on a file."""
     if file_path.endswith(".py"):
         command = ["cargo", "llvm-cov", "--no-report", "run", "--", file_path]
         subprocess.call(command)
 
+
 def iterate_files(folder: str):
-    """ Iterate over all files in a folder. """
+    """Iterate over all files in a folder."""
     for root, _, files in os.walk(folder):
         for file in files:
             file_path = os.path.join(root, file)
             run_llvm_cov(file_path)
 
+
 if __name__ == "__main__":
-    iterate_files(TARGET)
+    iterate_files(TARGET)
diff --git a/scripts/fix_test.py b/scripts/fix_test.py
@@ -10,21 +10,26 @@
 4. Ensure that there are no unexpected successes in the test.
 5. Actually fix the test.
 """
+
 import argparse
 import ast
 import itertools
 import platform
 from pathlib import Path
 
+
 def parse_args():
     parser = argparse.ArgumentParser(description="Fix test.")
     parser.add_argument("--path", type=Path, help="Path to test file")
     parser.add_argument("--force", action="store_true", help="Force modification")
-    parser.add_argument("--platform", action="store_true", help="Platform specific failure")
+    parser.add_argument(
+        "--platform", action="store_true", help="Platform specific failure"
+    )
 
     args = parser.parse_args()
     return args
 
+
 class Test:
     name: str = ""
     path: str = ""
@@ -33,6 +38,7 @@ class Test:
     def __str__(self):
         return f"Test(name={self.name}, path={self.path}, result={self.result})"
 
+
 class TestResult:
     tests_result: str = ""
     tests = []
@@ -52,7 +58,11 @@ def parse_results(result):
             in_test_results = True
         elif line.startswith("-----------"):
             in_test_results = False
-        if in_test_results and not line.startswith("tests") and not line.startswith("["):
+        if (
+            in_test_results
+            and not line.startswith("tests")
+            and not line.startswith("[")
+        ):
             line = line.split(" ")
             if line != [] and len(line) > 3:
                 test = Test()
@@ -67,9 +77,11 @@ def parse_results(result):
                 test_results.tests_result = res
     return test_results
 
+
 def path_to_test(path) -> list[str]:
     return path.split(".")[2:]
 
+
 def modify_test(file: str, test: list[str], for_platform: bool = False) -> str:
     a = ast.parse(file)
     lines = file.splitlines()
@@ -84,6 +96,7 @@ def modify_test(file: str, test: list[str], for_platform: bool = False) -> str:
                 break
     return "\n".join(lines)
 
+
 def modify_test_v2(file: str, test: list[str], for_platform: bool = False) -> str:
     a = ast.parse(file)
     lines = file.splitlines()
@@ -101,8 +114,13 @@ def modify_test_v2(file: str, test: list[str], for_platform: bool = False) -> st
                                         if fn.name == test[-1]:
                                             assert not for_platform
                                             indent = " " * fn.col_offset
-                                            lines.insert(fn.lineno - 1, indent + fixture)
-                                            lines.insert(fn.lineno - 1, indent + "# TODO: RUSTPYTHON")
+                                            lines.insert(
+                                                fn.lineno - 1, indent + fixture
+                                            )
+                                            lines.insert(
+                                                fn.lineno - 1,
+                                                indent + "# TODO: RUSTPYTHON",
+                                            )
                                             break
                     case ast.FunctionDef():
                         if n.name == test[0] and len(test) == 1:
@@ -115,11 +133,17 @@ def modify_test_v2(file: str, test: list[str], for_platform: bool = False) -> st
                     exit()
     return "\n".join(lines)
 
+
 def run_test(test_name):
     print(f"Running test: {test_name}")
     rustpython_location = "./target/release/rustpython"
     import subprocess
-    result = subprocess.run([rustpython_location, "-m", "test", "-v", test_name], capture_output=True, text=True)
+
+    result = subprocess.run(
+        [rustpython_location, "-m", "test", "-v", test_name],
+        capture_output=True,
+        text=True,
+    )
     return parse_results(result)
 
 

diff --git a/vm/sre_engine/generate_tests.py b/vm/sre_engine/generate_tests.py
@@ -10,6 +10,7 @@
 
 assert re._constants.MAGIC == sre_engine_magic
 
+
 class CompiledPattern:
     @classmethod
     def compile(cls, pattern, flags=0):
@@ -21,40 +22,50 @@ def compile(cls, pattern, flags=0):
         self.flags = re.RegexFlag(flags | p.state.flags)
         return self
 
+
 for k, v in re.RegexFlag.__members__.items():
     setattr(CompiledPattern, k, v)
 
 
 class EscapeRustStr:
     hardcoded = {
-        ord('\r'): '\\r',
-        ord('\t'): '\\t',
-        ord('\r'): '\\r',
-        ord('\n'): '\\n',
-        ord('\\'): '\\\\',
-        ord('\''): '\\\'',
-        ord('\"'): '\\\"',
+        ord("\r"): "\\r",
+        ord("\t"): "\\t",
+        ord("\r"): "\\r",
+        ord("\n"): "\\n",
+        ord("\\"): "\\\\",
+        ord("'"): "\\'",
+        ord('"'): '\\"',
     }
+
     @classmethod
     def __class_getitem__(cls, ch):
         if (rpl := cls.hardcoded.get(ch)) is not None:
             return rpl
-        if ch in range(0x20, 0x7f):
+        if ch in range(0x20, 0x7F):
             return ch
         return f"\\u{{{ch:x}}}"
+
+
 def rust_str(s):
     return '"' + s.translate(EscapeRustStr) + '"'
 
+
 # matches `// pattern {varname} = re.compile(...)`
-pattern_pattern = re.compile(r"^((\s*)\/\/\s*pattern\s+(\w+)\s+=\s+(.+?))$(?:.+?END GENERATED)?", re.M | re.S)
+pattern_pattern = re.compile(
+    r"^((\s*)\/\/\s*pattern\s+(\w+)\s+=\s+(.+?))$(?:.+?END GENERATED)?", re.M | re.S
+)
+
+
 def replace_compiled(m):
     line, indent, varname, pattern = m.groups()
     pattern = eval(pattern, {"re": CompiledPattern})
     pattern = f"Pattern {{ pattern: {rust_str(pattern.pattern)}, code: &{json.dumps(pattern.code)} }}"
-    return f'''{line}
+    return f"""{line}
 {indent}// START GENERATED by generate_tests.py
 {indent}#[rustfmt::skip] let {varname} = {pattern};
-{indent}// END GENERATED'''
+{indent}// END GENERATED"""
+
 
 with os.scandir("tests") as t, os.scandir("benches") as b:
     for f in chain(t, b):