Implement LC Flows.

LC_Code.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class LC_Code(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_Code.yaml

@@ -0,0 +1,81 @@
+name: "Code_Flow"
+description: |2- 
+  Given a problem description, generate code directly.
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:  # Applied when constructing the first user message.
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+
+input_interface_initialized:  # Applied when constructing all subsequent user messages.
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    Your goal is to provide executable Python code that solves a coding interview problem. The code should correctly handle all corner cases in order to pass the hidden test cases, which are used to evaluate the correctness of the solution.
+
+    The user will specify the problem by providing you with:
+      - the problem statement
+      - example test cases
+      - the constraints of the problem
+
+    The user will provide you with a task and an output format that you will strictly follow.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    {{io_description}}
+
+    # Constraints
+    {{constraints}}
+
+
+    Return Python code that solves the problem. The code should extend the following stub:
+    ```python
+    {{python_stub}}
+    ```
+    without changing the method signatures.
+    Reply in the following format:
+    ```python
+    {{code_placeholder}}
+    ```
+  input_variables:
+    - "problem_description"
+    - "io_description"
+    - "constraints"
+    - "python_stub"
+  partial_variables:
+    code_placeholder: "{{python_code}}"
+  template_format: jinja2

LC_CodeCollab.py

@@ -0,0 +1,6 @@
+from flows.base_flows import CircularFlow
+
+
+class LC_CodeCollab(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_CodeCollab.yaml

@@ -0,0 +1,91 @@
+name: "CodeCollab_Flow"
+description: |2-
+  Given a problem description, alternate between a step in which code is generated, and a step in which the produced code is evaluated and useful feedback is provided.
+
+max_rounds: 4
+early_exit_key: "end_of_interaction"
+
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+output_interface:
+  - "code"
+
+subflows_config:
+  CodeGenerator:
+    _target_: .LC_Code.instantiate_from_default_config
+    name: "CodeGenerator"
+    human_message_prompt_template:
+      _target_: langchain.PromptTemplate
+      template: |2-
+        # Feedback on the last proposed solution
+        {{code_feedback}}
+
+
+        Consider the original problem statement, the last proposed solution and the provided feedback. Does the solution need to be updated? If so, provide the corrected version of the code in the following format:
+        ```python
+        {{code_placeholder}}
+        ```
+        otherwise, reply:
+        "Final answer."
+      input_variables:
+        - code_feedback
+      partial_variables:
+        code_placeholder: "{{python_code}}"
+    input_interface_initialized:
+      - "code_feedback"
+  CodeCritic:
+    _target_: .LC_CodeCritic.instantiate_from_default_config
+
+topology:
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.EndOfInteraction
+          end_of_interaction_string: "Final answer"
+          input_key: "api_output"
+          output_key: "end_of_interaction"
+        - _target_: flows.data_transformations.PrintPreviousMessages
+    reset: false
+
+  # ~~~ Code Critic ~~~
+  - goal: "Provide feedback for the candidate solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        api_output: "code_feedback"
+
+    reset: true

LC_CodeCritic.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class LC_CodeCritic(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_CodeCritic.yaml

@@ -0,0 +1,86 @@
+name: "CodeCritic_Flow"
+description: |2-
+  Given a problem description and a solution candidate, provide useful feedback concerning the correctness of the solution candidate.
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+  - "code"
+
+input_interface_initialized:
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    Your goal is to identify potential issues with a competitive programming solution attempt.
+
+    The user will specify the problem by providing you with:
+      - the problem statement
+      - example test cases
+      - the constraints of the problem
+      - (optional) explanation of the test cases
+      - a Python solution attempt
+
+    Crucially, your goal is to correctly identify potential issues with the solution attempt, and not to provide the code implementation yourself.
+    The user will provide you with a task and an output format that you will strictly follow.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    {{io_description}}
+
+    # Constraints
+    {{constraints}}
+    
+    # code stub
+    ```python
+    {{python_stub}}
+    ```
+
+    # Python solution attempt
+    ```python
+    {{code}}
+    ```
+
+
+    Consider the problem statement and the solution attempt. Are there any issues with the proposed solution or it is correct? Explain your reasoning very concisely, and do not provide code.
+  input_variables:
+    - "problem_description"
+    - "io_description"
+    - "constraints"
+    - "python_stub"
+    - "code"
+  template_format: jinja2

LC_CodeCriticWrongAttempt.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class LC_CodeCriticWrongAttempt(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_CodeCriticWrongAttempt.yaml

@@ -0,0 +1,91 @@
+name: "CodeCriticWrongAttempt_Flow"
+description: |2-
+  Given a problem description and an incorrect solution candidate, provide useful feedback for correcting the mistakes in the solution. 
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+  - "testing_results_summary"
+  - "code"
+
+input_interface_initialized:
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    Your goal is to identify the issues with an incorrect competitive programming solution attempt.
+  
+    The user will specify the problem by providing you with:
+      - the problem statement
+      - example test cases
+      - the constraints of the problem
+      - python stub code
+      - an incorrect Python solution attempt and a description of its issue
+  
+    Crucially, your goal is to consider all aspects of the problem and pinpoint the issues with the solution attempt, and not to provide the code implementation yourself.
+    Some aspects to consider: Is the input correctly parsed? Is the output correctly formatted? Are the corner cases correctly handled? Is there a logical mistake with the algorithm itself?
+    Use the code execution results provided in the issue description to guide your reasoning/debugging.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    {{io_description}}
+
+    # Constraints
+    {{constraints}}
+    
+     The code should extend the following stub:
+    ```python
+    {{python_stub}}
+    ```
+
+    # Solution attempt to be fixed
+    ```python
+    {{code}}
+    ```
+
+    {{testing_results_summary}}
+
+
+    Consider the problem statement, the solution attempt and the issue. Why is the solution attempt incorrect? How should it be fixed? Explain your reasoning very concisely, and do not provide code.
+  input_variables:
+    - "problem_description"
+    - "io_description"
+    - "constraints"
+    - "python_stub"
+    - "code"
+    - "testing_results_summary"
+  template_format: jinja2

LC_CodeDebug.py

@@ -0,0 +1,12 @@
+from flows.base_flows import CircularFlow
+
+
+class LC_CodeDebug(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def _early_exit(self):
+        if self.flow_state.get("all_tests_passed", False):
+            return True
+
+        return super()._early_exit()

LC_CodeDebug.yaml

@@ -0,0 +1,172 @@
+name: "CodeDebug_Flow"
+description: |2-
+  Given a problem description, generate code, test and refine it until all tests pass or a maximum number of rounds is reached.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+  - "public_tests_individual_io"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+# ~~~ Flow specification ~~~
+max_rounds: 4
+
+### Subflows specification
+subflows_config:
+  CodeGenerator:
+    _target_: .LC_Code.instantiate_from_default_config
+    name: "CodeGenerator"
+    model_name: "gpt-4"
+    human_message_prompt_template:
+      template: |2-
+        {{testing_results_summary}}
+
+
+        Consider the problem statement, the last proposed solution, and its issue. Provide a corrected version of the code that solves the original problem and resolves the issue, without any explanation, in the following format:
+        ```python
+        {{code_placeholder}}
+        ```
+      input_variables:
+        - testing_results_summary
+      partial_variables:
+        code_placeholder: "{{python_code}}"
+
+    input_interface_initialized:
+      - "testing_results_summary"
+  CodeTestingCritic:
+    _target_: .LC_CodeTesting.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "code"
+
+    ### Reset flag
+    reset: false
+
+  # ~~~ Code Testing Critic ~~~
+  - goal: "Test the code on the public tests and provide a results summary."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeTestingCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: .src.data_transformations.CorrectnessFlag
+          input_key: "public_tests_results"
+          output_key: "all_tests_passed"
+        - _target_: .src.data_transformations.TestingResultsSummaryGeneration
+          output_key: "testing_results_summary"
+
+          single_test_error_message: True
+
+          no_error_template: |2-
+            ${.issue_title}
+            All of the executed tests passed.
+
+          compilation_error_template: |2-
+            ${.issue_title}
+            The execution resulted in a compilation error.
+            ## Compilation error message:
+            {{error_message}}
+          timeout_error_template: |2-
+            ${.issue_title}
+            The execution timed out, the solution is not efficient enough.
+          runtime_error_template: |2-
+            ${.issue_title}
+            The execution resulted in a runtime error on the following test.
+            ## [Failed test] Input
+            ```
+            {{test_input}}
+            ```
+            ## [Failed test] Runtime error message
+            {{error_message}}
+          single_test_error_template: |2-
+            ${.issue_title}
+            The Python code does not solve the problem in the problem description due to logical errors. It fails the following test:
+            ## [Failed test] Input
+            ```
+            {{test_input}}
+            ```
+            ## [Failed test] Expected output
+            ```
+            {{expected_output}}
+            ```
+            ## [Failed test] Generated output
+            ```
+            {{generated_output}}
+            ```
+          all_tests_header: |2-
+            ${.issue_title}
+            The Python code does not solve the problem in the problem description due to logical errors. It fails on the following tests.
+          test_error_template: |2-
+            ## [Failed test {{idx}}]
+            ### [Failed test {{idx}}] Input
+            ```
+            {{test_input}}
+            ```
+            ### [Failed test {{idx}}] Expected output
+            ```
+            {{expected_output}}
+            ```
+            ### [Failed test {{idx}}] Generated output
+            ```
+            {{generated_output}}
+            ```
+          tests_separator: "\n\n"
+
+          issue_title: "# Issue with the last proposed solution"
+
+          feedback_title: "# Feedback on the last proposed solution"
+
+          no_code_template: |2-
+            ${.feedback_title}
+            The code was not provided in the correct output format specified in the request or it was not provided at all.
+          feedback_only_template: |2-
+            ${.feedback_title}
+            {{feedback_content}}
+          feedback_and_issue_template: |2-
+            {{issue_description}}
+      
+            {{feedback_content}}
+
+    ### Reset flag
+    reset: true

LC_CodeDebugCollab.py

@@ -0,0 +1,12 @@
+from flows.base_flows import CircularFlow
+
+
+class LC_CodeDebugCollab(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def _early_exit(self):
+        if self.flow_state.get("all_tests_passed", False):
+            return True
+
+        return super()._early_exit()

LC_CodeDebugCollab.yaml

@@ -0,0 +1,89 @@
+name: "CodeDebugCollab_Flow"
+description: |2-
+  Given a problem description, alternate between a step in which code is generated, and a step in which the produced code is evaluated and useful feedback is provided.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+  - "public_tests_individual_io"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+# ~~~ Flow specification ~~~
+max_rounds: 4
+
+subflows_config:
+  CodeGenerator:
+    _target_: .LC_Code.instantiate_from_default_config
+    name: "CodeGenerator"
+    model_name: "gpt-4"
+    human_message_prompt_template:
+      _target_: langchain.PromptTemplate
+      template: |2-
+        {{testing_results_summary}}
+      
+        {{code_feedback}}
+
+
+        Consider the problem statement, the last proposed solution, its issue and the provided feedback. Return a corrected version of the code that solves the original problem and resolves the issue, without any explanation, in the following format:
+        ```python
+        {{code_placeholder}}
+        ```
+      input_variables:
+        - code_feedback
+        - testing_results_summary
+      partial_variables:
+        code_placeholder: "{{python_code}}"
+    input_interface_initialized:
+      - "code_feedback"
+      - "testing_results_summary"
+  CodeDebugCritic:
+    _target_: .LC_CodeDebugCritic.instantiate_from_default_config
+
+topology:
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+      keys_to_select:
+        - "code"
+
+    reset: false
+
+  # ~~~ Code Critic Grounded in Tests ~~~
+  - goal: "Provide feedback for the candidate solution that is grounded in test results."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeDebugCritic
+
+    reset: true

LC_CodeDebugCritic.py

@@ -0,0 +1,13 @@
+from flows.base_flows import SequentialFlow
+
+
+class LC_CodeDebugCritic(SequentialFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def _early_exit(self):
+        if self.flow_state.get("all_tests_passed", False):
+            self.flow_state["code_feedback"] = None
+            return True
+
+        return super()._early_exit()

LC_CodeDebugCritic.yaml

@@ -0,0 +1,142 @@
+name: "CodeDebugCritic_Flow"
+description: |-2
+  Given a problem description and a candidate solution, test the code and provide useful feedback concerning the correctness of the solution and the potential mistakes.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+  - "public_tests_individual_io"
+  - "code"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "testing_results_summary"
+  - "all_tests_passed"
+  - "code_feedback"
+
+# ~~~ Flow specification ~~~
+subflows_config:
+  CodeTestingCritic:
+    _target_: .LC_CodeTesting.instantiate_from_default_config
+  CodeCriticWrongAttempt:
+    _target_: .LC_CodeCriticWrongAttempt.instantiate_from_default_config
+
+topology:
+  # ~~~ Code Testing Critic ~~~
+  - goal: "Test the code on the public tests and provide a results summary."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeTestingCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: .src.data_transformations.CorrectnessFlag
+          input_key: "public_tests_results"
+          output_key: "all_tests_passed"
+        - _target_: .src.data_transformations.TestingResultsSummaryGeneration
+          output_key: "testing_results_summary"
+
+          single_test_error_message: True
+
+          no_error_template: |2-
+            ${.issue_title}
+            All of the executed tests passed.
+
+          compilation_error_template: |2-
+            ${.issue_title}
+            The execution resulted in a compilation error.
+            ## Compilation error message:
+            {{error_message}}
+          timeout_error_template: |2-
+            ${.issue_title}
+            The execution timed out, the solution is not efficient enough.
+          runtime_error_template: |2-
+            ${.issue_title}
+            The execution resulted in a runtime error on the following test.
+            ## [Failed test] Input
+            ```
+            {{test_input}}
+            ```
+            ## [Failed test] Runtime error message
+            {{error_message}}
+          single_test_error_template: |2-
+            ${.issue_title}
+            The Python code does not solve the problem in the problem description due to logical errors. It fails the following test:
+            ## [Failed test] Input
+            ```
+            {{test_input}}
+            ```
+            ## [Failed test] Expected output
+            ```
+            {{expected_output}}
+            ```
+            ## [Failed test] Generated output
+            ```
+            {{generated_output}}
+            ```
+          all_tests_header: |2-
+            ${.issue_title}
+            The Python code does not solve the problem in the problem description due to logical errors. It fails on the following tests.
+          test_error_template: |2-
+            ## [Failed test {{idx}}]
+            ### [Failed test {{idx}}] Input
+            ```
+            {{test_input}}
+            ```
+            ### [Failed test {{idx}}] Expected output
+            ```
+            {{expected_output}}
+            ```
+            ### [Failed test {{idx}}] Generated output
+            ```
+            {{generated_output}}
+            ```
+          tests_separator: "\n\n"
+
+          issue_title: "# Issue with the last proposed solution"
+
+          feedback_title: "# Feedback on the last proposed solution"
+
+          no_code_template: |2-
+            ${.feedback_title}
+            The code was not provided in the correct output format specified in the request or it was not provided at all.
+          feedback_only_template: |2-
+            ${.feedback_title}
+            {{feedback_content}}
+          feedback_and_issue_template: |2-
+            {{issue_description}}
+
+            {{feedback_content}}
+
+  # ~~~ Feedback Generator ~~~
+  - goal: "Generate feedback grounded in the test results summary."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeCriticWrongAttempt
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyRename
+          old_key2new_key:
+            api_output: "code_feedback"
+
+    reset: true

LC_CodeReflect.py

@@ -0,0 +1,6 @@
+from flows.base_flows import CircularFlow
+
+
+class LC_CodeReflect(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_CodeReflect.yaml

@@ -0,0 +1,86 @@
+name: "CodeReflect_Flow"
+description: |-2
+  Given a problem description, generate code, reflecting on it and improving it until a message suggesting that the code seems correct or a maximum number of rounds is reached."
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+# ~~~ Flow specification ~~~
+max_rounds: 4
+
+### Subflows specification
+subflows_config:
+  CodeGenerator:
+    _target_: .LC_Code.instantiate_from_default_config
+  CodeReflectCritic:
+    _target_: .FixedReply_CodeReflect.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+      keys_to_rename:
+        code_reflect_message: "query"
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.EndOfInteraction
+          end_of_interaction_string: "Final answer"
+          input_key: "api_output"
+          output_key: "end_of_interaction"
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "code"
+        - "end_of_interaction"
+
+    ### Reset flag
+    reset: false
+
+  - goal: "Generate a message that encourages reflection."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+
+    ### Flow Specification
+    flow: CodeReflectCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        fixed_reply: "code_reflect_message"
+
+    ### Reset flag
+    reset: true
+
+early_exit_key: "end_of_interaction"

LC_CodeTesting.py

@@ -0,0 +1,31 @@
+from typing import Any, Dict
+
+from flows.utils import logging
+from .src.evaluation import testing_utils_leetcode
+from .CodeTesting import CodeTesting
+
+log = logging.get_logger(__name__)
+
+
+class LC_CodeTesting(CodeTesting):
+    REQUIRED_KEYS_CONFIG = []
+    REQUIRED_KEYS_KWARGS = []
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def _get_test_data(self, input_data: Dict):
+        """This function retrieves (or generates) input-output pairs that will be used to test the implementation."""
+        return input_data["public_tests_individual_io"]
+
+    def _run_tests(self, input_data: Dict, test_data: Dict) -> Dict[str, Any]:
+        testing_results = testing_utils_leetcode.evaluate_solution_for_problem(
+            candidate_solution=input_data["code"],
+            python_stub=input_data["python_stub"],
+            public_tests_io=test_data
+        )
+
+        for test_output in testing_results["public_tests_results"]:
+            test_output["input"] = "\n".join(test_output["input"])
+
+        return testing_results

LC_CodeTesting.yaml

@@ -0,0 +1,11 @@
+name: "CodeTesting_Flow"
+description: "ToDo: add description"
+
+input_interface:
+  - "code"
+  - "python_stub"
+  - "public_tests_individual_io"
+
+output_interface:
+  - "all_tests_passed"
+  - "testing_results_summary"

LC_CodeWithPlan.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class LC_CodeWithPlan(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_CodeWithPlan.yaml

@@ -0,0 +1,90 @@
+name: "Code_Flow"
+description: |2- 
+  Given a problem description, generate code directly.
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:  # Applied when constructing the first user message.
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+  - "plan"
+
+input_interface_initialized:  # Applied when constructing all subsequent user messages.
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    Your goal is to provide executable Python code that solves a coding interview problem. The code should correctly handle all corner cases in order to pass the hidden test cases, which are used to evaluate the correctness of the solution.
+
+    The user will specify the problem by providing you with:
+      - the problem statement
+      - example test cases
+      - the constraints of the problem
+
+    Additionally, the user will provide you with a conceptual solution to the problem which should guide your reasoning and the code implementation.
+
+    The user will provide you with a task and an output format that you will strictly follow.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    {{io_description}}
+
+    # Constraints
+    {{constraints}}
+    
+    # Conceptual solution
+    {{plan}}
+
+
+    Return Python code that solves the problem. The code should extend the following stub:
+    ```python
+    {{python_stub}}
+    ```
+
+    without changing the method signatures.
+    Reply in the following format:
+    ```python
+    {{code_placeholder}}
+    ```
+    ```
+  input_variables:
+    - "problem_description"
+    - "io_description"
+    - "constraints"
+    - "python_stub"
+    - "plan"
+  partial_variables:
+    code_placeholder: "{{python_code}}"
+  template_format: jinja2

LC_Plan.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class LC_Plan(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_Plan.yaml

@@ -0,0 +1,76 @@
+name: "Plan_Flow"
+description: |2- 
+  Given a problem description, generate a high-level solution strategy.
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:  # Applied when constructing the first user message.
+    - "problem_description"
+    - "io_description"
+    - "constraints"
+
+input_interface_initialized:  # Applied when constructing all subsequent user messages.
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    Your goal is to provide a high-level conceptual solution that, if implemented, will solve a given coding interview problem.
+
+    The user will specify the problem by providing you with:
+      - the problem statement
+      - example test cases
+      - the constraints of the problem
+
+    The proposed algorithm should be computationally efficient, logically correct and handle all corner cases.
+
+    The user will provide you with a task and an output format that you will strictly follow.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    {{io_description}}
+
+    # Constraints
+    {{constraints}}
+
+
+    Return a high-level conceptual solution that would solve the problem. Be very concise, and do not provide code.
+    Reply in the following format:
+    # Conceptual solution
+    {{plan_placeholder}}
+  input_variables:
+    - "problem_description"
+    - "io_description"
+    - "constraints"
+  partial_variables:
+    plan_placeholder: "{{conceptual_solution}}"
+  template_format: jinja2
+

LC_PlanCollab.py

@@ -0,0 +1,6 @@
+from flows.base_flows import CircularFlow
+
+
+class LC_PlanCollab(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_PlanCollab.yaml

@@ -0,0 +1,94 @@
+name: "PlanCollab_Flow"
+description: |2-
+  Given a problem description, alternate between a step in which a solution strategy is generated, and a step in which the solution strategy is evaluated and useful feedback is provided.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "plan"
+
+# ~~~ Flow specification ~~~
+max_rounds: 4
+early_exit_key: "end_of_interaction"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .LC_Plan.instantiate_from_default_config
+    human_message_prompt_template:
+      _target_: langchain.PromptTemplate
+      template: |2-
+        # Feedback on the last proposed conceptual solution
+        {{plan_feedback}}
+  
+  
+        Consider the original problem statement, the last proposed solution and the provided feedback. Does the solution need to be updated? If so, provide the corrected version of the conceptual solution in the following format:
+        # Conceptual solution
+        {{plan_placeholder}}
+        otherwise, reply:
+        "Final answer."
+      input_variables:
+        - plan_feedback
+      partial_variables:
+        plan_placeholder: "{{conceptual_solution}}"
+      template_format: jinja2
+    input_interface_initialized:
+      - "plan_feedback"
+  PlanCritic:
+    _target_: .LC_PlanCritic.instantiate_from_default_config
+
+topology:
+  # ~~~ Plan Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=Conceptual solution)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          regex_fallback:
+            - '(?<=Conceptual solution:)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          input_key: "api_output"
+          output_key: "plan"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.EndOfInteraction
+          end_of_interaction_string: "Final answer"
+          input_key: "api_output"
+          output_key: "end_of_interaction"
+        - _target_: flows.data_transformations.PrintPreviousMessages
+    reset: false
+  # ~~~ Plan Critic ~~~
+  - goal: "Provide feedback for the candidate solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        api_output: "plan_feedback"
+
+    reset: true

LC_PlanCollab_Code.py

@@ -0,0 +1,6 @@
+from flows.base_flows import SequentialFlow
+
+
+class LC_PlanCollab_Code(SequentialFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_PlanCollab_Code.yaml

@@ -0,0 +1,67 @@
+name: "PlanCollab_Code_Flow"
+description: |2- 
+  Given a problem description, first generate a solution strategy in collaboration with at critic, and then implement the code.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .LC_PlanCollab.instantiate_from_default_config
+  CodeGenerator:
+    _target_: .LC_CodeWithPlan.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Plan Generator ~~~
+  - goal: "Generate a plan and reflect on it."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_select:
+        - "plan"
+
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "code"

LC_PlanCritic.py

@@ -0,0 +1,6 @@
+from flow_modules.aiflows.OpenAIChatFlowModule import OpenAIChatAtomicFlow
+
+
+class LC_PlanCritic(OpenAIChatAtomicFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_PlanCritic.yaml

@@ -0,0 +1,84 @@
+name: "PlanCritic_Flow"
+description: |2-
+  Given a problem description and a solution strategy candidate, provide useful feedback concerning its correctness. 
+
+# ~~~ Input interface specification ~~~
+input_interface_non_initialized:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+  - "plan"
+
+input_interface_initialized:
+  - "query"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "api_output"
+
+# ~~~ Flow specification ~~~
+model_name: "gpt-4"
+
+generation_parameters:
+  n: 1
+  max_tokens: 3000
+  temperature: 0.3
+
+  model_kwargs:
+    top_p: 0.2
+    frequency_penalty: 0
+    presence_penalty: 0
+
+system_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+      Your goal is to identify potential issues with a conceptual solution to a given competitive programming problem.
+
+      The user will specify the problem by providing you with:
+        - the problem statement
+        - example test cases
+        - the constraints of the problem
+        - a conceptual solution attempt
+
+      Crucially, your goal is to consider all aspects of the problem and pinpoint potential issues with the conceptual solution attempt (if any), and not to provide the conceptual solution or the code implementation yourself.
+      Some aspects to consider: Are there any logical mistakes with the proposed algorithm? Are the corner cases correctly handled?
+      The user will provide you with a task and an output format that you will strictly follow.
+  input_variables: []
+  template_format: jinja2
+
+human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: "{{query}}"
+  input_variables:
+    - "query"
+  template_format: jinja2
+
+init_human_message_prompt_template:
+  _target_: langchain.PromptTemplate
+  template: |2-
+    # Problem statement
+    {{problem_description}}
+
+    {{io_description}}
+
+    # Constraints
+    {{constraints}}
+    
+    # code stub
+    ```python
+    {{python_stub}}
+    ```
+
+    # Conceptual solution attempt
+    {{plan}}
+
+
+    Consider the problem statement and the solution attempt. Are there any issues with the proposed conceptual solution or it is correct? Explain your reasoning very concisely.
+  input_variables:
+    - "problem_description"
+    - "io_description"
+    - "constraints"
+    - "python_stub"
+    - "plan"
+  template_format: jinja2

LC_PlanReflect.py

@@ -0,0 +1,6 @@
+from flows.base_flows import CircularFlow
+
+
+class LC_PlanReflect(CircularFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_PlanReflect.yaml

@@ -0,0 +1,83 @@
+name: "CodeReflect_Flow"
+description: |-2
+  Given a problem description, generate code, reflect on it and improve it until a message suggesting that the code seems correct or a maximum number of rounds is reached.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "plan"
+
+# ~~~ Flow specification ~~~
+max_rounds: 4
+early_exit_key: "end_of_interaction"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .LC_Plan.instantiate_from_default_config
+  PlanReflectCritic:
+    _target_: .FixedReply_PlanReflect.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Plan Generator ~~~
+  - goal: "Generate/refine a plan."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+      keys_to_rename:
+        plan_reflect_message: "query"
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=Conceptual solution)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          regex_fallback:
+            - '(?<=Conceptual solution:)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          input_key: "api_output"
+          output_key: "plan"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.EndOfInteraction
+          end_of_interaction_string: "Final answer"
+          input_key: "api_output"
+          output_key: "end_of_interaction"
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "plan"
+        - "end_of_interaction"
+
+    ### Reset flag
+    reset: false
+
+  - goal: "Generate a message that encourages reflection."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanReflectCritic
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_rename:
+        fixed_reply: "plan_reflect_message"
+
+    ### Reset flag
+    reset: true

LC_PlanReflect_Code.py

@@ -0,0 +1,6 @@
+from flows.base_flows import SequentialFlow
+
+
+class LC_PlanReflect_Code(SequentialFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_PlanReflect_Code.yaml

@@ -0,0 +1,67 @@
+name: "Plan_Code_Flow"
+description: |2- 
+  Given a problem description, first generate a solution strategy, reflect on it, and then implement the code.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .LC_PlanReflect.instantiate_from_default_config
+  CodeGenerator:
+    _target_: .LC_CodeWithPlan.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Plan Generator ~~~
+  - goal: "Generate a plan and reflect on it."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      keys_to_select:
+        - "plan"
+
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "code"

LC_Plan_Code.py

@@ -0,0 +1,6 @@
+from flows.base_flows import SequentialFlow
+
+
+class LC_Plan_Code(SequentialFlow):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

LC_Plan_Code.yaml

@@ -0,0 +1,77 @@
+name: "Plan_Code_Flow"
+description: |2- 
+  Given a problem description, first generate a solution strategy and then implement the code.
+
+# ~~~ Input interface specification ~~~
+input_interface:
+  - "problem_description"
+  - "io_description"
+  - "constraints"
+  - "python_stub"
+
+# ~~~ Output interface specification ~~~
+output_interface:
+  - "code"
+
+subflows_config:
+  PlanGenerator:
+    _target_: .LC_Plan.instantiate_from_default_config
+  CodeGenerator:
+    _target_: .LC_CodeWithPlan.instantiate_from_default_config
+
+### Topology specification (specifies how the sequence of messages will flow from one of the subflows to another)
+topology:
+  # ~~~ Code Testing Critic ~~~
+  - goal: "Test the code on the public tests and provide a results summary."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: PlanGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=Conceptual solution)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          regex_fallback:
+            - '(?<=Conceptual solution:)([\s\S]*?)(?=\n\n# [A-Z]|\Z)'
+          input_key: "api_output"
+          output_key: "plan"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "plan"
+
+  # ~~~ Code Generator ~~~
+  - goal: "Generate/refine a solution."
+
+    ### Input Interface
+    input_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.KeyMatchInput
+
+    ### Flow Specification
+    flow: CodeGenerator
+
+    ### Output Interface
+    output_interface:
+      _target_: flows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: flows.data_transformations.RegexFirstOccurrenceExtractor
+          regex: '(?<=```python)([\s\S]*?)(?=```)'
+          regex_fallback: '(?<=```)([\s\S]*?)(?=```)'
+          input_key: "api_output"
+          output_key: "code"
+          strip: True
+          assert_unique: True
+        - _target_: flows.data_transformations.PrintPreviousMessages
+      keys_to_select:
+        - "code"

__init__.py

@@ -1,3 +1,14 @@
+# ~~~ Specify the dependencies ~~~
+dependencies = [
+    {"url": "aiflows/OpenAIChatFlowModule", "revision": "6a1e351a915f00193f18f3da3b61c497df1d31a3"},
+    {"url": "aiflows/FixedReplyFlowModule", "revision": "65fbdbe19f5a8fdc48810810812552c5674d35a5"},
+]
+
+from flows import flow_verse
+
+flow_verse.sync_dependencies(dependencies)
+# ~~~
+
 # ~~~ Codeforces ~~~
 # code
 from .CF_Code import CF_Code
@@ -14,7 +25,63 @@ from .CF_CodeCollab import CF_CodeCollab
 from .CF_CodeTesting import CF_CodeTesting
 from .CF_CodeDebug import CF_CodeDebug
 
-# cf-code_debug_collab
+# code_debug_collab
 from .CF_CodeCriticWrongAttempt import CF_CodeCriticWrongAttempt
 from .CF_CodeDebugCritic import CF_CodeDebugCritic
 from .CF_CodeDebugCollab import CF_CodeDebugCollab
+
+# plan-code (and plan_oracle-code)
+from .CF_Plan import CF_Plan
+from .CF_CodeWithPlan import CF_CodeWithPlan
+from .CF_Plan_Code import CF_Plan_Code
+
+# plan_reflect-code
+from .FixedReply_PlanReflect import FixedReply_PlanReflect
+from .CF_PlanReflect import CF_PlanReflect
+from .CF_PlanReflect_Code import CF_PlanReflect_Code
+
+# plan_collab-code
+from .CF_PlanCritic import CF_PlanCritic
+from .CF_PlanCollab import CF_PlanCollab
+from .CF_PlanCollab_Code import CF_PlanCollab_Code
+
+# plan_oracle-code_debug_collab
+from .CF_CodeCriticWrongAttemptWithPlan import CF_CodeCriticWrongAttemptWithPlan
+from .CF_CodeDebugCriticWithPlan import CF_CodeDebugCriticWithPlan
+from .CF_CodeDebugCollabWithPlan import CF_CodeDebugCollabWithPlan
+# ~~~
+
+# ~~~ LeetCode ~~~
+# code
+from .LC_Code import LC_Code
+
+# code_reflect
+from .LC_CodeReflect import LC_CodeReflect
+
+# code_collab
+from .LC_CodeCritic import LC_CodeCritic
+from .LC_CodeCollab import LC_CodeCollab
+
+# code_debug
+from .LC_CodeTesting import LC_CodeTesting
+from .LC_CodeDebug import LC_CodeDebug
+
+# code_debug_collab
+from .LC_CodeCriticWrongAttempt import LC_CodeCriticWrongAttempt
+from .LC_CodeDebugCritic import LC_CodeDebugCritic
+from .LC_CodeDebugCollab import LC_CodeDebugCollab
+
+# plan-code
+from .LC_Plan import LC_Plan
+from .LC_CodeWithPlan import LC_CodeWithPlan
+from .LC_Plan_Code import LC_Plan_Code
+
+# plan_reflect-code
+from .LC_PlanReflect import LC_PlanReflect
+from .LC_PlanReflect_Code import LC_PlanReflect_Code
+
+# plan_collab-code
+from .LC_PlanCritic import LC_PlanCritic
+from .LC_PlanCollab import LC_PlanCollab
+from .LC_PlanCollab_Code import LC_PlanCollab_Code
+# ~~~