Upload 169 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Llama2-Code-Interpreter-main/assets/result_nvidia_chart.gif filter=lfs diff=lfs merge=lfs -text
+Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/example_img/save_to_notebook_demo.gif filter=lfs diff=lfs merge=lfs -text

Llama2-Code-Interpreter-main/.gitignore

@@ -0,0 +1,48 @@
+# Ignore .ckpt files
+ckpt
+
+# Ignore Python compiled files
+__pycache__/
+*.py[cod]
+
+# Ignore Python virtual environment
+venv/
+
+# Ignore Jupyter notebook checkpoints
+.ipynb_checkpoints/
+.git/
+.vscode/
+
+# Ignore .DS_Store on MacOS
+.DS_Store
+
+rilab_key.txt
+gpt4_custom_code_interpreter/rilab_key.txt
+openai_api_key.txt
+
+gpt4_custom_code_interpreter/
+tmp/
+output/
+wandb/
+
+utils/const.py
+utils/hf_model_upload.py
+gpt_data_gen/
+*.json
+*.txt
+*.sh
+*.pt 
+*.pth 
+*.ckpt
+*.tokenizer
+
+# eval data
+eval/ds1000_data
+eval/grade-school-math 
+
+# gradio features
+chatbot_feat.py
+chatbot_feat2.py
+gradio_test.py
+
+

Llama2-Code-Interpreter-main/OpenCodeInterpreter/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Llama2-Code-Interpreter-main/OpenCodeInterpreter/README.md

@@ -0,0 +1,83 @@
+# OpenCodeInterpreter: Integrating Code Generation with Execution and Refinement
+
+<p align="center">
+<img width="1000px" alt="OpenCodeInterpreter" src="https://opencodeinterpreter.github.io/static/images/figure1.png">
+</p>
+<p align="center">
+  <a href="https://opencodeinterpreter.github.io/">[🏠Homepage]</a> 
+  |
+  <a href="https://github.com/OpenCodeInterpreter/OpenCodeInterpreter/">[🛠️Code]</a> 
+</p>
+<hr>
+
+## 🌟 Upcoming Features
+- 💡 **Open Sourcing OpenCodeInterpreter-SC2 series Model (based on StarCoder2 base)** 
+
+- 💡 **Open Sourcing OpenCodeInterpreter-GM-7b Model with gemma-7b Base** 
+
+## 🔔News
+🛠️[2024-02-29]: Our official online demo is deployed on HuggingFace Spaces! Take a look at [Demo Page](https://huggingface.co/spaces/m-a-p/OpenCodeInterpreter_demo)!
+
+🛠️[2024-02-28]: We have open-sourced the Demo Local Deployment Code with a Setup Guide.
+
+✨[2024-02-26]: We have open-sourced the [OpenCodeInterpreter-DS-1.3b](https://huggingface.co/m-a-p/OpenCodeInterpreter-DS-1.3B) Model.
+
+📘[2024-02-26]: We have open-sourced the [CodeFeedback-Filtered-Instruction](https://huggingface.co/datasets/m-a-p/CodeFeedback-Filtered-Instruction) Dataset.
+
+🚀[2024-02-23]: We have open-sourced the datasets used in our project named [Code-Feedback](https://huggingface.co/datasets/m-a-p/Code-Feedback).
+
+🔥[2024-02-19]: We have open-sourced all models in the OpenCodeInterpreter series! We welcome everyone to try out our models and look forward to your participation! 😆
+
+
+
+## Introduction
+OpenCodeInterpreter is a suite of open-source code generation systems aimed at bridging the gap between large language models and sophisticated proprietary systems like the GPT-4 Code Interpreter. It significantly enhances code generation capabilities by integrating execution and iterative refinement functionalities.
+
+## Models
+All models within the OpenCodeInterpreter series have been open-sourced on Hugging Face. You can access our models via the following link: [OpenCodeInterpreter Models](https://huggingface.co/collections/m-a-p/opencodeinterpreter-65d312f6f88da990a64da456).
+
+## Data Collection
+Supported by Code-Feedback, a dataset featuring 68K multi-turn interactions, OpenCodeInterpreter incorporates execution and human feedback for dynamic code refinement. 
+For additional insights into data collection procedures, please consult the readme provided under [Data Collection](https://github.com/OpenCodeInterpreter/OpenCodeInterpreter/blob/main/data_collection/README.md).
+
+## Evaluation
+Our evaluation framework primarily utilizes HumanEval and MBPP, alongside their extended versions, HumanEval+ and MBPP+, leveraging the [EvalPlus framework](https://github.com/evalplus/evalplus) for a more comprehensive assessment.
+For specific evaluation methodologies, please refer to the [Evaluation README](https://github.com/OpenCodeInterpreter/OpenCodeInterpreter/blob/main/evaluation/README.md) for more details.
+
+## Demo
+We're excited to present our open-source demo, enabling users to effortlessly generate and execute code with our LLM locally. Within the demo, users can leverage the power of LLM to generate code and execute it locally, receiving automated execution feedback. LLM dynamically adjusts the code based on this feedback, ensuring a smoother coding experience. Additionally, users can engage in chat-based interactions with the LLM model, providing feedback to further enhance the generated code.
+
+To begin exploring the demo and experiencing the capabilities firsthand, please refer to the instructions outlined in the [OpenCodeInterpreter Demo README](https://github.com/OpenCodeInterpreter/OpenCodeInterpreter/blob/main/demo/README.md) file. Happy coding!
+
+### Quick Start
+- **Entering the workspace**:
+   ```bash
+   git clone https://github.com/OpenCodeInterpreter/OpenCodeInterpreter.git
+   cd demo
+   ```
+- **Create a new conda environment**: `conda create -n demo python=3.10`
+
+- **Activate the demo environment you create**: `conda activate demo`
+
+- **Install requirements**: `pip install -r requirements.txt`
+
+- **Create a Huggingface access token with write permission [here](https://huggingface.co/docs/hub/en/security-tokens). Our code will only use this token to create and push content to a specific repository called `opencodeinterpreter_user_data` under your own Huggingface account. We cannot get access to your data if you deploy this demo on your own device.**
+
+- **Add the access token to environment variables:** `export HF_TOKEN="your huggingface access token"`
+
+- **Run the Gradio App**:
+   ```bash
+   python3 chatbot.py --path "the model name of opencodeinterpreter model family. e.g., m-a-p/OpenCodeInterpreter-DS-6.7B"
+   ```
+### Video
+https://github.com/OpenCodeInterpreter/OpenCodeInterpreter/assets/46103100/2337f34d-f5ed-4ecb-857b-3c2d085b72fd
+
+
+## Contact
+
+If you have any inquiries, please feel free to raise an issue or reach out to us via email at: xiangyue.work@gmail.com, zhengtianyu0428@gmail.com. 
+We're here to assist you!
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=OpenCodeInterpreter/OpenCodeInterpreter&type=Date)](https://star-history.com/#OpenCodeInterpreter/OpenCodeInterpreter&Date)

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/README.md

@@ -0,0 +1,143 @@
+**Read in other language: [中文](README_CN.md).**
+
+# Local-Code-Interpreter
+A local implementation of OpenAI's ChatGPT Code Interpreter (Advanced Data Analysis).
+
+## Introduction
+
+OpenAI's Code Interpreter (currently renamed as Advanced Data Analysis) for ChatGPT is a revolutionary feature that allows the execution of Python code within the AI model. However, it execute code within an online sandbox and has certain limitations. In this project, we present Local Code Interpreter – which enables code execution on your local device, offering enhanced flexibility, security, and convenience.
+![notebook_gif_demo](example_img/save_to_notebook_demo.gif)
+
+## Key Advantages
+
+- **Custom Environment**: Execute code in a customized environment of your choice, ensuring you have the right packages and settings.
+
+- **Seamless Experience**: Say goodbye to file size restrictions and internet issues while uploading. With Local Code Interpreter, you're in full control.
+
+- **GPT-3.5 Availability**: While official Code Interpreter is only available for GPT-4 model, the Local Code Interpreter offers the flexibility to switch between both GPT-3.5 and GPT-4 models.
+
+- **Enhanced Data Security**: Keep your data more secure by running code locally, minimizing data transfer over the internet.
+
+- **Jupyter Support**: You can save all the code and conversation history in a Jupyter notebook for future use.
+
+## Note
+Executing AI-generated code without human review on your own device is not safe. You are responsible for taking measures to protect the security of your device and data (such as using a virtural machine) before launching this program. All consequences caused by using this program shall be borne by youself.
+
+## Usage
+
+### Installation
+
+1. Clone this repository to your local device
+   ```shell
+   git clone https://github.com/MrGreyfun/Local-Code-Interpreter.git
+   cd Local-Code-Interpreter
+   ```
+
+2. Install the necessary dependencies. The program has been tested on Windows 10 and CentOS Linux 7.8, with Python 3.9.16. Required packages include:
+   ```text
+   Jupyter Notebook    6.5.4
+   gradio              3.39.0
+   openai              0.27.8
+   ansi2html           1.8.0
+   tiktoken            0.3.3
+   Pillow              9.4.0
+   ```
+   Other systems or package versions may also work. Please note that you should not update the `openai` package to the latest `1.x` version, as it has been rewritten and is not compatible with older versions.
+   You can use the following command to directly install the required packages:
+   ```shell
+   pip install -r requirements.txt
+   ```
+   For newcomers to Python, we offer a convenient command that installs additional packages commonly used for data processing and analysis:
+   ```shell
+   pip install -r requirements_full.txt
+   ```
+### Configuration
+
+1. Create a `config.json` file in the `src` directory, following the examples provided in the `config_example` directory.
+
+2. Configure your API key in the `config.json` file.
+
+Please Note:
+1. **Set the `model_name` Correctly**
+    This program relies on the function calling capability of the `0613` or newer versions of models:
+    - `gpt-3.5-turbo-0613` (and its 16K version)
+    - `gpt-3.5-turbo-1106`
+    - `gpt-4-0613` (and its 32K version)
+    - `gpt-4-1106-preview` 
+
+    Older versions of the models will not work. Note that `gpt-4-vision-preview` lacks support for function calling, therefore, it should not be set as `GPT-4` model. 
+
+    For Azure OpenAI service users:
+    - Set the `model_name` as your deployment name.
+    - Confirm that the deployed model corresponds to the `0613` or newer version.
+
+2. **API Version Settings**
+    If you're using Azure OpenAI service, set the `API_VERSION` to `2023-12-01-preview` in the `config.json` file. Note that API versions older than `2023-07-01-preview` do not support the necessary function calls for this program and `2023-12-01-preview` is recommended as older versions will be deprecated in the near future.
+
+3. **Vision Model Settings**
+    Despite the `gpt-4-vision-preview` currently does not support function calling, we have implemented vision input using a non-end-to-end approach. To enable vision input, set `gpt-4-vision-preview` as `GPT-4V` model and set `available` to `true`.  Conversely, setting `available` to `false` to disables vision input when unnecessary, which will remove vision-related system prompts and reduce your API costs.
+    ![vision_demo](example_img/vision_example.jpg)
+4. **Model Context Window Settings**
+    The `model_context_window` field records the context window for each model, which the program uses to slice conversations when they exceed the model's context window capacity. 
+    Azure OpenAI service users should manually insert context window information using the model's deployment name in the following format:
+    ```json
+    "<YOUR-DEPLOYMENT-NAME>": <contex_window (integer)>
+    ```
+   
+    Additionally, when OpenAI introduce new models, you can manually append the new model's context window information using the same format. (We will keep this file updated, but there might be delays)
+
+5. **Alternate API Key Handling**
+    If you prefer not to store your API key in the `config.json` file, you can opt for an alternate approach:
+    - Leave the `API_KEY` field in `config.json` as an empty string:
+        ```json
+        "API_KEY": ""
+        ```
+    - Set the environment variable `OPENAI_API_KEY` with your API key before running the program:
+        - On Windows:
+        ```shell
+        set OPENAI_API_KEY=<YOUR-API-KEY>
+        ```
+        - On Linux:
+        ```shell
+        export OPENAI_API_KEY=<YOUR-API-KEY>
+        ```
+
+## Getting Started
+
+1. Navigate to the `src` directory.
+   ```shell
+   cd src
+   ```
+
+2. Run the command:
+   ```shell
+   python web_ui.py
+   ```
+
+3. Access the generated link in your browser to start using the Local Code Interpreter.
+
+4. Use the `-n` or `--notebook` option to save the conversation in a Jupyter notebook.
+   By default, the notebook is saved in the working directory, but you can add a path to save it elsewhere.
+   ```shell
+   python web_ui.py -n <path_to_notebook>
+   ```
+
+## Example
+
+Imagine uploading a data file and requesting the model to perform linear regression and visualize the data. See how Local Code Interpreter provides a seamless experience:
+
+1. Upload the data and request linear regression:
+   ![Example 1](example_img/1.jpg)
+
+2. Encounter an error in the generated code:
+   ![Example 2](example_img/2.jpg)
+
+3. ChatGPT automatically checks the data structure and fixes the bug:
+   ![Example 3](example_img/3.jpg)
+
+4. The corrected code runs successfully:
+   ![Example 4](example_img/4.jpg)
+
+5. The final result meets your requirements:
+   ![Example 5](example_img/5.jpg)
+   ![Example 6](example_img/6.jpg)

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/README_CN.md

@@ -0,0 +1,140 @@
+**Read in other language: [English](README.md)**
+
+# 本地代码解释器
+OpenAI的ChatGPT代码解释器（Code Interpreter或Advanced Data Analysis）的本地版。
+
+## 简介
+
+OpenAI的ChatGPT代码解释器（Code Interpreter，现更名为Advanced Data Analysis）是一款强大的AI工具。然而，其在在线沙箱环境中运行代码的特性导致了一些限制，如包的缺失、上传速度较慢、仅支持上传不超过100MB的文件以及代码最多只能运行120秒等。为此，我们推出了本地代码解释器（Local Code Interpreter）。这款工具允许您在自己的设备上，利用自己专属的Python环境来执行ChatGPT生成的代码，从而解除了原有解释器的各种限制。
+![notebook_gif_demo](example_img/save_to_notebook_demo.gif)
+
+## 优势
+
+- **自定义环境**：在您本地环境中运行代码，确保各种依赖都已正确安装。
+
+- **无缝体验**：告别100MB文件大小限制和网速问题。使用本地版代码解释器，一切尽在掌控之中。
+
+- **可用GPT-3.5**：官方代码解释器只能在GPT-4中使用，但现在您甚至可以在一轮对话中自由切换GPT-3.5和GPT-4。
+
+- **数据更安全**：代码在本地运行，无需将文件上传至网络，提高了数据的安全性。
+
+- **支持Jupyter**：本程序可将代码和对话历史保存至Jupyter notebook文件中供以后使用。
+
+## 注意事项
+在您自己的设备上执行AI生成但未经人工审核的代码可能存在安全风险。在运行此程序前，您应当采用一些安全措施，例如使用虚拟机，以保护您的设备和数据。使用此程序所产生的所有后果，您需自行承担。
+
+## 使用方法
+
+### 安装
+
+1. 克隆本仓库
+   ```shell
+   git clone https://github.com/MrGreyfun/Local-Code-Interpreter.git
+   cd Local-Code-Interpreter
+   ```
+
+2. 安装依赖。该程序已在Windows 10和CentOS Linux 7.8上使用Python 3.9.16测试。所需的库及版本：
+   ```text 
+   Jupyter Notebook    6.5.4
+   gradio              3.39.0
+   openai              0.27.8
+   ansi2html           1.8.0 
+   ```
+   其他系统或库版本也可能有效。请注意，不要将`openai`包升级至最新的`1.x`版本，该版本已重写，与旧版本不兼容。
+   您可以使用以下命令直接安装所需的软件包：
+   ```shell
+   pip install -r requirements.txt
+   ```
+   如果您不熟悉Python，可以使用以下命令安装，它将额外安装常用的Python数据分析库：
+   ```shell
+   pip install -r requirements_full.txt
+   ```
+### 配置
+
+1. 在`src`目录中创建一个`config.json`文件，参照`config_example`目录中提供的示例进行配置。
+
+2. 在`config.json`文件中配置您的API密钥。
+
+请注意：
+1. **正确设置`model_name`**
+    该程序依赖于`0163`及以上版本的模型的函数调用能力，这些模型包括：
+    - `gpt-3.5-turbo-0613` (及其16K版本)
+    - `gpt-3.5-turbo-1106`
+    - `gpt-4-0613` (及其32K版本)
+    - `gpt-4-1106-preview` 
+
+   旧版本的模型将无法使用。请注意，`gpt-4-vision-preview`模型同样不支持函数调用，因此不能将其设置为`GPT-4`模型。
+
+   对于使用Azure OpenAI的用户：
+   - 请将`model_name`设置为您的模型的部署名（deployment name）。
+   - 确认部署的模型是`0613`及以上版本。
+
+2. **API版本设置**
+    如果您使用Azure OpenAI服务，请在`config.json`文件中将`API_VERSION`设置为`2023-07-01-preview`，其他API版本不支持函数调用。
+
+3. **视觉模型设置**
+   尽管`gpt-4-vision-preview`模型不支持函数调用，我们仍然通过另一种非端到端的方式实现了图像输入。如果想使用图像输入，请将`gpt-4-vision-preview`设置为`GPT-4V`模型，并设置`available`字段设置为`true`。当不需要使用图像输入时候，可以将`available`字段设置为`false`，这将移除图像相关的系统提示，从而减少您的API费用。
+   ![vision_demo](example_img/vision_example.jpg)
+4. **模型上下文窗口长度设置**
+    `model_context_window` 字段记录了每个模型的上下文窗口长度信息。当对话长度超过模型上下文窗口长度限制时，本程序会使用该信息来压缩对话长度。
+    Azure OpenAI的用户需要按照以下格式，使用模型的部署名手动添加上下文窗口长度信息：
+    ```json
+    "<模型部署名>": <上下文窗口长度 (整数)>
+    ```
+    此外，当OpenAI推出新模型的时候，您可以按照相同的格式手动添加新模型的上下文窗口长度信息。（我们会持续更新该文件，但是不一定及时）
+
+5. **使用环境变量配置密钥**
+    如果您不希望将API密钥存储在`config.json`文件中，可以选择通过环境变量来设置密钥：
+    - 将`config.json`文件中的`API_KEY`设为空字符串：
+        ```json
+        "API_KEY": ""
+        ```
+    - 在运行程序之前，使用您的API密钥设置环境变量`OPENAI_API_KEY`：
+        - Windows：
+        ```shell
+        set OPENAI_API_KEY=<你的API密钥>
+        ```
+        - Linux：
+        ```shell
+        export OPENAI_API_KEY=<你的API密钥>
+        ```
+
+## 使用
+
+1. 进入`src`目录。
+   ```shell
+   cd src
+   ```
+
+2. 运行以下命令：
+   ```shell
+   python web_ui.py
+   ```
+
+3. 在浏览器中访问终端生成的链接，开始使用本地版代码解释器。
+
+4. 添加`-n`或`--notebook`参数可以将对话保存到Jupyter notebook中。 
+   默认情况下，该Jupyter notebook文件保存在工作目录中，您可以添加路径以将其保存到其它位置。
+   ```shell
+   python web_ui.py-n<path_to_notebook>
+   ```
+
+## 示例
+
+以下是一个使用本程序进行线性回归任务的示例：
+
+1. 上传数据文件并要求模型对数据进行线性回归：
+   ![Example 1](example_img/1.jpg)
+
+2. 生成的代码执行中遇到错误：
+   ![Example 2](example_img/2.jpg)
+
+3. ChatGPT自动检查数据格式并修复bug：
+   ![Example 3](example_img/3.jpg)
+
+4. 修复bug后的代码成功运行：
+   ![Example 4](example_img/4.jpg)
+
+5. 最终结果符合要求：
+   ![Example 5](example_img/5.jpg)
+   ![Example 6](example_img/6.jpg)

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/config_example/config.azure.example.json

@@ -0,0 +1,24 @@
+{
+  "API_TYPE": "azure",
+  "API_base": "<YOUR-API-ENDPOINT>",
+  "API_VERSION": "2023-12-01-preview",
+  "API_KEY": "<YOUR-API-KEY>",
+  "model": {
+    "GPT-3.5": {
+      "model_name": "<YOUR-DEPLOYMENT-NAME>",
+      "available": true
+    },
+    "GPT-4": {
+      "model_name": "<YOUR-DEPLOYMENT-NAME>",
+      "available": true
+    },
+    "GPT-4V": {
+      "model_name": "<YOUR-DEPLOYMENT-NAME>",
+      "available": true
+    }
+  },
+  "model_context_window": {
+    "<YOUR-DEPLOYMENT-NAME1>": <contex_window (integer)>,
+    "<YOUR-DEPLOYMENT-NAME2>": <contex_window (integer)>
+  }
+}

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/config_example/config.example.json

@@ -0,0 +1,32 @@
+{
+  "API_TYPE": "open_ai",
+  "API_base": "https://api.openai.com/v1",
+  "API_VERSION": null,
+  "API_KEY": "<YOUR-API-KEY>",
+  "model": {
+    "GPT-3.5": {
+      "model_name": "gpt-3.5-turbo-0613",
+      "available": true
+    },
+    "GPT-4": {
+      "model_name": "gpt-4-0613",
+      "available": true
+    },
+    "GPT-4V": {
+      "model_name": "gpt-4-vision-preview",
+      "available": true
+    }
+  },
+  "model_context_window": {
+    "gpt-3.5-turbo": 4096,
+    "gpt-3.5-turbo-16k": 16385,
+    "gpt-3.5-turbo-0613": 4096,
+    "gpt-3.5-turbo-1106": 16385,
+    "gpt-4": 8192,
+    "gpt-4-32k": 32768,
+    "gpt-4-0613": 8192,
+    "gpt-4-32k-0613": 32768,
+    "gpt-4-1106-preview": 128000,
+    "gpt-4-vision-preview": 128000
+  }
+}

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/requirements.txt

@@ -0,0 +1,6 @@
+notebook==6.5.4
+openai==0.27.8
+gradio==3.39.0
+ansi2html==1.8.0
+tiktoken
+Pillow

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/requirements_full.txt

@@ -0,0 +1,18 @@
+notebook==6.5.4
+openai==0.27.8
+gradio==3.39.0
+ansi2html==1.8.0
+tiktoken
+Pillow
+numpy
+scipy
+openpyxl
+xlrd
+xlwt
+matplotlib
+pandas
+opencv-python
+PyPDF2
+pdfminer.six
+sympy
+scikit-learn

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/src/bot_backend.py

@@ -0,0 +1,324 @@
+import json
+import copy
+import shutil
+from jupyter_backend import *
+from tools import *
+from typing import *
+from notebook_serializer import add_markdown_to_notebook, add_code_cell_to_notebook
+
+functions = [
+    {
+        "name": "execute_code",
+        "description": "This function allows you to execute Python code and retrieve the terminal output. If the code "
+                       "generates image output, the function will return the text '[image]'. The code is sent to a "
+                       "Jupyter kernel for execution. The kernel will remain active after execution, retaining all "
+                       "variables in memory.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "code": {
+                    "type": "string",
+                    "description": "The code text"
+                }
+            },
+            "required": ["code"],
+        }
+    },
+]
+
+system_msg = '''You are an AI code interpreter.
+Your goal is to help users do a variety of jobs by executing Python code.
+
+You should:
+1. Comprehend the user's requirements carefully & to the letter.
+2. Give a brief description for what you plan to do & call the provided function to run code.
+3. Provide results analysis based on the execution output.
+4. If error occurred, try to fix it.
+5. Response in the same language as the user.
+
+Note: If the user uploads a file, you will receive a system message "User uploaded a file: filename". Use the filename as the path in the code. '''
+
+with open('config.json') as f:
+    config = json.load(f)
+
+if not config['API_KEY']:
+    config['API_KEY'] = os.getenv('OPENAI_API_KEY')
+    os.unsetenv('OPENAI_API_KEY')
+
+
+def get_config():
+    return config
+
+
+def config_openai_api(api_type, api_base, api_version, api_key):
+    openai.api_type = api_type
+    openai.api_base = api_base
+    openai.api_version = api_version
+    openai.api_key = api_key
+
+
+class GPTResponseLog:
+    def __init__(self):
+        self.assistant_role_name = ''
+        self.content = ''
+        self.function_name = None
+        self.function_args_str = ''
+        self.code_str = ''
+        self.display_code_block = ''
+        self.finish_reason = 'stop'
+        self.bot_history = None
+        self.stop_generating = False
+        self.code_executing = False
+        self.interrupt_signal_sent = False
+
+    def reset_gpt_response_log_values(self, exclude=None):
+        if exclude is None:
+            exclude = []
+
+        attributes = {'assistant_role_name': '',
+                      'content': '',
+                      'function_name': None,
+                      'function_args_str': '',
+                      'code_str': '',
+                      'display_code_block': '',
+                      'finish_reason': 'stop',
+                      'bot_history': None,
+                      'stop_generating': False,
+                      'code_executing': False,
+                      'interrupt_signal_sent': False}
+
+        for attr_name in exclude:
+            del attributes[attr_name]
+        for attr_name, value in attributes.items():
+            setattr(self, attr_name, value)
+
+    def set_assistant_role_name(self, assistant_role_name: str):
+        self.assistant_role_name = assistant_role_name
+
+    def add_content(self, content: str):
+        self.content += content
+
+    def set_function_name(self, function_name: str):
+        self.function_name = function_name
+
+    def copy_current_bot_history(self, bot_history: List):
+        self.bot_history = copy.deepcopy(bot_history)
+
+    def add_function_args_str(self, function_args_str: str):
+        self.function_args_str += function_args_str
+
+    def update_code_str(self, code_str: str):
+        self.code_str = code_str
+
+    def update_display_code_block(self, display_code_block):
+        self.display_code_block = display_code_block
+
+    def update_finish_reason(self, finish_reason: str):
+        self.finish_reason = finish_reason
+
+    def update_stop_generating_state(self, stop_generating: bool):
+        self.stop_generating = stop_generating
+
+    def update_code_executing_state(self, code_executing: bool):
+        self.code_executing = code_executing
+
+    def update_interrupt_signal_sent(self, interrupt_signal_sent: bool):
+        self.interrupt_signal_sent = interrupt_signal_sent
+
+
+class BotBackend(GPTResponseLog):
+    def __init__(self):
+        super().__init__()
+        self.unique_id = hash(id(self))
+        self.jupyter_work_dir = f'cache/work_dir_{self.unique_id}'
+        self.tool_log = f'cache/tool_{self.unique_id}.log'
+        self.jupyter_kernel = JupyterKernel(work_dir=self.jupyter_work_dir)
+        self.gpt_model_choice = "GPT-3.5"
+        self.revocable_files = []
+        self.system_msg = system_msg
+        self.functions = copy.deepcopy(functions)
+        self._init_api_config()
+        self._init_tools()
+        self._init_conversation()
+        self._init_kwargs_for_chat_completion()
+
+    def _init_conversation(self):
+        first_system_msg = {'role': 'system', 'content': self.system_msg}
+        self.context_window_tokens = 0  # num of tokens actually sent to GPT
+        self.sliced = False  # whether the conversion is sliced
+        if hasattr(self, 'conversation'):
+            self.conversation.clear()
+            self.conversation.append(first_system_msg)
+        else:
+            self.conversation: List[Dict] = [first_system_msg]
+
+    def _init_api_config(self):
+        self.config = get_config()
+        api_type = self.config['API_TYPE']
+        api_base = self.config['API_base']
+        api_version = self.config['API_VERSION']
+        api_key = config['API_KEY']
+        config_openai_api(api_type, api_base, api_version, api_key)
+
+    def _init_tools(self):
+        self.additional_tools = {}
+
+        tool_datas = get_available_tools(self.config)
+        if tool_datas:
+            self.system_msg += '\n\nAdditional tools:'
+
+        for tool_data in tool_datas:
+            system_prompt = tool_data['system_prompt']
+            tool_name = tool_data['tool_name']
+            tool_description = tool_data['tool_description']
+
+            self.system_msg += f'\n{tool_name}: {system_prompt}'
+
+            self.functions.append(tool_description)
+            self.additional_tools[tool_name] = {
+                'tool': tool_data['tool'],
+                'additional_parameters': copy.deepcopy(tool_data['additional_parameters'])
+            }
+            for parameter, value in self.additional_tools[tool_name]['additional_parameters'].items():
+                if callable(value):
+                    self.additional_tools[tool_name]['additional_parameters'][parameter] = value(self)
+
+    def _init_kwargs_for_chat_completion(self):
+        self.kwargs_for_chat_completion = {
+            'stream': True,
+            'messages': self.conversation,
+            'functions': self.functions,
+            'function_call': 'auto'
+        }
+
+        model_name = self.config['model'][self.gpt_model_choice]['model_name']
+
+        if self.config['API_TYPE'] == 'azure':
+            self.kwargs_for_chat_completion['engine'] = model_name
+        else:
+            self.kwargs_for_chat_completion['model'] = model_name
+
+    def _backup_all_files_in_work_dir(self):
+        count = 1
+        backup_dir = f'cache/backup_{self.unique_id}'
+        while os.path.exists(backup_dir):
+            count += 1
+            backup_dir = f'cache/backup_{self.unique_id}_{count}'
+        shutil.copytree(src=self.jupyter_work_dir, dst=backup_dir)
+
+    def _clear_all_files_in_work_dir(self, backup=True):
+        if backup:
+            self._backup_all_files_in_work_dir()
+        for filename in os.listdir(self.jupyter_work_dir):
+            path = os.path.join(self.jupyter_work_dir, filename)
+            if os.path.isdir(path):
+                shutil.rmtree(path)
+            else:
+                os.remove(path)
+
+    def _save_tool_log(self, tool_response):
+        with open(self.tool_log, 'a', encoding='utf-8') as log_file:
+            log_file.write(f'Previous conversion: {self.conversation}\n')
+            log_file.write(f'Model choice: {self.gpt_model_choice}\n')
+            log_file.write(f'Tool name: {self.function_name}\n')
+            log_file.write(f'Parameters: {self.function_args_str}\n')
+            log_file.write(f'Response: {tool_response}\n')
+            log_file.write('----------\n\n')
+
+    def add_gpt_response_content_message(self):
+        self.conversation.append(
+            {'role': self.assistant_role_name, 'content': self.content}
+        )
+        add_markdown_to_notebook(self.content, title="Assistant")
+
+    def add_text_message(self, user_text):
+        self.conversation.append(
+            {'role': 'user', 'content': user_text}
+        )
+        self.revocable_files.clear()
+        self.update_finish_reason(finish_reason='new_input')
+        add_markdown_to_notebook(user_text, title="User")
+
+    def add_file_message(self, path, bot_msg):
+        filename = os.path.basename(path)
+        work_dir = self.jupyter_work_dir
+
+        shutil.copy(path, work_dir)
+
+        gpt_msg = {'role': 'system', 'content': f'User uploaded a file: {filename}'}
+        self.conversation.append(gpt_msg)
+        self.revocable_files.append(
+            {
+                'bot_msg': bot_msg,
+                'gpt_msg': gpt_msg,
+                'path': os.path.join(work_dir, filename)
+            }
+        )
+
+    def add_function_call_response_message(self, function_response: Union[str, None], save_tokens=True):
+        if self.code_str is not None:
+            add_code_cell_to_notebook(self.code_str)
+
+        self.conversation.append(
+            {
+                "role": self.assistant_role_name,
+                "name": self.function_name,
+                "content": self.function_args_str
+            }
+        )
+        if function_response is not None:
+            if save_tokens and len(function_response) > 500:
+                function_response = f'{function_response[:200]}\n[Output too much, the middle part output is omitted]\n ' \
+                                    f'End part of output:\n{function_response[-200:]}'
+            self.conversation.append(
+                {
+                    "role": "function",
+                    "name": self.function_name,
+                    "content": function_response,
+                }
+            )
+        self._save_tool_log(tool_response=function_response)
+
+    def append_system_msg(self, prompt):
+        self.conversation.append(
+            {'role': 'system', 'content': prompt}
+        )
+
+    def revoke_file(self):
+        if self.revocable_files:
+            file = self.revocable_files[-1]
+            bot_msg = file['bot_msg']
+            gpt_msg = file['gpt_msg']
+            path = file['path']
+
+            assert self.conversation[-1] is gpt_msg
+            del self.conversation[-1]
+
+            os.remove(path)
+
+            del self.revocable_files[-1]
+
+            return bot_msg
+        else:
+            return None
+
+    def update_gpt_model_choice(self, model_choice):
+        self.gpt_model_choice = model_choice
+        self._init_kwargs_for_chat_completion()
+
+    def update_token_count(self, num_tokens):
+        self.__setattr__('context_window_tokens', num_tokens)
+
+    def update_sliced_state(self, sliced):
+        self.__setattr__('sliced', sliced)
+
+    def send_interrupt_signal(self):
+        self.jupyter_kernel.send_interrupt_signal()
+        self.update_interrupt_signal_sent(interrupt_signal_sent=True)
+
+    def restart(self):
+        self.revocable_files.clear()
+        self._init_conversation()
+        self.reset_gpt_response_log_values()
+        self.jupyter_kernel.restart_jupyter_kernel()
+        self._clear_all_files_in_work_dir()

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/src/cli.py

@@ -0,0 +1,108 @@
+from response_parser import *
+import copy
+import json
+from tqdm import tqdm
+import logging
+import argparse
+import os
+
+def initialization(state_dict: Dict) -> None:
+    if not os.path.exists('cache'):
+        os.mkdir('cache')
+    if state_dict["bot_backend"] is None:
+        state_dict["bot_backend"] = BotBackend()
+        if 'OPENAI_API_KEY' in os.environ:
+            del os.environ['OPENAI_API_KEY']
+
+def get_bot_backend(state_dict: Dict) -> BotBackend:
+    return state_dict["bot_backend"]
+
+def switch_to_gpt4(state_dict: Dict, whether_switch: bool) -> None:
+    bot_backend = get_bot_backend(state_dict)
+    if whether_switch:
+        bot_backend.update_gpt_model_choice("GPT-4")
+    else:
+        bot_backend.update_gpt_model_choice("GPT-3.5")
+
+def add_text(state_dict, history, text):
+    bot_backend = get_bot_backend(state_dict)
+    bot_backend.add_text_message(user_text=text)
+    history = history + [[text, None]]
+    return history, state_dict
+
+def bot(state_dict, history):
+    bot_backend = get_bot_backend(state_dict)
+    while bot_backend.finish_reason in ('new_input', 'function_call'):
+        if history[-1][1]:
+            history.append([None, ""])
+        else:
+            history[-1][1] = ""
+        logging.info("Start chat completion")
+        response = chat_completion(bot_backend=bot_backend)
+        logging.info(f"End chat completion, response: {response}")
+
+        logging.info("Start parse response")
+        history, _ = parse_response(
+            chunk=response,
+            history=history,
+            bot_backend=bot_backend
+        )
+        logging.info("End parse response")
+    return history
+
+def main(state, history, user_input):
+    history, state = add_text(state, history, user_input)
+    last_history = copy.deepcopy(history)
+    first_turn_flag = False
+    while True:
+        if first_turn_flag:
+            switch_to_gpt4(state, False)
+            first_turn_flag = False
+        else:
+            switch_to_gpt4(state, True)
+        logging.info("Start bot")
+        history = bot(state, history)
+        logging.info("End bot")
+        print(state["bot_backend"].conversation)
+        if last_history == copy.deepcopy(history):
+            logging.info("No new response, end conversation")
+            conversation = [item for item in state["bot_backend"].conversation if item["content"]]
+            return conversation
+        else:
+            logging.info("New response, continue conversation")
+            last_history = copy.deepcopy(history)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input_path', type=str)
+    parser.add_argument('--output_path', type=str)
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO)
+    logging.info("Initialization")
+
+    state = {"bot_backend": None}
+    history = []
+
+    initialization(state)
+    switch_to_gpt4(state_dict=state, whether_switch=True)
+
+    logging.info("Start")
+    with open(args.input_path, "r") as f:
+        instructions = [json.loads(line)["query"] for line in f.readlines()]
+    all_history = []
+    logging.info(f"{len(instructions)} remaining instructions for {args.input_path}")
+
+    for user_input_index, user_input in enumerate(tqdm(instructions)):
+        logging.info(f"Start conversation {user_input_index}")
+        conversation = main(state, history, user_input)
+        all_history.append(
+            {
+                "instruction": user_input,
+                "conversation": conversation
+            }
+        )
+        with open(f"{args.output_path}", "w") as f:
+            json.dump(all_history, f, indent=4, ensure_ascii=False)
+        state["bot_backend"].restart()
+        

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/src/functional.py

@@ -0,0 +1,197 @@
+from bot_backend import *
+import base64
+import time
+import tiktoken
+from notebook_serializer import add_code_cell_error_to_notebook, add_image_to_notebook, add_code_cell_output_to_notebook
+
+SLICED_CONV_MESSAGE = "[Rest of the conversation has been omitted to fit in the context window]"
+
+
+def get_conversation_slice(conversation, model, encoding_for_which_model, min_output_tokens_count=500):
+    """
+    Function to get a slice of the conversation that fits in the model's context window. returns: The conversation
+    with the first message(explaining the role of the assistant) + the last x messages that can fit in the context
+    window.
+    """
+    encoder = tiktoken.encoding_for_model(encoding_for_which_model)
+    count_tokens = lambda txt: len(encoder.encode(txt))
+    nb_tokens = count_tokens(conversation[0]['content'])
+    sliced_conv = [conversation[0]]
+    context_window_limit = int(config['model_context_window'][model])
+    max_tokens = context_window_limit - count_tokens(SLICED_CONV_MESSAGE) - min_output_tokens_count
+    sliced = False
+    for message in conversation[-1:0:-1]:
+        nb_tokens += count_tokens(message['content'])
+        if nb_tokens > max_tokens:
+            sliced_conv.insert(1, {'role': 'system', 'content': SLICED_CONV_MESSAGE})
+            sliced = True
+            break
+        sliced_conv.insert(1, message)
+    return sliced_conv, nb_tokens, sliced
+
+
+def chat_completion(bot_backend: BotBackend):
+    model_choice = bot_backend.gpt_model_choice
+    model_name = bot_backend.config['model'][model_choice]['model_name']
+    kwargs_for_chat_completion = copy.deepcopy(bot_backend.kwargs_for_chat_completion)
+    if bot_backend.config['API_TYPE'] == "azure":
+        kwargs_for_chat_completion['messages'], nb_tokens, sliced = \
+            get_conversation_slice(
+                conversation=kwargs_for_chat_completion['messages'],
+                model=model_name,
+                encoding_for_which_model='gpt-3.5-turbo' if model_choice == 'GPT-3.5' else 'gpt-4'
+            )
+    else:
+        kwargs_for_chat_completion['messages'], nb_tokens, sliced = \
+            get_conversation_slice(
+                conversation=kwargs_for_chat_completion['messages'],
+                model=model_name,
+                encoding_for_which_model=model_name
+            )
+
+    bot_backend.update_token_count(num_tokens=nb_tokens)
+    bot_backend.update_sliced_state(sliced=sliced)
+
+    assert config['model'][model_choice]['available'], f"{model_choice} is not available for your API key"
+
+    assert model_name in config['model_context_window'], \
+        f"{model_name} lacks context window information. Please check the config.json file."
+
+    response = openai.ChatCompletion.create(**kwargs_for_chat_completion)
+    return response
+
+
+def add_code_execution_result_to_bot_history(content_to_display, history, unique_id):
+    images, text = [], []
+
+    # terminal output
+    error_occurred = False
+
+    for mark, out_str in content_to_display:
+        if mark in ('stdout', 'execute_result_text', 'display_text'):
+            text.append(out_str)
+            add_code_cell_output_to_notebook(out_str)
+        elif mark in ('execute_result_png', 'execute_result_jpeg', 'display_png', 'display_jpeg'):
+            if 'png' in mark:
+                images.append(('png', out_str))
+                add_image_to_notebook(out_str, 'image/png')
+            else:
+                add_image_to_notebook(out_str, 'image/jpeg')
+                images.append(('jpg', out_str))
+        elif mark == 'error':
+            # Set output type to error
+            text.append(delete_color_control_char(out_str))
+            error_occurred = True
+            add_code_cell_error_to_notebook(out_str)
+    text = '\n'.join(text).strip('\n')
+    if error_occurred:
+        history.append([None, f'❌Terminal output:\n```shell\n\n{text}\n```'])
+    else:
+        history.append([None, f'✔️Terminal output:\n```shell\n{text}\n```'])
+
+    # image output
+    for filetype, img in images:
+        image_bytes = base64.b64decode(img)
+        temp_path = f'cache/temp_{unique_id}'
+        if not os.path.exists(temp_path):
+            os.mkdir(temp_path)
+        path = f'{temp_path}/{hash(time.time())}.{filetype}'
+        with open(path, 'wb') as f:
+            f.write(image_bytes)
+        width, height = get_image_size(path)
+        history.append(
+            [
+                None,
+                f'<img src=\"file={path}\" style=\'{"" if width < 800 else "width: 800px;"} max-width:none; '
+                f'max-height:none\'> '
+            ]
+        )
+
+
+def add_function_response_to_bot_history(hypertext_to_display, history):
+    if hypertext_to_display is not None:
+        if history[-1][1]:
+            history.append([None, hypertext_to_display])
+        else:
+            history[-1][1] = hypertext_to_display
+
+
+def parse_json(function_args: str, finished: bool):
+    """
+    GPT may generate non-standard JSON format string, which contains '\n' in string value, leading to error when using
+    `json.loads()`.
+    Here we implement a parser to extract code directly from non-standard JSON string.
+    :return: code string if successfully parsed otherwise None
+    """
+    parser_log = {
+        'met_begin_{': False,
+        'begin_"code"': False,
+        'end_"code"': False,
+        'met_:': False,
+        'met_end_}': False,
+        'met_end_code_"': False,
+        "code_begin_index": 0,
+        "code_end_index": 0
+    }
+    try:
+        for index, char in enumerate(function_args):
+            if char == '{':
+                parser_log['met_begin_{'] = True
+            elif parser_log['met_begin_{'] and char == '"':
+                if parser_log['met_:']:
+                    if finished:
+                        parser_log['code_begin_index'] = index + 1
+                        break
+                    else:
+                        if index + 1 == len(function_args):
+                            return None
+                        else:
+                            temp_code_str = function_args[index + 1:]
+                            if '\n' in temp_code_str:
+                                try:
+                                    return json.loads(function_args + '"}')['code']
+                                except json.JSONDecodeError:
+                                    try:
+                                        return json.loads(function_args + '}')['code']
+                                    except json.JSONDecodeError:
+                                        try:
+                                            return json.loads(function_args)['code']
+                                        except json.JSONDecodeError:
+                                            if temp_code_str[-1] in ('"', '\n'):
+                                                return None
+                                            else:
+                                                return temp_code_str.strip('\n')
+                            else:
+                                return json.loads(function_args + '"}')['code']
+                elif parser_log['begin_"code"']:
+                    parser_log['end_"code"'] = True
+                else:
+                    parser_log['begin_"code"'] = True
+            elif parser_log['end_"code"'] and char == ':':
+                parser_log['met_:'] = True
+            else:
+                continue
+        if finished:
+            for index, char in enumerate(function_args[::-1]):
+                back_index = -1 - index
+                if char == '}':
+                    parser_log['met_end_}'] = True
+                elif parser_log['met_end_}'] and char == '"':
+                    parser_log['code_end_index'] = back_index - 1
+                    break
+                else:
+                    continue
+            code_str = function_args[parser_log['code_begin_index']: parser_log['code_end_index'] + 1]
+            if '\n' in code_str:
+                return code_str.strip('\n')
+            else:
+                return json.loads(function_args)['code']
+
+    except Exception as e:
+        return None
+
+
+def get_image_size(image_path):
+    with Image.open(image_path) as img:
+        width, height = img.size
+    return width, height

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/src/jupyter_backend.py

@@ -0,0 +1,108 @@
+import jupyter_client
+import re
+
+
+def delete_color_control_char(string):
+    ansi_escape = re.compile(r'(\x9B|\x1B\[)[0-?]*[ -\/]*[@-~]')
+    return ansi_escape.sub('', string)
+
+
+class JupyterKernel:
+    def __init__(self, work_dir):
+        self.kernel_manager, self.kernel_client = jupyter_client.manager.start_new_kernel(kernel_name='python3')
+        self.work_dir = work_dir
+        self.interrupt_signal = False
+        self._create_work_dir()
+        self.available_functions = {
+            'execute_code': self.execute_code,
+            'python': self.execute_code
+        }
+
+    def execute_code_(self, code):
+        msg_id = self.kernel_client.execute(code)
+
+        # Get the output of the code
+        msg_list = []
+        while True:
+            try:
+                iopub_msg = self.kernel_client.get_iopub_msg(timeout=1)
+                msg_list.append(iopub_msg)
+                if iopub_msg['msg_type'] == 'status' and iopub_msg['content'].get('execution_state') == 'idle':
+                    break
+            except:
+                if self.interrupt_signal:
+                    self.kernel_manager.interrupt_kernel()
+                    self.interrupt_signal = False
+                continue
+
+        all_output = []
+        for iopub_msg in msg_list:
+            if iopub_msg['msg_type'] == 'stream':
+                if iopub_msg['content'].get('name') == 'stdout':
+                    output = iopub_msg['content']['text']
+                    all_output.append(('stdout', output))
+            elif iopub_msg['msg_type'] == 'execute_result':
+                if 'data' in iopub_msg['content']:
+                    if 'text/plain' in iopub_msg['content']['data']:
+                        output = iopub_msg['content']['data']['text/plain']
+                        all_output.append(('execute_result_text', output))
+                    if 'text/html' in iopub_msg['content']['data']:
+                        output = iopub_msg['content']['data']['text/html']
+                        all_output.append(('execute_result_html', output))
+                    if 'image/png' in iopub_msg['content']['data']:
+                        output = iopub_msg['content']['data']['image/png']
+                        all_output.append(('execute_result_png', output))
+                    if 'image/jpeg' in iopub_msg['content']['data']:
+                        output = iopub_msg['content']['data']['image/jpeg']
+                        all_output.append(('execute_result_jpeg', output))
+            elif iopub_msg['msg_type'] == 'display_data':
+                if 'data' in iopub_msg['content']:
+                    if 'text/plain' in iopub_msg['content']['data']:
+                        output = iopub_msg['content']['data']['text/plain']
+                        all_output.append(('display_text', output))
+                    if 'text/html' in iopub_msg['content']['data']:
+                        output = iopub_msg['content']['data']['text/html']
+                        all_output.append(('display_html', output))
+                    if 'image/png' in iopub_msg['content']['data']:
+                        output = iopub_msg['content']['data']['image/png']
+                        all_output.append(('display_png', output))
+                    if 'image/jpeg' in iopub_msg['content']['data']:
+                        output = iopub_msg['content']['data']['image/jpeg']
+                        all_output.append(('display_jpeg', output))
+            elif iopub_msg['msg_type'] == 'error':
+                if 'traceback' in iopub_msg['content']:
+                    output = '\n'.join(iopub_msg['content']['traceback'])
+                    all_output.append(('error', output))
+
+        return all_output
+
+    def execute_code(self, code):
+        text_to_gpt = []
+        content_to_display = self.execute_code_(code)
+        for mark, out_str in content_to_display:
+            if mark in ('stdout', 'execute_result_text', 'display_text'):
+                text_to_gpt.append(out_str)
+            elif mark in ('execute_result_png', 'execute_result_jpeg', 'display_png', 'display_jpeg'):
+                text_to_gpt.append('[image]')
+            elif mark == 'error':
+                text_to_gpt.append(delete_color_control_char(out_str))
+
+        return '\n'.join(text_to_gpt), content_to_display
+
+    def _create_work_dir(self):
+        # set work dir in jupyter environment
+        init_code = f"import os\n" \
+                    f"if not os.path.exists('{self.work_dir}'):\n" \
+                    f"    os.mkdir('{self.work_dir}')\n" \
+                    f"os.chdir('{self.work_dir}')\n" \
+                    f"del os"
+        self.execute_code_(init_code)
+
+    def send_interrupt_signal(self):
+        self.interrupt_signal = True
+
+    def restart_jupyter_kernel(self):
+        self.kernel_client.shutdown()
+        self.kernel_manager, self.kernel_client = jupyter_client.manager.start_new_kernel(kernel_name='python3')
+        self.interrupt_signal = False
+        self._create_work_dir()

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/src/notebook_serializer.py

@@ -0,0 +1,71 @@
+import nbformat
+from nbformat import v4 as nbf
+import ansi2html
+import os
+import argparse
+
+# main code
+parser = argparse.ArgumentParser()
+parser.add_argument("-n", "--notebook", help="Path to the output notebook", default=None, type=str)
+args = parser.parse_args()
+if args.notebook:
+    notebook_path = os.path.join(os.getcwd(), args.notebook)
+    base, ext = os.path.splitext(notebook_path)
+    if ext.lower() != '.ipynb':
+        notebook_path += '.ipynb'
+    if os.path.exists(notebook_path):
+        print(f'File at {notebook_path} already exists. Please choose a different file name.')
+        exit()
+
+# Global variable for code cells
+nb = nbf.new_notebook()
+
+
+def ansi_to_html(ansi_text):
+    converter = ansi2html.Ansi2HTMLConverter()
+    html_text = converter.convert(ansi_text)
+    return html_text
+
+
+def write_to_notebook():
+    if args.notebook:
+        with open(notebook_path, 'w', encoding='utf-8') as f:
+            nbformat.write(nb, f)
+
+
+def add_code_cell_to_notebook(code):
+    code_cell = nbf.new_code_cell(source=code)
+    nb['cells'].append(code_cell)
+    write_to_notebook()
+
+
+def add_code_cell_output_to_notebook(output):
+    html_content = ansi_to_html(output)
+    cell_output = nbf.new_output(output_type='display_data', data={'text/html': html_content})
+    nb['cells'][-1]['outputs'].append(cell_output)
+    write_to_notebook()
+
+
+def add_code_cell_error_to_notebook(error):
+    nbf_error_output = nbf.new_output(
+        output_type='error',
+        ename='Error',
+        evalue='Error message',
+        traceback=[error]
+    )
+    nb['cells'][-1]['outputs'].append(nbf_error_output)
+    write_to_notebook()
+
+
+def add_image_to_notebook(image, mime_type):
+    image_output = nbf.new_output(output_type='display_data', data={mime_type: image})
+    nb['cells'][-1]['outputs'].append(image_output)
+    write_to_notebook()
+
+
+def add_markdown_to_notebook(content, title=None):
+    if title:
+        content = "##### " + title + ":\n" + content
+    markdown_cell = nbf.new_markdown_cell(content)
+    nb['cells'].append(markdown_cell)
+    write_to_notebook()

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/src/response_parser.py

@@ -0,0 +1,259 @@
+from functional import *
+
+
+class ChoiceStrategy(metaclass=ABCMeta):
+    def __init__(self, choice):
+        self.choice = choice
+        self.delta = choice['delta']
+
+    @abstractmethod
+    def support(self):
+        pass
+
+    @abstractmethod
+    def execute(self, bot_backend: BotBackend, history: List, whether_exit: bool):
+        pass
+
+
+class RoleChoiceStrategy(ChoiceStrategy):
+
+    def support(self):
+        return 'role' in self.delta
+
+    def execute(self, bot_backend: BotBackend, history: List, whether_exit: bool):
+        bot_backend.set_assistant_role_name(assistant_role_name=self.delta['role'])
+        return history, whether_exit
+
+
+class ContentChoiceStrategy(ChoiceStrategy):
+    def support(self):
+        return 'content' in self.delta and self.delta['content'] is not None
+        # null value of content often occur in function call:
+        #     {
+        #       "role": "assistant",
+        #       "content": null,
+        #       "function_call": {
+        #         "name": "python",
+        #         "arguments": ""
+        #       }
+        #     }
+
+    def execute(self, bot_backend: BotBackend, history: List, whether_exit: bool):
+        bot_backend.add_content(content=self.delta.get('content', ''))
+        history[-1][1] = bot_backend.content
+        return history, whether_exit
+
+
+class NameFunctionCallChoiceStrategy(ChoiceStrategy):
+    def support(self):
+        return 'function_call' in self.delta and 'name' in self.delta['function_call']
+
+    def execute(self, bot_backend: BotBackend, history: List, whether_exit: bool):
+        python_function_dict = bot_backend.jupyter_kernel.available_functions
+        additional_tools = bot_backend.additional_tools
+        bot_backend.set_function_name(function_name=self.delta['function_call']['name'])
+        bot_backend.copy_current_bot_history(bot_history=history)
+        if bot_backend.function_name not in python_function_dict and bot_backend.function_name not in additional_tools:
+            history.append(
+                [
+                    None,
+                    f'GPT attempted to call a function that does '
+                    f'not exist: {bot_backend.function_name}\n '
+                ]
+            )
+            whether_exit = True
+
+        return history, whether_exit
+
+
+class ArgumentsFunctionCallChoiceStrategy(ChoiceStrategy):
+
+    def support(self):
+        return 'function_call' in self.delta and 'arguments' in self.delta['function_call']
+
+    def execute(self, bot_backend: BotBackend, history: List, whether_exit: bool):
+        bot_backend.add_function_args_str(function_args_str=self.delta['function_call']['arguments'])
+
+        if bot_backend.function_name == 'python':  # handle hallucinatory function calls
+            """
+            In practice, we have noticed that GPT, especially GPT-3.5, may occasionally produce hallucinatory
+            function calls. These calls involve a non-existent function named `python` with arguments consisting 
+            solely of raw code text (not a JSON format).
+            """
+            temp_code_str = bot_backend.function_args_str
+            bot_backend.update_code_str(code_str=temp_code_str)
+            bot_backend.update_display_code_block(
+                display_code_block="\n🔴Working:\n```python\n{}\n```".format(temp_code_str)
+            )
+            history = copy.deepcopy(bot_backend.bot_history)
+            history[-1][1] += bot_backend.display_code_block
+        elif bot_backend.function_name == 'execute_code':
+            temp_code_str = parse_json(function_args=bot_backend.function_args_str, finished=False)
+            if temp_code_str is not None:
+                bot_backend.update_code_str(code_str=temp_code_str)
+                bot_backend.update_display_code_block(
+                    display_code_block="\n🔴Working:\n```python\n{}\n```".format(
+                        temp_code_str
+                    )
+                )
+                history = copy.deepcopy(bot_backend.bot_history)
+                history[-1][1] += bot_backend.display_code_block
+            else:
+                history = copy.deepcopy(bot_backend.bot_history)
+                history[-1][1] += bot_backend.display_code_block
+        else:
+            pass
+
+        return history, whether_exit
+
+
+class FinishReasonChoiceStrategy(ChoiceStrategy):
+    def support(self):
+        return self.choice['finish_reason'] is not None
+
+    def execute(self, bot_backend: BotBackend, history: List, whether_exit: bool):
+
+        if bot_backend.content:
+            bot_backend.add_gpt_response_content_message()
+
+        bot_backend.update_finish_reason(finish_reason=self.choice['finish_reason'])
+        if bot_backend.finish_reason == 'function_call':
+
+            if bot_backend.function_name in bot_backend.jupyter_kernel.available_functions:
+                history, whether_exit = self.handle_execute_code_finish_reason(
+                    bot_backend=bot_backend, history=history, whether_exit=whether_exit
+                )
+            else:
+                history, whether_exit = self.handle_tool_finish_reason(
+                    bot_backend=bot_backend, history=history, whether_exit=whether_exit
+                )
+
+        bot_backend.reset_gpt_response_log_values(exclude=['finish_reason'])
+
+        return history, whether_exit
+
+    def handle_execute_code_finish_reason(self, bot_backend: BotBackend, history: List, whether_exit: bool):
+        function_dict = bot_backend.jupyter_kernel.available_functions
+        try:
+
+            code_str = self.get_code_str(bot_backend)
+
+            bot_backend.update_code_str(code_str=code_str)
+            bot_backend.update_display_code_block(
+                display_code_block="\n🟢Finished:\n```python\n{}\n```".format(code_str)
+            )
+            history = copy.deepcopy(bot_backend.bot_history)
+            history[-1][1] += bot_backend.display_code_block
+
+            # function response
+            bot_backend.update_code_executing_state(code_executing=True)
+            text_to_gpt, content_to_display = function_dict[
+                bot_backend.function_name
+            ](code_str)
+            bot_backend.update_code_executing_state(code_executing=False)
+
+            # add function call to conversion
+            bot_backend.add_function_call_response_message(function_response=text_to_gpt, save_tokens=True)
+
+            if bot_backend.interrupt_signal_sent:
+                bot_backend.append_system_msg(prompt='Code execution is manually stopped by user, no need to fix.')
+
+            add_code_execution_result_to_bot_history(
+                content_to_display=content_to_display, history=history, unique_id=bot_backend.unique_id
+            )
+            return history, whether_exit
+
+        except json.JSONDecodeError:
+            history.append(
+                [None, f"GPT generate wrong function args: {bot_backend.function_args_str}"]
+            )
+            whether_exit = True
+            return history, whether_exit
+
+        except KeyError as key_error:
+            history.append([None, f'Backend key_error: {key_error}'])
+            whether_exit = True
+            return history, whether_exit
+
+        except Exception as e:
+            history.append([None, f'Backend error: {e}'])
+            whether_exit = True
+            return history, whether_exit
+
+    @staticmethod
+    def handle_tool_finish_reason(bot_backend: BotBackend, history: List, whether_exit: bool):
+        function_dict = bot_backend.additional_tools
+        function_name = bot_backend.function_name
+        function = function_dict[function_name]['tool']
+
+        # parser function args
+        try:
+            kwargs = json.loads(bot_backend.function_args_str)
+            kwargs.update(function_dict[function_name]['additional_parameters'])
+        except json.JSONDecodeError:
+            history.append(
+                [None, f"GPT generate wrong function args: {bot_backend.function_args_str}"]
+            )
+            whether_exit = True
+            return history, whether_exit
+
+        else:
+            # function response
+            function_response, hypertext_to_display = function(**kwargs)
+
+            # add function call to conversion
+            bot_backend.add_function_call_response_message(function_response=function_response, save_tokens=False)
+
+            # add hypertext response to bot history
+            add_function_response_to_bot_history(hypertext_to_display=hypertext_to_display, history=history)
+
+            return history, whether_exit
+
+    @staticmethod
+    def get_code_str(bot_backend):
+        if bot_backend.function_name == 'python':
+            code_str = bot_backend.function_args_str
+        else:
+            code_str = parse_json(function_args=bot_backend.function_args_str, finished=True)
+            if code_str is None:
+                raise json.JSONDecodeError
+        return code_str
+
+
+class ChoiceHandler:
+    strategies = [
+        RoleChoiceStrategy, ContentChoiceStrategy, NameFunctionCallChoiceStrategy,
+        ArgumentsFunctionCallChoiceStrategy, FinishReasonChoiceStrategy
+    ]
+
+    def __init__(self, choice):
+        self.choice = choice
+
+    def handle(self, bot_backend: BotBackend, history: List, whether_exit: bool):
+        for Strategy in self.strategies:
+            strategy_instance = Strategy(choice=self.choice)
+            if not strategy_instance.support():
+                continue
+            history, whether_exit = strategy_instance.execute(
+                bot_backend=bot_backend,
+                history=history,
+                whether_exit=whether_exit
+            )
+        return history, whether_exit
+
+
+def parse_response(chunk, history: List, bot_backend: BotBackend):
+    """
+    :return: history, whether_exit
+    """
+    whether_exit = False
+    if chunk['choices']:
+        choice = chunk['choices'][0]
+        choice_handler = ChoiceHandler(choice=choice)
+        history, whether_exit = choice_handler.handle(
+            history=history,
+            bot_backend=bot_backend,
+            whether_exit=whether_exit
+        )
+
+    return history, whether_exit

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/src/tools.py

@@ -0,0 +1,202 @@
+import openai
+import base64
+import os
+import io
+import time
+from PIL import Image
+from abc import ABCMeta, abstractmethod
+
+
+def create_vision_chat_completion(vision_model, base64_image, prompt):
+    try:
+        response = openai.ChatCompletion.create(
+            model=vision_model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt},
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{base64_image}",
+                            },
+                        },
+                    ],
+                }
+            ],
+            max_tokens=1000,
+        )
+        return response.choices[0].message.content
+    except:
+        return None
+
+
+def create_image(prompt):
+    try:
+        response = openai.Image.create(
+            model="dall-e-3",
+            prompt=prompt,
+            response_format="b64_json"
+        )
+        return response.data[0]['b64_json']
+    except:
+        return None
+
+
+def image_to_base64(path):
+    try:
+        _, suffix = os.path.splitext(path)
+        if suffix not in {'.jpg', '.jpeg', '.png', '.webp'}:
+            img = Image.open(path)
+            img_png = img.convert('RGB')
+            img_png.tobytes()
+            byte_buffer = io.BytesIO()
+            img_png.save(byte_buffer, 'PNG')
+            encoded_string = base64.b64encode(byte_buffer.getvalue()).decode('utf-8')
+        else:
+            with open(path, "rb") as image_file:
+                encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
+        return encoded_string
+    except:
+        return None
+
+
+def base64_to_image_bytes(image_base64):
+    try:
+        return base64.b64decode(image_base64)
+    except:
+        return None
+
+
+def inquire_image(work_dir, vision_model, path, prompt):
+    image_base64 = image_to_base64(f'{work_dir}/{path}')
+    hypertext_to_display = None
+    if image_base64 is None:
+        return "Error: Image transform error", None
+    else:
+        response = create_vision_chat_completion(vision_model, image_base64, prompt)
+        if response is None:
+            return "Model response error", None
+        else:
+            return response, hypertext_to_display
+
+
+def dalle(unique_id, prompt):
+    img_base64 = create_image(prompt)
+    text_to_gpt = "Image has been successfully generated and displayed to user."
+
+    if img_base64 is None:
+        return "Error: Model response error", None
+
+    img_bytes = base64_to_image_bytes(img_base64)
+    if img_bytes is None:
+        return "Error: Image transform error", None
+
+    temp_path = f'cache/temp_{unique_id}'
+    if not os.path.exists(temp_path):
+        os.mkdir(temp_path)
+    path = f'{temp_path}/{hash(time.time())}.png'
+
+    with open(path, 'wb') as f:
+        f.write(img_bytes)
+
+    hypertext_to_display = f'<img src=\"file={path}\" width="50%" style=\'max-width:none; max-height:none\'>'
+    return text_to_gpt, hypertext_to_display
+
+
+class Tool(metaclass=ABCMeta):
+    def __init__(self, config):
+        self.config = config
+
+    @abstractmethod
+    def support(self):
+        pass
+
+    @abstractmethod
+    def get_tool_data(self):
+        pass
+
+
+class ImageInquireTool(Tool):
+    def support(self):
+        return self.config['model']['GPT-4V']['available']
+
+    def get_tool_data(self):
+        return {
+            "tool_name": "inquire_image",
+            "tool": inquire_image,
+            "system_prompt": "If necessary, utilize the 'inquire_image' tool to query an AI model regarding the "
+                             "content of images uploaded by users. Avoid phrases like\"based on the analysis\"; "
+                             "instead, respond as if you viewed the image by yourself. Keep in mind that not every"
+                             "tasks related to images require knowledge of the image content, such as converting "
+                             "an image format or extracting image file attributes, which should use `execute_code` "
+                             "tool instead. Use the tool only when understanding the image content is necessary.",
+            "tool_description": {
+                "name": "inquire_image",
+                "description": "This function enables you to inquire with an AI model about the contents of an image "
+                               "and receive the model's response.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "File path of the image"
+                        },
+                        "prompt": {
+                            "type": "string",
+                            "description": "The question you want to pose to the AI model about the image"
+                        }
+                    },
+                    "required": ["path", "prompt"]
+                }
+            },
+            "additional_parameters": {
+                "work_dir": lambda bot_backend: bot_backend.jupyter_work_dir,
+                "vision_model": self.config['model']['GPT-4V']['model_name']
+            }
+        }
+
+
+class DALLETool(Tool):
+    def support(self):
+        return True
+
+    def get_tool_data(self):
+        return {
+            "tool_name": "dalle",
+            "tool": dalle,
+            "system_prompt": "If user ask you to generate an art image, you can translate user's requirements into a "
+                             "prompt and sending it to the `dalle` tool. Please note that this tool is specifically "
+                             "designed for creating art images. For scientific figures, such as plots, please use the "
+                             "Python code execution tool `execute_code` instead.",
+            "tool_description": {
+                "name": "dalle",
+                "description": "This function allows you to access OpenAI's DALL·E-3 model for image generation.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "prompt": {
+                            "type": "string",
+                            "description": "A detailed description of the image you want to generate, should be in "
+                                           "English only. "
+                        }
+                    },
+                    "required": ["prompt"]
+                }
+            },
+            "additional_parameters": {
+                "unique_id": lambda bot_backend: bot_backend.unique_id,
+            }
+        }
+
+
+def get_available_tools(config):
+    tools = [ImageInquireTool]
+
+    available_tools = []
+    for tool in tools:
+        tool_instance = tool(config)
+        if tool_instance.support():
+            available_tools.append(tool_instance.get_tool_data())
+    return available_tools

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/Local-Code-Interpreter/src/web_ui.py

@@ -0,0 +1,279 @@
+import gradio as gr
+from response_parser import *
+
+
+def initialization(state_dict: Dict) -> None:
+    if not os.path.exists('cache'):
+        os.mkdir('cache')
+    if state_dict["bot_backend"] is None:
+        state_dict["bot_backend"] = BotBackend()
+        if 'OPENAI_API_KEY' in os.environ:
+            del os.environ['OPENAI_API_KEY']
+
+
+def get_bot_backend(state_dict: Dict) -> BotBackend:
+    return state_dict["bot_backend"]
+
+
+def switch_to_gpt4(state_dict: Dict, whether_switch: bool) -> None:
+    bot_backend = get_bot_backend(state_dict)
+    if whether_switch:
+        bot_backend.update_gpt_model_choice("GPT-4")
+    else:
+        bot_backend.update_gpt_model_choice("GPT-3.5")
+
+
+def add_text(state_dict: Dict, history: List, text: str) -> Tuple[List, Dict]:
+    bot_backend = get_bot_backend(state_dict)
+    bot_backend.add_text_message(user_text=text)
+
+    history = history + [(text, None)]
+
+    return history, gr.update(value="", interactive=False)
+
+
+def add_file(state_dict: Dict, history: List, files) -> List:
+    bot_backend = get_bot_backend(state_dict)
+    for file in files:
+        path = file.name
+        filename = os.path.basename(path)
+
+        bot_msg = [f'📁[{filename}]', None]
+        history.append(bot_msg)
+
+        bot_backend.add_file_message(path=path, bot_msg=bot_msg)
+
+        _, suffix = os.path.splitext(filename)
+        if suffix in {'.jpg', '.jpeg', '.png', '.bmp', '.webp'}:
+            copied_file_path = f'{bot_backend.jupyter_work_dir}/{filename}'
+            width, height = get_image_size(copied_file_path)
+            bot_msg[0] += \
+                f'\n<img src=\"file={copied_file_path}\" style=\'{"" if width < 800 else "width: 800px;"} max-width' \
+                f':none; max-height:none\'> '
+
+    return history
+
+
+def undo_upload_file(state_dict: Dict, history: List) -> Tuple[List, Dict]:
+    bot_backend = get_bot_backend(state_dict)
+    bot_msg = bot_backend.revoke_file()
+
+    if bot_msg is None:
+        return history, gr.Button.update(interactive=False)
+
+    else:
+        assert history[-1] == bot_msg
+        del history[-1]
+        if bot_backend.revocable_files:
+            return history, gr.Button.update(interactive=True)
+        else:
+            return history, gr.Button.update(interactive=False)
+
+
+def refresh_file_display(state_dict: Dict) -> List[str]:
+    bot_backend = get_bot_backend(state_dict)
+    work_dir = bot_backend.jupyter_work_dir
+    filenames = os.listdir(work_dir)
+    paths = []
+    for filename in filenames:
+        path = os.path.join(work_dir, filename)
+        if not os.path.isdir(path):
+            paths.append(path)
+    return paths
+
+
+def refresh_token_count(state_dict: Dict):
+    bot_backend = get_bot_backend(state_dict)
+    model_choice = bot_backend.gpt_model_choice
+    sliced = bot_backend.sliced
+    token_count = bot_backend.context_window_tokens
+    token_limit = config['model_context_window'][config['model'][model_choice]['model_name']]
+    display_text = f"**Context token:** {token_count}/{token_limit}"
+    if sliced:
+        display_text += '\\\nToken limit exceeded, conversion has been sliced.'
+    return gr.Markdown.update(value=display_text)
+
+
+def restart_ui(history: List) -> Tuple[List, Dict, Dict, Dict, Dict, Dict, Dict]:
+    history.clear()
+    return (
+        history,
+        gr.Textbox.update(value="", interactive=False),
+        gr.Button.update(interactive=False),
+        gr.Button.update(interactive=False),
+        gr.Button.update(interactive=False),
+        gr.Button.update(interactive=False),
+        gr.Button.update(visible=False)
+    )
+
+
+def restart_bot_backend(state_dict: Dict) -> None:
+    bot_backend = get_bot_backend(state_dict)
+    bot_backend.restart()
+
+
+def stop_generating(state_dict: Dict) -> None:
+    bot_backend = get_bot_backend(state_dict)
+    if bot_backend.code_executing:
+        bot_backend.send_interrupt_signal()
+    else:
+        bot_backend.update_stop_generating_state(stop_generating=True)
+
+
+def bot(state_dict: Dict, history: List) -> List:
+    bot_backend = get_bot_backend(state_dict)
+
+    while bot_backend.finish_reason in ('new_input', 'function_call'):
+        if history[-1][1]:
+            history.append([None, ""])
+        else:
+            history[-1][1] = ""
+
+        try:
+            response = chat_completion(bot_backend=bot_backend)
+            for chunk in response:
+                if chunk['choices'] and chunk['choices'][0]['finish_reason'] == 'function_call':
+                    if bot_backend.function_name in bot_backend.jupyter_kernel.available_functions:
+                        yield history, gr.Button.update(value='⏹️ Interrupt execution'), gr.Button.update(visible=False)
+                    else:
+                        yield history, gr.Button.update(interactive=False), gr.Button.update(visible=False)
+
+                if bot_backend.stop_generating:
+                    response.close()
+                    if bot_backend.content:
+                        bot_backend.add_gpt_response_content_message()
+                    if bot_backend.display_code_block:
+                        bot_backend.update_display_code_block(
+                            display_code_block="\n⚫Stopped:\n```python\n{}\n```".format(bot_backend.code_str)
+                        )
+                        history = copy.deepcopy(bot_backend.bot_history)
+                        history[-1][1] += bot_backend.display_code_block
+                        bot_backend.add_function_call_response_message(function_response=None)
+
+                    bot_backend.reset_gpt_response_log_values()
+                    break
+
+                history, weather_exit = parse_response(
+                    chunk=chunk,
+                    history=history,
+                    bot_backend=bot_backend
+                )
+
+                yield (
+                    history,
+                    gr.Button.update(
+                        interactive=False if bot_backend.stop_generating else True,
+                        value='⏹️ Stop generating'
+                    ),
+                    gr.Button.update(visible=False)
+                )
+                if weather_exit:
+                    exit(-1)
+        except openai.OpenAIError as openai_error:
+            bot_backend.reset_gpt_response_log_values(exclude=['finish_reason'])
+            yield history, gr.Button.update(interactive=False), gr.Button.update(visible=True)
+            raise openai_error
+
+    yield history, gr.Button.update(interactive=False, value='⏹️ Stop generating'), gr.Button.update(visible=False)
+
+
+if __name__ == '__main__':
+    config = get_config()
+    with gr.Blocks(theme=gr.themes.Base()) as block:
+        """
+        Reference: https://www.gradio.app/guides/creating-a-chatbot-fast
+        """
+        # UI components
+        state = gr.State(value={"bot_backend": None})
+        with gr.Tab("Chat"):
+            chatbot = gr.Chatbot([], elem_id="chatbot", label="Local Code Interpreter", height=750)
+            with gr.Row():
+                with gr.Column(scale=0.85):
+                    text_box = gr.Textbox(
+                        show_label=False,
+                        placeholder="Enter text and press enter, or upload a file",
+                        container=False
+                    )
+                with gr.Column(scale=0.15, min_width=0):
+                    file_upload_button = gr.UploadButton("📁", file_count='multiple', file_types=['file'])
+            with gr.Row(equal_height=True):
+                with gr.Column(scale=0.08, min_width=0):
+                    check_box = gr.Checkbox(label="Use GPT-4", interactive=config['model']['GPT-4']['available'])
+                with gr.Column(scale=0.314, min_width=0):
+                    model_token_limit = config['model_context_window'][config['model']['GPT-3.5']['model_name']]
+                    token_count_display_text = f"**Context token:** 0/{model_token_limit}"
+                    token_monitor = gr.Markdown(value=token_count_display_text)
+                with gr.Column(scale=0.15, min_width=0):
+                    retry_button = gr.Button(value='🔂OpenAI Error, click here to retry', visible=False)
+                with gr.Column(scale=0.15, min_width=0):
+                    stop_generation_button = gr.Button(value='⏹️ Stop generating', interactive=False)
+                with gr.Column(scale=0.15, min_width=0):
+                    restart_button = gr.Button(value='🔄 Restart')
+                with gr.Column(scale=0.15, min_width=0):
+                    undo_file_button = gr.Button(value="↩️Undo upload file", interactive=False)
+        with gr.Tab("Files"):
+            file_output = gr.Files()
+
+        # Components function binding
+        txt_msg = text_box.submit(add_text, [state, chatbot, text_box], [chatbot, text_box], queue=False).then(
+            lambda: gr.Button.update(interactive=False), None, [undo_file_button], queue=False
+        ).then(
+            bot, [state, chatbot], [chatbot, stop_generation_button, retry_button]
+        )
+        txt_msg.then(fn=refresh_file_display, inputs=[state], outputs=[file_output])
+        txt_msg.then(lambda: gr.update(interactive=True), None, [text_box], queue=False)
+        txt_msg.then(fn=refresh_token_count, inputs=[state], outputs=[token_monitor])
+
+        retry_button.click(lambda: gr.Button.update(visible=False), None, [retry_button], queue=False).then(
+            bot, [state, chatbot], [chatbot, stop_generation_button, retry_button]
+        ).then(
+            fn=refresh_file_display, inputs=[state], outputs=[file_output]
+        ).then(
+            lambda: gr.update(interactive=True), None, [text_box], queue=False
+        ).then(
+            fn=refresh_token_count, inputs=[state], outputs=[token_monitor]
+        )
+
+        check_box.change(fn=switch_to_gpt4, inputs=[state, check_box]).then(
+            fn=refresh_token_count, inputs=[state], outputs=[token_monitor]
+        )
+
+        file_msg = file_upload_button.upload(
+            add_file, [state, chatbot, file_upload_button], [chatbot], queue=False
+        )
+        file_msg.then(lambda: gr.Button.update(interactive=True), None, [undo_file_button], queue=False)
+        file_msg.then(fn=refresh_file_display, inputs=[state], outputs=[file_output])
+
+        undo_file_button.click(
+            fn=undo_upload_file, inputs=[state, chatbot], outputs=[chatbot, undo_file_button]
+        ).then(
+            fn=refresh_file_display, inputs=[state], outputs=[file_output]
+        )
+
+        stop_generation_button.click(fn=stop_generating, inputs=[state], queue=False).then(
+            fn=lambda: gr.Button.update(interactive=False), inputs=None, outputs=[stop_generation_button], queue=False
+        )
+
+        restart_button.click(
+            fn=restart_ui, inputs=[chatbot],
+            outputs=[
+                chatbot, text_box, restart_button, file_upload_button, undo_file_button, stop_generation_button,
+                retry_button
+            ]
+        ).then(
+            fn=restart_bot_backend, inputs=[state], queue=False
+        ).then(
+            fn=refresh_file_display, inputs=[state], outputs=[file_output]
+        ).then(
+            fn=lambda: (gr.Textbox.update(interactive=True), gr.Button.update(interactive=True),
+                        gr.Button.update(interactive=True)),
+            inputs=None, outputs=[text_box, restart_button, file_upload_button], queue=False
+        ).then(
+            fn=refresh_token_count,
+            inputs=[state], outputs=[token_monitor]
+        )
+
+        block.load(fn=initialization, inputs=[state])
+
+    block.queue()
+    block.launch(inbrowser=True)

Llama2-Code-Interpreter-main/OpenCodeInterpreter/data_collection/README.md

@@ -0,0 +1,3 @@
+# Data Collection
+
+Our data collection process is implemented using https://github.com/MrGreyfun/Local-Code-Interpreter. To achieve more efficient data collection, we implement a command line interface instead of the original web UI. Please check out `cli.py` for more details.

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Magnetic2014
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/README.md

@@ -0,0 +1,50 @@
+# OpenCodeInterpreter Demo
+
+Based on our powerful OpenCodeInterpreter models, this project allows LLM to generate code, execute it, receive feedback, debug, and answer questions based on the whole process. It is designed to be intuitive and versatile, capable of dealing with multiple languages and frameworks.
+
+
+## Disclaimer
+
+This demo is designed to leverage large language models for generating code, which is then executed in a Jupyter environment. Before you begin using this project, it is important that you read and understand the following disclaimer:
+
+- **Academic Nature and Security Risks:** This project is developed for academic purposes only and is not designed to be fully secure against all forms of code attacks. While we strive to maintain a safe environment, we cannot guarantee the security of your data during use. We urge all users to refrain from executing malicious code intentionally. By choosing to use this project, you acknowledge the potential risks to your data and agree to proceed with caution.
+
+- **Model Compatibility Notice:** Please be advised that our demo is only guaranteed to be compatible with the `opencodeinterpreter` model. We cannot ensure that using other models will achieve the expected output or performance. Users attempting to substitute or use models other than the officially recommended ones do so at their own risk, and may encounter issues with performance mismatches or other related risks. We encourage users to fully understand the potential impacts before making any such modifications.
+
+- **User Responsibility:** Users are responsible for the code they generate and execute using this project. We strongly advise against running any code without a thorough understanding of its function and potential impact. Users should take precautions to protect their own data and the integrity of their systems.
+
+- **Limitation of Liability:** The creators and maintainers of this project will not be liable for any damages, data loss, or security breaches that may occur from using this service. Users assume all responsibility and risk associated with their use of the project.
+
+- **Changes to the Disclaimer:** This disclaimer is subject to change at any time. We will make efforts to communicate any changes through the project's official channels, but it is the responsibility of the users to review this disclaimer periodically to ensure they are aware of any updates.
+
+By using this demo, you acknowledge that you have read this disclaimer, understand its terms, and agree to be bound by them.
+
+
+## Features
+
+- **Multi-user support**
+
+- **Save your conversations to both Huggingface datasets and offline json files**
+
+## License
+
+Distributed under the MIT License. See `LICENSE` for more information.
+
+## Acknowledgement
+
+This project is based on [Llama2-Code-Interpreter](https://github.com/SeungyounShin/Llama2-Code-Interpreter). 
+
+---
+
+## Citation
+
+If you find this demo useful for your research, please kindly cite our paper:
+
+```
+@article{zheng2024opencodeinterpreter,
+   title={OpenCodeInterpreter: Integrating Code Generation with Execution and Refinement},
+   author={Zheng, Tianyu and Zhang, Ge and Shen, Tianhao and Liu, Xueling and Lin, Bill Yuchen and Fu, Jie and Chen, Wenhu and Yue, Xiang},
+   journal={arXiv preprint arXiv:2402.14658},
+   year={2024}
+}
+```

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/chatbot.py

@@ -0,0 +1,316 @@
+import ast
+import gradio as gr
+import os
+import re
+import json
+import logging
+
+import torch
+from datetime import datetime
+
+from threading import Thread
+from typing import Optional
+from transformers import TextIteratorStreamer
+from functools import partial
+from huggingface_hub import CommitScheduler
+from uuid import uuid4
+from pathlib import Path
+
+from code_interpreter.JupyterClient import JupyterNotebook
+
+MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "4096"))
+
+import warnings
+
+warnings.filterwarnings("ignore", category=UserWarning, module="transformers")
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+
+
+from code_interpreter.OpenCodeInterpreter import OpenCodeInterpreter
+
+JSON_DATASET_DIR = Path("json_dataset")
+JSON_DATASET_DIR.mkdir(parents=True, exist_ok=True)
+
+scheduler = CommitScheduler(
+    repo_id="opencodeinterpreter_user_data",
+    repo_type="dataset",
+    folder_path=JSON_DATASET_DIR,
+    path_in_repo="data",
+    private=True
+)
+
+logging.basicConfig(level=logging.INFO)
+
+class StreamingOpenCodeInterpreter(OpenCodeInterpreter):
+    streamer: Optional[TextIteratorStreamer] = None
+
+    # overwirte generate function
+    @torch.inference_mode()
+    def generate(
+        self,
+        prompt: str = "",
+        max_new_tokens = 1024,
+        do_sample: bool = False,
+        top_p: float = 0.95,
+        top_k: int = 50,
+    ) -> str:
+        # Get the model and tokenizer, and tokenize the user text.
+
+        self.streamer = TextIteratorStreamer(
+            self.tokenizer, skip_prompt=True, Timeout=5
+        )
+
+        inputs = self.tokenizer([prompt], return_tensors="pt", truncation=True, max_length=MAX_INPUT_TOKEN_LENGTH)
+        inputs = inputs.to(self.model.device)
+
+        kwargs = dict(
+            **inputs,
+            streamer=self.streamer,
+            max_new_tokens=max_new_tokens,
+            do_sample=do_sample,
+            top_p=top_p,
+            top_k=top_k,
+            eos_token_id=self.tokenizer.eos_token_id
+        )
+
+        thread = Thread(target=self.model.generate, kwargs=kwargs)
+        thread.start()
+
+        return ""
+
+def save_json(dialog, mode, json_file_path, dialog_id) -> None:
+    with scheduler.lock:
+        with json_file_path.open("a") as f:
+            json.dump({"id": dialog_id, "dialog": dialog, "mode": mode, "datetime": datetime.now().isoformat()}, f, ensure_ascii=False)
+            f.write("\n")
+
+def convert_history(gradio_history: list[list], interpreter_history: list[dict]):
+    interpreter_history = [interpreter_history[0]] if interpreter_history and interpreter_history[0]["role"] == "system" else []
+    if not gradio_history:
+        return interpreter_history
+    for item in gradio_history:
+        if item[0] is not None:
+            interpreter_history.append({"role": "user", "content": item[0]})
+        if item[1] is not None:
+            interpreter_history.append({"role": "assistant", "content": item[1]})
+    return interpreter_history
+
+def update_uuid(dialog_info):
+    new_uuid = str(uuid4())
+    logging.info(f"allocating new uuid {new_uuid} for conversation...")
+    return [new_uuid, dialog_info[1]]
+
+def is_valid_python_code(code):
+    try:
+        ast.parse(code)
+        return True
+    except SyntaxError:
+        return False
+
+
+class InputFunctionVisitor(ast.NodeVisitor):
+    def __init__(self):
+        self.found_input = False
+
+    def visit_Call(self, node):
+        if isinstance(node.func, ast.Name) and node.func.id == 'input':
+            self.found_input = True
+        self.generic_visit(node)
+
+def has_input_function_calls(code):
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return False
+    visitor = InputFunctionVisitor()
+    visitor.visit(tree)
+    return visitor.found_input
+
+def gradio_launch(model_path: str, MAX_TRY: int = 3):
+    with gr.Blocks() as demo:
+        chatbot = gr.Chatbot(height=600, label="OpenCodeInterpreter", avatar_images=["assets/user.pic.jpg", "assets/assistant.pic.jpg"], show_copy_button=True)
+        with gr.Group():
+            with gr.Row():
+                msg = gr.Textbox(
+                    container=False,
+                    show_label=False,
+                    label="Message",
+                    placeholder="Type a message...",
+                    scale=7,
+                    autofocus=True
+                )
+                sub = gr.Button(
+                    "Submit",
+                    variant="primary",
+                    scale=1,
+                    min_width=150
+                )
+                # stop = gr.Button(
+                #     "Stop",
+                #     variant="stop",
+                #     visible=False,
+                #     scale=1,
+                #     min_width=150
+                # )
+
+        with gr.Row():
+            # retry = gr.Button("🔄  Retry", variant="secondary")
+            # undo = gr.Button("↩️ Undo", variant="secondary")
+            clear = gr.Button("🗑️  Clear", variant="secondary")
+
+        session_state = gr.State([])
+        jupyter_state = gr.State(JupyterNotebook())
+        dialog_info = gr.State(["", 0])
+        demo.load(update_uuid, dialog_info, dialog_info)
+
+        def bot(user_message, history, jupyter_state, dialog_info, interpreter):
+            logging.info(f"user message: {user_message}")
+            interpreter.dialog = convert_history(gradio_history=history, interpreter_history=interpreter.dialog)
+            history.append([user_message, None])
+
+            interpreter.dialog.append({"role": "user", "content": user_message})
+
+            # setup
+            HAS_CODE = False  # For now
+            prompt = interpreter.dialog_to_prompt(dialog=interpreter.dialog)
+
+            _ = interpreter.generate(prompt)
+            history[-1][1] = ""
+            generated_text = ""
+            for character in interpreter.streamer:
+                history[-1][1] += character
+                history[-1][1] = history[-1][1].replace("<|EOT|>","")
+                generated_text += character
+                yield history, history, jupyter_state, dialog_info
+
+            if is_valid_python_code(history[-1][1].strip()):
+                history[-1][1] = f"```python\n{history[-1][1].strip()}\n```"
+                generated_text = history[-1][1]
+
+            HAS_CODE, generated_code_block = interpreter.extract_code_blocks(
+                generated_text
+            )
+
+            interpreter.dialog.append(
+                {
+                    "role": "assistant",
+                    "content": generated_text.replace("<unk>_", "")
+                    .replace("<unk>", "")
+                    .replace("<|EOT|>", ""),
+                }
+            )
+
+            logging.info(f"saving current dialog to file {dialog_info[0]}.json...")
+            logging.info(f"current dialog: {interpreter.dialog}")
+            save_json(interpreter.dialog, mode="openci_only", json_file_path=JSON_DATASET_DIR/f"{dialog_info[0]}.json", dialog_id=dialog_info[0])
+
+            attempt = 1
+            while HAS_CODE:
+                if attempt > MAX_TRY:
+                    break
+                # if no code then doesn't have to execute it
+                generated_text = "" # clear generated text
+
+                yield history, history, jupyter_state, dialog_info
+
+                # replace unknown thing to none ''
+                generated_code_block = generated_code_block.replace(
+                    "<unk>_", ""
+                ).replace("<unk>", "")
+
+                if has_input_function_calls(generated_code_block):
+                    code_block_output = "Please directly assign the value of inputs instead of using input() function in your code."
+                else:
+                    (
+                        code_block_output,
+                        error_flag,
+                    ) = interpreter.execute_code_and_return_output(
+                        f"{generated_code_block}",
+                        jupyter_state
+                    )
+                    if error_flag == "Timeout":
+                        logging.info(f"{dialog_info[0]}: Restart jupyter kernel due to timeout")
+                        jupyter_state = JupyterNotebook()
+                    code_block_output = interpreter.clean_code_output(code_block_output)
+
+                    if code_block_output.strip():
+                        code_block_output = "Execution result: \n" + code_block_output
+                    else:
+                        code_block_output = "Code is executed, but result is empty. Please make sure that you include test case in your code."
+
+                history.append([code_block_output, ""])
+
+                interpreter.dialog.append({"role": "user", "content": code_block_output})
+
+                yield history, history, jupyter_state, dialog_info
+
+                prompt = interpreter.dialog_to_prompt(dialog=interpreter.dialog)
+
+                logging.info(f"generating answer for dialog {dialog_info[0]}")
+                _ = interpreter.generate(prompt)
+                for character in interpreter.streamer:
+                    history[-1][1] += character
+                    history[-1][1] = history[-1][1].replace("<|EOT|>","")
+                    generated_text += character
+                    yield history, history, jupyter_state, dialog_info
+                logging.info(f"finish generating answer for dialog {dialog_info[0]}")
+
+                HAS_CODE, generated_code_block = interpreter.extract_code_blocks(
+                    history[-1][1]
+                )
+
+                interpreter.dialog.append(
+                    {
+                        "role": "assistant", 
+                        "content": generated_text.replace("<unk>_", "")
+                        .replace("<unk>", "")
+                        .replace("<|EOT|>", ""),
+                    }
+                )
+
+                attempt += 1
+
+                logging.info(f"saving current dialog to file {dialog_info[0]}.json...")
+                logging.info(f"current dialog: {interpreter.dialog}")
+                save_json(interpreter.dialog, mode="openci_only", json_file_path=JSON_DATASET_DIR/f"{dialog_info[0]}.json", dialog_id=dialog_info[0])
+
+                if generated_text.endswith("<|EOT|>"):
+                    continue
+
+            return history, history, jupyter_state, dialog_info
+
+
+        def reset_textbox():
+            return gr.update(value="")
+
+
+        def clear_history(history, jupyter_state, dialog_info, interpreter):
+            interpreter.dialog = []
+            jupyter_state.close()
+            return [], [], JupyterNotebook(), update_uuid(dialog_info)
+
+        interpreter = StreamingOpenCodeInterpreter(model_path=model_path)
+
+        sub.click(partial(bot, interpreter=interpreter), [msg, session_state, jupyter_state, dialog_info], [chatbot, session_state, jupyter_state, dialog_info])
+        sub.click(reset_textbox, [], [msg])
+
+        clear.click(partial(clear_history, interpreter=interpreter), [session_state, jupyter_state, dialog_info], [chatbot, session_state, jupyter_state, dialog_info], queue=False)
+
+    demo.queue(max_size=20)
+    demo.launch(share=True)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--path",
+        type=str,
+        required=False,
+        help="Path to the OpenCodeInterpreter Model.",
+        default="m-a-p/OpenCodeInterpreter-DS-6.7B",
+    )
+    args = parser.parse_args()
+
+    gradio_launch(model_path=args.path)

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/code_interpreter/BaseCodeInterpreter.py

@@ -0,0 +1,29 @@
+import os
+import sys
+import re
+
+prj_root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(prj_root_path)
+
+
+from utils.const import *
+
+class BaseCodeInterpreter:
+    def __init__(self):
+        self.dialog = [
+            {
+                "role": "system",
+                "content": CODE_INTERPRETER_SYSTEM_PROMPT,
+            },
+        ]
+
+    @staticmethod
+    def extract_code_blocks(text: str):
+        pattern = r"```(?:python\n)?(.*?)```"  # Match optional 'python\n' but don't capture it
+        code_blocks = re.findall(pattern, text, re.DOTALL)
+        return [block.strip() for block in code_blocks]
+
+    def execute_code_and_return_output(self, code_str: str, nb):
+        _, _ = nb.add_and_run(GUARD_CODE)
+        outputs, error_flag = nb.add_and_run(code_str)
+        return outputs, error_flag

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/code_interpreter/JupyterClient.py

@@ -0,0 +1,85 @@
+from jupyter_client import KernelManager
+import threading
+import re
+from utils.const import *
+
+
+class JupyterNotebook:
+    def __init__(self):
+        self.km = KernelManager()
+        self.km.start_kernel()
+        self.kc = self.km.client()
+        _ = self.add_and_run(TOOLS_CODE)
+
+    def clean_output(self, outputs):
+        outputs_only_str = list()
+        for i in outputs:
+            if type(i) == dict:
+                if "text/plain" in list(i.keys()):
+                    outputs_only_str.append(i["text/plain"])
+            elif type(i) == str:
+                outputs_only_str.append(i)
+            elif type(i) == list:
+                error_msg = "\n".join(i)
+                error_msg = re.sub(r"\x1b\[.*?m", "", error_msg)
+                outputs_only_str.append(error_msg)
+
+        return "\n".join(outputs_only_str).strip()
+
+    def add_and_run(self, code_string):
+        # This inner function will be executed in a separate thread
+        def run_code_in_thread():
+            nonlocal outputs, error_flag
+
+            # Execute the code and get the execution count
+            msg_id = self.kc.execute(code_string)
+
+            while True:
+                try:
+                    msg = self.kc.get_iopub_msg(timeout=20)
+
+                    msg_type = msg["header"]["msg_type"]
+                    content = msg["content"]
+
+                    if msg_type == "execute_result":
+                        outputs.append(content["data"])
+                    elif msg_type == "stream":
+                        outputs.append(content["text"])
+                    elif msg_type == "error":
+                        error_flag = True
+                        outputs.append(content["traceback"])
+
+                    # If the execution state of the kernel is idle, it means the cell finished executing
+                    if msg_type == "status" and content["execution_state"] == "idle":
+                        break
+                except:
+                    break
+
+        outputs = []
+        error_flag = False
+
+        # Start the thread to run the code
+        thread = threading.Thread(target=run_code_in_thread)
+        thread.start()
+
+        # Wait for 20 seconds for the thread to finish
+        thread.join(timeout=20)
+
+        # If the thread is still alive after 20 seconds, it's a timeout
+        if thread.is_alive():
+            outputs = ["Execution timed out."]
+            # outputs = ["Error"]
+            error_flag = "Timeout"
+
+        return self.clean_output(outputs), error_flag
+
+    def close(self):
+        """Shutdown the kernel."""
+        self.km.shutdown_kernel()
+    
+    def __deepcopy__(self, memo):
+        if id(self) in memo:
+            return memo[id(self)]
+        new_copy = type(self)()
+        memo[id(self)] = new_copy
+        return new_copy

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/code_interpreter/OpenCodeInterpreter.py

@@ -0,0 +1,80 @@
+import sys
+import os
+
+prj_root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(prj_root_path)
+
+from code_interpreter.BaseCodeInterpreter import BaseCodeInterpreter
+from utils.const import *
+
+from typing import List, Tuple, Dict
+import re
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+sys.path.append(os.path.dirname(__file__))
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+import warnings
+
+warnings.filterwarnings("ignore", category=UserWarning, module="transformers")
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+
+
+class OpenCodeInterpreter(BaseCodeInterpreter):
+    def __init__(
+        self,
+        model_path: str,
+        load_in_8bit: bool = False,
+        load_in_4bit: bool = False,
+    ):
+        # build tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            model_path,
+            padding_side="right",
+            trust_remote_code=True
+        )
+
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            device_map="auto",
+            load_in_4bit=load_in_4bit,
+            load_in_8bit=load_in_8bit,
+            torch_dtype=torch.float16,
+            trust_remote_code=True
+        )
+
+        self.model.resize_token_embeddings(len(self.tokenizer))
+
+        self.model = self.model.eval()
+
+        self.dialog = []
+        self.MAX_CODE_OUTPUT_LENGTH = 1000
+        
+
+    def dialog_to_prompt(self, dialog: List[Dict]) -> str:
+        full_str = self.tokenizer.apply_chat_template(dialog, tokenize=False)
+
+        return full_str
+
+    def extract_code_blocks(self, prompt: str) -> Tuple[bool, str]:
+        pattern = re.escape("```python") + r"(.*?)" + re.escape("```")
+        matches = re.findall(pattern, prompt, re.DOTALL)
+
+        if matches:
+            # Return the last matched code block
+            return True, matches[-1].strip()
+        else:
+            return False, ""
+
+    def clean_code_output(self, output: str) -> str:
+        if self.MAX_CODE_OUTPUT_LENGTH < len(output):
+            return (
+                output[: self.MAX_CODE_OUTPUT_LENGTH // 5]
+                + "\n...(truncated due to length)...\n"
+                + output[-self.MAX_CODE_OUTPUT_LENGTH // 5 :]
+            )
+
+        return output

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/requirements.txt

@@ -0,0 +1,32 @@
+accelerate==0.21.0
+bitsandbytes==0.41.1
+colorama==0.4.6
+coloredlogs==15.0.1
+colorlog==6.7.0
+datasets==2.12.0
+deepspeed==0.10.1
+diffusers==0.20.0
+einops==0.6.1
+gradio==3.48.0
+ipykernel==6.25.1
+ipython==8.12.2
+jupyter_client==8.3.0
+jupyter_core==5.3.0
+Markdown==3.4.3
+nbclient==0.8.0
+nbconvert==7.7.1
+nbformat==5.8.0
+omegaconf==2.3.0
+openai==0.27.7
+rich==13.7.0
+scikit-learn==1.4.0
+scipy==1.12.0
+seaborn==0.13.2
+sentencepiece==0.1.99
+termcolor==2.3.0
+tqdm==4.66.1
+transformers==4.37.1
+triton==2.0.0
+yfinance==0.2.28
+retrying==1.3.4
+pydantic<2.0.0

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/utils/cleaner.py

@@ -0,0 +1,31 @@
+import re
+import os
+
+PYTHON_PREFIX = os.environ.get("CONDA_PREFIX", "/usr/local")
+
+SITE_PKG_ERROR_PREFIX = f'File {PYTHON_PREFIX}/lib/python3.10/'
+
+def get_error_header(traceback_str):
+    lines = traceback_str.split('\n')
+    for line in lines:
+        if 'Error:' in line:
+            return line
+    return ''  # Return None if no error message is found
+
+def clean_error_msg(error_str:str =''):
+    filtered_error_msg = error_str.__str__().split('An error occurred while executing the following cell')[-1].split("\n------------------\n")[-1]
+    raw_error_msg = "".join(filtered_error_msg)
+
+    # Remove escape sequences for colored text
+    ansi_escape = re.compile(r'\x1b\[[0-?]*[ -/]*[@-~]')
+    error_msg = ansi_escape.sub('', raw_error_msg)
+    
+    error_str_out = ''
+    error_msg_only_cell = error_msg.split(SITE_PKG_ERROR_PREFIX)
+
+    error_str_out += f'{error_msg_only_cell[0]}\n'
+    error_header = get_error_header(error_msg_only_cell[-1])
+    if error_header not in error_str_out:
+        error_str_out += get_error_header(error_msg_only_cell[-1])
+
+    return error_str_out

Llama2-Code-Interpreter-main/OpenCodeInterpreter/demo/utils/const.py

@@ -0,0 +1,88 @@
+TOOLS_CODE = """
+import numpy as np
+import pandas as pd 
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy import stats
+import os,sys
+import re
+from datetime import datetime
+from sympy import symbols, Eq, solve
+import torch 
+import requests
+from bs4 import BeautifulSoup
+import json
+import math
+import yfinance
+import time
+"""
+
+write_denial_function = 'lambda *args, **kwargs: (_ for _ in ()).throw(PermissionError("Writing to disk operation is not permitted due to safety reasons. Please do not try again!"))'
+read_denial_function = 'lambda *args, **kwargs: (_ for _ in ()).throw(PermissionError("Reading from disk operation is not permitted due to safety reasons. Please do not try again!"))'
+class_denial = """Class Denial:
+    def __getattr__(self, name):
+        def method(*args, **kwargs):
+            return "Using this class is not permitted due to safety reasons. Please do not try again!"
+        return method
+"""
+
+GUARD_CODE = f"""
+import os
+
+os.kill = {write_denial_function}
+os.system = {write_denial_function}
+os.putenv = {write_denial_function}
+os.remove = {write_denial_function}
+os.removedirs = {write_denial_function}
+os.rmdir = {write_denial_function}
+os.fchdir = {write_denial_function}
+os.setuid = {write_denial_function}
+os.fork = {write_denial_function}
+os.forkpty = {write_denial_function}
+os.killpg = {write_denial_function}
+os.rename = {write_denial_function}
+os.renames = {write_denial_function}
+os.truncate = {write_denial_function}
+os.replace = {write_denial_function}
+os.unlink = {write_denial_function}
+os.fchmod = {write_denial_function}
+os.fchown = {write_denial_function}
+os.chmod = {write_denial_function}
+os.chown = {write_denial_function}
+os.chroot = {write_denial_function}
+os.fchdir = {write_denial_function}
+os.lchflags = {write_denial_function}
+os.lchmod = {write_denial_function}
+os.lchown = {write_denial_function}
+os.getcwd = {write_denial_function}
+os.chdir = {write_denial_function}
+os.popen = {write_denial_function}
+
+import shutil
+
+shutil.rmtree = {write_denial_function}
+shutil.move = {write_denial_function}
+shutil.chown = {write_denial_function}
+
+import subprocess
+
+subprocess.Popen = {write_denial_function}  # type: ignore
+
+import sys
+
+sys.modules["ipdb"] = {write_denial_function}
+sys.modules["joblib"] = {write_denial_function}
+sys.modules["resource"] = {write_denial_function}
+sys.modules["psutil"] = {write_denial_function}
+sys.modules["tkinter"] = {write_denial_function}
+"""
+
+CODE_INTERPRETER_SYSTEM_PROMPT = """You are an AI code interpreter.
+Your goal is to help users do a variety of jobs by executing Python code.
+
+You should:
+1. Comprehend the user's requirements carefully & to the letter.
+2. Give a brief description for what you plan to do & call the provided function to run code.
+3. Provide results analysis based on the execution output.
+4. If error occurred, try to fix it.
+5. Response in the same language as the user."""

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/README.md

@@ -0,0 +1,51 @@
+# Evaluation
+
+This repository contains code for evaluating the performance of LLM models through both single-turn and multi-turn scenarios.
+
+To set up the environment, you can install the required dependencies by running:
+```bash
+pip install -r evaluation/requirements.txt
+```
+
+## Single-turn Evaluation
+
+For single-turn evaluation, the processes of inference, post-processing, and result aggregation are separated as follows:
+
+1. Execute `bash evaluation/evaluate/scripts/01_gen_single.sh` to generate model results.
+2. Perform post-processing on the model output by executing `bash evaluation/evaluate/scripts/02_sanitize_single.sh`.
+3. Finally, compute evaluation metrics by executing `bash evaluation/evaluate/scripts/03_eval_single.sh`.
+
+## Multi-turn Evaluation
+
+### Multi-turn Evaluation with Execution Feedback
+
+Evaluate the performance of the models with execution feedback using the provided scripts:
+
+- For OpenCodeInterpreter:
+  ```bash
+  bash evaluation/evaluate/scripts/04_execution_feedback_multiround_OpenCodeInterpreter.sh
+  ```
+
+- For OpenAI's GPT Models:
+  Before proceeding with evaluation, ensure to implement the `get_predict` function in `chat_with_gpt.py` to enable interaction with the GPT Models. Then, execute the following script:
+  ```bash
+  bash evaluation/evaluate/scripts/05_execution_feedback_multiround_gpt.sh
+  ```
+
+### Multi-turn Evaluation with GPT-4 Simulated Human Feedback
+
+Execute either of the following scripts to evaluate the models with simulated human feedback:
+
+- For OpenCodeInterpreter:
+  ```bash
+  bash evaluation/evaluate/scripts/06_human_feedback_multiround_OpenCodeInterpreter.sh
+  ```
+
+- For Oracle OpenCodeInterpreter:
+  ```bash
+  bash evaluation/evaluate/scripts/07_human_feedback_multiround_Oracle_OpenCodeInterpreter.sh
+  ```
+
+These scripts facilitate the multi-turn evaluation with simulated human feedback.
+
+This evaluation code is based on [EvalPlus](https://github.com/evalplus/evalplus) and has been modified for specific purposes. We extend our gratitude to the contributors of EvalPlus for their foundational work.

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/.dockerignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#  nuclear option because steven uses PyCharm.
+.idea/
+
+# VSCode
+.vscode/
+EvalPlus/
+backup/
+passrate.p*
+min_cov_dir/
+HumanEvalPlus*.jsonl
+HumanEvalPlus*.gz
+MbppPlus*.jsonl
+MbppPlus*.gz
+evalplus/_version.py
+*mbpp.json

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/.github/ISSUE_TEMPLATE/buggy_contract.yml

@@ -0,0 +1,48 @@
+name: "🐛 Report Bad Contract"
+description: Report to us that certain program contract should be repaired.
+title: "🐛 [TestRemoval] - <TASK_ID> <WHY>"
+labels: ["program contract"]
+body:
+  - type: input
+    id: version
+    attributes:
+      label: "EvalPlus version"
+      description: What is the version of EvalPlus? You can find it by running `pip show evalplus`.
+      placeholder: For example, 0.1.0
+    validations:
+      required: true
+  - type: input
+    id: cache
+    attributes:
+      label: "Output of running `ls ~/.cache/evalplus`"
+    validations:
+      required: true
+  - type: input
+    id: task_id
+    attributes:
+      label: "Task ID of the programming task"
+      placeholder: HumanEval/[??]
+    validations:
+      required: true
+  - type: textarea
+    id: original
+    attributes:
+      label: "The original wrong contract"
+      description: You can run `python -c "from evalplus.data import get_human_eval_plus; print(get_human_eval_plus()['HumanEval/❓']['contract'])"`
+      render: python
+    validations:
+      required: true
+  - type: textarea
+    id: new
+    attributes:
+      label: "Your proposed new contract"
+      render: python
+    validations:
+      required: true
+  - type: textarea
+    id: other
+    attributes:
+      label: "Other context"
+      description: (Optional) Anything else the maintainer should notice?
+    validations:
+      required: false

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/.github/ISSUE_TEMPLATE/buggy_test.yml

@@ -0,0 +1,49 @@
+name: "🐛 Report Bad Test Inputs"
+description: Report to us that certain test inputs should be removed.
+title: "🐛 [TestRemoval] - <TASK_ID> <WHY>"
+labels: ["bug"]
+body:
+  - type: input
+    id: version
+    attributes:
+      label: "EvalPlus version"
+      description: What is the version of EvalPlus? You can find it by running `pip show evalplus`.
+      placeholder: For example, 0.1.0
+    validations:
+      required: true
+  - type: input
+    id: cache
+    attributes:
+      label: "Output of running `ls ~/.cache/evalplus`"
+    validations:
+      required: true
+  - type: input
+    id: task_id
+    attributes:
+      label: "Task ID of the programming task"
+      placeholder: HumanEval/[??]
+    validations:
+      required: true
+  - type: textarea
+    id: test_input
+    attributes:
+      label: "Test input"
+      description: The text form of the test input that you think should be removed
+      render: python
+    validations:
+      required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: "Description"
+      description: An explicit description of why you think this test should be removed
+      placeholder: Here is a correct solution but it is incorrectly falsified by the test because ...
+    validations:
+      required: true
+  - type: textarea
+    id: other
+    attributes:
+      label: "Other context"
+      description: (Optional) Anything else the maintainer should notice?
+    validations:
+      required: false

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: true

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/.github/ISSUE_TEMPLATE/model_eval_request.yml

@@ -0,0 +1,67 @@
+name: "🤗 Model Evaluation Request"
+description: Request EvalPlus maintainers to evaluate your model independently and update it on our leaderboard.
+title: "🤗 [REQUEST] - <MODEL_NAME>"
+labels: ["model eval"]
+body:
+  - type: textarea
+    id: about
+    attributes:
+      label: "Model introduction"
+      description: Provide a brief introduction to the model.
+      placeholder: The models is created by ... and is used for ...
+    validations:
+      required: true
+  - type: input
+    id: url
+    attributes:
+      label: "Model URL"
+      description: Indicate the URL (e.g., huggingface or other release pages) of the model
+      placeholder: https://huggingface.co/[???]/[???]
+    validations:
+      required: true
+  - type: dropdown
+    id: dtype
+    attributes:
+      label: "Data type"
+      description: What is the intended data type for running the model?
+      multiple: false
+      options:
+        - "float16"
+        - "bfloat16"
+        - "float32"
+        - "None of above: specify the details in the 'Other context' section"
+    validations:
+      required: true
+  - type: textarea
+    id: other
+    attributes:
+      label: "Additional instructions (Optional)"
+      description: Special steps indicating how to run the model with preferably scripts/codes.
+      placeholder: What data type precision should be used? What is the minimal hardware requirement? Can it be accelerated by tools such as vLLM?
+    validations:
+      required: false
+  - type: dropdown
+    id: author
+    attributes:
+      label: "Author"
+      description: "Are you (one of) the author(s) of the model?"
+      multiple: false
+      options:
+        - "Yes"
+        - "No"
+    validations:
+      required: true
+  - type: checkboxes
+    id: security
+    attributes:
+      label: "Security"
+      options:
+        - label: "I confirm that the model is safe to run which does not contain any malicious code or content."
+          required: true
+  - type: checkboxes
+    id: integrity
+    attributes:
+      label: "Integrity"
+      options:
+        - label: "I confirm that the model comes from unique and original work and does not contain any plagiarism."
+          required: true

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/.gitignore

@@ -0,0 +1,173 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#  nuclear option because steven uses PyCharm.
+.idea/
+
+# VSCode
+.vscode/
+EvalPlus/
+backup/
+passrate.p*
+min_cov_dir/
+HumanEvalPlus*.gz
+MbppPlus*.gz
+evalplus/_version.py
+*mbpp.json
+*.jsonl

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+repos:
+-   repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+    -   id: isort
+        name: isort (python)
+        args: ["--profile", "black"]
+-   repo: https://github.com/psf/black
+    rev: 22.6.0
+    hooks:
+    -   id: black
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+exclude: (?x)^(
+        groundtruth/.*
+    )$

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/CITATION.cff

@@ -0,0 +1,25 @@
+cff-version: 1.2.0
+message: "If you use this work and love it, consider citing it as below \U0001F917"
+title: EvalPlus
+authors:
+  - family-names: EvalPlus Team
+url: https://github.com/evalplus/evalplus
+doi: https://doi.org/10.48550/arXiv.2305.01210
+date-released: 2023-05-01
+license: Apache-2.0
+preferred-citation:
+  type: article
+  title: "Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation"
+  authors:
+    - family-names: Liu
+      given-names: Jiawei
+    - family-names: Xia
+      given-names: Chunqiu Steven
+    - family-names: Wang
+      given-names: Yuyao
+    - family-names: Zhang
+      given-names: Lingming
+  year: 2023
+  journal: "arXiv preprint arXiv:2305.01210"
+  doi: https://doi.org/10.48550/arXiv.2305.01210
+  url: https://arxiv.org/abs/2305.01210

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/Dockerfile

@@ -0,0 +1,19 @@
+# base env: py38 ubuntu20.04
+FROM python:3.8-slim-buster
+
+# install git
+RUN apt-get update && apt-get install -y git
+
+# upgrade to latest pip
+RUN pip install --upgrade pip
+
+COPY . /evalplus
+
+RUN cd /evalplus && pip install .
+
+# Pre-install the dataset
+RUN python3 -c "from evalplus.data import get_human_eval_plus, get_mbpp_plus; get_human_eval_plus(); get_mbpp_plus()"
+
+WORKDIR /app
+
+ENTRYPOINT ["python3", "-m", "evalplus.evaluate"]

Llama2-Code-Interpreter-main/OpenCodeInterpreter/evaluation/evalplus/LICENSE

@@ -0,0 +1,205 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+-------------------------------------------------------------------------------
+The files under "evalplus/eval/" additionally complies with the MIT License for
+being built on OpenAI's HumanEval work.