itp-interface 1.1.0__tar.gz → 1.1.2__tar.gz

{itp_interface-1.1.0 → itp_interface-1.1.2}/.github/workflows/github-build-actions.yaml

@@ -75,9 +75,16 @@ jobs:
       - name: List repository files (debug step)
         run: find . -type f
 
-      - name: Run tests
+      - name: Run Simple Env Test
         shell: bash
         run: |
           eval $(opam env)
           source $HOME/.elan/env
-          python src/test/simple_env_test.py
+          python src/test/simple_env_test.py
+
+      - name: Run Data Gen Test
+        shell: bash
+        run: |
+          eval $(opam env)
+          source $HOME/.elan/env
+          python src/test/simple_data_gen_test.py

{itp_interface-1.1.0 → itp_interface-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itp_interface
-Version: 1.1.0
+Version: 1.1.2
 Summary: Generic interface for hooking up to any Interactive Theorem Prover (ITP) and collecting data for training ML models for AI in formal theorem proving.
 Project-URL: Homepage, https://github.com/trishullab/itp-interface
 Project-URL: Issues, https://github.com/trishullab/itp-interface/issues
@@ -65,9 +65,9 @@ install-itp-interface
 >NOTE: These steps are only tested on Linux. For Windows, you can use WSL. These steps will not setup the Coq interface.
 
 # Full Setup for Coq and Lean:
-1. Install OCaml first. Use the instructions here: https://opam.ocaml.org/doc/Install.html . The opam version used in this project is 2.1.3 (OCaml 4.14.0). Note that OCaml officially only supports Linux installations. One can use WSL on Windows machines.
+1. Install OCaml first. Use the instructions here: https://opam.ocaml.org/doc/Install.html. Note that OCaml officially only supports Linux installations. One can use WSL on Windows machines.
 
-2. Run the following to install Coq on Linux. The Coq version used in this project is <= 8.15. 
+2. Run the following to install Coq on Linux.
 ```
 sudo apt install build-essential unzip bubblewrap
 sh <(curl -sL https://raw.githubusercontent.com/ocaml/opam/master/shell/install.sh)
@@ -232,17 +232,35 @@ action = ProofAction(
 
 ## Generating Proof Step Data:
 
+>NOTE: Make sure that you have installed the `itp-interface` package before running the following commands.
+
 1.a. You need to run the following command to generate sample proof step data for Lean 4:
 ```
-python src/itp_interface/main/run_tool.py --config-name simple_lean_data_gen
+run-itp-data-gen --config-dir src/itp_interface/main/configs  --config-name simple_lean_data_gen
 ```
-Check the `simple_lean_data_gen.yaml` configuration in the `src/itp_interface/configs` directory for more details. These config files are based on the `hydra` library (see [here](https://hydra.cc/docs/intro/)).
+Check the `simple_lean_data_gen.yaml` configuration in the `src/itp_interface/main/configs` directory for more details. These config files are based on the `hydra` library (see [here](https://hydra.cc/docs/intro/)).
 
 1.b. You need to run the following command to generate sample proof step data for Coq:
 ```
-python src/itp_interface/main/run_tool.py --config-name simple_coq_data_gen
+run-itp-data-gen --config-dir src/itp_interface/main/configs --config-name simple_coq_data_gen
 ```
-Check the `simple_coq_data_gen.yaml` configuration in the `src/itp_interface/configs` directory for more details about where the generated data is stored and where the different ITP (Coq and Lean) projects are located in the file system.
+Check the `simple_coq_data_gen.yaml` configuration in the `src/itp_interface/main/configs` directory for more details about where the generated data is stored and where the different ITP (Coq and Lean) projects are located in the file system.
 
 ## Important Note:
-The ITP projects must be built before running proof step data generation. Make sure that the switch is set correctly while generating data for Coq projects because the Coq projects can be using different versions of Coq. Instructions for Coq project setup are listed in `src/itp_interface/main/config/repo/coq_repos.yaml` file.
+The ITP projects must be built before running proof step data generation. Make sure that the switch is set correctly while generating data for Coq projects because the Coq projects can be using different versions of Coq. Instructions for Coq project setup are listed in `src/itp_interface/main/configs/repo/coq_repos.yaml` file.
+
+## Our Paper:
+
+For more details, please refer to our paper: [ProofWala: Multilingual Proof Data Synthesis and Theorem-Proving](https://arxiv.org/abs/2502.04671).
+
+```bibtex
+@misc{thakur2025proofwala,
+      title={${\rm P{\small ROOF}W{\small ALA}}$: Multilingual Proof Data Synthesis and Theorem-Proving}, 
+      author={Amitayush Thakur and George Tsoukalas and Greg Durrett and Swarat Chaudhuri},
+      year={2025},
+      eprint={2502.04671},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2502.04671}, 
+}
+```

{itp_interface-1.1.0 → itp_interface-1.1.2}/README.md

@@ -26,9 +26,9 @@ install-itp-interface
 >NOTE: These steps are only tested on Linux. For Windows, you can use WSL. These steps will not setup the Coq interface.
 
 # Full Setup for Coq and Lean:
-1. Install OCaml first. Use the instructions here: https://opam.ocaml.org/doc/Install.html . The opam version used in this project is 2.1.3 (OCaml 4.14.0). Note that OCaml officially only supports Linux installations. One can use WSL on Windows machines.
+1. Install OCaml first. Use the instructions here: https://opam.ocaml.org/doc/Install.html. Note that OCaml officially only supports Linux installations. One can use WSL on Windows machines.
 
-2. Run the following to install Coq on Linux. The Coq version used in this project is <= 8.15. 
+2. Run the following to install Coq on Linux.
 ```
 sudo apt install build-essential unzip bubblewrap
 sh <(curl -sL https://raw.githubusercontent.com/ocaml/opam/master/shell/install.sh)
@@ -193,17 +193,35 @@ action = ProofAction(
 
 ## Generating Proof Step Data:
 
+>NOTE: Make sure that you have installed the `itp-interface` package before running the following commands.
+
 1.a. You need to run the following command to generate sample proof step data for Lean 4:
 ```
-python src/itp_interface/main/run_tool.py --config-name simple_lean_data_gen
+run-itp-data-gen --config-dir src/itp_interface/main/configs  --config-name simple_lean_data_gen
 ```
-Check the `simple_lean_data_gen.yaml` configuration in the `src/itp_interface/configs` directory for more details. These config files are based on the `hydra` library (see [here](https://hydra.cc/docs/intro/)).
+Check the `simple_lean_data_gen.yaml` configuration in the `src/itp_interface/main/configs` directory for more details. These config files are based on the `hydra` library (see [here](https://hydra.cc/docs/intro/)).
 
 1.b. You need to run the following command to generate sample proof step data for Coq:
 ```
-python src/itp_interface/main/run_tool.py --config-name simple_coq_data_gen
+run-itp-data-gen --config-dir src/itp_interface/main/configs --config-name simple_coq_data_gen
 ```
-Check the `simple_coq_data_gen.yaml` configuration in the `src/itp_interface/configs` directory for more details about where the generated data is stored and where the different ITP (Coq and Lean) projects are located in the file system.
+Check the `simple_coq_data_gen.yaml` configuration in the `src/itp_interface/main/configs` directory for more details about where the generated data is stored and where the different ITP (Coq and Lean) projects are located in the file system.
 
 ## Important Note:
-The ITP projects must be built before running proof step data generation. Make sure that the switch is set correctly while generating data for Coq projects because the Coq projects can be using different versions of Coq. Instructions for Coq project setup are listed in `src/itp_interface/main/config/repo/coq_repos.yaml` file.
+The ITP projects must be built before running proof step data generation. Make sure that the switch is set correctly while generating data for Coq projects because the Coq projects can be using different versions of Coq. Instructions for Coq project setup are listed in `src/itp_interface/main/configs/repo/coq_repos.yaml` file.
+
+## Our Paper:
+
+For more details, please refer to our paper: [ProofWala: Multilingual Proof Data Synthesis and Theorem-Proving](https://arxiv.org/abs/2502.04671).
+
+```bibtex
+@misc{thakur2025proofwala,
+      title={${\rm P{\small ROOF}W{\small ALA}}$: Multilingual Proof Data Synthesis and Theorem-Proving}, 
+      author={Amitayush Thakur and George Tsoukalas and Greg Durrett and Swarat Chaudhuri},
+      year={2025},
+      eprint={2502.04671},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2502.04671}, 
+}
+```

{itp_interface-1.1.0 → itp_interface-1.1.2}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [
 build-backend = "hatchling.build"
 [project]
 name = "itp_interface"
-version = "1.1.0"
+version = "1.1.2"
 authors = [
   { name="Amitayush Thakur", email="amitayush@utexas.edu" },
 ]
@@ -52,4 +52,5 @@ Issues = "https://github.com/trishullab/itp-interface/issues"
 
 [project.scripts]
 install-itp-interface = "itp_interface.main.install:install_itp_interface"
-install-lean-repl = "itp_interface.main.install:install_lean_repl"
+install-lean-repl = "itp_interface.main.install:install_lean_repl"
+run-itp-data-gen = "itp_interface.main.run_tool:main"

{itp_interface-1.1.0/src/itp_interface/main/config → itp_interface-1.1.2/src/itp_interface/main/configs}/benchmark/simple_benchmark_lean.yaml

@@ -6,7 +6,7 @@ few_shot_metadata_filename_for_retrieval:
 dfs_data_path_for_retrieval: 
 dfs_metadata_filename_for_retrieval: 
 datasets:
-  - project: data/test/lean4_proj
+  - project: src/data/test/lean4_proj
     files:
       - path: Lean4Proj/Basic.lean
         theorems: "*"

{itp_interface-1.1.0 → itp_interface-1.1.2}/src/itp_interface/main/run_tool.py

@@ -420,17 +420,19 @@ def run_data_generation(experiment: Experiments, log_dir: str, logger: logging.L
             time.sleep(10)
     logger.info(f"Finished running experiment: \n{experiment.to_json(indent=4)}")
 
-@hydra.main(config_path="config", config_name="experiments", version_base="1.2")
+@hydra.main(config_path="configs", config_name="simple_lean_data_gen", version_base="1.2")
 def main(cfg):
     os.environ["PYTHONPATH"] = f"{root_dir}:{os.environ.get('PYTHONPATH', '')}"
     # RayUtils.init_ray(num_of_cpus=cfg.run_settings.pool_size, object_store_memory_in_gb=100)
     experiment = parse_config(cfg)
-    os.chdir(root_dir)
+    # os.chdir(root_dir)
     # top_level_dir = os.path.dirname(root_dir)
     # top_level_dir = os.path.dirname(top_level_dir)
     # os.chdir(top_level_dir)
     log_dir = ".log/data_generation/benchmark/{}/{}".format(experiment.benchmark.name, time.strftime("%Y%m%d-%H%M%S"))
     os.makedirs(log_dir, exist_ok=True)
+    abs_path = os.path.abspath(log_dir)
+    print(f"Log Dir: {abs_path}")
     log_path = os.path.join(log_dir, "eval.log")
     logger = setup_logger(__name__, log_path, logging.INFO, '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
     logger.info(f"Pid: {os.getpid()}")

{itp_interface-1.1.0 → itp_interface-1.1.2}/src/itp_interface/tools/coq_training_data_generator.py

@@ -9,11 +9,6 @@ import typing
 import logging
 import enum
 from itp_interface.tools.training_data_format import MergableCollection, TrainingDataFormat
-from torch.multiprocessing import set_start_method
-try:
-     set_start_method('spawn')
-except RuntimeError:
-    pass
 logger = logging.getLogger("CoqTrainingGenerator")
 
 class TrainingDataGenerationType(enum.Enum):

{itp_interface-1.1.0 → itp_interface-1.1.2}/src/itp_interface/tools/run_data_generation_transforms.py

@@ -14,7 +14,6 @@ import psutil
 import gc
 from itp_interface.tools.ray_utils import RayUtils
 from itp_interface.tools.training_data import TrainingData
-from itp_interface.tools.coq_build_tool import CoqRepoBuilder
 from itp_interface.tools.coq_executor import CoqExecutor
 from itp_interface.tools.lean_cmd_executor import Lean3Executor
 from itp_interface.tools.lean4_sync_executor import Lean4SyncExecutor

itp_interface-1.1.2/src/test/simple_data_gen_test.py

@@ -0,0 +1,52 @@
+import unittest
+import os
+import subprocess
+
+class TestDataGen(unittest.TestCase):
+    def test_proof_step_data_gen(self):
+        """
+        Test that the 'run-itp-data-gen' command runs successfully with the given configuration.
+        """
+        # Construct the command as a single string.
+        command = (
+            "run-itp-data-gen --config-dir=src/itp_interface/main/configs "
+            "--config-name=simple_lean_data_gen.yaml"
+        )
+
+        try:
+            # Run the command using shell=True so that the shell does the PATH lookup.
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=700
+            )
+        except subprocess.TimeoutExpired as e:
+            self.fail(f"'run-itp-data-gen' command timed out: {e}")
+        except Exception as e:
+            self.fail(f"Error running 'proof-wala-search': {e}")
+
+        # Check that the command exited with a return code of 0.
+        self.assertEqual(
+            result.returncode, 0,
+            msg=f"'run-itp-data-gen' failed with return code {result.returncode}. Stderr: {result.stderr}"
+        )
+
+        # Print all the files in the .log/data_generation/benchmark/simple_benchmark_lean
+        # directory to see what was generated.
+        # Do a list and pick the last folder in the list as per the sorted order
+        dirs = sorted(os.listdir(".log/data_generation/benchmark/simple_benchmark_lean"))
+        print(dirs)
+        last_dir = dirs[-1]
+        train_data = os.path.join(".log/data_generation/benchmark/simple_benchmark_lean", last_dir, "train")
+        data_gen_file = os.path.join(train_data, "local_data_0000000016.json")
+        print("Data Gen File:", data_gen_file)
+        with open(data_gen_file, "r") as f:
+            print(f.read())
+
+def main():
+    unittest.main()
+
+if __name__ == '__main__':
+    main()

itp_interface-1.1.0/src/itp_interface/tools/coq_build_tool.py

@@ -1,319 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-root_dir = f"{__file__.split('itp_interface')[0]}"
-if root_dir not in sys.path:
-    sys.path.append(root_dir)
-import os
-import logging
-import typing
-import argparse
-from dataclasses_json import dataclass_json
-from dataclasses import dataclass, field
-from itp_interface.tools.coq_executor import CoqExecutor
-from itp_interface.tools.coq_build_spec import CoqBuildSpec
-from torch.multiprocessing import Pool, set_start_method
-from multiprocessing.pool import AsyncResult
-from multiprocessing import Lock
-global_locks: typing.Dict[str, Lock] = {
-    "train_lock": Lock(), # The lock has to be global because the lock needs to be shared across processes
-    "test_lock": Lock(), # The lock has to be global because the lock needs to be shared across processes
-}
-try:
-     set_start_method('spawn')
-except RuntimeError:
-    pass
-
-@dataclass_json
-@dataclass
-class CoqRepoBuilder:
-    root: str
-    compilable_projects: typing.Set[str] = field(default_factory=set)
-    compilable_files: typing.List[str] = field(default_factory=list)
-    uncompilable_projects: typing.Set[str] = field(default_factory=set)
-    uncompilable_files: typing.List[str] = field(default_factory=list)
-    train_compilable_files: typing.List[str] = field(default_factory=list)
-    train_uncompilable_files: typing.List[str] = field(default_factory=list)
-    test_compilable_files: typing.List[str] = field(default_factory=list)
-    test_uncompilable_files: typing.List[str] = field(default_factory=list)
-
-    def __post_init__(self):
-        self.logger = logging.getLogger(__name__)
-        self.transform = None
-        self.build_specs = None
-        self.build_disabled = False
-        self.projects_to_exclude = set()
-        self.log_error = False
-    
-
-    def enable_error_loggging(self):
-        self.log_error = True
-
-    def set_logger(self, logger: logging.Logger):
-        self.logger = logger
-    
-    def add_project_to_exclude(self, project_name: str):
-        self.projects_to_exclude.add(project_name)
-    
-    def set_build_spec(self, build_specs: typing.List[CoqBuildSpec]):
-        assert isinstance(build_specs, list), "build_specs must be a list"
-        assert all([isinstance(spec, CoqBuildSpec) for spec in build_specs]), "build_specs must be a list of CoqBuildSpec"
-        self.build_specs = build_specs
-    
-    def set_transform(self, transform: typing.Callable[[str, CoqExecutor], None]):
-        assert callable(transform), "transform must be a callable"
-        self.transform = transform
-    
-    def disable_build(self):
-        self.build_disabled = True
-    
-    def _compile_file(self, project_path: str, file_path: str):
-        global global_locks
-        t_compiled_files_successfully = True
-        if os.path.exists(file_path):
-            # Compile the file
-            try:
-                with CoqExecutor(project_path, file_path, suppress_error_log=self.log_error) as coq_exec:
-                    coq_exec.run_to_finish()
-                    self.logger.info(f"[PID: {os.getpid()}] Compiled {file_path} successfully")
-            except:
-                self.logger.warning(f"[PID: {os.getpid()}] Couldn't Compile {file_path}")
-                t_compiled_files_successfully = False
-                pass
-        else:
-            self.logger.warning(f"File {file_path} does not exist")
-        return t_compiled_files_successfully
-
-    def build_from_spec(self, spec: CoqBuildSpec):
-        assert isinstance(spec, CoqBuildSpec), "spec must be a CoqBuildSpec"
-        if spec.project_name == '.':
-                spec.project_name = os.path.basename(os.path.normpath(self.root))
-                project_path = self.root
-        else:
-            project_path = os.path.join(self.root, spec.project_name)
-        assert os.path.exists(project_path), f"Project {spec.project_name} does not exist (project_path: {project_path})"
-        if not self.build_disabled:
-            # Build the project
-            build_command = f"cd {project_path}"
-            if spec.switch is not None:
-                build_command += f" && eval \"$(opam env --set-switch --switch={spec.switch})\""
-            if spec.build_command is not None:
-                build_command += f" && {spec.build_command}"
-            else:
-                build_command += f" && make"
-            self.logger.info(f"[START] Build Attempt for project {spec.project_name} with command {build_command}")
-            try:
-                error_code = os.system(build_command)
-                if error_code != 0:
-                    self.uncompilable_projects.add(spec.project_name)
-                    self.logger.warning(f"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX>ERROR building project {spec.project_name} with command {build_command}<XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
-                else:
-                    self.compilable_projects.add(spec.project_name)
-                    self.logger.info(f"==============================>Successfully compiled project {spec.project_name}<==============================")
-            except:
-                self.logger.error(f"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX>FAILED to compile project {spec.project_name}<XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
-        else:
-            self.logger.info(f"Build is disabled for all projects.")
-        
-        # Compile the files in the project parallelly
-        compiled_files_successfully = True
-        results: typing.List[AsyncResult] = []
-        self.logger.info(f"Compiling files for project \"{spec.project_name}\" parallelly")
-        with Pool() as pool:
-            train_results: typing.List[AsyncResult] = []
-            test_results: typing.List[AsyncResult] = []
-            for file in spec.train_files:
-                file = file.lstrip('./')
-                file_path = os.path.join(project_path, file)
-                res = pool.apply_async(self._compile_file, 
-                    (project_path, file_path))
-                results.append(res)
-                train_results.append(res)
-                # if not _compile_file(file_path, self.train_compilable_files, self.train_uncompilable_files):
-                #     compiled_files_successfully = False
-            for file in spec.test_files:
-                file = file.lstrip('./')
-                file_path = os.path.join(project_path, file)
-                res = pool.apply_async(self._compile_file, 
-                    (project_path, file_path))
-                results.append(res)
-                test_results.append(res)
-                # if not _compile_file(file_path, self.test_compilable_files, self.test_uncompilable_files):
-                #     compiled_files_successfully = False
-            for result in results:
-                result.wait()
-            compiled_files_successfully = all([result.get() for result in results])
-            for result, file in zip(train_results, spec.train_files):
-                file = file.lstrip('./')
-                file_path = os.path.join(project_path, file)
-                if result.get():
-                    self.train_compilable_files.append(file_path)
-                    self.compilable_files.append(file_path)
-                else:
-                    self.train_uncompilable_files.append(file_path)
-                    self.uncompilable_files.append(file_path)
-            for result, file in zip(test_results, spec.test_files):
-                file = file.lstrip('./')
-                file_path = os.path.join(project_path, file)
-                if result.get():
-                    self.test_compilable_files.append(file_path)
-                    self.compilable_files.append(file_path)
-                else:
-                    self.test_uncompilable_files.append(file_path)
-                    self.uncompilable_files.append(file_path)
-        if not self.build_disabled:
-            self.logger.info(f"[END] Build Attempt for project {spec.project_name} with command {build_command}")
-        else:
-            if compiled_files_successfully:
-                self.compilable_projects.add(spec.project_name)
-            else:
-                self.uncompilable_projects.add(spec.project_name)
-
-    def build_all(self):
-        assert self.build_specs is not None, "build_specs is not set. Please use set_build_spec to set it"
-        self.logger.info(f"Starting to build all projects...")
-        for spec in self.build_specs:
-            if spec.project_name not in self.projects_to_exclude:
-                self.build_from_spec(spec)
-            else:
-                self.logger.warning(f"Skipping project {spec.project_name} since it is in the exclusion list")
-        self.logger.info(f"Compilable Projects: {self.compilable_projects}")
-        self.logger.info(f"Uncompilable Projects: {self.uncompilable_projects}")
-
-    def serialize(self):
-        return self.to_json(indent=4)
-    
-    def run_transform_over_compilable_files(self, use_human_readable: bool = False):
-        assert self.transform is not None, "transform is not set. Please use set_transform to set it"
-        assert callable(self.transform), "transform must be a callable"
-        for project in sorted(self.compilable_projects):
-            self.logger.info(f"==============================>Running transform over project {project}<==============================")
-            project_path = os.path.join(self.root, project)
-            # Use os.walk with sorted to ensure that the files are processed in the same order
-            for root, _, files in sorted(os.walk(project_path)):
-                for file in sorted(files):
-                    file_path = os.path.join(root, file)
-                    if file_path in self.compilable_files:
-                        try:
-                            with CoqExecutor(project_path, file_path, use_human_readable_proof_context=use_human_readable) as coq_exec:
-                                project_id = project_path.replace('/', '.')
-                                self.transform(project_id, coq_exec)
-                        except:
-                            self.logger.error(f"Got an exception while running transform over {file}")
-                            self.logger.exception(f"Exception Log")
-                            pass
-    
-    def run_local_transform(self, project_path: str, file_path: str, use_human_readable: bool, transform: typing.Callable[[str, CoqExecutor, typing.Callable[[], CoqExecutor]], None]):
-        try:
-            def _print_coq_callback():
-                t_coq_exec = CoqExecutor(project_path, file_path, suppress_error_log=self.log_error, use_human_readable_proof_context=use_human_readable)
-                t_coq_exec.__enter__()
-                return t_coq_exec
-            self.logger.info(f"==============================>Running transform over file {file_path}<==============================")
-            with CoqExecutor(project_path, file_path, suppress_error_log=self.log_error, use_human_readable_proof_context=use_human_readable) as coq_exec:
-                project_id = project_path.replace('/', '.')
-                transform(project_id, coq_exec, _print_coq_callback)
-            self.logger.info(f"==============================>Successfully ran transform over file {file_path}<==============================")
-        except:
-            self.logger.warning(f"XXXXXXXXXXXXXXXXXXXXXXX>Failed in running transform over file {file_path}<XXXXXXXXXXXXXXXXXXXXXXXXXX")
-            self.logger.error(f"Got an exception while running transform over {file_path}")
-            self.logger.exception(f"Exception Log")
-            pass
-
-    def run_transform(self, transform: typing.Callable[[str, CoqExecutor, typing.Callable[[], CoqExecutor]], None], projects: typing.List[str], files: typing.List[str], use_human_readable: bool = False):
-        assert callable(transform), "transform must be a callable"
-        assert projects is not None, "projects should not be None"
-        assert files is not None, "files should not be None"
-        assert isinstance(projects, list), "projects should be a list"
-        assert len(projects) > 0, "projects should not be empty"
-        assert isinstance(files, list), "files should be a list"
-        assert len(files) > 0, "files should not be empty"
-        assert len(projects) <= len(files)
-
-        for project in sorted(projects):
-            self.logger.info(f"==============================>Running transform over project {project}<==============================")
-            project_path = os.path.join(self.root, project)
-            assert os.path.exists(project_path), f"project_path {project_path} does not exist"
-            some_files_processed = False
-            for file_path in sorted(files):
-                if file_path.startswith(project_path):
-                    some_files_processed = True
-                    
-                    try:
-                        def _print_coq_callback():
-                            t_coq_exec = CoqExecutor(project_path, file_path, suppress_error_log=self.log_error, use_human_readable_proof_context=use_human_readable)
-                            t_coq_exec.__enter__()
-                            return t_coq_exec
-                        self.logger.info(f"==============================>Running transform over file {file_path}<==============================")
-                        with CoqExecutor(project_path, file_path, suppress_error_log=self.log_error, use_human_readable_proof_context=use_human_readable) as coq_exec:
-                            project_id = project_path.replace('/', '.')
-                            transform(project_id, coq_exec, _print_coq_callback)
-                        self.logger.info(f"==============================>Successfully ran transform over file {file_path}<==============================")
-                    except:
-                        self.logger.warning(f"XXXXXXXXXXXXXXXXXXXXXXX>Failed in running transform over file {file_path}<XXXXXXXXXXXXXXXXXXXXXXXXXX")
-                        self.logger.error(f"Got an exception while running transform over {file_path}")
-                        self.logger.exception(f"Exception Log")
-                        pass
-            if not some_files_processed:
-                self.logger.info(f"==============================>No files processed for project {project}<==============================")
-            else:
-                self.logger.info(f"==============================>Finished transform over project {project}<==============================")
-
-    def load_from_file(file_path: str):
-        assert os.path.exists(file_path), "file_path must be a valid path to a file"
-        json_text = None
-        with open(file_path, "r") as f:
-            json_text = f.read()
-        return CoqRepoBuilder.schema().loads(json_text)
-
-# nohup python3 src/tools/coq_build_tool.py --root_project data/benchmarks/CompCert --build_spec data/benchmarks/compcert_projs_splits.json --info_file data/benchmarks/compcert_projs_build.log.json --option build &
-if __name__ == "__main__":
-    import time
-    os.chdir(root_dir)
-    current_time = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
-    logging_dir = f".log/build_logs"
-    try:
-        os.mkdir(logging_dir)
-    except FileExistsError:
-        pass
-    log_file = f"{os.path.join(logging_dir, f'coq_build_tool_{current_time}.log')}"
-    with open(log_file, "w") as f:
-        f.write("") # Clear the file
-    logging.basicConfig(filename=log_file, filemode='w', level=logging.INFO)
-    logger = logging.getLogger(__name__)
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--root_project", type=str, default="data/test/coq/custom_group_theory", help="The root folder of the coq project")
-    parser.add_argument("--build_spec", type=str, default="data/test/coq/custom_group_theory/grp_theory_splits.json", help="The file which has the build spec")
-    parser.add_argument("--info_file", type=str, default="data/test/coq/custom_group_theory/compilable_projects_info.log.json", help="The file which will have the info about the compilable projects")
-    parser.add_argument("--option", choices=["build", "load"], default="build", help="The option to run. Either build or load")
-    parser.add_argument("--projects_to_exclude", type=str, default=None, required=False)
-    parser.add_argument("--only_compile_files", type=bool, default=False, required=False)
-    args = parser.parse_args()
-    root_project = args.root_project
-    info_file = args.info_file
-    option = args.option
-    if option == "build":
-        builder = CoqRepoBuilder(root_project)
-        # Create build spec
-        with open(args.build_spec, 'r') as f:
-            build_specs = CoqBuildSpec.schema().loads(f.read(), many=True)
-        builder.set_build_spec(build_specs)
-        if args.projects_to_exclude is not None:
-            projects_to_exclude = args.projects_to_exclude.split(',')
-            for project in projects_to_exclude:
-                project = project.strip()
-                assert os.path.exists(os.path.join(root_project, project)), f"{project} is not a valid project"
-                builder.add_project_to_exclude(project)
-        if args.only_compile_files:
-            builder.disable_build()
-        builder.build_all()
-        with open(info_file, 'w') as f:
-            f.write(builder.serialize())
-    elif option == "load":
-        builder = CoqRepoBuilder.load_from_file(info_file)
-        logger.info(builder.compilable_projects)
-        logger.info(builder.compilable_files)
-        logger.info(builder.uncompilable_projects)
-        logger.info(builder.uncompilable_files)
-    else:
-        raise Exception("Invalid option")