coding package

Submodules

coding.code_cache module

class coding.code_cache.CodeCache(db_file='coding.db')

Bases: object

close()

get_errors(iteration_id, fields=None)

get_iteration(iteration_id, fields=None)

get_iterations(session_id, fields=None)

get_session(session_id, fields=None)

get_session_history(session_id)

get_session_id(identifier, type_='iteration')

initialize_database()

insert_error(iteration_id, error_type, error_message, error_line=None)

insert_iteration(session_id, code, feedback=None)

insert_session(design_goal, parent_session_id=None, coding_plan=None)

update_error(error_id, error_message, error_line=None)

update_iteration(iteration_id, code=None, feedback=None, is_correct=None, is_runnable=None)

update_session(session_id, design_goal: str | None = None, coding_plan: dict | None = None)

coding.code_executor module

class coding.code_executor.CodeExecutor

Bases: object

check_grammar(code: str) → tuple[bool, str | None]

check_imports(code: str) → tuple[bool, str | None]

check_syntax(code: str) → tuple[bool, str | None]

execute_and_save(code: str, output_path: str, certain_file_types: list[str] | None = None, timeout: int = 10) → tuple[bool, str]

Executes the provided code and saves the output artifacts to the specified directory.

Parameters:

• code (str) – The Python code to execute.

• output_path (str) – The directory where the output artifacts should be saved.

• certain_file_types (list, optional) – A list of file extensions to save. If None, all files are saved.

• timeout (int, optional) – The maximum execution time in seconds. Defaults to 10 seconds.

Returns:

A tuple containing a boolean indicating success and a message string.

Return type:

tuple

execute_code(code: str, timeout: int = 10, test_run: bool = False) → tuple[bool, dict]

Executes the provided Python code in a temporary directory and returns the results.

Parameters:

• code (str) – The Python code to execute.

• timeout (int, optional) – The maximum time (in seconds) to allow for the execution. Defaults to 10.

Returns:

A tuple where the first element is a boolean indicating success (True) or failure (False), and the second element is a dictionary containing the results. If successful, the dictionary will contain the standard output and any generated files. If unsuccessful, it will contain an error message.

Return type:

tuple[bool, dict]

validate_code(code: str) → tuple[bool, str | None]

validate_code_with_flake8(code: str) → tuple[bool, str | None]

Check the syntax of the generated code using flake8.

Parameters:

code (str) – The generated code to be checked.

Returns:

A tuple containing:

• bool: True if the code is syntactically correct, False otherwise.

• str | None: Error message if there is a syntax error, None otherwise.

Return type:

tuple[bool, str | None]

coding.code_generator module

class coding.code_generator.CodeGenerator(api_key, api_base_url, model_name, org_id, prompt_templates, **model_kwargs)

Bases: LanguageModel

fix_code(code: str, design_goal: DesignGoal, feedbacks: List[str] | None) → str

Fixes the code using error feedback, leveraging dochelper to query documentation insights if necessary.

generate_code(design_goal: DesignGoal, plan: dict = None) → str

Generates a build123d script based on the design goal and plan, focusing purely on geometric information.

generate_or_fix_code(design_goal: DesignGoal, plan: dict = None, existing_code: str = None, feedbacks: List[str] = None) → str

Generate new code or fix existing code based on the provided design goal, plan, and feedback.

Parameters:

• design_goal (DesignGoal) – The design goal containing text and decomposition details.

• plan (dict, optional) – A dictionary containing the coding plan, typically including a ‘plan’ key.

• existing_code (str, optional) – The existing code that needs to be fixed or improved.

• feedbacks (List[str], optional) – A list of feedback messages or errors from previous iterations.

Returns:

The generated or fixed code as a string. Returns None if no code could be generated or fixed.

Return type:

str

patch_code_to_export(code, format: Literal['stl', 'step'] = 'stl', target_output_dir=None) → tuple[str, str]

This method appends code to center the 3D model at the origin and export it in the desired format (STL or STEP). The exported file is saved in the specified directory or the current working directory if none is provided.

Parameters:

• code (str) – The original code to be extended with export functionality.

• format (Literal["stl", "step"], optional) – The desired export format. Defaults to “stl”.

• target_output_dir (str, optional) – The directory where the exported 3D file will be saved.

• None (If)

• directory. (the file will be saved in the current working)

Returns:

A tuple containing:

• patched_code: The extended code with the added export functionality.

• target_output_dir: The directory where the exported 3D file will be saved.

Return type:

tuple[str, str]

plan_code(design_goal: DesignGoal, feedbacks: str = None, previous_plan: dict = None) → dict | None

Plans out the building blocks using build123d API, focusing purely on geometric information.

save_code_to_file(code, filename='generated_code.py')

coding.code_generator.test_code_generator(code_generator, design_goal, output_dir)

Performs end-to-end testing of the CodeGenerator class functionalities.

coding.coder module

class coding.coder.Coder(api_key, api_base_url, model_name, org_id, prompt_templates, code_master_config: dict = None, max_coding_iterations: int = 10, **model_kwargs)

Bases: object

generate_executable_code(design_goal: DesignGoal, feedbacks: str = None, generated_code: str = None, coding_plan: dict = None) → tuple[str, dict] | None

render_from_code(code: str, output_dir: str, format: str = 'stl') → tuple[bool, str, str]

coding.coder.parse_args()

Module contents