Update shared_vis_python_exe.py

shared_vis_python_exe.py

@@ -104,7 +104,6 @@ plt.close()
             
             exec(modified_code, self._global_vars)
         else:
-            print("###################################### I am excuting code. ##############################################")
             exec(code_piece, self._global_vars)
 
     def eval_code(self, expr: str) -> Any:
@@ -140,7 +139,6 @@ class ImageRuntime(GenericRuntime):
     ]
 
     def __init__(self, messages):
-        print("############################### I am initing image runtime ################################")
         super().__init__()
         # pdb.set_trace()
 
@@ -153,7 +151,6 @@ class ImageRuntime(GenericRuntime):
 
         image_var_dict = {}
         image_var_idx = 0
-        print("############################### I am initing image runtime ################################")
         for message_item in messages:
             content = message_item['content']  # {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
             for item in content:
@@ -165,7 +162,6 @@ class ImageRuntime(GenericRuntime):
                     image_var_idx += 1
 
         self.inject(image_var_dict)
-        print("##################### Initialize ImageRuntime. ##########################")
                     
 
 class DateRuntime(GenericRuntime):
@@ -195,7 +191,6 @@ class PythonExecutor:
         get_answer_from_stdout: bool = True,
         timeout_length: int = 20,
     ) -> None:
-        print(f"#################### When Init PythonExcutor, RunTime typel:, TimeOut Length: {timeout_length} #############################")
         self.runtime_class = runtime_class if runtime_class else ImageRuntime
         print(self.runtime_class)
         self.answer_symbol = get_answer_symbol
@@ -205,81 +200,10 @@ class PythonExecutor:
 
         # Create a persistent runtime instance if messages are provided
         self.persistent_runtime = None
-        # if messages:
-        #     self.persistent_runtime = self.runtime_class(messages)
 
     def process_generation_to_code(self, gens: str):
         return [g.split("\n") for g in gens]
 
-    # @staticmethod
-    # def execute(
-    #     self,
-    #     code,
-    #     messages,
-    #     get_answer_from_stdout=True,
-    #     runtime_class=None,
-    #     # run_time_instance=None,
-    #     answer_symbol=None,
-    #     answer_expr=None,
-    #     timeout_length=20,
-    # ) -> Tuple[Union[str, Dict[str, Any]], str]:
-    #     # print("dome")
-    #     # try:
-    #     # 在每个进程中创建新的运行时实例
-    #     print(f"################################################## I am excuting ! #############################################################")
-    #     print(str(messages)[0:500])
-    #     print(str(messages)[-500:])
-    #     print(runtime_class)
-    #     # runtime = runtime_class(messages)
-    #     runtime = self.persistent_runtime
-    #     print(f"################################################## I am excuting ! #############################################################")
-        
-    #     if get_answer_from_stdout:
-    #         program_io = io.StringIO()
-    #         with redirect_stdout(program_io):
-    #             timeout(timeout_length)(runtime.exec_code)("\n".join(code))
-    #         program_io.seek(0)
-    #         result = program_io.read()
-    #     elif answer_symbol:
-    #         timeout(timeout_length)(runtime.exec_code)("\n".join(code))
-    #         result = runtime._global_vars.get(answer_symbol, "")
-    #     elif answer_expr:
-    #         timeout(timeout_length)(runtime.exec_code)("\n".join(code))
-    #         result = timeout(timeout_length)(runtime.eval_code)(answer_expr)
-    #     else:
-    #         if len(code) > 1:
-    #             timeout(timeout_length)(runtime.exec_code)("\n".join(code[:-1]))
-    #             result = timeout(timeout_length)(runtime.eval_code)(code[-1])
-    #         else:
-    #             timeout(timeout_length)(runtime.exec_code)("\n".join(code))
-    #             result = ""
-        
-    #     # 检查是否有捕获的图像
-    #     captured_figures = runtime._global_vars.get("_captured_figures", [])
-    #     if captured_figures:
-    #         # 如果有文本输出和图像，将它们组合
-    #         if result:
-    #             result = {
-    #                 'text': result,
-    #                 'images': captured_figures
-    #             }
-    #         else:
-    #             result = {'images': captured_figures}
-        
-    #     report = "Done"
-    #     # except Exception as e:
-    #     #     result = ""
-    #     #     report = f"Error: {str(e)}\n{traceback.format_exc()}"
-        
-    #     # 确保结果可序列化
-    #     try:
-    #         pickle.dumps(result)
-    #     except Exception as e:
-    #         result = f"Result serialization error: {str(e)}"
-    #         report = f"Serialization Error: {str(e)}"
-            
-    #     return result, report
-
     def execute(
         self,
         code,
@@ -294,13 +218,9 @@ class PythonExecutor:
         # print("dome")
         # try:
         # 在每个进程中创建新的运行时实例
-        # print(f"################################################## I am excuting ! #############################################################")
-        # print(str(messages)[0:500])
-        # print(str(messages)[-500:])
         print(runtime_class)
         # runtime = runtime_class(messages)
         runtime = self.persistent_runtime
-        # print(f"################################################## I am excuting ! #############################################################")
         
         if get_answer_from_stdout:
             program_io = io.StringIO()
@@ -386,72 +306,6 @@ class PythonExecutor:
     def get_persistent_runtime(self):
         return self.persistent_runtime
 
-    # def batch_apply(self, batch_code, messages):
-    #     if not self.persistent_runtime and messages:
-    #         self.persistent_runtime = self.runtime_class(messages)
-    #     all_code_snippets = self.process_generation_to_code(batch_code)
-
-    #     timeout_cnt = 0
-    #     all_exec_results = []
-    #     print(f"################################### num of cpu: {os.cpu_count()} ; len of code: {len(all_code_snippets)} ######################################")
-    #     with ProcessPool(
-    #         max_workers=min(len(all_code_snippets), os.cpu_count())
-    #     ) as pool:
-    #         executor = partial(
-    #             self.execute,
-    #             get_answer_from_stdout=self.get_answer_from_stdout,
-    #             runtime_class=self.runtime_class,
-    #             # run_time_instance=self.persistent_runtime,
-    #             answer_symbol=self.answer_symbol,
-    #             answer_expr=self.answer_expr,
-    #             timeout_length=self.timeout_length,
-    #         )
-    #         future = pool.map(executor, all_code_snippets, [messages], timeout=self.timeout_length)
-    #         iterator = future.result()
-
-    #         if len(all_code_snippets) > 100:
-    #             progress_bar = tqdm(total=len(all_code_snippets), desc="Execute")
-    #         else:
-    #             progress_bar = None
-
-    #         while True:
-    #             try:
-    #                 result = next(iterator)
-    #                 all_exec_results.append(result)
-    #             except StopIteration:
-    #                 break
-    #             except TimeoutError as error:
-    #                 print(error)
-    #                 all_exec_results.append(("", "Timeout Error"))
-    #                 timeout_cnt += 1
-    #             except Exception as error:
-    #                 print(f"Error in batch_apply: {error}")
-    #                 all_exec_results.append(("", f"Error: {str(error)}"))
-    #             if progress_bar is not None:
-    #                 progress_bar.update(1)
-
-    #         if progress_bar is not None:
-    #             progress_bar.close()
-
-    #     batch_results = []
-    #     for code, (res, report) in zip(all_code_snippets, all_exec_results):
-    #         # 处理结果
-    #         if isinstance(res, dict):
-    #             # 如果结果包含图像，特殊处理
-    #             if 'text' in res:
-    #                 res['text'] = str(res['text']).strip()
-    #                 res['text'] = self.truncate(res['text'])
-    #             report = str(report).strip()
-    #             report = self.truncate(report)
-    #         else:
-    #             # 普通文本结果
-    #             res = str(res).strip()
-    #             res = self.truncate(res)
-    #             report = str(report).strip()
-    #             report = self.truncate(report)
-    #         batch_results.append((res, report))
-    #     return batch_results
-
     def batch_apply(self, batch_code, messages):
         if not self.persistent_runtime and messages:
             self.persistent_runtime = self.runtime_class(messages)
@@ -459,8 +313,6 @@ class PythonExecutor:
 
         timeout_cnt = 0
         all_exec_results = []
-        
-        print(f"################################### num of cpu: {os.cpu_count()} ; len of code: {len(all_code_snippets)} ######################################")
 
         # 去掉 ProcessPool，改为单进程顺序执行
         if len(all_code_snippets) > 100: