Keep only code that is used

.gitignore

@@ -1,4 +1,5 @@
 .docusaurus/
+.notebook/
 node_modules/
 # Project
 /.vs

autogen/code_utils.py

@@ -138,84 +138,6 @@ def extract_code(
     return extracted
 
 
-def generate_code(pattern: str = CODE_BLOCK_PATTERN, **config) -> Tuple[str, float]:
-    """(openai<1) Generate code.
-
-    Args:
-        pattern (Optional, str): The regular expression pattern for finding the code block.
-            The default pattern is for finding a code block in a markdown file.
-        config (Optional, dict): The configuration for the API call.
-
-    Returns:
-        str: The generated code.
-        float: The cost of the generation.
-    """
-    response = oai.Completion.create(**config)
-    return extract_code(oai.Completion.extract_text(response)[0], pattern), response["cost"]
-
-
-_IMPROVE_FUNCTION_CONFIG = {
-    "prompt": """Improve the function '{func_name}' to achieve the objective '{objective}'.
-The current implementation of the function is as follows:
-{file_string}""",
-    "model": DEFAULT_MODEL,
-    "request_timeout": 600,
-}
-
-
-def improve_function(file_name, func_name, objective, **config):
-    """(openai<1) Improve the function to achieve the objective."""
-    params = {**_IMPROVE_FUNCTION_CONFIG, **config}
-    # read the entire file into a str
-    with open(file_name, "r") as f:
-        file_string = f.read()
-    response = oai.Completion.create(
-        {"func_name": func_name, "objective": objective, "file_string": file_string}, **params
-    )
-    return oai.Completion.extract_text(response)[0], response["cost"]
-
-
-_IMPROVE_CODE_CONFIG = {
-    "prompt": """Analyze the code in the following files and return a list of suggestions for improvement{followup}, to achieve the objective of '{objective}'.
-{code}
-""",
-    "model": DEFAULT_MODEL,
-    "request_timeout": 900,
-}
-
-
-def improve_code(files, objective, suggest_only=True, **config):
-    """(openai<1) Improve the code to achieve a given objective.
-
-    Args:
-        files (list): A list of file names containing the source code.
-        objective (str): The objective to achieve.
-        suggest_only (bool): Whether to return only the suggestions or the improved code.
-        config (Optional, dict): The configuration for the API call.
-
-    Returns:
-        str: The improved code if suggest_only=False; a list of suggestions if suggest_only=True (default).
-        float: The cost of the generation.
-    """
-    code = ""
-    for file_name in files:
-        # read the entire file into a string
-        with open(file_name, "r") as f:
-            file_string = f.read()
-        code += f"""{file_name}:
-{file_string}
-
-"""
-    params = {**_IMPROVE_CODE_CONFIG, **config}
-    followup = "" if suggest_only else " followed by the improved code"
-    response = oai.Completion.create({"objective": objective, "code": code, "followup": followup}, **params)
-    return oai.Completion.extract_text(response)[0], response["cost"]
-
-
-def timeout_handler(signum, frame):
-    raise TimeoutError("Timed out!")
-
-
 def _cmd(lang):
     if lang.startswith("python") or lang in ["bash", "sh", "powershell"]:
         return lang
@@ -232,6 +154,7 @@ def is_docker_running():
     Returns:
         bool: True if docker is running; False otherwise.
     """
+    # Docker is None if the docker package is not installed
     if docker is None:
         return False
     try:
@@ -367,7 +290,7 @@ def execute_code(
     # SENTINEL is used to indicate that the user did not explicitly set the argument
     if use_docker is SENTINEL:
         use_docker = decide_use_docker(use_docker=None)
-    check_can_use_docker_or_throw(use_docker)
+    check_can_use_docker_or_throw(use_docker)  # If it wants to use docker and it cannot, it will throw an error
 
     timeout = timeout or DEFAULT_TIMEOUT
     original_filename = filename
@@ -382,7 +305,7 @@ def execute_code(
 
     filepath = os.path.join(work_dir, filename)
     file_dir = os.path.dirname(filepath)
-    os.makedirs(file_dir, exist_ok=True)
+    os.makedirs(file_dir, exist_ok=True)  # Create the folder
 
     if code is not None:
         with open(filepath, "w", encoding="utf-8") as fout:
@@ -509,192 +432,3 @@ def execute_code(
         logs = logs.replace(f"/workspace/{filename if original_filename is None else ''}", "")
     # return the exit code, logs and image
     return exit_code, logs, f"python:{tag}"
-
-
-_GENERATE_ASSERTIONS_CONFIG = {
-    "prompt": """Given the signature and docstring, write the exactly same number of assertion(s) for the provided example(s) in the docstring, without assertion messages.
-
-func signature:
-{definition}
-assertions:""",
-    "model": FAST_MODEL,
-    "max_tokens": 256,
-    "stop": "\n\n",
-}
-
-
-def generate_assertions(definition: str, **config) -> Tuple[str, float]:
-    """(openai<1) Generate assertions for a function.
-
-    Args:
-        definition (str): The function definition, including the signature and docstr.
-        config (Optional, dict): The configuration for the API call.
-
-    Returns:
-        str: The generated assertions.
-        float: The cost of the generation.
-    """
-    params = {**_GENERATE_ASSERTIONS_CONFIG, **config}
-    response = oai.Completion.create(
-        {"definition": definition},
-        **params,
-    )
-    assertions = oai.Completion.extract_text(response)[0]
-    return assertions, response["cost"]
-
-
-def _remove_check(response):
-    """Remove the check function from the response."""
-    # find the position of the check function
-    pos = response.find("def check(")
-    if pos == -1:
-        return response
-    return response[:pos]
-
-
-def eval_function_completions(
-    responses: List[str],
-    definition: str,
-    test: Optional[str] = None,
-    entry_point: Optional[str] = None,
-    assertions: Optional[Union[str, Callable[[str], Tuple[str, float]]]] = None,
-    timeout: Optional[float] = 3,
-    use_docker: Optional[bool] = True,
-) -> Dict:
-    """(openai<1) Select a response from a list of responses for the function completion task (using generated assertions), and/or evaluate if the task is successful using a gold test.
-
-    Args:
-        responses (list): The list of responses.
-        definition (str): The input definition.
-        test (Optional, str): The test code.
-        entry_point (Optional, str): The name of the function.
-        assertions (Optional, str or Callable): The assertion code which serves as a filter of the responses, or an assertion generator.
-            When provided, only the responses that pass the assertions will be considered for the actual test (if provided).
-        timeout (Optional, float): The timeout for executing the code.
-
-    Returns:
-        dict: The success metrics.
-    """
-    n = len(responses)
-    if assertions is None:
-        # no assertion filter
-        success_list = []
-        for i in range(n):
-            response = _remove_check(responses[i])
-            code = (
-                f"{response}\n{test}\ncheck({entry_point})"
-                if response.startswith("def")
-                else f"{definition}{response}\n{test}\ncheck({entry_point})"
-            )
-            success = execute_code(code, timeout=timeout, use_docker=use_docker)[0] == 0
-            success_list.append(success)
-        return {
-            "expected_success": 1 - pow(1 - sum(success_list) / n, n),
-            "success": any(s for s in success_list),
-        }
-    if callable(assertions) and n > 1:
-        # assertion generator
-        assertions, gen_cost = assertions(definition)
-    else:
-        assertions, gen_cost = None, 0
-    if n > 1 or test is None:
-        for i in range(n):
-            response = responses[i] = _remove_check(responses[i])
-            code = (
-                f"{response}\n{assertions}" if response.startswith("def") else f"{definition}{response}\n{assertions}"
-            )
-            succeed_assertions = execute_code(code, timeout=timeout, use_docker=use_docker)[0] == 0
-            if succeed_assertions:
-                break
-    else:
-        # just test, no need to check assertions
-        succeed_assertions = False
-        i, response = 0, responses[0]
-    if test is None:
-        # no test code
-        return {
-            "index_selected": i,
-            "succeed_assertions": succeed_assertions,
-            "gen_cost": gen_cost,
-            "assertions": assertions,
-        }
-    code_test = (
-        f"{response}\n{test}\ncheck({entry_point})"
-        if response.startswith("def")
-        else f"{definition}{response}\n{test}\ncheck({entry_point})"
-    )
-    success = execute_code(code_test, timeout=timeout, use_docker=use_docker)[0] == 0
-    return {
-        "index_selected": i,
-        "succeed_assertions": succeed_assertions,
-        "success": success,
-        "gen_cost": gen_cost,
-        "assertions": assertions,
-    }
-
-
-_FUNC_COMPLETION_PROMPT = "# Python 3{definition}"
-_FUNC_COMPLETION_STOP = ["\nclass", "\ndef", "\nif", "\nprint"]
-_IMPLEMENT_CONFIGS = [
-    {"model": FAST_MODEL, "prompt": _FUNC_COMPLETION_PROMPT, "temperature": 0, "cache_seed": 0},
-    {"model": FAST_MODEL, "prompt": _FUNC_COMPLETION_PROMPT, "stop": _FUNC_COMPLETION_STOP, "n": 7, "cache_seed": 0},
-    {"model": DEFAULT_MODEL, "prompt": _FUNC_COMPLETION_PROMPT, "temperature": 0, "cache_seed": 1},
-    {"model": DEFAULT_MODEL, "prompt": _FUNC_COMPLETION_PROMPT, "stop": _FUNC_COMPLETION_STOP, "n": 2, "cache_seed": 2},
-    {"model": DEFAULT_MODEL, "prompt": _FUNC_COMPLETION_PROMPT, "stop": _FUNC_COMPLETION_STOP, "n": 1, "cache_seed": 2},
-]
-
-
-class PassAssertionFilter:
-    def __init__(self, assertions):
-        self._assertions = assertions
-        self.cost = 0
-        self.metrics = self.responses = None
-
-    def pass_assertions(self, context, response, **_):
-        """(openai<1) Check if the response passes the assertions."""
-        responses = oai.Completion.extract_text(response)
-        metrics = eval_function_completions(responses, context["definition"], assertions=self._assertions)
-        self._assertions = metrics["assertions"]
-        self.cost += metrics["gen_cost"]
-        self.metrics = metrics
-        self.responses = responses
-        return metrics["succeed_assertions"]
-
-
-def implement(
-    definition: str,
-    configs: Optional[List[Dict]] = None,
-    assertions: Optional[Union[str, Callable[[str], Tuple[str, float]]]] = generate_assertions,
-) -> Tuple[str, float]:
-    """(openai<1) Implement a function from a definition.
-
-    Args:
-        definition (str): The function definition, including the signature and docstr.
-        configs (list): The list of configurations for completion.
-        assertions (Optional, str or Callable): The assertion code which serves as a filter of the responses, or an assertion generator.
-
-    Returns:
-        str: The implementation.
-        float: The cost of the implementation.
-        int: The index of the configuration which generates the implementation.
-    """
-    cost = 0
-    configs = configs or _IMPLEMENT_CONFIGS
-    if len(configs) > 1 and callable(assertions):
-        assertions, cost = assertions(definition)
-    assertion_filter = PassAssertionFilter(assertions)
-    response = oai.Completion.create(
-        {"definition": definition}, config_list=configs, filter_func=assertion_filter.pass_assertions
-    )
-    cost += assertion_filter.cost + response["cost"]
-    return assertion_filter.responses[assertion_filter.metrics["index_selected"]], cost, response["config_id"]
-
-    # for i, config in enumerate(configs):
-    #     response = oai.Completion.create({"definition": definition}, **config)
-    #     cost += oai.Completion.cost(response)
-    #     responses = oai.Completion.extract_text(response)
-    #     metrics = eval_function_completions(responses, definition, assertions=assertions)
-    #     assertions = metrics["assertions"]
-    #     cost += metrics["gen_cost"]
-    #     if metrics["succeed_assertions"] or i == len(configs) - 1:
-    #         return responses[metrics["index_selected"]], cost, i

notebook/agentchat_auto_feedback_from_code_execution.ipynb

@@ -67,7 +67,7 @@
     "from typing import Dict, Union\n",
     "\n",
     "from IPython import get_ipython\n",
-    "from IPython.display import Image\n",
+    "from IPython.display import display, Image\n",
     "\n",
     "import autogen\n",
     "\n",
@@ -498,7 +498,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -515,7 +515,8 @@
    ],
    "source": [
     "try:\n",
-    "    Image(filename=\"coding/stock_price_ytd.png\")\n",
+    "    image = Image(filename=\"coding/stock_price_ytd.png\")\n",
+    "    display(image)\n",
     "except FileNotFoundError:\n",
     "    print(\"Image not found. Please check the file name and modify if necessary.\")"
    ]
@@ -813,7 +814,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.10.13"
   },
   "vscode": {
    "interpreter": {