Format linter

Author: Merricx

src/zkregex_fuzzer/cli.py

@@ -14,9 +14,14 @@
 from zkregex_fuzzer.harness import HarnessStatus
 from zkregex_fuzzer.logger import logger
 from zkregex_fuzzer.reproduce import reproduce
-from zkregex_fuzzer.runner.circom import CircomSubprocess, SnarkjsSubprocess, ZkRegexSubprocess
+from zkregex_fuzzer.runner.circom import (
+    CircomSubprocess,
+    SnarkjsSubprocess,
+    ZkRegexSubprocess,
+)
 from zkregex_fuzzer.runner.subprocess import BarretenbergSubprocess, NoirSubprocess
 
+
 def fuzz_parser():
     parser = argparse.ArgumentParser(add_help=False)
     parser.add_argument(
@@ -49,7 +54,7 @@ def fuzz_parser():
     parser.add_argument(
         "--seed",
         default=str(uuid.uuid4()),
-        help=f"Seed for random generator (default: UUIDv4)"
+        help="Seed for random generator (default: UUIDv4)",
     )
     parser.add_argument(
         "--save",
@@ -103,16 +108,15 @@ def fuzz_parser():
     parser.add_argument(
         "--noir-prove",
         action="store_true",
-        help="Run the proving and verification step with Barretenberg."
+        help="Run the proving and verification step with Barretenberg.",
     )
 
     parser.add_argument(
         "--logger-level",
         choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
         default="INFO",
-        help="Set the logger level (default: INFO)."
+        help="Set the logger level (default: INFO).",
     )
-    
 
     return parser
 
@@ -131,7 +135,7 @@ def reproduce_parser():
         "--logger-level",
         choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
         default="INFO",
-        help="Set the logger level (default: INFO)."
+        help="Set the logger level (default: INFO).",
     )
 
     return parser

src/zkregex_fuzzer/configs.py

@@ -1,7 +1,6 @@
-from zkregex_fuzzer.runner import CircomRunner, PythonReRunner, NoirRunner
 from zkregex_fuzzer.grammar import REGEX_GRAMMAR
 from zkregex_fuzzer.regexgen import DatabaseRegexGenerator, GrammarRegexGenerator
-from zkregex_fuzzer.runner import CircomRunner, PythonReRunner
+from zkregex_fuzzer.runner import CircomRunner, NoirRunner, PythonReRunner
 from zkregex_fuzzer.vinpgen import ExrexGenerator, GrammarBasedGenerator, RstrGenerator
 
 TARGETS = {

src/zkregex_fuzzer/grammar.py

@@ -19,6 +19,7 @@
 TODO:
  - Add more grammars.
 """
+
 import string
 from typing import List
 

src/zkregex_fuzzer/report.py

@@ -1,4 +1,5 @@
 """
 Implements the logic for generating a report from the fuzzing results.
 """
+
 from zkregex_fuzzer.harness import HarnessResult

src/zkregex_fuzzer/runner/__init__.py

@@ -1,5 +1,4 @@
 from .base_runner import RegexCompileError, RegexRunError, Runner
 from .circom import CircomRunner
-from .python import PythonReRunner
-from .circom import CircomRunner
 from .noir import NoirRunner
+from .python import PythonReRunner

src/zkregex_fuzzer/runner/circom.py

@@ -2,14 +2,17 @@
 Runner for Circom.
 """
 
-import json, tempfile, subprocess, shutil
+import json
+import shutil
+import tempfile
 from pathlib import Path
+
 from zkregex_fuzzer.logger import logger
-from zkregex_fuzzer.runner.base_runner import Runner, RegexCompileError, RegexRunError
+from zkregex_fuzzer.runner.base_runner import RegexRunError, Runner
 from zkregex_fuzzer.runner.subprocess import (
-    ZkRegexSubprocess,
     CircomSubprocess,
     SnarkjsSubprocess,
+    ZkRegexSubprocess,
 )
 
 
@@ -40,7 +43,7 @@ def compile(self, regex: str) -> None:
         """
         Compile the regex.
         """
-        logger.debug(f"Compiling regex starts")
+        logger.debug("Compiling regex starts")
         # Create JSON for the regex for zk-regex
         base_json = {"parts": []}
         # TODO: handle the following if is_public is set to True:
@@ -57,11 +60,11 @@ def compile(self, regex: str) -> None:
         circom_file_path = str(Path(self._dir_path) / "regex.circom")
 
         # Call zk-regex to generate the circom code
-        logger.debug(f"Generating circom code starts")
+        logger.debug("Generating circom code starts")
         ZkRegexSubprocess.compile_to_circom(
             json_file_path, circom_file_path, self._template_name
         )
-        logger.debug(f"Generating circom code ends")
+        logger.debug("Generating circom code ends")
 
         # Append the circom file to include the main function
         with open(circom_file_path, "a") as f:
@@ -74,25 +77,25 @@ def compile(self, regex: str) -> None:
         self._circom_path = circom_file_path
 
         # Compile the circom code to wasm
-        logger.debug(f"Compiling circom code starts")
+        logger.debug("Compiling circom code starts")
         self._wasm_path, self._r1cs_path = CircomSubprocess.compile(
             circom_file_path, self._link_path
         )
-        logger.debug(f"Compiling circom code ends")
+        logger.debug("Compiling circom code ends")
 
         # Also setup the proving and verification key if the flag is set
         if self._run_the_prover:
             self._zkey_path = SnarkjsSubprocess.setup_zkey(
                 self._r1cs_path, self._ptau_path
             )
             self._vkey_path = SnarkjsSubprocess.export_verification_key(self._zkey_path)
-        logger.debug(f"Compiling regex ends")
+        logger.debug("Compiling regex ends")
 
     def match(self, input: str) -> tuple[bool, str]:
         """
         Match the regex on an input.
         """
-        logger.debug(f"Matching regex starts")
+        logger.debug("Matching regex starts")
         # Convert input to list of decimal ASCII values and pad input with zeroes
         numeric_input = [ord(c) for c in input] + [0] * (
             self._circom_max_input_size - len(input)
@@ -110,9 +113,9 @@ def match(self, input: str) -> tuple[bool, str]:
             raise RegexRunError(f"Input too large for input: {len(numeric_input)}")
 
         # Generate the witness
-        logger.debug(f"Generating witness starts")
+        logger.debug("Generating witness starts")
         witness_path = SnarkjsSubprocess.witness_gen(self._wasm_path, input_path)
-        logger.debug(f"Generating witness ends")
+        logger.debug("Generating witness ends")
 
         # Also run the proving backend if the flag is set
         if self._run_the_prover:
@@ -121,7 +124,7 @@ def match(self, input: str) -> tuple[bool, str]:
             # Verification
             if not SnarkjsSubprocess.verify(self._vkey_path, proof, public_input):
                 raise RegexRunError(
-                    f"Error running with SnarkJS: Proof verification failed"
+                    "Error running with SnarkJS: Proof verification failed"
                 )
 
         # Extract from the witness the result of the match
@@ -131,7 +134,7 @@ def match(self, input: str) -> tuple[bool, str]:
 
         # Return the output of the match
         output = int(result[1])
-        logger.debug(f"Matching regex ends")
+        logger.debug("Matching regex ends")
         return output == 1, ""
 
     def clean(self):

src/zkregex_fuzzer/runner/noir.py

@@ -2,11 +2,19 @@
 Runner for Circom.
 """
 
-import json, tempfile, subprocess, shutil
+import json
+import shutil
+import tempfile
 from pathlib import Path
+
 from zkregex_fuzzer.logger import logger
-from zkregex_fuzzer.runner.base_runner import Runner, RegexCompileError, RegexRunError
-from zkregex_fuzzer.runner.subprocess import BarretenbergSubprocess, NoirSubprocess, ZkRegexSubprocess
+from zkregex_fuzzer.runner.base_runner import RegexRunError, Runner
+from zkregex_fuzzer.runner.subprocess import (
+    BarretenbergSubprocess,
+    NoirSubprocess,
+    ZkRegexSubprocess,
+)
+
 
 class NoirRunner(Runner):
     """
@@ -23,40 +31,40 @@ def __init__(self, regex: str, kwargs: dict):
         self.identifer = ""
 
     def _construct_working_dir(self) -> str:
-
         dir_path = Path(self._path)
 
         # create nargo.toml
         with open(dir_path / "Nargo.toml", "w") as f:
             content = '[package]\nname = "test_regex"\ntype = "bin"\nauthors = [""]\n\n[dependencies]'
             f.write(content)
 
-        src_path = (dir_path / "src")
+        src_path = dir_path / "src"
         src_path.mkdir()
 
         # create src/main.nr
         with open(src_path / "main.nr", "w") as f:
             main_func = "mod regex;\n\n"
-            main_func += f"global MAX_INPUT_SIZE: u32 = {self._noir_max_input_size};\n\n"
-            main_func += "fn main(input: [u8; MAX_INPUT_SIZE]) { regex::regex_match(input); }"
+            main_func += (
+                f"global MAX_INPUT_SIZE: u32 = {self._noir_max_input_size};\n\n"
+            )
+            main_func += (
+                "fn main(input: [u8; MAX_INPUT_SIZE]) { regex::regex_match(input); }"
+            )
             f.write(main_func)
 
         return str(src_path)
 
-
     def compile(self, regex: str) -> None:
         """
         Compile the regex.
         """
-        logger.debug(f"Compiling regex starts")
+        logger.debug("Compiling regex starts")
 
         # Setup main directory
         src_path = self._construct_working_dir()
 
-        # Create JSON for the regex for zk-regex 
-        base_json = {
-            "parts": []
-        }
+        # Create JSON for the regex for zk-regex
+        base_json = {"parts": []}
         # TODO: handle the following if is_public is set to True:
         # the section containing this ^ must be non-public (is_public: false).
         regex_parts = {"regex_def": regex, "is_public": False}
@@ -65,67 +73,71 @@ def compile(self, regex: str) -> None:
 
         # Write the JSON to a temporary file
         json_file_path = str(Path(self._path) / "regex.json")
-        with open(json_file_path, 'wb') as f:
+        with open(json_file_path, "wb") as f:
             f.write(regex_json.encode())
 
         noir_file_path = str(Path(src_path) / "regex.nr")
 
         # Call zk-regex to generate the noir code
-        logger.debug(f"Generating noir code starts")
+        logger.debug("Generating noir code starts")
         ZkRegexSubprocess.compile_to_noir(json_file_path, noir_file_path)
-        logger.debug(f"Generating noir code ends")
+        logger.debug("Generating noir code ends")
 
         # Compile the noir code (nargo check)
-        logger.debug(f"Compiling noir code starts")
+        logger.debug("Compiling noir code starts")
         NoirSubprocess.compile(self._path)
-        logger.debug(f"Compiling noir code ends")
+        logger.debug("Compiling noir code ends")
 
         if self._run_the_prover:
             BarretenbergSubprocess.export_verification_key(self._path)
 
-        logger.debug(f"Compiling regex ends")        
+        logger.debug("Compiling regex ends")
 
     def match(self, input: str) -> tuple[bool, str]:
         """
         Match the regex on an input.
         """
 
-        logger.debug(f"Matching regex starts")
+        logger.debug("Matching regex starts")
         # Convert input to list of decimal ASCII values and pad input with zeroes
-        numeric_input = [ord(c) for c in input] + [0] * (self._noir_max_input_size - len(input))
-        
+        numeric_input = [ord(c) for c in input] + [0] * (
+            self._noir_max_input_size - len(input)
+        )
+
         # Write input to a Prover.toml
         with open(Path(self._path) / "Prover.toml", "w") as f:
             f.write(f"input = {str(numeric_input)}")
-        
+
         # Skip if input is larger than noir max input size
         if len(numeric_input) > self._noir_max_input_size:
-            raise RegexRunError(f"Input too large for input: {len(numeric_input)}")
-        
+            raise RegexRunError("Input too large for input: {len(numeric_input)}")
+
         # Generate the witness
-        logger.debug(f"Generating witness starts")
+        logger.debug("Generating witness starts")
         match = NoirSubprocess.witness_gen(self._path)
-        logger.debug(f"Generating witness ends")
+        logger.debug("Generating witness ends")
 
         if self._run_the_prover and match:
             # prove
             BarretenbergSubprocess.prove(self._path)
             # verify
             if not BarretenbergSubprocess.verify(self._path):
-                raise RegexRunError(f"Error running with Barretenberg: Proof verification failed")
+                raise RegexRunError(
+                    "Error running with Barretenberg: Proof verification failed"
+                )
 
         return match, ""
-    
+
     def clean(self):
         # Remove all temporary files
         if Path(self._path).exists():
             shutil.rmtree(self._path)
-    
+
     def save(self, path) -> str:
         base_path = Path(self._path)
         target_path = Path(path).resolve()
 
         dst_path = target_path / f"output_{base_path.stem}"
         base_path.replace(dst_path)
 
-        return str(dst_path)
+        return str(dst_path)