Skip to content

Latest commit

 

History

History
608 lines (428 loc) · 18.2 KB

README.md

File metadata and controls

608 lines (428 loc) · 18.2 KB
Raw

Exploring the Code Interpreter in OpenAI (GPT)

(version 21.05.2024)

The code interpreter is an advanced feature of OpenAI's GPTs.x & ChatGPT that brings a new level of interactivity to the AI model. It is designed to execute Python code in a sandboxed environment and provide real-time results, making it a powerful tool for a wide range of tasks from mathematical computations to data analysis, from code prototyping to teaching and learning Python programming interactively. While there are certain limitations to its functionality due to security reasons, it opens up a whole new set of possibilities for how users can interact with ChatGPT.

Table of Contents

The Code Interpreter in OpenAI ChatGPT

What is the Code Interpreter?

The code interpreter is a tool developed by OpenAI to execute programming code in an interactive environment. It is capable of running Python code and displaying the results in real-time.

What is the Code Interpreter used for?

The code interpreter can be used for a variety of tasks, including:

  • Performing complex mathematical calculations
  • Analyzing and visualizing data
  • Prototyping and debugging Python code
  • Interactive learning and practicing Python programming

How can ChatGPT assist with programming?

ChatGPT can generate, review, and debug code based on the provided requirements. It can also assist in structuring code and provide suggestions for improvements. Moreover, it can explain complex programming concepts and assist in solving coding problems.

What are the limitations?

While the code interpreter is a powerful tool, it has certain limitations:

  • It does not have access to the internet. This means it cannot make external requests.
  • It runs in an isolated environment and does not have access to the operating system or its resources.
  • Code execution that takes longer than 120 seconds is automatically stopped.
  • It has access to a special location, '/mnt/data', where it can read and write files.

Despite these limitations, the code interpreter is a versatile tool that can greatly assist programmers of all skill levels.

What are the benefits?

The code interpreter offers several benefits:

  • It provides a safe environment to run code without the risk of affecting the operating system or data.
  • It allows for real-time interaction with the code, providing immediate feedback.
  • It can assist in learning Python programming and improving coding skills.
  • It can handle a variety of tasks, from simple calculations to data analysis and visualization.

Installation and Setup

To execute the examples mentioned in this README, you need to install some Python libraries. You can install them using pip:

pip install pandas openpyxl python-docx PyPDF2 fpdf2 matplotlib pillow

Data Storage

The code interpreter has access to a special directory, '/mnt/data', where it can read and write files. This can be used for operations that need to save or load data, like writing logs, saving plots, or loading data for analysis. However, no other locations on the filesystem can be accessed.

Detailed Explanation of the Data Storage

The '/mnt/data' directory is a special storage location that the code interpreter can access to read and write files. This is especially useful for operations that require persistent storage or the exchange of data between different code executions.

Here are some ways you can use the '/mnt/data' directory:

  1. Saving and Loading Data Files: If you're working with data in formats like .csv, .json, .txt, etc., you can read from and write to these files directly in this directory. For instance, to write a list of numbers to a .txt file, you would do:
with open('/mnt/data/numbers.txt', 'w') as file:
    for num in range(10):
        file.write(str(num) + '\n')

To read the file, you would do:

with open('/mnt/data/numbers.txt', 'r') as file:
    numbers = file.readlines()
  1. Storing Logs: If you're running code that generates logs (like debugging information, progress of a task, etc.), you can write these logs to a file in '/mnt/data'.
with open('/mnt/data/log.txt', 'w') as file:
    file.write('This is a log message.')
  1. Saving Plots and Images: If you're generating plots or other images with your code, you can save them to '/mnt/data' as .png, .jpg, or other image formats. For instance, if you're using matplotlib to create a plot, you can save it with:
import matplotlib.pyplot as plt

plt.plot([0, 1, 2, 3, 4], [0, 1, 4, 9, 16])
plt.savefig('/mnt/data/plot.png')

You can then download the image file directly from the generated sandbox link.

Remember, any file operations need to be done using the '/mnt/data' path. The code interpreter does not have access to any other locations on the filesystem.

Working with Images

With the help of various Python libraries such as PIL (Python Imaging Library), OpenCV, and matplotlib, a variety of operations can be performed on images. Here are some examples:

  1. Displaying Image: Display an image.
from PIL import Image
import matplotlib.pyplot as plt

# Open the image file
img = Image.open('/mnt/data/your_image.jpg')

# Display the image
plt.imshow(img)
plt.axis('off')  # Turn off the axis
plt.show()
  1. Resizing Image: Change the size of an image, enlarge or shrink it.
# Resize the image
img_resized = img.resize((new_width, new_height))
  1. Rotating or Flipping Image: Rotate an image or flip it horizontally or vertically.
# Rotate the image
img_rotated = img.rotate(angle)

# Flip the image
img_flipped = img.transpose(Image.FLIP_LEFT_RIGHT)
  1. Color Conversions: Convert an image to grayscale or change the color mode.
# Convert the image to grayscale
img_gray = img.convert('L')
  1. Adjusting Brightness, Contrast, and Saturation: Adjust the brightness, contrast, or saturation of an image.
from PIL import ImageEnhance

# Increase the brightness
enhancer = ImageEnhance.Brightness(img)
img_brighter = enhancer.enhance(1.5)
  1. Applying Filters: Apply different types of filters, like Gaussian blur, edge detection, etc.
from PIL import ImageFilter

# Apply a filter
img_blurred = img.filter(ImageFilter.GaussianBlur(radius=5))
  1. Image Analysis: Perform simple image analysis, like calculating the histogram.
# Get the histogram
hist = img.histogram()
  1. Image Merging: Merge multiple images into a single image.
# Merge images
img_merged = Image.merge('RGB', [img1, img2, img3])

Working with Excel Files

Handling Excel files is a common task that can range from data analysis to generating reports. Here's a guide on basic and advanced operations with Excel files using Python:

Reading and Writing Excel Files

To read and write Excel files, pandas along with openpyxl is commonly used. Here's how to read from and write to an Excel file:

import pandas as pd

# Load an Excel file
df = pd.read_excel('/mnt/data/example.xlsx')

# Display data
print(df.head())

###To write data to an Excel file:

# Create a DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)

# Write DataFrame to an Excel file
df.to_excel('/mnt/data/saved_data.xlsx', index=False)

Filtering and Manipulating Data

You can filter data based on conditions, add new columns, or transform existing data:

# Filter rows where age is greater than 28
filtered_df = df[df['Age'] > 28]

# Add a new column
df['Age Next Year'] = df['Age'] + 1

# Sort data
sorted_df = df.sort_values(by='Age', ascending=False)

Advanced Excel Processing

Besides reading and writing Excel files, you can also perform advanced data processing tasks such as creating pivot tables or merging multiple Excel files.

Creating a Pivot Table

import pandas as pd

# Load example data
df = pd.read_excel('/mnt/data/example.xlsx')

# Create a pivot table
pivot_table = df.pivot_table(index='Category', values='Sales', aggfunc='sum')

# Display the pivot table
print(pivot_table)

Merging Multiple Excel Files

import pandas as pd
import glob

# Read all Excel files in the directory
files = glob.glob('/mnt/data/*.xlsx')

# Merge data from all files
df_list = [pd.read_excel(file) for file in files]
merged_df = pd.concat(df_list, ignore_index=True)

# Display the merged data
print(merged_df.head())

Troubleshooting

Here are some common issues and their solutions:

  1. ImportError: No module named '...':
  • Ensure that all required libraries are installed. Use pip install <library_name> to install any missing libraries.
  1. FileNotFoundError: [Errno 2] No such file or directory: '...':
  • Check the file path and ensure that the file is in the correct directory. Use absolute paths or ensure that the file is saved in /mnt/data.
  1. PermissionError: [Errno 13] Permission denied: '...':
  • Ensure that you have permissions to read and write in the /mnt/data directory.

If you encounter further issues, open an issue on GitHub or contact the project maintainer.

Working with Word Files

Handling Microsoft Word files involves reading, writing, and modifying documents. Here’s how you can manage Word files using Python:

Reading from Word Files

To read text from Word documents, the python-docx library is used:

from docx import Document

# Load a Word document
doc = Document('/mnt/data/example.docx')

# Read each paragraph
for para in doc.paragraphs:
    print(para.text)

Writing to Word Files

To create and write to Word documents:

from docx import Document

# Create a new Word document
doc = Document()
doc.add_paragraph('Hello, this is a test document.')

# Save the document
doc.save('/mnt/data/new_example.docx')

Advanced Word Processing

from docx import Document

# Create a new Word document
doc = Document()

# Add a table with specified number of rows and columns
table = doc.add_table(rows=3, cols=3)

# Add data to the table
data = [
    ["Header 1", "Header 2", "Header 3"],
    ["Row 1, Col 1", "Row 1, Col 2", "Row 1, Col 3"],
    ["Row 2, Col 1", "Row 2, Col 2", "Row 2, Col 3"]
]

for row_index, row_data in enumerate(data):
    row = table.rows[row_index]
    for col_index, cell_data in enumerate(row_data):
        row.cells[col_index].text = cell_data

# Save the document
doc.save('/mnt/data/table_example.docx')

Formatting Text in a Word Document

from docx import Document
from docx.shared import Pt, RGBColor

# Load a Word document
doc = Document('/mnt/data/example.docx')

# Add a paragraph with specific formatting
paragraph = doc.add_paragraph()
run = paragraph.add_run('This is a formatted text.')
run.font.size = Pt(14)  # Font size
run.font.bold = True  # Bold text
run.font.color.rgb = RGBColor(255, 0, 0)  # Red color text

# Save the document
doc.save('/mnt/data/formatted_text.docx')

Adding Images to a Word Document

from docx import Document
from docx.shared import Inches

# Create a new Word document
doc = Document()

# Add a paragraph
doc.add_paragraph('Below is an image:')

# Add an image to the document
doc.add_picture('/mnt/data/your_image.jpg', width=Inches(4), height=Inches(3))

# Save the document
doc.save('/mnt/data/image_example.docx')

Inserting Headers and Footers

from docx import Document

# Create a new Word document
doc = Document()

# Add a header
header = doc.sections[0].header
header_paragraph = header.paragraphs[0]
header_paragraph.text = "This is the header"

# Add a footer
footer = doc.sections[0].footer
footer_paragraph = footer.paragraphs[0]
footer_paragraph.text = "This is the footer"

# Add some body text
doc.add_paragraph("This is the body text of the document.")

# Save the document
doc.save('/mnt/data/header_footer_example.docx')

Working with PDF Files

Managing PDF files often involves reading, extracting text, and sometimes converting them to other formats. Here’s how to handle PDF files using Python:

Reading and Extracting Text from PDF Files

To read and extract text from PDF files, the PyPDF2 library is commonly used:

import PyPDF2

# Open a PDF file
with open('/mnt/data/example.pdf', 'rb') as file:
    pdf_reader = PyPDF2.PdfReader(file)
    
    # Extract text from the first page
    page = pdf_reader.pages[0]
    text = page.extract_text()
    print(text)

Creating and Writing to PDF Files

Creating and writing text to PDF files can be done using the fpdf2 library:

from fpdf import FPDF

# Create instance of FPDF class
pdf = FPDF()

# Add a page
pdf.add_page()

# Set font
pdf.set_font("Arial", size = 12)

# Add a cell
pdf.cell(200, 10, txt = "Welcome to PDF handling with Python!", ln = True, align = 'C')

# Save the PDF to a file
pdf.output('/mnt/data/new_example.pdf')

Advanced PDF Processing

Handling PDF files often involves reading, extracting text, merging, splitting, and modifying documents. Here are some advanced operations using Python:

Merging Multiple PDF Files

import PyPDF2

# List of PDF files to be merged
pdf_files = ['/mnt/data/file1.pdf', '/mnt/data/file2.pdf', '/mnt/data/file3.pdf']

# Create a PDF merger object
pdf_merger = PyPDF2.PdfMerger()

# Append each PDF file
for pdf in pdf_files:
    pdf_merger.append(pdf)

# Write out the merged PDF
with open('/mnt/data/merged.pdf', 'wb') as merged_pdf:
    pdf_merger.write(merged_pdf)

Splitting a PDF into Multiple Files

import PyPDF2

# Path to the PDF file
pdf_path = '/mnt/data/example.pdf'

# Create a PDF reader object
pdf_reader = PyPDF2.PdfReader(pdf_path)

# Split the PDF into separate pages
for page_num in range(len(pdf_reader.pages)):
    pdf_writer = PyPDF2.PdfWriter()
    pdf_writer.add_page(pdf_reader.pages[page_num])
    
    # Save each page as a separate PDF
    output_path = f'/mnt/data/split_page_{page_num + 1}.pdf'
    with open(output_path, 'wb') as output_pdf:
        pdf_writer.write(output_pdf)

Adding a Watermark to a PDF

import PyPDF2

# Paths to the original PDF and the watermark PDF
original_pdf_path = '/mnt/data/original.pdf'
watermark_pdf_path = '/mnt/data/watermark.pdf'

# Create PDF reader objects
original_pdf = PyPDF2.PdfReader(original_pdf_path)
watermark_pdf = PyPDF2.PdfReader(watermark_pdf_path)

# Create a PDF writer object
pdf_writer = PyPDF2.PdfWriter()

# Apply the watermark to each page
for page_num in range(len(original_pdf.pages)):
    original_page = original_pdf.pages[page_num]
    watermark_page = watermark_pdf.pages[0]
    original_page.merge_page(watermark_page)
    pdf_writer.add_page(original_page)

# Save the watermarked PDF
with open('/mnt/data/watermarked.pdf', 'wb') as watermarked_pdf:
    pdf_writer.write(watermarked_pdf)

Extracting Text from a Specific Page Range

import PyPDF2

# Path to the PDF file
pdf_path = '/mnt/data/example.pdf'

# Create a PDF reader object
pdf_reader = PyPDF2.PdfReader(pdf_path)

# Specify the range of pages to extract text from
start_page = 1
end_page = 3

# Extract text from the specified page range
extracted_text = ''
for page_num in range(start_page - 1, end_page):
    page = pdf_reader.pages[page_num]
    extracted_text += page.extract_text()

print(extracted_text)

Adding Metadata to a PDF

import PyPDF2

# Path to the PDF file
pdf_path = '/mnt/data/example.pdf'

# Create a PDF reader object
pdf_reader = PyPDF2.PdfReader(pdf_path)
pdf_writer = PyPDF2.PdfWriter()

# Copy all pages to the writer object
for page_num in range(len(pdf_reader.pages)):
    pdf_writer.add_page(pdf_reader.pages[page_num])

# Add metadata
metadata = {
    '/Title': 'Example PDF',
    '/Author': 'Your Name',
    '/Subject': 'Example Subject',
    '/Keywords': 'PDF, example, metadata'
}
pdf_writer.add_metadata(metadata)

# Save the PDF with metadata
with open('/mnt/data/metadata_example.pdf', 'wb') as metadata_pdf:
    pdf_writer.write(metadata_pdf)

Contributing

Contributions are welcome! Please feel free to submit a pull request.

❤️ Thank you for your support!

If you appreciate my work, please consider supporting me:

👣 other GPT stuff

Credits