auto-coder 0.1.206__py3-none-any.whl → 0.1.208__py3-none-any.whl

autocoder/auto_coder.py

@@ -207,7 +207,8 @@ def main(input_args: Optional[List[str]] = None):
             max_seq = max(seqs)
 
         new_seq = str(max_seq + 1).zfill(12)
-        prev_files = [f for f in action_files if int(get_old_seq(f)) < int(new_seq)]
+        prev_files = [f for f in action_files if int(
+            get_old_seq(f)) < int(new_seq)]
 
         if raw_args.from_yaml:
             # If --from_yaml is specified, copy content from the matching YAML file
@@ -278,9 +279,30 @@ def main(input_args: Optional[List[str]] = None):
         llm = byzerllm.ByzerLLM(verbose=args.print_request)
 
         if args.code_model:
-            code_model = byzerllm.ByzerLLM()
-            code_model.setup_default_model_name(args.code_model)
-            llm.setup_sub_client("code_model", code_model)
+            if "," in args.code_model:
+                # Multiple code models specified
+                model_names = args.code_model.split(",")
+                models = []
+                for _, model_name in enumerate(model_names):
+                    code_model = byzerllm.ByzerLLM()
+                    code_model.setup_default_model_name(model_name.strip())
+                    models.append(code_model)
+                llm.setup_sub_client("code_model", models)
+            else:
+                # Single code model
+                code_model = byzerllm.ByzerLLM()
+                code_model.setup_default_model_name(args.code_model)
+                llm.setup_sub_client("code_model", code_model)
+
+        if args.generate_rerank_model:
+            generate_rerank_model = byzerllm.ByzerLLM()
+            generate_rerank_model.setup_default_model_name(args.generate_rerank_model)
+            llm.setup_sub_client("generate_rerank_model", generate_rerank_model)
+
+        if args.inference_model:
+            inference_model = byzerllm.ByzerLLM()
+            inference_model.setup_default_model_name(args.inference_model)
+            llm.setup_sub_client("inference_model", inference_model)
 
         if args.human_as_model:
 
@@ -386,18 +408,25 @@ def main(input_args: Optional[List[str]] = None):
 
             llm.add_event_callback(
                 EventName.BEFORE_CALL_MODEL, intercept_callback)
-            code_model = llm.get_sub_client("code_model")
-            if code_model:
-                code_model.add_event_callback(
-                    EventName.BEFORE_CALL_MODEL, intercept_callback
-                )
+            
+            code_models = llm.get_sub_client("code_model")
+            if code_models:
+                if not isinstance(code_models, list):
+                    code_models = [code_models]
+                for model in code_models:
+                    model.add_event_callback(
+                        EventName.BEFORE_CALL_MODEL, intercept_callback
+                    )
         # llm.add_event_callback(EventName.AFTER_CALL_MODEL, token_counter_interceptor)
 
-        code_model = llm.get_sub_client("code_model")
-        if code_model:
-            code_model.add_event_callback(
-                EventName.AFTER_CALL_MODEL, token_counter_interceptor
-            )
+        code_models = llm.get_sub_client("code_model")
+        if code_models:
+            if not isinstance(code_models, list):
+                code_models = [code_models]
+            for model in code_models:
+                model.add_event_callback(
+                    EventName.AFTER_CALL_MODEL, token_counter_interceptor
+                )
 
         llm.setup_template(model=args.model, template="auto")
         llm.setup_default_model_name(args.model)
@@ -493,7 +522,7 @@ def main(input_args: Optional[List[str]] = None):
         from autocoder.index.for_command import index_query_command
 
         index_query_command(args, llm)
-        return   
+        return
 
     if raw_args.command == "agent":
         if raw_args.agent_command == "planner":
@@ -694,24 +723,39 @@ def main(input_args: Optional[List[str]] = None):
             memory_file = os.path.join(memory_dir, "chat_history.json")
             console = Console()
             if args.new_session:
-                chat_history = {"ask_conversation": []}
+                if os.path.exists(memory_file):
+                    with open(memory_file, "r") as f:
+                        old_chat_history = json.load(f)
+                    if "conversation_history" not in old_chat_history:
+                        old_chat_history["conversation_history"] = []
+                    old_chat_history["conversation_history"].append(
+                        old_chat_history.get("ask_conversation", []))
+                    chat_history = {"ask_conversation": [
+                    ], "conversation_history": old_chat_history["conversation_history"]}
+                else:
+                    chat_history = {"ask_conversation": [],
+                                    "conversation_history": []}
                 with open(memory_file, "w") as f:
                     json.dump(chat_history, f, ensure_ascii=False)
                 console.print(
                     Panel(
-                        "New session started. Previous chat history has been cleared.",
+                        "New session started. Previous chat history has been archived.",
                         title="Session Status",
                         expand=False,
                         border_style="green",
                     )
                 )
-                return
+                if not args.query:
+                    return
 
             if os.path.exists(memory_file):
                 with open(memory_file, "r") as f:
                     chat_history = json.load(f)
+                if "conversation_history" not in chat_history:
+                    chat_history["conversation_history"] = []
             else:
-                chat_history = {"ask_conversation": []}
+                chat_history = {"ask_conversation": [],
+                                "conversation_history": []}
 
             chat_history["ask_conversation"].append(
                 {"role": "user", "content": args.query}
@@ -937,6 +981,7 @@ def main(input_args: Optional[List[str]] = None):
 
             with open(memory_file, "w") as f:
                 json.dump(chat_history, f, ensure_ascii=False)
+
             return
 
         else:

autocoder/auto_coder_rag.py

@@ -314,6 +314,12 @@ def main(input_args: Optional[List[str]] = None):
         action="store_true",
         help="Whether to return responses without contexts. only works when pro plugin is installed",
     )
+    serve_parser.add_argument(
+        "--data_cells_max_num",
+        type=int,
+        default=2000,
+        help="Maximum number of data cells to process",
+    )
 
     serve_parser.add_argument(
         "--recall_model",
@@ -358,6 +364,9 @@ def main(input_args: Optional[List[str]] = None):
     benchmark_parser.add_argument(
         "--base_url", default="", help="Base URL for OpenAI client"
     )
+    benchmark_parser.add_argument(
+        "--query", default="Hello, how are you?", help="Query to use for benchmarking"
+    )
 
     # Tools command
     tools_parser = subparsers.add_parser("tools", help="Various tools")
@@ -413,11 +422,11 @@ def main(input_args: Optional[List[str]] = None):
                 return
             asyncio.run(
                 benchmark_openai(
-                    args.model, args.parallel, args.api_key, args.base_url, args.rounds
+                    args.model, args.parallel, args.api_key, args.base_url, args.rounds, args.query
                 )
             )
         else:  # byzerllm
-            benchmark_byzerllm(args.model, args.parallel, args.rounds)
+            benchmark_byzerllm(args.model, args.parallel, args.rounds, args.query)
 
     elif args.command == "serve":
         if not args.quick:

autocoder/benchmark.py

@@ -9,16 +9,19 @@ from loguru import logger
 import byzerllm
 from concurrent.futures import ThreadPoolExecutor
 
-async def benchmark_openai(model: str, parallel: int, api_key: str, base_url: str = None, rounds: int = 1):
+
+async def benchmark_openai(
+    model: str, parallel: int, api_key: str, base_url: str = None, rounds: int = 1, query: str = "Hello, how are you?"
+):
     client = AsyncOpenAI(api_key=api_key, base_url=base_url if base_url else None)
     start_time = time.time()
-    
+
     async def single_request():
         try:
             t1 = time.time()
             response = await client.chat.completions.create(
                 model=model,
-                messages=[{"role": "user", "content": "Hello, how are you?"}]
+                messages=[{"role": "user", "content": query}],
             )
             t2 = time.time()
             return t2 - t1
@@ -32,15 +35,15 @@ async def benchmark_openai(model: str, parallel: int, api_key: str, base_url: st
         tasks = [single_request() for _ in range(parallel)]
         results = await asyncio.gather(*tasks)
         all_results.extend(results)
-    
+
     results = all_results
-    
+
     # Filter out None values from failed requests
     results = [r for r in results if r is not None]
-    
+
     end_time = time.time()
     total_time = end_time - start_time
-    
+
     if not results:
         print("All requests failed")
         return
@@ -51,14 +54,14 @@ async def benchmark_openai(model: str, parallel: int, api_key: str, base_url: st
     p90 = np.percentile(results, 90)
     p95 = np.percentile(results, 95)
     p99 = np.percentile(results, 99)
-    
+
     # Create rich table for output
     console = Console()
     table = Table(title=f"OpenAI Client Benchmark Results (Parallel={parallel})")
-    
+
     table.add_column("Metric", style="cyan")
     table.add_column("Value (seconds)", style="magenta")
-    
+
     table.add_row("Total Time", f"{total_time:.2f}")
     table.add_row("Average Response Time", f"{avg_time:.2f}")
     table.add_row("Median (P50)", f"{p50:.2f}")
@@ -66,21 +69,21 @@ async def benchmark_openai(model: str, parallel: int, api_key: str, base_url: st
     table.add_row("P95", f"{p95:.2f}")
     table.add_row("P99", f"{p99:.2f}")
     table.add_row("Requests/Second", f"{parallel/total_time:.2f}")
-    
+
     console.print(table)
 
-def benchmark_byzerllm(model: str, parallel: int, rounds: int = 1):
+
+def benchmark_byzerllm(model: str, parallel: int, rounds: int = 1, query: str = "Hello, how are you?"):
     byzerllm.connect_cluster(address="auto")
     llm = byzerllm.ByzerLLM()
-    llm.setup_default_model_name(model)    
+    llm.setup_default_model_name(model)
 
     def single_request(llm):
         try:
             t1 = time.time()
-            llm.chat_oai(conversations=[{
-                "role": "user",
-                "content": "Hello, how are you?"
-            }])
+            llm.chat_oai(
+                conversations=[{"role": "user", "content": query}]
+            )
             t2 = time.time()
             return t2 - t1
         except Exception as e:
@@ -97,39 +100,39 @@ def benchmark_byzerllm(model: str, parallel: int, rounds: int = 1):
             # get results from futures
             results = [future.result() for future in futures]
             all_results.extend(results)
-    
+
         results = all_results
-        
+
         # Filter out None values from failed requests
         results = [r for r in results if r is not None]
-        
+
         end_time = time.time()
         total_time = end_time - start_time
 
-        if not results:
-            print("All requests failed")
-            return
-
-        # Calculate statistics
-        avg_time = np.mean(results)
-        p50 = np.percentile(results, 50)
-        p90 = np.percentile(results, 90)
-        p95 = np.percentile(results, 95)
-        p99 = np.percentile(results, 99)
-        
-        # Create rich table for output
-        console = Console()
-        table = Table(title=f"ByzerLLM Client Benchmark Results (Parallel={parallel})")
-        
-        table.add_column("Metric", style="cyan")
-        table.add_column("Value (seconds)", style="magenta")
-        
-        table.add_row("Total Time", f"{total_time:.2f}")
-        table.add_row("Average Response Time", f"{avg_time:.2f}")
-        table.add_row("Median (P50)", f"{p50:.2f}")
-        table.add_row("P90", f"{p90:.2f}")
-        table.add_row("P95", f"{p95:.2f}")
-        table.add_row("P99", f"{p99:.2f}")
-        table.add_row("Requests/Second", f"{parallel/total_time:.2f}")
-        
-        console.print(table)
+    if not results:
+        print("All requests failed")
+        return
+
+    # Calculate statistics
+    avg_time = np.mean(results)
+    p50 = np.percentile(results, 50)
+    p90 = np.percentile(results, 90)
+    p95 = np.percentile(results, 95)
+    p99 = np.percentile(results, 99)
+
+    # Create rich table for output
+    console = Console()
+    table = Table(title=f"ByzerLLM Client Benchmark Results (Parallel={parallel})")
+
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value (seconds)", style="magenta")
+
+    table.add_row("Total Time", f"{total_time:.2f}")
+    table.add_row("Average Response Time", f"{avg_time:.2f}")
+    table.add_row("Median (P50)", f"{p50:.2f}")
+    table.add_row("P90", f"{p90:.2f}")
+    table.add_row("P95", f"{p95:.2f}")
+    table.add_row("P99", f"{p99:.2f}")
+    table.add_row("Requests/Second", f"{parallel/total_time:.2f}")
+
+    console.print(table)

autocoder/chat_auto_coder.py

@@ -59,6 +59,7 @@ import byzerllm
 from byzerllm.utils import format_str_jinja2
 from autocoder.chat_auto_coder_lang import get_message
 from autocoder.utils import operate_config_api
+from autocoder.agent.auto_guess_query import AutoGuessQuery
 
 
 class SymbolItem(BaseModel):
@@ -930,6 +931,14 @@ class CommandCompleter(Completer):
                             yield Completion(
                                 lib_name, start_position=-len(current_word)
                             )
+            elif words[0] == "/coding":
+                new_text = text[len("/coding"):]
+                parser = CommandTextParser(new_text, words[0])
+                parser.lib()
+                current_word = parser.current_word()
+                for command in parser.get_sub_commands():
+                    if command.startswith(current_word):
+                        yield Completion(command, start_position=-len(current_word))
 
             elif words[0] == "/conf":
                 new_words = text[len("/conf"):].strip().split()
@@ -1427,19 +1436,105 @@ def convert_yaml_to_config(yaml_file: str):
                 setattr(args, key, value)
     return args
 
-def commit():
+
+def code_next(query: str):
+    conf = memory.get("conf", {})
+    yaml_config = {
+        "include_file": ["./base/base.yml"],
+        "auto_merge": conf.get("auto_merge", "editblock"),
+        "human_as_model": conf.get("human_as_model", "false") == "true",
+        "skip_build_index": conf.get("skip_build_index", "true") == "true",
+        "skip_confirm": conf.get("skip_confirm", "true") == "true",
+        "silence": conf.get("silence", "true") == "true",
+        "include_project_structure": conf.get("include_project_structure", "true")
+        == "true",
+    }
+    for key, value in conf.items():
+        converted_value = convert_config_value(key, value)
+        if converted_value is not None:
+            yaml_config[key] = converted_value
+
+    temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
+    try:
+        with open(temp_yaml, "w") as f:
+            f.write(convert_yaml_config_to_str(yaml_config=yaml_config))
+        args = convert_yaml_to_config(temp_yaml)
+    finally:
+        if os.path.exists(temp_yaml):
+            os.remove(temp_yaml)
+
+    llm = byzerllm.ByzerLLM.from_default_model(
+        args.inference_model or args.model)
+
+    auto_guesser = AutoGuessQuery(
+        llm=llm,
+        project_dir=os.getcwd(),
+        skip_diff=True
+    )
+
+    predicted_tasks = auto_guesser.predict_next_tasks(
+        5, is_human_as_model=args.human_as_model)
+
+    if not predicted_tasks:
+        console = Console()
+        console.print(Panel("No task predictions available", style="yellow"))
+        return
+
+    console = Console()
+
+    # Create main panel for all predicted tasks
+    table = Table(show_header=True,
+                  header_style="bold magenta", show_lines=True)
+    table.add_column("Priority", style="cyan", width=8)
+    table.add_column("Task Description", style="green",
+                     width=40, overflow="fold")
+    table.add_column("Files", style="yellow", width=30, overflow="fold")
+    table.add_column("Reason", style="blue", width=30, overflow="fold")
+    table.add_column("Dependencies", style="magenta",
+                     width=30, overflow="fold")
+
+    for task in predicted_tasks:
+        # Format file paths to be more readable
+        file_list = "\n".join([os.path.relpath(f, os.getcwd())
+                              for f in task.urls])
+
+        # Format dependencies to be more readable
+        dependencies = "\n".join(
+            task.dependency_queries) if task.dependency_queries else "None"
+
+        table.add_row(
+            str(task.priority),
+            task.query,
+            file_list,
+            task.reason,
+            dependencies
+        )
+
+    console.print(Panel(
+        table,
+        title="[bold]Predicted Next Tasks[/bold]",
+        border_style="blue",
+        padding=(1, 2)  # Add more horizontal padding
+    ))
+
+
+def commit(query: str):
     def prepare_commit_yaml():
         auto_coder_main(["next", "chat_action"])
 
     prepare_commit_yaml()
 
+    # no_diff = query.strip().startswith("/no_diff")
+    # if no_diff:
+    #     query = query.replace("/no_diff", "", 1).strip()
+
     latest_yaml_file = get_last_yaml_file("actions")
-    
+
     conf = memory.get("conf", {})
     current_files = memory["current_files"]["files"]
     execute_file = None
-    
-    if latest_yaml_file:        
+
+    if latest_yaml_file:
         try:
             execute_file = os.path.join("actions", latest_yaml_file)
             yaml_config = {
@@ -1465,26 +1560,30 @@ def commit():
             temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
             try:
                 with open(temp_yaml, "w") as f:
-                    f.write(convert_yaml_config_to_str(yaml_config=yaml_config))
+                    f.write(convert_yaml_config_to_str(
+                        yaml_config=yaml_config))
                 args = convert_yaml_to_config(temp_yaml)
             finally:
                 if os.path.exists(temp_yaml):
                     os.remove(temp_yaml)
-            
-            llm = byzerllm.ByzerLLM.from_default_model(args.code_model or args.model)
-            uncommitted_changes = git_utils.get_uncommitted_changes(".")            
+
+            llm = byzerllm.ByzerLLM.from_default_model(
+                args.code_model or args.model)
+            uncommitted_changes = git_utils.get_uncommitted_changes(".")
             commit_message = git_utils.generate_commit_message.with_llm(
                 llm).run(uncommitted_changes)
-            memory["conversation"].append({"role": "user", "content": commit_message})
+            memory["conversation"].append(
+                {"role": "user", "content": commit_message})
             yaml_config["query"] = commit_message
-            yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)            
+            yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
             with open(os.path.join(execute_file), "w") as f:
-                f.write(yaml_content) 
-                        
+                f.write(yaml_content)
+
             file_content = open(execute_file).read()
-            md5 = hashlib.md5(file_content.encode('utf-8')).hexdigest()            
-            file_name = os.path.basename(execute_file)             
-            commit_result = git_utils.commit_changes(".", f"auto_coder_{file_name}_{md5}")            
+            md5 = hashlib.md5(file_content.encode('utf-8')).hexdigest()
+            file_name = os.path.basename(execute_file)
+            commit_result = git_utils.commit_changes(
+                ".", f"auto_coder_{file_name}_{md5}")
             git_utils.print_commit_info(commit_result=commit_result)
         except Exception as e:
             print(f"Failed to commit: {e}")
@@ -1498,6 +1597,14 @@ def coding(query: str):
     if is_apply:
         query = query.replace("/apply", "", 1).strip()
 
+    is_next = query.strip().startswith("/next")
+    if is_next:
+        query = query.replace("/next", "", 1).strip()
+
+    if is_next:
+        code_next(query)
+        return
+
     memory["conversation"].append({"role": "user", "content": query})
     conf = memory.get("conf", {})
 
@@ -2194,7 +2301,7 @@ def main():
         mode = memory["mode"]
         human_as_model = memory["conf"].get("human_as_model", "false")
         return (
-            f" Mode: {MODES[mode]} (ctl+k) | Human as Model: {human_as_model} (ctl+n)"
+            f" Mode: {MODES[mode]} (ctl+k) | Human as Model: {human_as_model} (ctl+n or /conf human_as_model:true/false)"
         )
 
     session = PromptSession(
@@ -2305,7 +2412,8 @@ def main():
             elif user_input.startswith("/revert"):
                 revert()
             elif user_input.startswith("/commit"):
-                commit()
+                query = user_input[len("/commit"):].strip()
+                commit(query)
             elif user_input.startswith("/help"):
                 show_help()
             elif user_input.startswith("/exclude_dirs"):

autocoder/command_args.py

@@ -102,7 +102,11 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
         "--print_request", action="store_true", help=desc["print_request"]
     )
     parser.add_argument("--code_model", default="", help=desc["code_model"])
-    parser.add_argument("--system_prompt", default="", help=desc["system_prompt"])
+    parser.add_argument("--generate_rerank_model", default="", help=desc["generate_rerank_model"])
+    parser.add_argument("--inference_model", default="",
+                        help="The name of the inference model to use. Default is empty")
+    parser.add_argument("--system_prompt", default="",
+                        help=desc["system_prompt"])
     parser.add_argument("--planner_model", default="",
                         help=desc["planner_model"])
     parser.add_argument(
@@ -111,6 +115,9 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
     parser.add_argument(
         "--human_as_model", action="store_true", help=desc["human_as_model"]
     )
+    parser.add_argument(
+        "--human_model_num", type=int, default=1, help=desc["human_model_num"]
+    )
     parser.add_argument("--urls", default="", help=desc["urls"])
     parser.add_argument(
         "--urls_use_model", action="store_true", help=desc["urls_use_model"]
@@ -129,6 +136,13 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
         "--search_engine_token", default="", help=desc["search_engine_token"]
     )
 
+    parser.add_argument(
+        "--generate_times_same_model",
+        type=int,
+        default=1,
+        help=desc["generate_times_same_model"],
+    )
+
     parser.add_argument(
         "--enable_rag_search",
         nargs="?",
@@ -196,7 +210,6 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
         help="是否静默执行,不打印任何信息。默认为False",
     )
 
-
     revert_parser = subparsers.add_parser("revert", help=desc["revert_desc"])
     revert_parser.add_argument("--file", help=desc["revert_desc"])
     revert_parser.add_argument(
@@ -554,7 +567,8 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
 
     read_project_parser.add_argument("--rag_token", default="", help="")
     read_project_parser.add_argument("--rag_url", default="", help="")
-    read_project_parser.add_argument("--rag_params_max_tokens", default=4096, help="")
+    read_project_parser.add_argument(
+        "--rag_params_max_tokens", default=4096, help="")
     read_project_parser.add_argument(
         "--rag_type", default="storage", help="RAG type, default is storage"
     )
@@ -644,7 +658,8 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
 
     auto_tool_parser.add_argument("--rag_token", default="", help="")
     auto_tool_parser.add_argument("--rag_url", default="", help="")
-    auto_tool_parser.add_argument("--rag_params_max_tokens", default=4096, help="")
+    auto_tool_parser.add_argument(
+        "--rag_params_max_tokens", default=4096, help="")
     auto_tool_parser.add_argument(
         "--rag_type", default="storage", help="RAG type, default is storage"
     )
@@ -710,7 +725,8 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
 
     planner_parser.add_argument("--rag_token", default="", help="")
     planner_parser.add_argument("--rag_url", default="", help="")
-    planner_parser.add_argument("--rag_params_max_tokens", default=4096, help="")   
+    planner_parser.add_argument(
+        "--rag_params_max_tokens", default=4096, help="")
     planner_parser.add_argument(
         "--rag_type", default="storage", help="RAG type, default is storage"
     )

autocoder/common/__init__.py

@@ -248,9 +248,12 @@ class AutoCoderArgs(pydantic.BaseModel):
     sd_model: Optional[str] = ""
     emb_model: Optional[str] = ""
     code_model: Optional[str] = ""
+    generate_rerank_model: Optional[str] = ""
+    inference_model: Optional[str] = ""
     system_prompt: Optional[str] = ""
-    text2voice_model: Optional[str] = ""
+    planner_model: Optional[str] = ""
     voice2text_model: Optional[str] = ""
+    text2voice_model: Optional[str] = ""
     
     skip_build_index: Optional[bool] = False
     skip_filter_index: Optional[bool] = False
@@ -291,6 +294,7 @@ class AutoCoderArgs(pydantic.BaseModel):
 
     auto_merge: Optional[Union[bool, str]] = False
     human_as_model: Optional[bool] = False
+    human_model_num: Optional[int] = 1
 
     image_file: Optional[str] = ""
     image_mode: Optional[str] = "direct"
@@ -341,6 +345,8 @@ class AutoCoderArgs(pydantic.BaseModel):
     inference_compute_precision: int = 64
     without_contexts: Optional[bool] = False
     skip_events: Optional[bool] = False
+    data_cells_max_num: Optional[int] = 2000
+    generate_times_same_model: Optional[int] = 1
 
     class Config:
         protected_namespaces = ()