itp-interface 1.0.0__py3-none-any.whl

itp_interface/tools/isabelle_local_data_generation_transform.py

@@ -0,0 +1,149 @@
+#!/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 typing
+import uuid
+import os
+from itp_interface.tools.isabelle_executor import IsabelleExecutor
+from itp_interface.tools.isabelle_context_helper import IsabelleContextHelper
+from itp_interface.tools.coq_training_data_generator import GenericTrainingDataGenerationTransform, TrainingDataGenerationType
+from itp_interface.tools.training_data_format import Goal, MergableCollection, TrainingDataMetadataFormat, TrainingDataCollection, TrainingDataFormat
+from itp_interface.tools.training_data import TrainingData
+
+# See this for running transformation on AFP
+# https://github.com/albertqjiang/Portal-to-ISAbelle/blob/56def2c39f85d211e1f40cc5765581a567879106/src/main/python/legacy/demo.py#L2
+
+class LocalDataGenerationTransform(GenericTrainingDataGenerationTransform):
+    def __init__(self,
+                depth = None,
+                max_search_results = None,
+                buffer_size : int = 10000,
+                logger = None,
+                max_parallelism : int = 4,
+                **kwargs):
+        super().__init__(TrainingDataGenerationType.LOCAL, buffer_size, logger)
+        self.depth = depth
+        self.max_search_results = max_search_results
+        self.max_parallelism = max_parallelism
+        self.ray_resource_pool = kwargs.get('resource_pool', None)
+        self.pisa_severs = []
+
+    def get_meta_object(self) -> MergableCollection:
+        return TrainingDataMetadataFormat(training_data_buffer_size=self.buffer_size)
+
+    def get_data_collection_object(self) -> MergableCollection:
+        return TrainingDataCollection()
+    
+    def load_meta_from_file(self, file_path) -> MergableCollection:
+        return TrainingDataMetadataFormat.load_from_file(file_path)
+    
+    def load_data_from_file(self, file_path) -> MergableCollection:
+        return TrainingDataCollection.load_from_file(file_path, self.logger)
+
+    def __call__(self, training_data: TrainingData, project_id : str, isabelle_executor: IsabelleExecutor, print_coq_executor_callback: typing.Callable[[], IsabelleExecutor], theorems: typing.List[str] = None, other_args: dict = {}) -> TrainingData:
+        print_isabelle_executor = print_coq_executor_callback()
+        isabelle_context_helper = IsabelleContextHelper(print_isabelle_executor, self.depth, self.logger)
+        isabelle_context_helper.__enter__()
+        file_namespace = isabelle_executor.main_file.replace('/', '.')
+        self.logger.info(f"=========================Processing {file_namespace}=========================")
+        proof_running = False
+        cmd_ran = isabelle_executor.run_next(proof_search_mode=False)
+        cmd_exec = isabelle_executor.current_stmt
+        prev_goal : typing.List[Goal] = isabelle_context_helper.get_focussed_goals(isabelle_executor) if isabelle_executor.is_in_proof_mode() else []
+        line_number = isabelle_executor.line_num
+        lemma_name = isabelle_executor.get_lemma_name_if_running()
+        if lemma_name is None:
+            lemma_name = "__NONE__"
+        theorem_id = str(uuid.uuid4())
+        proof_id = theorem_id # self.get_proof_id(theorem_id, file_namespace, line_number, lemma_name)
+        local_lemma_refs_cnt = 0
+        external_lemma_refs_cnt = 0
+        theorems = set(theorems) if theorems is not None else None
+        while cmd_ran:
+            if isabelle_executor.is_in_proof_mode() and lemma_name != "__NONE__" and (theorems is None or lemma_name in theorems):
+                proof_running = True
+                prev_goal : typing.List[Goal] = [Goal(goal.hypotheses, goal.goal) for goal in prev_goal]
+                next_goal : typing.List[Goal] = isabelle_context_helper.get_focussed_goals(isabelle_executor)
+                if len(prev_goal) > 0:
+                    training_data_format = TrainingDataFormat(
+                        proof_id=proof_id,
+                        all_useful_defns_theorems=[],
+                        start_goals=prev_goal,
+                        end_goals=next_goal,
+                        proof_steps=[cmd_exec],
+                        simplified_goals=[], 
+                        addition_state_info={},
+                        file_path=isabelle_executor.main_file,
+                        theorem_name=lemma_name,
+                        project_id=project_id)
+                    assert len(training_data_format.proof_steps) > 0, f"Proof steps cannot be empty for {proof_id}"
+                    for goal in training_data_format.start_goals:
+                        lemma_cnt = len(training_data_format.all_useful_defns_theorems)
+                        assert all([0 <= lemma_ref.lemma_idx < lemma_cnt for lemma_ref in goal.used_theorems_local]), f"Invalid lemma idx in {proof_id}"
+                        assert all([0 <= lemma_ref.lemma_idx < lemma_cnt for lemma_ref in goal.used_theorems_external]), f"Invalid lemma idx in {proof_id}"
+                        assert all([0 <= lemma_ref.lemma_idx < lemma_cnt for lemma_ref in goal.possible_useful_theorems_external]), f"Invalid lemma idx in {proof_id}"
+                        assert all([0 <= lemma_ref.lemma_idx < lemma_cnt for lemma_ref in goal.possible_useful_theorems_local]), f"Invalid lemma idx in {proof_id}"
+                    training_data.merge(training_data_format)
+                    local_lemma_refs_cnt += sum([len(goal.used_theorems_local) for goal in training_data_format.start_goals])
+                    external_lemma_refs_cnt += sum([len(goal.used_theorems_external) for goal in training_data_format.start_goals])
+                prev_goal = next_goal
+            else:
+                prev_goal = []
+            cmd_ran = isabelle_executor.run_next(proof_search_mode=False)
+            cmd_exec = isabelle_executor.current_stmt
+            line_number = isabelle_executor.line_num
+            if proof_running and not isabelle_executor.is_in_proof_mode():
+                proof_running = False
+                self.logger.info(f"Finished processing lemma [{theorem_id}] {lemma_name}")
+                theorem_id = str(uuid.uuid4())
+            lemma_name = isabelle_executor.get_lemma_name_if_running()
+            if lemma_name is None:
+                lemma_name = "__NONE__"
+            proof_id = theorem_id # self.get_proof_id(theorem_id, file_namespace, line_number, lemma_name)
+            
+        self.logger.info(f"===============Finished processing {file_namespace}=====================")
+        try:
+            isabelle_context_helper.__exit__(None, None, None)
+        except:
+            pass
+
+
+if __name__ == "__main__":
+    import logging
+    import time
+    os.chdir(root_dir)
+    project_dir = "data/test/isabelle/custom_hol"
+    file_name = "data/test/isabelle/custom_hol/Basic_Logic.thy"
+    project_id = project_dir.replace('/', '.')
+    time_str = time.strftime("%Y%m%d-%H%M%S")
+    output_path = f".log/local_data_generation_transform/data/{time_str}"
+    log_path = f".log/local_data_generation_transform/log/{time_str}"
+    log_file = f"{log_path}/local_data_generation_transform-{time_str}.log"
+    os.makedirs(output_path, exist_ok=True)
+    os.makedirs(log_path, exist_ok=True)
+    logging.basicConfig(filename=log_file, level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+    logger = logging.getLogger(__name__)
+    def _print_isabelle_executor_callback():
+        search_isabelle_exec = IsabelleExecutor(project_root=project_dir, main_file=file_name, use_human_readable_proof_context=True, suppress_error_log=True)
+        search_isabelle_exec.__enter__()
+        return search_isabelle_exec
+    transform = LocalDataGenerationTransform(0, buffer_size=1000)
+    training_data = TrainingData(
+        output_path, 
+        "training_metadata.json",
+        training_meta=transform.get_meta_object(), 
+        logger=logger)
+
+    IsabelleExecutor.start_server(port=13000)
+    
+    try:
+        with IsabelleExecutor(project_root=project_dir, main_file=file_name, use_human_readable_proof_context=True, suppress_error_log=True) as isabelle_exec:
+            transform(training_data, project_id, isabelle_exec, _print_isabelle_executor_callback)
+    finally:
+        IsabelleExecutor.stop_server()
+    
+    save_info = training_data.save()
+    logger.info(f"Saved training data to {save_info}")

itp_interface/tools/isabelle_parse_utils.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+
+# TODO: this parser doesn't work well because it relies on newlines as delimiters, 
+# which is often not the case in Isar proofs. However, Isar doesn't have a good delimiter in general.
+
+import os
+import sys
+root_dir = f"{__file__.split('itp_interface')[0]}"
+if root_dir not in sys.path:
+    sys.path.append(root_dir)
+import typing
+import re
+
+class IsabelleLineByLineReader:
+
+    theorem_regex = r"((((theorem\s+|lemma\s+)([\w+|\d+'_]*)))(\s*:\s*)([\S|\s]*?))(\ssorry|\susing\s|\sby\s|\sproof)"
+    theorem_match = re.compile(theorem_regex, re.MULTILINE)
+
+    def __init__(self, file_name: str = None, file_content: str = None):
+        assert file_name is not None or file_content is not None, "Either file_name or file_content must be provided"
+        assert file_name is None or file_content is None, "Only one of file_name or file_content must be provided"
+        self.file_name : str = file_name
+        self.file_content : str = file_content
+        if self.file_name is not None:
+            with open(file_name, 'r') as fd:
+                self.file_content : str = fd.read()
+        self.remove_comments()
+        self.handle_theorems()
+    
+    def remove_comments(self):
+        CODE_MODE = 0
+        COMMENT_MODE = 1
+        idx = 0
+        mode = CODE_MODE
+        code_without_comments = []
+        comment_stack = []
+        while idx < len(self.file_content):
+            ch = self.file_content[idx]
+            if mode == CODE_MODE and ch == '(' and idx + 1 < len(self.file_content) and self.file_content[idx + 1] == '*':
+                mode = COMMENT_MODE
+                idx += 2
+                comment_stack.append("(*")
+            elif mode == COMMENT_MODE and ch == '(' and idx + 1 < len(self.file_content) and self.file_content[idx + 1] == '*':
+                mode = COMMENT_MODE
+                idx += 2
+                comment_stack.append("(*") # Start of nested comment
+            elif mode == COMMENT_MODE and ch == '*' and idx + 1 < len(self.file_content) and self.file_content[idx + 1] == ')':
+                comment_stack.pop()
+                if len(comment_stack) == 0:
+                    mode = CODE_MODE
+                else:
+                    assert comment_stack[-1] == "(*", "Comment stack should only contain '(*'"
+                    mode = COMMENT_MODE # There is some nested comment still open
+                idx += 2
+            elif mode == COMMENT_MODE:
+                mode = COMMENT_MODE
+                idx += 1
+            elif mode == CODE_MODE:
+                code_without_comments.append(ch)
+                idx += 1
+            else:
+                raise Exception("Unknown mode")
+        self.file_content = "".join(code_without_comments)
+
+    # Make sure that when a theorem is parsed, there aren't any tactics on the same line
+    def handle_theorems(self):
+        self.file_content = IsabelleLineByLineReader.theorem_match.sub(r'\1\n\8', self.file_content)
+
+    def instruction_step_generator(self) -> typing.Iterator[str]:
+        lines = self.file_content.split('\n')
+        for line in lines:
+            if not len(line.strip()) == 0:
+                yield line.strip()
+
+class IsabelleStepByStepStdInReader:
+    def __init__(self):
+        pass
+
+    def instruction_step_generator(self) -> typing.Iterator[str]:
+        while True:
+            try:
+                line = input()
+                if line == "(* exit *)":
+                    break
+                yield line.strip() # Keep going line by line
+            except EOFError:
+                break
+
+if __name__ == "__main__":
+    file_content = """
+(*
+  Authors: Wenda Li
+*)
+
+theory aime_1983_p1 imports Complex_Main
+begin
+
+theorem aime_1983_p1:
+  fixes x y z w :: nat
+  assumes ht : "1 < x \<and> 1 < y \<and> 1 < z"
+    and hw : "0 \<le> w"
+    and h0 : "ln w / ln x = 24"
+    and h1 : "ln w / ln y = 40"
+    and h2 : "ln w / ln (x * y * z) = 12"
+  shows "ln w / ln z = 60"
+proof -
+  define xx yy zz ww where "xx=ln x" and "yy = ln y" 
+      and "zz = ln z" and "ww = ln w"
+  have "xx= ww/24" using h0 ht unfolding xx_def ww_def 
+    by (auto simp:field_simps)
+  moreover have "yy = ww / 40" using ht h1 unfolding yy_def ww_def
+    by (auto simp:field_simps)
+  moreover have "xx+yy+zz > 0" 
+    unfolding xx_def yy_def zz_def using ht 
+    by (metis ln_gt_zero of_nat_1 of_nat_less_iff pos_add_strict)
+  then have "ww = 12*(xx+yy+zz)"using ht h2
+    unfolding xx_def yy_def zz_def ww_def
+    by (auto simp:field_simps ln_mult)
+  ultimately have "ww = 12*(ww/24 + ww/40 + zz)"
+    by blast
+  then have "ww=60*zz"
+    by (auto simp:field_simps)
+  then show ?thesis unfolding ww_def zz_def using ht by auto
+qed
+
+end
+"""
+    isabelle_reader = IsabelleLineByLineReader(file_content=file_content)
+    assert isabelle_reader.file_content is not None
+    for idx, instruction in enumerate(isabelle_reader.instruction_step_generator()):
+        print(f"[{idx}]: {instruction}")

itp_interface/tools/isabelle_server.py

@@ -0,0 +1,106 @@
+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 ray
+import signal
+import subprocess
+import time
+import threading
+import uuid
+from itp_interface.tools.log_utils import setup_logger
+
+@ray.remote
+class IsabelleServer(object):
+    def __init__(self, log_filename: str, port: int = 8000):
+        assert port > 0, "Port number must be greater than 0"
+        assert port < 65536, "Port number must be less than 65536"
+        self.log_filename = log_filename
+        self.port = port
+        logger_id = str(uuid.uuid4())
+        with open(log_filename, "w") as f:
+            f.write("")
+        self.logger = setup_logger(f"isabelle_server_{logger_id}", log_filename)
+        self.pid = None
+        self.thread_id = None
+        self.process_killed = False
+        self.process = None
+
+    def start_server(self):
+        last_dir = os.path.dirname(root_dir)
+        os.chdir(last_dir)
+
+        jar_path = "itp_interface/pisa/target/scala-2.13/PISA-assembly-0.1.jar"
+        assert os.path.exists(jar_path), "PISA jar file not found. Please build the project using 'sbt assembly' commnad"
+        cmd = f"java -cp {jar_path} pisa.server.PisaOneStageServer{self.port}"
+        # Start the server in a separate process
+        cwd = os.getcwd()
+        server_process = subprocess.Popen(
+            cmd, 
+            cwd=cwd,
+            shell=True, 
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.PIPE,
+            preexec_fn=os.setsid) # Create a new process group so that we can kill the process and all its children
+        pid = server_process.pid
+        self.pid = pid
+        # Log the process id
+        self.logger.info(f"Server process id: {self.pid}")
+        # Log the port number
+        self.logger.info(f"Server port: {self.port}")
+        self.logger.info("Waiting for server to start")
+        time.sleep(5)
+        server_running = self.check_server_running()
+        if not server_running:
+            self.logger.error(f"Server is not running on port {self.port}")
+        else:
+            self.process = server_process
+            thread = threading.Thread(target=self._server_logging_thread)
+            thread.start()
+            thread_id = thread.ident
+            self.thread_id = thread_id
+        pass
+
+    def check_server_running(self):
+        # log the netsat result netstat -nlp | grep :{port}
+        netstat_cmd = f"netstat -nlp | grep :{self.port}"
+        self.logger.info(f"Netstat command: {netstat_cmd}")
+        output = subprocess.run(netstat_cmd, shell=True, capture_output=True)
+        self.logger.info(f"Netstat output: {output}")
+        output_str = output.stdout.decode("utf-8")
+        self.logger.info(f"Netstat output stdout: {output_str}")        
+        server_running = "tcp" in output_str
+        return server_running
+
+    def _server_logging_thread(self):
+        # Keep checking the server is running
+        while not self.process_killed:
+            try:
+                line = self.process.stdout.readline()
+                if not line:
+                    break
+                self.logger.info(line)
+            except:
+                self.logger.info("Stdout is closed")
+                time.sleep(1)
+        self.logger.info("Server is shut down")
+        # Print the environment variables
+        self.logger.info(f"Environment variables at shutdown time: {os.environ}")
+        time.sleep(1)
+        pass
+
+    def stop_server(self):
+        self.process_killed = True
+        try:
+            # Kill the server process
+            os.killpg(self.pid, signal.SIGTERM)
+        except:
+            pass
+        thread_id = self.thread_id
+        # Find the right thread object
+        for thread in threading.enumerate():
+            if thread.ident == thread_id:
+                thread.join(5)
+                break
+        pass

itp_interface/tools/lean4_context_helper.py

@@ -0,0 +1,72 @@
+#!/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 logging
+import typing
+from itp_interface.tools.lean4_sync_executor import Lean4SyncExecutor, ProofContext
+from itp_interface.tools.training_data_format import Goal, LemmaRefWithScore, LemmaReferences, TrainingDataFormat
+from typing import List
+
+class Lean4ContextHelper(object):
+    max_relevance_score = 0.95
+    def __init__(self, search_executor: Lean4SyncExecutor, depth : typing.Optional[int] = None, logger: logging.Logger = None) -> None:
+        assert search_executor is not None, "Search executor cannot be None"
+        assert depth is None or depth >= 0, "Depth should be greater than 0"
+        self.search_executor = search_executor
+        self.depth = depth if depth is not None else -1
+        self.logger = logger if logger is not None else logging.getLogger(__name__)
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        pass
+
+    def get_focussed_goals(self, lean_executor: Lean4SyncExecutor) -> List[Goal]:
+        # Only consider the foreground goals because we can handle the multi-line tactics
+        return [Goal(hypotheses=goal.hypotheses, goal=goal.goal) for goal in lean_executor.proof_context.fg_goals]
+
+    def get_focussed_goals_from_proof_context(self, proof_context: ProofContext) -> List[Goal]:
+        # Only consider the foreground goals because we can handle the multi-line tactics
+        return [Goal(hypotheses=goal.hypotheses, goal=goal.goal) for goal in proof_context.fg_goals]
+    
+    def get_unfocussed_goals(self, lean_executor: Lean4SyncExecutor) -> List[Goal]:
+        # Only consider the foreground goals because we can handle the multi-line tactics
+        other_goals = lean_executor.proof_context.bg_goals + lean_executor.proof_context.shelved_goals + lean_executor.proof_context.given_up_goals
+        return [Goal(hypotheses=goal.hypotheses, goal=goal.goal) for goal in other_goals]
+
+    def get_local_lemmas(self, lean_executor: Lean4SyncExecutor, logger: logging.Logger = None) -> List[typing.Tuple[str, str]]:
+        # Search is not supported in Lean as of now
+        raise Exception("Search is not supported in Lean as of now")
+
+
+    def set_relevant_defns_in_training_data_point(self, training_data_point: TrainingDataFormat, lean_executor: Lean4SyncExecutor, logger: logging.Logger = None, depth: int = None):
+        # Search is not supported in Lean as of now
+        raise Exception("Search is not supported in Lean as of now")
+
+    def set_all_type_matched_query_result(self, training_data_point: TrainingDataFormat, lean_executor: Lean4SyncExecutor, logger: logging.Logger = None, depth: int = None):
+        unique_thms = {defn.lemma_name: idx for idx, defn in enumerate(training_data_point.all_useful_defns_theorems)}
+        # query = training_data_point.get_human_readable_serialized_goal(idx, skip_special_tokens=True)
+        relevant_thms = self.search_executor.search_type_matching_defns("") # Here the search simply returns everything
+        # Add all lemma references to unique_defns
+        for thm in relevant_thms:
+            thm_name = f"{thm.namespace}.{thm.name}"
+            if thm.name not in unique_thms:
+                _idx = len(training_data_point.all_useful_defns_theorems)
+                unique_thms[thm_name] = _idx
+                training_data_point.all_useful_defns_theorems.append(LemmaReferences(_idx, thm_name, thm.dfn))
+        for _, goal in enumerate(training_data_point.start_goals):
+            goal.possible_useful_theorems_external = [LemmaRefWithScore(unique_thms[f"{thm.namespace}.{thm.name}"], 1.0) for thm in relevant_thms]
+            goal.possible_useful_theorems_local = []
+
+    def set_useful_defns_theorems_for_training_data_generation(self, current_stmt: str, training_data_point: TrainingDataFormat, lean_executor: Lean4SyncExecutor, logger: logging.Logger = None, depth: int = None, max_search_res: typing.Optional[int] = None):
+        # Search is not supported in Lean as of now
+        raise Exception("Search is not supported in Lean as of now")
+
+    def set_local_thms_dfns(self, training_data_point: TrainingDataFormat, lean_executor: Lean4SyncExecutor, logger: logging.Logger = None):
+        # Search is not supported in Lean as of now
+        raise Exception("Search is not supported in Lean as of now")        

itp_interface/tools/lean4_local_data_generation_transform.py

@@ -0,0 +1,122 @@
+#!/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 typing
+import uuid
+from itp_interface.tools.lean4_sync_executor import Lean4SyncExecutor
+from itp_interface.tools.lean4_context_helper import Lean4ContextHelper
+from itp_interface.tools.coq_training_data_generator import GenericTrainingDataGenerationTransform, TrainingDataGenerationType
+from itp_interface.tools.training_data_format import MergableCollection, TrainingDataMetadataFormat, TrainingDataCollection, TrainingDataFormat
+from itp_interface.tools.training_data import TrainingData
+
+class Local4DataGenerationTransform(GenericTrainingDataGenerationTransform):
+    def __init__(self,
+                depth = None,
+                max_search_results = None,
+                buffer_size : int = 10000,
+                logger = None,
+                max_parallelism : int = 4):
+        super().__init__(TrainingDataGenerationType.LOCAL, buffer_size, logger)
+        self.depth = depth
+        self.max_search_results = max_search_results
+        self.max_parallelism = max_parallelism
+
+    def get_meta_object(self) -> MergableCollection:
+        return TrainingDataMetadataFormat(training_data_buffer_size=self.buffer_size)
+
+    def get_data_collection_object(self) -> MergableCollection:
+        return TrainingDataCollection()
+    
+    def load_meta_from_file(self, file_path) -> MergableCollection:
+        return TrainingDataMetadataFormat.load_from_file(file_path)
+    
+    def load_data_from_file(self, file_path) -> MergableCollection:
+        return TrainingDataCollection.load_from_file(file_path, self.logger)
+
+    def __call__(self, training_data: TrainingData, project_id : str, lean_executor: Lean4SyncExecutor, print_coq_executor_callback: typing.Callable[[], Lean4SyncExecutor], theorems: typing.List[str] = None, other_args: dict = {}) -> TrainingData:
+        print_lean_executor = print_coq_executor_callback()
+        lean_context_helper = Lean4ContextHelper(print_lean_executor, self.depth, self.logger)
+        lean_context_helper.__enter__()
+        file_namespace = lean_executor.main_file.replace('/', '.')
+        self.logger.info(f"=========================Processing {file_namespace}=========================")
+        theorem_id = str(uuid.uuid4())
+        theorems = set(theorems) if theorems is not None else None
+        assert len(theorems) == 1, "Only one theorem can be processed at a time"
+        with lean_executor:
+            lean_executor.set_run_exactly()
+            lean_executor._skip_to_theorem(theorems.pop())
+            start_goals = lean_context_helper.get_focussed_goals_from_proof_context(lean_executor.proof_context)
+            ran_next = lean_executor.run_next()
+            cmd_ran = lean_executor.current_stmt
+            try:
+                theorem_id = theorem_id + "/" + lean_executor.get_current_lemma_name()
+            except:
+                pass
+            proof_id = theorem_id
+            while not lean_executor.execution_complete and ran_next:
+                if lean_executor.is_in_proof_mode():
+                    end_goals = lean_context_helper.get_focussed_goals_from_proof_context(lean_executor.proof_context)
+                else:
+                    end_goals = []
+                if len(start_goals) > 0 and \
+                    (len(start_goals) != len(end_goals) or not all(s_g == e_g for s_g, e_g in zip(start_goals, end_goals))):
+                    tdf = TrainingDataFormat(
+                        proof_id=proof_id,
+                        all_useful_defns_theorems=[],
+                        start_goals=start_goals,
+                        end_goals=end_goals,
+                        proof_steps=[cmd_ran],
+                        simplified_goals=[],
+                        addition_state_info={},
+                        file_path=lean_executor.main_file,
+                        theorem_name=proof_id,
+                        project_id=project_id)
+                    training_data.merge(tdf)
+                if lean_executor.is_in_proof_mode():
+                    start_goals = end_goals
+                    ran_next = lean_executor.run_next()
+                    cmd_ran = lean_executor.current_stmt
+                else:
+                    ran_next = False
+        training_data.meta.num_theorems += 1
+        self.logger.info(f"===============Finished processing {file_namespace}=====================")
+        self.logger.info(f"Total theorems processed in this transform: 1")
+        try:
+            lean_context_helper.__exit__(None, None, None)
+        except:
+            pass
+
+
+if __name__ == "__main__":
+    import os
+    import logging
+    import time
+    os.chdir(root_dir)
+    project_dir = 'data/test/lean4_proj/'
+    file_name = 'data/test/lean4_proj/Lean4Proj/Basic.lean'
+    project_id = project_dir.replace('/', '.')
+    time_str = time.strftime("%Y%m%d-%H%M%S")
+    output_path = f".log/local_data_generation_transform/data/{time_str}"
+    log_path = f".log/local_data_generation_transform/log/{time_str}"
+    log_file = f"{log_path}/local_data_generation_transform-{time_str}.log"
+    os.makedirs(output_path, exist_ok=True)
+    os.makedirs(log_path, exist_ok=True)
+    logging.basicConfig(filename=log_file, level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+    logger = logging.getLogger(__name__)
+    def _print_lean_executor_callback():
+        search_lean_exec = Lean4SyncExecutor(main_file=file_name, project_root=project_dir)
+        search_lean_exec.__enter__()
+        return search_lean_exec
+    transform = Local4DataGenerationTransform(0, buffer_size=1000)
+    training_data = TrainingData(
+        output_path, 
+        "training_metadata.json",
+        training_meta=transform.get_meta_object(), 
+        logger=logger)
+    with Lean4SyncExecutor(project_root=project_dir, main_file=file_name, use_human_readable_proof_context=True, suppress_error_log=True) as coq_exec:
+        transform(training_data, project_id, coq_exec, _print_lean_executor_callback, theorems=['{"namespace": "Lean4Proj1", "name": "test2"}'])
+    save_info = training_data.save()
+    logger.info(f"Saved training data to {save_info}")