Added BardCoder

CHANGELOGS.md

@@ -0,0 +1,27 @@
+# Changelog 📝
+
+All notable changes to this project will be documented in this file.
+## [1.3] - 2023-05-2
+### Added
+- **Updated** with totaly new _UI_ and _UX_. 🎨
+- Updated security for code checking and prompt checking. 🔒
+- Added new Help section. 🆘
+- Fix API Key bugs. 🛠
+
+## [1.2] - 2023-05-28
+### Added
+- **Advanced security** for code checking and prompt checking. 🔒
+- Support for graphs, charts, and tables. 📊
+- More libraries for data science. 🧬
+
+## [1.1] - 2023-05-22
+### Added
+- Upload files option. 📤
+- API key settings. 🔑
+### Fixed
+- Error handling from server. 🛠
+
+## [1.0] - 2023-05-21
+### Added
+- Auto barcode generator. 🏷
+- Auto barcode interpreter. 🔎

LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2023 HeavenHM
+
+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.

README.md

@@ -1,13 +1,166 @@
+# AutoBard-Coder
+![cover_logo](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/logo.png?raw=true "")</br>
+- **Support this Project** <a href="https://www.buymeacoffee.com/haseebheaven"><img src="https://img.buymeacoffee.com/button-api/?text=Buy me a coffee&emoji=&slug=haseebheaven&button_colour=40DCA5&font_colour=ffffff&font_family=Cookie&outline_colour=000000&coffee_colour=FFDD00" /></a>
+
+[![Plugin](https://img.shields.io/badge/Auto%20Bard-Repo-blue)](https://replit.com/@HaseebMir/AutoBard-Coder)
+[![Plugin](https://img.shields.io/badge/Auto%20Bard-Replit-blue)](https://autobard-coder.haseebmir.repl.co)
+[![Plugin](https://img.shields.io/badge/Code%20Interpreter-Hosted-blue)](https://haseeb-heaven-autobard-coder-bardcode-interpreter-5g2n5e.streamlit.app/)
+[![Plugin](https://img.shields.io/badge/Code%20Interpreter-CodeSpace-blue)](https://haseeb-heaven-legendary-guide-x555j7vpv4phprg6-8501.preview.app.github.dev/)</br>
+
+## General Information
+AutoBard-Coder is a code generator for bard.🙌👩‍💻👨‍💻 It uses the Bard API to interact with bard and refine the results for coding purposes. The main purpose of this is for research and educational purposes. This can generate code from prompts and fix itself unless the code is fixed. It is written in Python and has dependencies on streamlit and bard-coder.
+
+## Application main UI.
+### BardCoder:
+![bard_coder](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/bardcoder_main.png?raw=true "")</br>
+
+### Coder Interpreter:
+![code_interpreter](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/code_interpreter_main_ui.png?raw=true "")</br>
+
+## Setup Process
+To set up AutoBard-Coder, you will need to install the dependencies: `streamlit` and `bardapi`. </br>
+You will also need to authenticate with the Bard API by visiting https://bard.google.com/, </br>
+1.Opening the console with F12 </br>
+2.Going to **Application** → **Cookies**, and copying the value of the **__Secure-1PSID** cookie.</br>
+3.Then you can setup the key to your **local environment** by running the following command:</br>
+```export _BARD_API_KEY=<__Secure-1PSID value>``` Remember the `_` before `BARD_API_KEY` is important. </br>
+Or you can use `bardcoder_lib.py` to set the key to your **local environment** by running the following method `bard_coder.set_api_key(<__Secure-1PSID value>)` </br>
+![showcase_api_key](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/showcase_api_key.png?raw=true "")</br>
+
+4.Then you can run the application by running the following command:
+```python bardcoder.py``` </br>
+5.You can also run the code interpreter by running the following command:
+```python code_interpreter.py``` </br>
+
+## Installation Guide
+Do not expose the `__Secure-1PSID value`. 
+Note that while it is referred to as an `API KEY` for convenience, it is not an officially provided API KEY.
+
+To install the dependencies, you can use pip to install from the **requirements.txt** file:
+This will install streamlit, bard-coder-api, and any other dependencies listed in the `requirements.txt` file.
+
+## Usage
+There are 3 components of this application:
+1. BardCoder: A coding assistant from Bard which automatically generates code from bard responses and refines it for coding purposes. This can be used by developers to get the correct code from Bard when they need help because the output is refined and fixed multiple times to provide the correct code.
+- File: `bardcoder.py`
+
+![bardcoder_main](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/bardcoder_main.png?raw=true "")</br>
+
+2. AutoBard-Coder Interpreter: This is an interpreter for bardcoder which can be used to run the code generated from bardcoder. This can be very useful for all users who want to do data analysis and machine learning with bard. This can generate graphs and charts from bard responses and can be used to do data analysis.
+- File: `bardcode_interpreter.py`
+
+3. BardCoder Lib: This is a library for bardcoder which can be used to generate code from bard responses and refine it for coding purposes. You can use it to build your own application using bard.
+- File: `bardcoder_lib.py`
+
+## Using BardCoder:
+To use BardCoder, you will need to run the following command:
+```python bardcoder.py```
+This will open the BardCoder UI in the terminal. And will be asked to enter prompts for bard.
+![bard_coder](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/bardcoder_main.png?raw=true "")</br>
+Not this assumes you have already set the `API KEY` in your local environment. If you have not, please refer to the setup process.
+The code generated will be placed in folder `codes` and the response will be placed in folder `response`.
+
+## Using Code Interpreter:
+To use Code Interpreter, you will need to run the following command:
+```python bardcode_interpreter.py```
+This will open the Code Interpreter UI in the Web Browser. And will be asked to enter prompts for bard.
+![code_interpreter](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/code_interpreter_main_ui.png?raw=true "")</br>
+
+Now this assumes you have already set the `API KEY` in your local environment. If you have not, please refer to the setup process.
+You can also setup the `API KEY` in the UI settings.
+![code_interpreter_settings](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/code_interpreter_settings.png?raw=true "")</br>
+
+Before prompting you should check the **Options** to change **Filenames** and **Filepaths** and other settings.
+
+### Uploading data for data analysis:
+You can set the `Upload Data` in **Options** to upload data for data analysis.
+![upload_data_ui](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/upload_data_ui.png?raw=true "")</br>
+
+After uploading the files you can ask for the prompts from bard. And you will get the output like this.
+![upload_data_output](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/upload_data_output.png?raw=true "")</br>
+
+You can also set the `Expected Output` in **Options** to get the **Accuracy** of the code generated.
+![expected_output](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/code_interpreter_expected_output.png?raw=true "")</br>
+
+And output will be generated like this with hilighting the **Accuracy** of the code generated.
+![expected_output](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/code_interpreter_output.png?raw=true "")</br>
+
+### Sharing code with others:
+You can share code with others by using the **ShareGPT** feature. You will get sharable link for your code.
+![bard_code_share](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/bard_code_share.png?raw=true "")</br>
+
+### Code Interpreter Demo:
+[Code Interpreter Demo](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/code_interpreter_demo.webm)</br>
+[![code_interpreter_demo](https://img.youtube.com/vi/Flg1qUzs9ew/0.jpg)](https://youtube.com/shorts/Flg1qUzs9ew)
+
+The code generated will be placed in folder `codes` and the response will be placed in folder `response` and upload files will be placed in folder `uploads`.
+
+### Safety and Measures:
+This now has **safety measures** built in _Code Interpreter_ and now it can detect the **safety** of the code generated and can **fix** it.</br>
+So now all the repo and code in **READ_ONLY** mode. And you can only run the code in **READ_ONLY** mode.</br>
+All the commands which **__changes,move,delete,rename__** files are disabled in **READ_ONLY** mode.</br>
+This has advanced **safety measures** and can detect the **safety** of the code generated and can **fix** it.</br>
+![safety_output](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/safety_output.png?raw=true "")</br>
+
+
+### Graphs and Visual Charts output:
+To get Graphs and Charts output for your data visualization, you will install python packages `matplotlib`, `seaborn`, `cartopy`, `plotnine` and more. and run the following command: </br>
+```python bardcode_interpreter.py``` </br>
+And ask for the prompts from bard. And you will get the output like this:
+Example Prompt:
+```
+In Python write me program to.
+1.Read the data from file called 'employees.json'
+2.Count no. of Males and Females in file.
+4.Draw PIE graph of these in using Python Matplotlib.
+5.Show me that output.
+```
+
+And you will get output like this.
+![expected_output](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/employees_chart.png?raw=true "")</br>
+
+## Directory Structure
+This application uses the Bard API to interact with bard and refine the results for coding purposes. All data that is generated is stored in the following directories:
+- `response`: This directory contains all the responses from bard.
+- `codes`: This directory contains all the code generated from bard.
+- `uploads`: This directory contains all the data that is uploaded to bard.
+
+## Features
+Some of the features of AutoBard-Coder include:
+- Automatic code generation from bard responses
+- Refinement of code for coding purposes
+- Ability to fix its own code
+- Ability to debug its own code
+- Ability to generate single or multiple responses from bard
+- Ability to save responses and run them locally
+- Ability to access local files for code interpretation
+- Data analysis and machine learning capabilities
+- Graphs and charts generation from bard responses
+- Ability to upload files for data analysis and machine learning.
+- Share code with others with powerered by ShareGPT.
+- Advanced safety measures to detect the safety of the code generated.
+
+## Help Section.
+Now you can get help directly from the application. You can get help by clicking on the **Help** button in the UI.
+![code_interpreter_help](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/resources/code_interpreter_help.png?raw=true "")</br>
+
+## Changelog 📝
+
+All notable changes to this project will be documented in this file.
+
+[CHANGELOGS](https://github.com/haseeb-heaven/AutoBard-Coder/blob/master/CHANGELOGS.md)
+
 ---
-title: AutoBard Coder
-emoji: 🦀
-colorFrom: red
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
-license: mit
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+| Version | Date       | Added                                              | Fixed                |
+| ------- | ---------- | -------------------------------------------------- | -------------------- |
+| 1.3     | 2023-05-29 | - **Updated** with totally new _UI_ and _UX_. 🎨<br>- Updated security for code checking and prompt checking. 🔒<br>- Added new Help section. 🆘 | - Fixed API Key issues. |
+| 1.2     | 2023-05-28 | - Advanced security for code and prompt checking. 🔒<br>- Support for graphs, charts, and tables. 📊<br>- More libraries for data science. 🧬 |                      |
+| 1.1     | 2023-05-27 | - Upload files option. 📤<br>- API key settings. 🔑  | - Error handling from server. 🛠 |
+| 1.0     | 2023-05-26 | - Auto barcode generator. 🏷<br>- Auto barcode interpreter. 🔎 |                      |
+
+
+
+
+## License and Author
+AutoBard-Coder was created by HeavenHM and is licensed under the MIT license.

app.py

@@ -0,0 +1,629 @@
+"""
+Details : AutoBard-Coder is code genrator for bard. It is used to generate code from bard response.
+its using Bard API to interact with bard and refine the results for coding purpose.
+The main purpose of this is for research and educational purpose.
+This is using unofficial bard api and not affiliated with bard in any way - So use it at your own risk.
+This can generate the code from prompt and fix itself unless the code is fixed.
+Language : Python
+Dependencies : streamlit, bard-coder
+Author : HeavenHM.
+License : MIT
+Date : 21-05-2023
+"""
+
+# Import the required libraries
+import logging
+import sys
+import streamlit as st
+from os import path
+import time
+import traceback
+from lib.bardcoder_lib import BardCoder
+import subprocess
+from io import StringIO
+import re
+from lib.sharegpt_api import sharegpt_get_url
+from lib.blacklist_commands import harmful_commands_python, harmful_commands_cpp, harmful_prompts
+from PIL import Image
+import tokenize
+import io
+
+# The input limit of Bard is 4,000 character (As per the Bard API documentation)
+# But you can give more input upto 10,000 characters. so we are gonna stick to that.
+BARD_FILE_SIZE_LIMIT = 10000
+
+# Function to measure the accuracy of the code
+
+
+def measure_accuracy(counter):
+    accuracy = 1 / (counter + 1)
+    accuracy_percentage = accuracy * 100
+    st.info(
+        f"Output has been fixed {counter} times with accuracy {accuracy_percentage:.0f}%")
+
+
+def show_content(content):
+    # Open the file and read its contents
+    with open(content, "r") as f:
+        markdown_text = f.read()
+
+    # Display the Markdown text in the app
+    st.markdown(markdown_text)
+
+
+# method to execute the bard coder process
+def auto_bard_execute(prompt, code_file='code.txt', code_choices='code_choice', expected_output=None, exec_type='single', rate_limiter_delay=5):
+    try:
+        # Additional prompt for class clarification.
+        # prompt += "\n" + f"Note: The Name the class should be {code_file} if Java language is requested"
+
+        # Additional prompt for no input clarification.
+        prompt += "\n" + "Dont ask the input from user.If input values are provided in code just use them. otherwise, you can hardcode the input values in code."
+
+        # Setting the prompt.
+        prompt_status, error_reason = st.session_state.bard_coder.set_prompt(prompt)
+        if not prompt_status:
+            st.error(f"Error no data was recieved from Server, Reason {error_reason}")
+            st.stop()
+
+        # Get the code from the response.
+        code = st.session_state.bard_coder.get_code()
+        # Save the code to file
+        saved_file = st.session_state.bard_coder.save_code(code_file, code)
+        if saved_file:
+            st.info(f"Code saved to file {saved_file}")
+        else:
+            st.info("Code not saved to file")
+            return None, None, False
+
+        st.info("Executing primary code")
+        # check for safe code to run.
+        code = st.session_state.bard_coder.read_file(saved_file)
+        safe_code = False
+        code_snippet = None
+        code_command = None
+        safe_code_dict = []
+
+        if code:
+            safe_code_dict = is_code_safe(code)
+            # Get tuple from list of tuples code_safe_dict
+            safe_code = safe_code_dict[0][0]
+            code_command = safe_code_dict[0][1]
+            code_snippet = safe_code_dict[0][2]
+
+        if safe_code:
+            code_output = st.session_state.bard_coder.execute_code(saved_file)
+            if code_output and code_output != None and code_output.__len__() > 0:
+                if 'error' in code_output.lower() or 'exception' in code_output.lower():
+                    st.info(f"Error in executing code with type {exec_type}")
+                    return code_output, saved_file, False
+
+                # Check if expected output is in code output.
+                if expected_output and expected_output in code_output:
+                    code_choices_output = [code_output]
+                    return code_output, saved_file, True
+                else:
+                    if exec_type == 'single':
+                        time.sleep(rate_limiter_delay)
+                        return code_output, saved_file, False
+                    else:
+                        time.sleep(rate_limiter_delay)
+            else:
+                return code_output, saved_file, False
+
+            # Save all the code choices to file
+            if exec_type == 'multiple':
+                st.session_state.bard_coder.save_code_choices(code_choices)
+
+                st.info("Executing code choices")
+                code_choices_output = st.session_state.bard_coder.execute_code_choices()
+                code_choices_output.append(code_output)
+                st.info(f"Output: {code_choices_output}")
+
+            return code_choices_output, saved_file, False
+        else:
+            for safe_codes in safe_code_dict:
+                if safe_codes[0]:  # Skip if code is safe
+                    continue
+
+                safe_code = safe_codes[0]
+                code_command = safe_codes[1]
+                code_snippet = safe_codes[2]
+                st.error(f"Error: Cannot execute the code because of illegal command found '{code_command}' in code snippet '{code_snippet}'")
+                BardCoder.write_log(f"Cannot run the code:\n'{code}'\nbecause of illegal command found '{code_command}' in code snippet '{code_snippet}'")
+            st.stop()
+            return None, None, False
+
+    except Exception as e:
+        # show_outputf the stack trace
+        stack_trace = traceback.format_exc()
+        st.info(stack_trace)
+        st.info(str(e))
+
+
+# method to execute the bard coder process
+def auto_bard_setup(prompt, code_file='code.txt', code_choices='code_choice', expected_output=None, exec_type='single', rate_limiter_delay=5):
+
+    # Append the codes directory to filename
+    code_file = path.join("codes", code_file)
+    test_cases_output = 0  # Test cases for output.
+
+    # Start the bard coder process
+    code_choices_output, saved_file, status = auto_bard_execute(
+        prompt, code_file, code_choices, expected_output, exec_type)
+    code_output = None
+
+    # Check if file is saved.
+    if not saved_file:
+        return code_choices_output, saved_file, status
+
+    if status:
+        st.info(
+            f"Expected output found in file {saved_file}\nOutput: {code_choices_output}")
+    else:
+        st.info(
+            f"Expected output not found in file {saved_file}\nOutput: {code_choices_output}")
+        if code_choices_output:
+            code_output = ''.join(code_choices_output)
+        if code_output and code_output != None and code_output.__len__() > 0:
+
+            # Check for errors like 'error' or 'Error' check case sensitivity and add more error checks.
+            if code_output is not None:
+                code_output = "".join(code_output)
+            else:
+                code_output = ""
+
+            if code_output:
+                while 'error' in code_output.lower() or 'exception' in code_output.lower():
+                    st.info(
+                        "Error in executing code,Trying to fix the code with error")
+
+                    # Re-prompt on error.
+                    code = st.session_state.bard_coder.get_code()
+                    prompt = f"I got error while running the code {code_output}.\nPlease fix the code ``\n`{code}\n``` \nand try again.\nHere is error {code_output}\n\n" + \
+                        "Note:The output should only be fixed code and nothing else. No explanation or anything else."
+
+                    # Start the bard coder process again.
+                    code_output, saved_file, status = auto_bard_execute(
+                        prompt, code_file, code_choices, expected_output, exec_type)
+                    # Sleep for 5 seconds before re-prompting. Dont get Rate limited.
+                    time.sleep(rate_limiter_delay)
+                    test_cases_output += 1
+
+            st.info("Code has been fixed for errors")
+            st.code(code_output, language="python")
+
+            # Check for expected output.
+            if code_output and expected_output and code_output.__len__() > 0:
+
+                # While expected output does not contain in code output.
+                while expected_output not in code_output:
+                    st.info(
+                        f"Expected output {expected_output} not found in code\nOutput: {code_output}")
+
+                    # Re-prompt on expected output not found.
+                    code = st.session_state.bard_coder.get_code()
+                    prompt = f"I got output {code_output}.\nPlease fix the code ``\n`{code}\n```  \nand try again.\nHere is expected output: {code_output}\n\n" + \
+                        "Note:The output should only be fixed code and nothing else. No explanation or anything else."
+
+                    # start the bard coder process again.
+                    code_output, saved_file, status = auto_bard_execute(
+                        prompt, code_file, code_choices, expected_output, exec_type)
+
+                    # Sleep for N seconds before re-prompting. Dont get Rate limited.
+                    time.sleep(rate_limiter_delay)
+                    test_cases_output += 1
+
+                st.info("Code has been fixed for expected output")
+                st.info(code_output)
+            else:
+                st.info("Not checking for code expected output")
+        else:
+            st.info("Code output is empty for error")
+
+    # Print output and information.
+    measure_accuracy(test_cases_output)
+    content_file = "response/content.md"
+    show_content(content_file)
+    return code_output, saved_file, status
+
+
+def find_image_files(file_path):
+    # Create a regular expression for image files
+    image_regex = re.compile(r"\b\w+\.(png|jpg|jpeg|gif|bmp)", re.IGNORECASE)
+
+    # Open the code file
+    with open(file_path) as f:
+        # Read the lines
+        lines = f.readlines()
+        # Loop through the lines
+        for line in lines:
+            # Search for image files in the line
+            match = image_regex.search(line)
+            # If there is a match
+            if match:
+                # Get the image file name
+                image_file = match.group()
+                # Print the image file name
+                return image_file
+    return None
+
+
+def is_prompt_safe(prompt):
+    if prompt is None:
+        BardCoder.write_log("Prompt is Empty")
+        return False
+    
+    BardCoder.write_log("Checking prompt for safety")
+
+    # Extra care for prompt input.
+    prompt_list = [re.sub(r'[^\w\s]', '', re.sub(r'(\*\*|__)(.*?)(\*\*|__)', r'\2', re.sub(
+        r'^\W+|\W+$', '', item))).strip() for item in re.split('\n| ', prompt.lower()) if item.strip() != '']
+    prompt_list = [re.sub(r'\d+', '', i) for i in prompt_list]
+    BardCoder.write_log(f"Prompt list is {prompt_list}")
+
+    # Convert the code to lowercase and split it into a list of words
+
+    # Check if any harmful command is in the list of words
+    for command in harmful_prompts:
+        if command in prompt_list:
+            BardCoder.write_log(f"Prompt is not safe because of illegal command found '{command}'")
+            return False, command
+    BardCoder.write_log(f"Input Prompt is safe")
+    return True, None
+
+
+def tokenize_source_code(source_code):
+    tokens = []
+    try:
+        for token in tokenize.generate_tokens(io.StringIO(source_code).readline):
+            if token.type not in [tokenize.ENCODING, tokenize.NEWLINE, tokenize.INDENT, tokenize.DEDENT]:
+                if any(char in token.string for char in ['::', '.', '->', '_']) or token.string.isalnum():
+                    token_str = re.sub(r'\'|\"', '', token.string)
+                    tokens.append(token_str)
+    except tokenize.TokenError:
+        if st.session_state.bard_coder:
+          BardCoder.write_log("Error parsing the tokens")
+    if tokens:
+        tokens = list(([token.lower() for token in tokens]))
+    if st.session_state.bard_coder:
+      BardCoder.write_log(f"Tokenise was called and Tokens length is {tokens.__len__()}")
+    return tokens
+
+
+def is_code_safe(code):
+    if st.session_state.bard_coder:
+      BardCoder.write_log("Checking code for safety")
+
+    # Combine both lists
+    harmful_code_commands = harmful_commands_python + harmful_commands_cpp
+
+    # Tokenize the code
+    tokens_list = tokenize_source_code(code)
+
+    # Initialize the output dictionary
+    output_dict = []
+
+    # Check if any harmful command is in the list of words
+    for command in harmful_code_commands:
+        for token in tokens_list:
+            if command == token:
+                output_dict.append((False, command, token))
+
+    if output_dict is None or output_dict.__len__() == 0:
+        output_dict = [(True, None, None)]
+    if st.session_state.bard_coder:
+      BardCoder.write_log(f"Output dict is {output_dict}")
+    return output_dict
+
+
+def load_css(file_name):
+    # Open the file and read the content
+    with open(file_name) as fp:
+        css = fp.read()
+    # Use st.components.v1.html to load the CSS file
+    st.markdown(f'<style>{css}</style>', unsafe_allow_html=True)
+
+
+def display_logo(logo_file: str, title: str):
+    # create two columns
+    col1, col2 = st.columns(2, gap='large')
+
+    # use the first column for the image
+    col1.image(logo_file, width=370)
+
+    # use the second column for the title
+    col2.title(title)
+
+
+def dsiplay_buttons(is_prompt_valid: bool):
+    col1, col2, col3 = st.columns(3, gap='large')
+
+    with col1:  # use the first column
+        run_button = st.button("Run", key="run-button", use_container_width=True,
+                               disabled=not is_prompt_valid)  # place the run button as a regular button
+
+    with col2:  # use the second column
+        share_button = st.button("Share", key="share-button", use_container_width=True,
+                                 disabled=not is_prompt_valid)  # place the share button as a regular button
+
+    with col3:
+        # place the help button as a regular button
+        help_button = st.button(
+            "Help", key="help-button", use_container_width=True)
+
+    return run_button, share_button, help_button
+
+
+def init_bard_coder_session(api_key=None, timeout=10):
+    # Initialize the bard coder session
+    bard_coder = BardCoder(api_key=api_key, enable_logs=True, timeout=timeout)
+    return bard_coder
+
+
+def init_session_state():
+  # Initialize the session state variables
+    if "bard_coder" not in st.session_state:
+        st.session_state.bard_coder = None
+    
+    if "api_key_initialized" not in st.session_state:
+        st.session_state.api_key_initialized = False
+
+    if "code_output" not in st.session_state:
+        st.session_state.code_output = ""
+
+    if "messages" not in st.session_state:
+        st.session_state.messages = ""
+
+    if "text_area" not in st.session_state:
+        st.session_state.text_area = ""
+
+    if "file_size" not in st.session_state:
+        st.session_state.file_size = 0
+
+    if "file_char_count" not in st.session_state:
+        st.session_state.file_char_count = 0
+
+
+if __name__ == "__main__":
+    try:
+        BardCoder.write_log("Starting the streamlit App")
+                    
+        # Load the CSS file named style.css
+        load_css("styles/style.css")
+
+        # Upload file data variables
+        upload_prompt_data, upload_data, uploaded_file = None, None, None
+
+        # Initialize the session state variables
+        BardCoder.write_log("Initializing the session state variables")
+        init_session_state()
+        BardCoder.write_log("Session state variables initialized")
+
+        # Set the logo and title
+        logo_file = "resources/logo.png"
+        title = "Code Interpreter"
+        display_logo(logo_file, title)
+        BardCoder.write_log("Logo and title set")
+
+        # Use the text_area variable from the session state for input
+        prompt = st.text_area(placeholder="Enter your prompt here", label="Prompt",label_visibility="hidden", height=300, key="text_area_input")
+
+        # check if prompt is changed.
+        if prompt != st.session_state.text_area:
+            BardCoder.write_log(f"Prompt changed from '{st.session_state.text_area}' to '{prompt}'")
+            st.session_state.text_area = prompt
+
+        character_count: int = len(st.session_state.text_area)
+
+        # Status info message. (Char count and file size)
+        status_info_msg = f"Characters:{character_count}/{BARD_FILE_SIZE_LIMIT}"
+
+        if st.session_state.file_size > 0:
+            BardCoder.write_log(f"File Char count is {st.session_state.file_char_count}")
+            character_count += st.session_state.file_char_count
+            # Update the character count for file size.
+            status_info_msg = f"Characters:{character_count}/{BARD_FILE_SIZE_LIMIT}"
+            status_info_msg += " | " + f"File Size is {st.session_state.file_size/1024:.2f}Kb | {st.session_state.file_size/1024/1024:.2f}Mb"
+
+        st.info(status_info_msg)
+
+        # check the Prompt for safety and file size exceeding 4,000 characters.
+        prompt_safe = True
+        if st.session_state.bard_coder:
+            prompt_safe, command = is_prompt_safe(prompt)
+            if not prompt_safe:
+                BardCoder.write_log(f"Error in prompt because of unsafe command found '{command}'")
+                st.error(f"Error in prompt because of illegal command found '{command}'")
+
+        if character_count > BARD_FILE_SIZE_LIMIT or st.session_state.file_char_count > BARD_FILE_SIZE_LIMIT:
+            st.error(f"Error in prompt The file size limit exceeded {BARD_FILE_SIZE_LIMIT} characters")
+
+            # Adding the upload file option
+            uploaded_file = st.file_uploader("Choose a file")
+            if uploaded_file is not None:
+
+                # To read file as bytes:
+                bytes_data = uploaded_file.getvalue()
+                # get the file size
+                st.session_state.file_size = uploaded_file.size
+
+                # To convert to a string based IO:
+                stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
+                # To read file as string:
+                upload_data = stringio.read()
+
+                # Count the number of characters in the file
+                st.session_state.file_char_count = len(upload_data)
+
+                # write the file to uploads directory
+                with open("uploads/" + uploaded_file.name, "w") as f:
+                    f.write(upload_data)
+
+                # Display a success message
+                st.success("File uploaded successfully.")
+
+        # Setting options for the application
+        with st.expander("Options"):
+            code_file = st.text_input("Filename for the generated code (without extension):", value="generated_code")
+            code_choices = st.text_input("Filename for code choices:", value="code_choices")
+            expected_output = st.text_input("Expected output (leave blank if none):")
+            exec_type = st.selectbox("Execution type:", ["single", "multiple"], index=0)
+            timeout_delay = st.number_input("Timeout (in seconds):", value=10)
+            
+        with st.expander("Settings"):
+            bard_key_help_text = """
+      How to obtain Google Bard API key.
+      1. Visit bard.google.com and open the console with F12
+      2. Go to Application → Cookies and copy the __Secure-1PSID value
+      3. This is your API key paste it below.
+      """
+            st.info(bard_key_help_text)
+            bard_api_key = st.text_input(label="API Key", label_visibility="hidden", type="password", placeholder="Enter your bard API key.")
+            
+            if bard_api_key and not st.session_state.api_key_initialized:
+                # how to call write_file static method from BardCoder class
+                BardCoder.write_log("Starting init API Key")
+                
+                st.session_state.bard_coder = init_bard_coder_session(bard_api_key,timeout_delay)
+                if BardCoder.bard_init:
+                    st.session_state.api_key_initialized = True
+                    BardCoder.write_log("Bard Coder initialized successfully")
+                    st.info("Bard Coder initialized successfully")
+                else:
+                    st.session_state.api_key_initialized = False
+                    BardCoder.write_log("Error initializing Bard Coder")
+                    st.error("Error initializing Bard Coder")
+                  
+
+
+        # Setting advanced options for the application
+        with st.expander("Advanced"):
+            try:
+                # button to show logs.
+                show_logs = st.button("Show Logs", key="show-logs-button", use_container_width=True)
+                if show_logs:
+                    if st.session_state.bard_coder:
+                        logs_data = st.session_state.bard_coder.read_file(st.session_state.bard_coder.logs_file)
+                        st.code(logs_data, language="python")
+            except Exception as e:
+                st.error(f"Error in showing logs {e}")
+                    
+            # button to show content.
+            try:
+                show_content_button = st.button("Show Content", key="show-content-button", use_container_width=True)
+                if show_content_button:
+                    if st.session_state.bard_coder:
+                        content_data = st.session_state.bard_coder.read_file("response/response.md")
+                        st.code(content_data, language="python")
+            except Exception as e:
+                st.error(f"Error in showing content {e}")
+            
+            # button to show response.
+            try:
+                show_response_button = st.button("Show Response", key="show-response-button", use_container_width=True)
+                if show_response_button:
+                    if st.session_state.bard_coder:
+                        response_data = st.session_state.bard_coder.read_file("response/response.json")
+                        st.code(response_data, language="json")
+            except Exception as e:
+                st.error(f"Error in showing response {e}")
+                        
+        # Setting the buttons for the application
+        run_button, share_button, help_button = dsiplay_buttons(prompt_safe and st.session_state.file_char_count < BARD_FILE_SIZE_LIMIT)
+
+        # Setting application to run
+        if run_button:
+            # Code to execute when the "Run" button is clicked
+
+            # Check if API Key is empty
+            if bard_api_key is None or bard_api_key == "" or bard_api_key.__len__() == 0:
+                st.error("Error executing code the API key is missing from settings.\nPlease go to settings and add your API key.")
+                BardCoder.write_log("Error executing code the API key is missing from settings.Please go to settings and add your API key.")
+                st.stop()
+
+            # Clear the previous cache.
+            st.info("Running the code interpreter...")
+            subprocess.call(['bash', 'bash_src/clear_cache.sh'])
+
+            # Append the uploaded file data to prompt
+            if upload_data:
+                prompt += "\n" + f"Here is the file called {uploaded_file.name} at location {'uploads/' + uploaded_file.name} data.\n" + \
+                    f"```\n{upload_data}\n```"
+
+            # If graph were requested.
+            if 'graph' in prompt.lower():
+                prompt += "\n" + "using Python use Matplotlib save the graph in file called 'graph.png'"
+
+            # if Chart were requested
+            if 'chart' in prompt.lower() or 'plot' in prompt.lower():
+                prompt += "\n" + "using Python use Plotly save the chart in file called 'chart.png'"
+
+            # if Table were requested
+            if 'table' in prompt.lower():
+                prompt += "\n" + "using Python use Pandas save the table in file called 'table.md'"
+
+            # Refine the prompt for harmful commands.
+            if prompt_safe:
+                # Run the auto bard setup process.
+                log_container = st.empty()
+                st.session_state.code_output, saved_file, status = auto_bard_setup(prompt, code_file, code_choices, 
+                                                                                   expected_output, exec_type,timeout_delay)
+            else:
+                st.error(f"Cannot execute the prompt because of illegal command found '{command}'")
+                BardCoder.write_log(f"Cannot execute the prompt: '{prompt}' because of illegal command found '{command}'")
+                st.stop()
+
+            # Check if output is Graph,Chart request.
+            if 'graph' in prompt.lower() or 'chart' in prompt.lower():
+                image_file_graph = find_image_files(saved_file)
+                if image_file_graph:
+                    BardCoder.write_log(f"Graph image file is {image_file_graph} and code file is {saved_file}")
+                    image = Image.open(image_file_graph)
+                    st.image(image, caption='Graph Output')
+
+            # Check if output in Table request.
+            if 'table' in prompt.lower():
+                table_file = "table.md"
+                table_file_data = st.session_state.bard_coder.read_file(
+                    table_file)
+                if table_file_data:
+                    st.markdown(table_file_data)
+
+        # Adding Share button
+        if share_button:
+            if st.session_state.code_output is None or st.session_state.messages is None:
+                BardCoder.write_log("ShareGPT: Error Please run the code generator first")
+                st.error("Error: Please run the code generator first")
+            else:
+                gpt_data = prompt
+                human_data = ""
+
+                if st.session_state.messages:
+                    human_data = "Bard Logs: \n" + st.session_state.messages
+                if st.session_state.code_output:
+                    human_data += "\nOutput:\n" + st.session_state.code_output
+                human_data += "\n\n[AutoBard-Coder: Repo](https:#github.com/haseeb-heaven/AutoBard-Coder)"
+
+                if gpt_data.__len__() > 0 and human_data.__len__() > 0:
+                    sharegpt_url = sharegpt_get_url(gpt_data, human_data)
+                    st.info(f"ShareGPT Url: {sharegpt_url}")
+                else:
+                    BardCoder.write_log("ShareGPT: Error Please run the code generator first")
+                    st.error("Error: Please run the code generator first")
+
+        # Adding Help button
+        if help_button:
+            content_file = "README.md"
+            if st.session_state.bard_coder:
+                content_data = st.session_state.bard_coder.read_file(content_file)
+                st.markdown(content_data, unsafe_allow_html=True)
+            else:
+                st.error("API key is missing from settings.\nPlease go to settings and add your API key.")
+                BardCoder.write_log("Help: Error API key is missing from settings.")
+
+    except Exception as e:
+        # show_outputf the stack trace
+        stack_trace = traceback.format_exc()
+        st.error("Error: " + str(e))
+        st.error(stack_trace)

bash_src/clear_cache.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# Create codes folder if it doesn't exist
+if [ ! -d "codes" ]; then
+  mkdir codes
+fi
+
+# removing only all executables from codes.
+file -F: codes/* | grep "executable" | cut -d: -f1 | xargs rm
+
+# clearing response files and logs
+#truncate -s 0 bardcoder.log
+truncate -s 0 response/content.md
+truncate -s 0 response/response.json

bash_src/code_runner.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+
+filename=$1
+debug=0
+cpp_version="c++17"
+
+if [[ $filename == *.c ]]; then
+  extension=".c"
+  compiler="gcc"
+  language="c"
+elif [[ $filename == *.cpp ]]; then
+  extension=".cpp"
+  compiler="g++"
+  language="c++"
+elif [[ $filename == *.java ]]; then
+  extension=".java"
+  compiler="javac"
+  language="java"
+elif [[ $filename == *.go ]]; then
+  extension=".go"
+  compiler="go run"
+  language="go"
+elif [[ $filename == *.cs ]]; then
+  extension=".cs"
+  compiler="csc"
+  language="csharp"
+elif [[ $filename == *.swift ]]; then
+  extension=".swift"
+  compiler="swift"
+  language="swift"
+# add for python
+elif [[ $filename == *.py ]]; then
+  extension=".py"
+  compiler="python3"
+  language="python"
+elif [[ $filename == *.js ]]; then
+  extension=".js"
+  compiler="node"
+  language="javascript"
+elif [[ $filename == *.rs ]]; then
+  extension=".rs"
+  compiler="rustc"
+  language="rust"
+else
+  echo "Error: Unsupported file type"
+  exit 1
+fi
+
+if [ $language == "c++" ]; then
+  if [[ $3 == c++* ]]; then
+    version=${3#c++}
+    if [[ $version == 17 || $version == 14 || $version == 11 || $version == 0x ]]; then
+      cpp_version="c++$version"
+    fi
+  fi
+fi
+
+if [[ $2 == "--debug" ]]; then
+  debug=1
+fi
+
+if [ $debug -eq 1 ]; then
+  if [ $language == "c++" ]; then
+    echo "Compiling $filename with $compiler (C++ $cpp_version)..."
+  else
+    echo "Compiling $filename with $compiler..."
+  fi
+fi
+
+if [ $language == "c" ]; then
+  $compiler $filename -o ${filename%.*}
+elif [ $language == "c++" ]; then
+  $compiler $filename -std=$cpp_version -o ${filename%.*}
+elif [ $language == "java" ]; then
+  $compiler $filename
+elif [ $language == "go" ]; then
+  $compiler $filename
+elif [ $language == "csharp" ]; then
+  $compiler /out:${filename%.*}.exe $filename
+elif [ $language == "swift" ]; then
+  $compiler $filename
+elif [ $language == "python" ]; then
+  $compiler $filename
+elif [ $language == "javascript" ]; then
+  $compiler $filename
+elif [ $language == "rust" ]; then
+  $compiler $filename
+else
+  echo "Error: Unsupported file type"
+  exit 1
+fi
+
+if [ $? -ne 0 ]; then
+  echo "Compilation failed"
+  exit 1
+fi
+
+if [ $debug -eq 1 ]; then
+  echo "Running ${filename%.*}..."
+fi
+
+if [ $language == "java" ]; then
+  java ${filename%.*}
+elif [ $language == "go" ]; then
+  $compiler $filename
+else
+  ./${filename%.*}
+fi
+
+if [ $debug -eq 1 ]; then
+  echo "Finished running ${filename%.*}"
+fi
+

lib/bardcoder_lib.py

@@ -0,0 +1,440 @@
+"""
+Details : BardCoder Library is code genrator for bard. It is used to generate code from bard response.
+its using Bard API to interact with bard and refine the results for coding purpose.
+The main purpose of this is to integrate bard with any projects and make code generation easy.
+Language : Python
+Author : HeavenHM.
+License : MIT
+Date : 21-05-2023
+"""
+
+# import libraries
+import json
+import logging
+import os
+import json
+from bardapi import Bard
+import traceback
+import subprocess
+import time
+from os import path
+import lib.extensions_map as extensions_map
+from lib.extensions_map import get_file_extesion
+import inspect
+
+class BardCoder:
+    global bard
+    global logger
+    bard_init = False
+    logs_enabled = False
+    logs_file = "bardcoder.log"
+    response_id, conversation_id, content, factuality_queries, text_query, code_choices, code_extension = None, None, None, None, None, None, None
+    
+    # Initial setup
+    def __init__(self,api_key=None,timeout=10,enable_logs=False):
+        try:
+            BardCoder.write_log("Starting to initialize BardCoder.")
+            # Dont initialize if api key is None.
+            if api_key is None or api_key == "" or '.' not in api_key:
+                BardCoder.write_log("BardCoder API key is missing or is invalid Skipping init")
+                self.bard = None
+                BardCoder.bard_init = False
+                return None
+            
+            # Setting up the api key.
+            BardCoder.write_log("Setting up the api key")
+            if api_key and '.' in api_key:
+                self.set_api_key(api_key)
+            
+            BardCoder.write_log("Setting up the prompt")
+            # Setting up Bard from BardAPI.
+            self.bard = Bard(timeout=timeout)  # Set timeout in seconds
+            
+            if not self.bard:
+                BardCoder.write_log("BardCoder not initialized...Skipping init.")
+                self.bard = None
+                BardCoder.bard_init = False
+                return None
+
+            # Enable logs
+            if enable_logs:
+                self.enable_logs()
+            
+            BardCoder.write_log("Setting up the logger")
+            # Setups the logging.
+            self.logger = self.setup_logger(self.logs_file)
+            
+            BardCoder.bard_init = True
+            BardCoder.write_log("BardCoder initialized successfully.")
+            
+        except Exception as e:
+            self.add_log(str(e))
+            stack_trace = traceback.format_exc()
+            self.add_log(stack_trace)
+            self.bard = None
+    
+    def write_log(data:str=None):
+        if data is None:
+            raise ValueError("Data cannot be None")
+        with open("bardcoder.log",'a') as f:
+            # Get the name of the calling function
+            caller_name = inspect.stack()[1][3]            
+            f.write(f"{time.strftime('%d-%m-%Y %H:%M:%S')} {caller_name}: {data}\n")
+
+    # Set the api key
+    def set_api_key(self, api_key):
+        if api_key:
+            os.environ['_BARD_API_KEY'] = api_key
+    
+    # Set the prompt for bard
+    def set_prompt(self, prompt):
+        try:
+            # Get the response from the prompt.
+            response = self.get_response(prompt)
+            if response:
+                data = json.dumps(response, indent=4)
+
+                if data:
+                    # Getting the data from the response.
+                    json_data = json.loads(data)
+                    if json_data:
+                        self.content = json_data['content']
+                        self.add_log("Content: " + self.content)
+
+                        # Saving the response to file.
+                        self.add_log("Saving response to file.")
+                        self.save_file("response/response.json",json.dumps(response, indent=4))
+                        self.save_file("response/content.md", self.content)
+
+                        # Getting the content from the response.
+                        self.conversation_id = json_data['conversation_id']
+                        if self.conversation_id:
+                            self.add_log(f"Conversation ID: {self.conversation_id}")
+
+                        # Getting the conversation ID from the response.
+                        self.response_id = json_data['response_id']
+                        if self.response_id:
+                            self.add_log(f"Response ID: {self.response_id}")
+
+                        # Get the factuality queries from the response.
+                        self.factuality_queries = json_data['factualityQueries']
+                        if self.factuality_queries:
+                            for factualityQuery in self.factuality_queries:
+                                self.add_log(f"Factuality Query: {factualityQuery}")
+                            # Get the links from the response.
+                            links = self.get_links()
+                            self.add_log(f"Links: {links}")
+
+                        # Get the text query from the response.
+                        self.text_query = json_data['textQuery']
+                        if self.text_query:
+                            self.add_log(f"Text Query: {self.text_query}")
+
+                        # Getting the code choices from the response.
+                        self.code_choices = json_data['choices']
+                        self.add_log(f"Code Choices: {self.code_choices}")
+                        if self.code_choices:
+                            for code_choice in self.code_choices:
+                                self.add_log(f"Code Choice: {code_choice}")
+
+                        # Mark end of init. - Success
+                        self.add_log("Success.")
+                        return True,"Success."
+                    else:
+                        self.add_log("Json data is empty.")
+                        return False,"Json data is empty."
+                else:
+                    self.add_log("Data is empty.")
+                    return False,"Data is empty."
+            else:
+                self.add_log("Response is empty.\nCheck if the API key is valid.")
+                return False,"Response is empty.\nCheck if the API key is valid."
+
+        except Exception as e:
+            # show stack trace
+            stack_trace = traceback.format_exc()
+            self.add_log(stack_trace)
+            return False,str(e)
+
+    # get the response from bard
+    def get_response(self, prompt: str):
+        if not prompt:
+            self.add_log("Prompt is empty.")
+            return ""
+        if self.bard:
+            self.add_log("Getting response from bard.")
+            response = self.bard.get_answer(prompt)
+        else:
+            self.add_log("Bard is not initialized.")
+            return None
+
+        # get response from bard
+        return response
+
+    # get multiple responses from bard
+    def get_code_choice(self, index):
+        if index < len(self.code_choices):
+            choice_content = self.code_choices[index]['content'][0]
+            start_index = choice_content.find('```') + 3
+            end_index = choice_content.find('```', start_index)
+            if start_index != -1 and end_index != -1:
+                extracted_data = choice_content[start_index:end_index]
+                result = extracted_data.strip()
+                # Remove the code language identifier
+                result = result[result.find('\n') + 1:]
+                return result
+            else:
+                return None
+        else:
+            return None
+
+    # setting the logger
+    def setup_logger(self, filename: str, level=logging.INFO):
+        # Remove existing handlers from the root logger
+        for handler in logging.root.handlers[:]:
+            logging.root.removeHandler(handler)
+
+        # Set up a file handler to write logs to a file
+        file_handler = logging.FileHandler(filename)
+        formatter = logging.Formatter('%(asctime)s - %(message)s', datefmt='%d-%m-%y %H:%M:%S')
+        file_handler.setFormatter(formatter)
+        logging.root.addHandler(file_handler)
+        logging.root.setLevel(level)
+
+        return logging.getLogger(__name__)
+
+    # get the code from bard response
+    def get_code(self):
+        try:
+            if self.content:
+                self.add_log("Getting code from content.")
+                
+                data = self.content
+                start_index = data.find("```")
+                if start_index == -1:
+                    return None
+                start_index += 3
+                end_index = data.find("```", start_index)
+                if end_index == -1:
+                    return None
+                extracted_data = data[start_index:end_index]
+                result = extracted_data.strip()
+                
+                # Remove the code language identifier
+                result = result[result.find('\n') + 1:]
+                self.add_log(f"Code: {result}")
+                return result
+        except Exception as e:
+            self.add_log(str(e))
+            stack_trace = traceback.format_exc()
+            self.add_log(stack_trace)
+            
+    def save_code(self, filename="code.txt"):
+        code = self.get_code()
+        self.code_extenstion = '.' + self.get_code_extension()
+        if code:
+            code = code.replace("\\n", "\n").replace("\\t", "\t")
+            self.add_log(f"Saving code with filename: {filename} and extension: {self.code_extenstion} and code: {code}")
+
+            # Add extension to filename
+            extension = extensions_map.get_file_extesion(self.code_extenstion) or self.code_extenstion
+            filename = filename + extension
+
+            with open(filename, 'w') as f:
+                f.write(code)
+                self.add_log(f"{filename} saved.")
+            return filename
+
+    def save_code(self, filename="code.txt", code='self.add_log("Hello World")'):
+        self.add_log(f"Saving code with filename: {filename}")
+        extension = self.get_code_extension()
+        if extension:
+            self.code_extenstion = '.' + extension
+            #code = self.get_code()
+            if code:
+                code = code.replace("\\n", "\n").replace("\\t", "\t")
+                self.add_log(f"Saving code with filename: {filename} and extension: {self.code_extenstion} and code: {code}")
+
+                # Add extension to filename
+                extension = extensions_map.get_file_extesion(self.code_extenstion) or self.code_extenstion
+                filename = filename + extension
+
+                with open(filename, 'w') as f:
+                    f.write(code)
+                    self.add_log(f"{filename} saved.")
+                return filename
+
+    # save multiple codes from bard response
+    def save_code_choices(self, filename):
+        self.add_log(f"Saving code choices with filename: {filename}")
+        extension = self.get_code_extension()
+        if extension:
+            self.code_extension = '.' + extension
+            self.code_extension = extensions_map.get_file_extesion(self.code_extenstion) or self.code_extenstion
+
+            for index, choice in enumerate(self.code_choices):
+                choice_content = self.get_code_choice(index)
+                self.add_log(f"Enumurated Choice content: {choice}")
+                self.save_file("codes/"+filename+'_'+str(index+1) +
+                               self.code_extension, choice_content)
+                
+    # execute code from bard response using locally installed compilers.
+    # a support for online compilers will be added soon.
+    def execute_code(self, filename):
+        if filename:
+            self.add_log(f"Running {filename}")
+            output = self.run_code_exec(filename)
+            self.add_log(f"Output: {output}")
+            return output
+        return None
+    
+    # execute code from bard response using locally installed compilers.
+    def run_code_exec(self, filename: str, debug: bool = False, cpp_version: str = "c++17"):
+        compiler_map = {
+            ".c": ("gcc", "c"),
+            ".cpp": ("g++", "c++"),
+            ".java": ("java", "java"),
+            ".go": ("go run", "go"),
+            ".cs": ("csc", "csharp"),
+            ".swift": ("swift", "swift"),
+            ".py": ("python3", "python"),
+            ".js": ("node", "javascript"),
+            ".rs": ("rustc", "rust")
+        }
+
+        _, extension = os.path.splitext(filename)
+        self.add_log(f"Extension: {extension}")
+        if extension not in compiler_map:
+            self.add_log(f"Extension {extension} not supported.")
+            return
+
+        compiler, language = compiler_map[extension]
+        self.add_log(f"Compiler: {compiler}")
+
+        if language == "c++" and cpp_version.startswith("c++"):
+            version = cpp_version[3:]
+            if version in ["17", "14", "11", "0x"]:
+                cpp_version = f"c++{version}"
+                self.add_log(f":C++ Version: {cpp_version}")
+
+        if debug:
+            if language == "c++":
+                 self.add_log(f"Compiling {filename} with {compiler} (C++ {cpp_version})...")
+            else:
+                 self.add_log(f"Compiling {filename} with {compiler}...")
+
+        output = ""
+        try:
+            if language == "c":
+                output = subprocess.check_output([compiler, filename, "-o", f"{filename[:-len(extension)]}"], stderr=subprocess.STDOUT).decode('utf-8')
+            elif language == "c++":
+                output = subprocess.check_output([compiler, filename, f"-std={cpp_version}", "-o", f"{filename[:-len(extension)]}"], stderr=subprocess.STDOUT).decode('utf-8')
+            elif language == "java":
+                output = subprocess.check_output([compiler, filename], stderr=subprocess.STDOUT).decode('utf-8')
+            elif language in ["go", "swift", "python", "javascript","java"]:
+                output = subprocess.check_output([compiler, filename], stderr=subprocess.STDOUT).decode('utf-8')
+            elif language == "csharp":
+                output = subprocess.check_output([compiler, f"/out:{filename[:-len(extension)]}.exe", filename], stderr=subprocess.STDOUT).decode('utf-8')
+            elif language == "rust":
+                output = subprocess.check_output([compiler, filename], stderr=subprocess.STDOUT).decode('utf-8')
+            else:
+                self.add_log("Error: Unsupported file type")
+                return
+            self.add_log(f"Output: {output}")
+        except subprocess.CalledProcessError as e:
+            output += e.output.decode('utf-8')
+            self.add_log(f"Error: {output}")
+
+        if debug:
+            self.add_log(f"Running {filename[:-len(extension)]}...")
+
+        # Checking further output for syntax ./path/filename to run the executable
+        try:
+            # run C# with mono command. like this mono ./path/filename.exe
+            if language == "csharp":
+                output_file_exec = f"{filename[:-len(extension)]}.exe"
+                output += subprocess.check_output(['mono',output_file_exec], stderr=subprocess.STDOUT).decode('utf-8')
+            
+            else:
+                output_file_exec = f"./{filename[:-len(extension)]}"
+                # checking if file exists output_file_exec
+                if os.path.isfile(output_file_exec):
+                    output += subprocess.check_output([output_file_exec], stderr=subprocess.STDOUT).decode('utf-8')
+        except (subprocess.CalledProcessError, Exception) as e:
+            if isinstance(e, subprocess.CalledProcessError):
+                output += '\n' + e.output.decode('utf-8')
+            else:
+                output += '\n' + str(e)
+            self.add_log(f"Error: {output}")
+        
+
+        if debug:
+            self.add_log(f"Finished running {filename[:-len(extension)]}")
+
+        self.add_log(f"Output: {output}")
+        return output
+
+    # execute all the code choices from bard response using locally installed compilers.
+    def execute_code_choices(self):
+        self.add_log("Running codes")
+        codes_choices_output = list()
+        for filename in os.listdir('codes'):
+            filepath = path.join('codes', filename)
+            self.add_log(f"Running {filepath}")
+            output = self.execute_code(filepath)
+            if output:
+                codes_choices_output.append(output)
+            time.sleep(5)
+        return codes_choices_output
+
+    # get the code extension from bard response - automatically detects the language from bard response.
+    def get_code_extension(self):
+        try:
+            code_content = self.content
+            if code_content and not code_content in "can't help":
+                self.code_extension = code_content.split('```')[1].split('\n')[0]
+                self.add_log(f"Code extension: {self.code_extension}")
+                return self.code_extension
+        except Exception as e:
+            stack_trace = traceback.format_exc()
+            self.add_log(stack_trace)
+        return None
+
+    # get the links from bard response
+    def get_links(self):
+        data = self.factuality_queries
+        links = []
+        self.add_log("Data: " + str(data))
+        if data is None or len(data) == 0:
+            self.add_log("Data is None.")
+            return links
+        try:
+            for inner_list in data[0]:
+                link = inner_list[2][0]
+                if link:
+                    links.append(link)
+        except Exception as e:
+            stack_trace = traceback.format_exc()
+            self.add_log(stack_trace)
+            return links
+        self.add_log("Links: " + str(links))
+        return links
+
+    def save_file(self, filename, data):
+        with open(filename, 'w') as f:
+            f.write(data)
+
+    def read_file(self, filename):
+        with open(filename, 'r') as f:
+            return f.read()
+
+    def add_log(self, log, level=logging.INFO):
+        log_msg = inspect.stack()[1][3] + ": " + log
+        if self.logs_enabled:
+            self.logger.log(level, log_msg)
+        else:
+            self.logger = self.setup_logger(self.logs_file)
+            self.logger.log(level, log_msg)
+
+    def enable_logs(self):
+        self.logs_enabled = True

lib/blacklist_commands.py

@@ -0,0 +1,369 @@
+harmful_prompts = [
+  'rename',  # Existing commands
+  'delete',
+  'remove',
+  'shutdown',
+  'reboot',
+  'format',
+  'halt',
+  'poweroff',
+  'remove file',
+  'remove folder',
+  'remove directory',
+  'delete file',
+  'delete folder',
+  'delete directory',
+  'rename file',
+  'rename folder',
+  'rename directory',
+  'move file',
+  'move folder',
+  'move directory',
+  'replace file',
+  'replace folder',
+  'replace directory',
+  'exit',  # Additional harmful prompts
+  'quit',
+  'vanish',
+  'null',
+  'void',
+  'wipe',
+  'erase',
+  'obliterate',
+  'discard',
+  'purge',
+  'exterminate',
+  'terminate',
+  'expunge',
+  'eliminate',
+  'kill file',
+  'kill folder',
+  'kill directory',
+  'destroy file',
+  'destroy folder',
+  'destroy directory',
+  'nullify file',
+  'nullify folder',
+  'nullify directory',
+  'void file',
+  'void folder',
+  'void directory',
+  'change file',
+  'change folder',
+  'change directory',
+  'shift file',
+  'shift folder',
+  'shift directory',
+   # Standalone commands
+  'remove', 
+  'delete',
+  'rename',
+  'move',
+  'replace',
+  'kill',
+  'destroy',
+  'nullify',
+  'void',
+  'change',
+  'shift',
+   # Blacklisted files
+  'bardcode_interpreter.py', 
+  'bardcoder.py',
+  'bardcoder_lib.py',
+  'bardcoder',
+  'bardcoder_lib',
+  'bardcode_interpreter',
+  'blacklist_commands.py',
+  'blacklist_commands',
+  'requirements.txt',
+  'clear_cache.sh',
+  'code_runner.sh'
+]
+
+harmful_commands_python = [
+    # Existing commands
+  'cut',
+  'dig',
+  'kedit',
+  'ftp',
+  'iwconfig',
+  'pkill',
+  'whois',
+  'scp',
+  'chgrp',
+  'nc',
+  'traceroute',
+  'pgrep',
+  'mv',
+  'move',
+  'replace',
+  'chdir',
+  'rename',
+  'kate',
+  'arp',
+  'route',
+  'host',
+  'curl',
+  'ncat.openbsd',
+  'nmap',
+  'ncat.traditional',
+  'htop',
+  'ls',
+  'netstat',
+  'ping',
+  'sudo',
+  'cd',
+  'mousepad',
+  'wireshark',
+  'wget',
+  'chown',
+  'ps',
+  'tcpdump',
+  'grep',
+  'netcat',
+  'nc.openbsd',
+  'mkdir',
+  'cp',
+  'mac',
+  'nslookup',
+  'sftp',
+  'top',
+  'format',
+  'ifconfig',
+  'nc.traditional',
+  'ip',
+  'nano',
+  'ssh',
+  'chmod',
+  'vim',
+  'kill',
+  'rm',
+  'ss',
+  'restart',
+  'telnet',
+  'kwrite',
+  'cat',
+  'ncat',
+  'rsync',
+  'delete',
+  'deleted',
+  'remove',
+  'shutdown',
+  'reboot',
+  'append',
+  'appended',
+  'remove',
+  'removed',
+  'rmdir',
+  'rmtree',
+  'shutil.rmtree',
+  'subprocess.call',
+  'eval',
+  'exec',
+  'unlink',
+  'pathlib.unlink',
+  '_exit',
+  'abort',
+  'kill',
+  'fork',
+  'execl',
+  'execle',
+  'execlp',
+  'execlpe',
+  'execv',
+  'execve',
+  'execvp',
+  'execvpe',
+  'popen',
+  'popen2',
+  'popen3',
+  'popen4',
+  'startfile',
+  'spawnl',
+  'spawnle',
+  'spawnlp',
+  'spawnlpe',
+  'spawnv',
+  'spawnve',
+  'spawnvp',
+  'spawnvpe',
+  'write(\"\")',
+  'write(\'\')',
+  'write(NULL)',
+  'write(0)',
+  'os.remove',
+  'os.rmdir',
+  'os.removedirs',
+  'os.unlink',
+  'os.rename',
+  'os.renames',
+  'os.system',
+  'os.chdir',
+  'os.mkdir',
+  'os.makedirs',
+  # Blacklisted files
+  'bardcode_interpreter.py',  
+  'bardcoder.py',
+  'bardcoder_lib.py',
+  'bardcoder',
+  'bardcoder_lib',
+  'bardcode_interpreter',
+  'blacklist_commands.py',
+  'blacklist_commands',
+  'requirements.txt',
+  'clear_cache.sh',
+  'code_runner.sh'
+  'dd',  # Additional shell commands  # Can be used to write and backup raw disk images
+  'gksudo',  # Graphical sudo
+  'lshw',  # Can reveal hardware details
+  'lspci',  # Can reveal PCI devices
+  'lsusb',  # Can reveal USB devices
+  'dmidecode',  # Can reveal system details
+  'hdparm',  # Can change hard drive settings
+  'iptables',  # Can manipulate network traffic rules
+  'passwd',  # Can change user passwords
+  'useradd',
+  'userdel',
+  'adduser',
+  'deluser',  # Can manipulate user accounts
+  'gpasswd',  # Can change group passwords
+  'groupadd',
+  'groupdel',
+  'addgroup',
+  'delgroup',  # Can manipulate group accounts
+  'crontab',  # Can schedule tasks
+  'mount',
+  'umount',  # Can mount and unmount file systems
+  'nohup',  # Can keep processes running after their parent process ends
+  'reboot',
+  'halt',
+  'poweroff',  # Can shutdown or reboot the system
+  'su',
+  'sudo',  # Can run commands as other users
+  'chsh',  # Can change the default shell
+  'chfn',  # Can change the user's full name
+  'chage',  # Can change password expiry
+  'chpasswd',  # Can change passwords
+  'chroot',  # Can change the root directory
+  'chrt',  # Can change process scheduling
+  'crontab',  # Can schedule tasks
+  'date',  # Can change the system date and time
+  'dd',  # Can write and backup raw disk images
+  'dmesg',  # Can show kernel messages
+  'fdisk',  # Can manipulate disk partitions
+  'fsck',  # Can check and repair file systems
+  'fuser',  # Can show which processes are using a file
+  'hdparm',  # Can change hard drive settings
+  'kill',  # Can send signals to processes
+  'killall',  # Can send signals to processes by name
+  'last',  # Can show recent logins
+  'lastlog',  # Can show recent logins
+  'lsof',  # Can show which files are open by which processes
+  'lsusb',  # Can show USB devices
+  'lspci',  # Can show PCI devices
+  'lsmod',  # Can show kernel modules
+  'modinfo',  # Can show kernel module details
+  'modprobe',  # Can load and unload kernel modules
+  'mount',  # Can mount file systems
+  'netstat',  # Can show network statistics
+  'nice',  # Can change process priority
+  'pstree',  # Can show running processes as a tree
+  'pickle',  # Can execute arbitrary code during unpickling
+  'os.popen',  # Can be used to execute shell commands
+  'os.startfile',  # Can be used to start a file with its associated application
+  'os.exec*',  # Any function starting with 'os.exec' can be used to execute different programs
+  'os.spawn*',  # Any function starting with 'os.spawn' can be used to spawn new process using os-level commands
+  'os.fork',  # Can be used to create new processes
+  'os.kill',  # Can be used to send signals to processes
+  'socket',  # Can be used to create network connections
+  'ctypes',  # Can be used to call C functions in Python programs
+  'gc.get_objects',  # Can be used to inspect objects currently in memory
+  'os.setuid',  # Can be used to set the current process's user id
+  'os.setgid',  # Can be used to set the current process's group id
+  'os.chroot',  # Can be used to change the root directory of the current process
+  'os.chmod',  # Can be used to change file permissions
+  'os.chown',  # Can be used to change file ownership
+  'os.chflags',  # Can be used to change file flags
+  'os.chroot',  # Can be used to change the root directory of the current process
+  'os.seteuid',  # Can be used to set the current process's effective user id
+  'os.setegid',  # Can be used to set the current process's effective group id
+  'os.setreuid',  # Can be used to set the current process's real and effective user id
+  'os.setregid',  # Can be used to set the current process's real and effective group id
+  'os.setresuid',  # Can be used to set the current process's real, effective, and saved user id
+]
+
+harmful_commands_cpp = [
+  "remove",  # Existing commands
+  "std::remove",
+  "remove_all",
+  "ilesystem::remove_all",
+  "filesystem::remove",
+  "rename",
+  "std::rename",
+  "filesystem::rename",
+  "std::system",
+  "abort",
+  "std::abort",
+  "exit",
+  "std::exit",
+  "move",
+  "std::move",
+  "filesystem::move",
+  "std::ofstream",
+  "std::quick_exit",
+  "ios::app",
+  "trunc",
+  "ios::trunc",
+  "std::ios::app",
+  "std::ios::trunc",
+  "std::filesystem::remove",
+  "std::_Exit",
+  "fp << NULL",
+  'fp << "" <<',
+  "file << NULL",
+  'file << "" <<',
+  "std::system_clock::now().time_since_epoch().count()",
+  "std::chrono::system_clock::now().time_since_epoch().count()",
+  "std::system(\"rm -rf",
+  "std::system(\"format",
+  "std::system(\"curl",
+  "system",  # Additional commands # Executes an shell command
+  "popen",  # Can open a process by creating apipe, forking, and invoking the shell
+  "_popen",  # Windows version of popen
+  "WinExec",  # Can run a command
+  "ShellExecute",  # Can run a command
+  "fork",  # Can be used to create new processes
+  "execl",
+  "execlp",
+  "execle",
+  "execv",
+  "execvp",
+  "execvpe",  # Can be used to execute different programs
+  "spawnl",
+  "spawnlp",
+  "spawnle",
+  "spawnv",
+  "spawnvp",
+  "spawnvpe",  # Can be used to spawn new process using os-level commands
+  "kill",  # Can be used to send signals to processes
+  "raise",  # Can be used to send a signal to the current process
+  "socket",  # Can be used to create network connections
+  "setuid",  # Can be used to set the current process's user id
+  "setgid",  # Can be used to set the current process's group id
+  "chroot",  # Can be used to change the root directory of the current process
+]
+
+
+# define method to get the list of harmful prompts
+def get_harmful_prompts():
+  return harmful_prompts
+
+
+# define method to get the list of harmful commands for python
+def get_harmful_commands_python():
+  return harmful_commands_python
+
+
+# define method to get the list of harmful commands for cpp
+def get_harmful_commands_cpp():
+  return harmful_commands_cpp

lib/extensions_map.py

@@ -0,0 +1,58 @@
+# Define a dictionary to map language name to file extension
+extension_map = {
+    ".python": ".py",
+    ".javascript": ".js",
+    ".java": ".java",
+    ".c": ".c",
+    ".c++": ".cpp",
+    ".c#": ".cs",
+    ".php": ".php",
+    ".ruby": ".rb",
+    ".go": ".go",
+    ".swift": ".swift",
+    ".kotlin": ".kt",
+    ".rust": ".rs",
+    ".dart": ".dart",
+    ".r": ".r",
+    ".typescript": ".ts",
+    ".scala": ".scala",
+    ".perl": ".pl",
+    ".haskell": ".hs",
+    ".lua": ".lua",
+    ".julia": ".jl",
+    ".elixir": ".ex",
+    ".clojure": ".clj",
+    ".erlang": ".erl",
+    ".ocaml": ".ml",
+}
+
+streamlit_code_langs = {
+    ".py": "python",
+    ".js": "javascript",
+    ".html": "html",
+    ".css": "css",
+    ".java": "java",
+    ".cpp": "c++",
+    ".cs": "csharp",
+    ".r": "r",
+    ".sql": "sql"
+}
+
+def get_streamlit_code_lang(language):
+    # make language name small letters
+    language = language.lower()
+    # get file extension from ext_map
+    file_extension = streamlit_code_langs.get(language)
+    # return file extension
+    #print(f"get_file_extesion: Language: {language} File Extension: {file_extension}")
+    return file_extension
+    
+# Method to get file extension from language name
+def get_file_extesion(language):
+    # make language name small letters
+    language = language.lower()
+    # get file extension from ext_map
+    file_extension = extension_map.get(language)
+    # return file extension
+    #print(f"get_file_extesion: Language: {language} File Extension: {file_extension}")
+    return file_extension

lib/sharegpt_api.py

@@ -0,0 +1,29 @@
+"""
+Description: This file contains methods to post conversation data to ShareGPT API and get ShareGPT URL.
+Link : https://github.com/domeccleston/sharegpt#rest-api
+Author of ShareGPT : Dome Eccleston
+"""
+import json
+import requests
+
+url = "https://sharegpt.com/api/conversations"
+
+# Method to post conversation data to ShareGPT API    
+def sharegpt_post_conversation(conversation_data):
+    headers = {"Content-Type": "application/json"}
+    response = requests.post(url, headers=headers, data=json.dumps(conversation_data))
+    response_data = response.json()
+    id = response_data["id"]
+    sharegpt_url = f"https://shareg.pt/{id}"
+    return sharegpt_url
+
+# Method to get ShareGPT URL
+def sharegpt_get_url(gpt_data="", human_data=""):
+    conversation_data = {
+        "items": [
+            {"from": "gpt", "value": gpt_data},
+            {"from": "human", "value": human_data},
+        ]
+    }
+    sharegpt_url = sharegpt_post_conversation(conversation_data)
+    return sharegpt_url

requirements.txt

@@ -0,0 +1,12 @@
+streamlit
+bardapi
+pillow
+matplotlib
+pandas
+plotly
+requests
+keras
+scikit-learn
+tabulate
+librosa
+scipy