Category: AI

pandas
numpy
scipy
xarray
#Machine Learning:
scikit-learn
xgboost
keras
torch
#Natural Language Processing:
nltk
spacy
textblob
gensim
#Data Visualization:
matplotlib
seaborn
plotly
bokeh
#Web Scraping and Network:
requests
urllib3
aiohttp
beautifulsoup4
#Deep Learning:
keras
torch
theano
#Image Processing:
pillow
imageio
opencv-python
scikit-image
#Audio Processing:
librosa
pyaudio
soundfile
#File Format:
openpyxl
xlrd
pyPDF2
python-docx
#Database:
sqlalchemy
psycopg2
mysql-connector-python
#Web Development:
flask
django
tornado
quart
#Others:
pytest
joblib
pytz
pyyaml

python-docx
pdfkit
wkhtmltopdf
pandoc 
pdfplumber  
reportlab
open-interpreter

pip install -r requirements.txt

pip install open-interpreter

interpreter -y

import interpreter

interpreter.chat("Plot AAPL and META's normalized stock prices") # Executes a single command
interpreter.chat() # Starts an interactive chat

PS D:\interpreter> & d:/interpreter/.venv/Scripts/Activate.ps1
(.venv) PS D:\interpreter> py teste.py

▌ Model set to GPT-4
Tip: To run locally, use interpreter --local

Open Interpreter will require approval before running code. Use interpreter -y to bypass this.

Press CTRL-C to exit.

  To plot AAPL and META's normalized stock prices, we will need to follow these steps:

   1 Install necessary packages. We will need pandas, yfinance, and matplotlib for Python.
   2 Download the stock prices for AAPL and META using yfinance.
   3 Normalize the stock prices.
   4 Plot the normalized stock prices.

  Let's start with the first step, which is installing the necessary packages.

  import pkg_resources                                                                                                                                                          
                                                                                                                                                                                
  REQUIRED_PACKAGES = ['pandas', 'yfinance', 'matplotlib']                                                                                                                      
                                                                                                                                                                                
  for package in REQUIRED_PACKAGES:                                                                                                                                             
      try:                                                                                                                                                                      
          dist = pkg_resources.get_distribution(package)                                                                                                                        
          print('{} ({}) is installed'.format(dist.key, dist.version))                                                                                                          
      except pkg_resources.DistributionNotFound:                                                                                                                                
          print('{} is NOT installed'.format(package))                                                                                                                          

  import pkg_resources                                                                                                                                                          
                                                                                                                                                                                
  REQUIRED_PACKAGES = ['pandas', 'yfinance', 'matplotlib']                                                                                                                      
                                                                                                                                                                                
  for package in REQUIRED_PACKAGES:                                                                                                                                             
          dist = pkg_resources.get_distribution(package)                                                                                                                        
          print('{} ({}) is installed'.format(dist.key, dist.version))                                                                                                          
      except pkg_resources.DistributionNotFound:                                                                                                                                
          print('{} is NOT installed'.format(package))                                                                                                                          


  pandas (2.1.0) is installed
  yfinance (0.2.28) is installed
  matplotlib (3.8.0) is installed

  Great! All the necessary packages are already installed.

  Now, let's move on to the next step: downloading the stock prices for AAPL (Apple Inc.) and META (Meta Platforms Inc., formerly Facebook Inc.) using the yfinance package.    
  We will download the last 5 years of daily closing prices.

  import yfinance as yf                                                                                                                                                         
                                                                                                                                                                                
  # Define the ticker symbols                                                                                                                                                   
  symbols = ['AAPL', 'META']                                                                                                                                                    
                                                                                                                                                                                
  # Download the stock data                                                                                                                                                     
  stock_data = yf.download(symbols, start='2017-01-01', end='2022-12-31')['Close']                                                                                              
                                                                                                                                                                                
  # Print the first few rows of the data                                                                                                                                        
  stock_data.head()                                                                                                                                                             

  import yfinance as yf                                                                                                                                                         
                                                                                                                                                                                
  # Define the ticker symbols                                                                                                                                                   
  symbols = ['AAPL', 'META']                                                                                                                                                    
                                                                                                                                                                                
  stock_data = yf.download(symbols, start='2017-01-01', end='2022-12-31')['Close']                                                                                              
                                                                                                                                                                                
  # Print the first few rows of the data                                                                                                                                        
  stock_data.head()                                                                                                                                                             

  [                       0%%                      ]
  [*********************100%%**********************]  2 of 2 completed
  AAPL        META
  Date
  2017-01-03  29.037500  116.860001
  2017-01-04  29.004999  118.690002
  2017-01-05  29.152500  120.669998
  2017-01-06  29.477501  123.410004
  2017-01-09  29.747499  124.900002

  We have successfully downloaded the stock prices for AAPL and META.

  The next step is to normalize these stock prices. Normalizing the stock prices allows us to compare the two stocks on the same scale. We will normalize the prices such that  
  the first price is 1 and all subsequent prices are relative to the first price.

  normalized_data = stock_data / stock_data.iloc[0]                                                                                                                             
                                                                                                                                                                                
  # Print the first few rows of the normalized data                                                                                                                             
  normalized_data.head()                                                                                                                                                        

  normalized_data = stock_data / stock_data.iloc[0]                                                                                                                             
                                                                                                                                                                                
  # Print the first few rows of the normalized data                                                                                                                             
  normalized_data.head()                                                                                                                                                        

  AAPL      META
  Date
  2017-01-03  1.000000  1.000000
  2017-01-04  0.998881  1.015660
  2017-01-05  1.003960  1.032603
  2017-01-06  1.015153  1.056050


  The stock prices for AAPL and META have been successfully normalized.

  Now, let's move on to the final step: plotting the normalized stock prices. We will use the matplotlib package for this.

  import matplotlib.pyplot as plt                                                                                                                                               
                                                                                                                                                                                
  # Create a new figure                                                                                                                                                         
  plt.figure(figsize=(14, 7))                                                                                                                                                   
                                                                                                                                                                                
  # Plot the normalized stock prices                                                                                                                                            
  for symbol in symbols:                                                                                                                                                        
      plt.plot(normalized_data.index, normalized_data[symbol], label=symbol)                                                                                                    
                                                                                                                                                                                
  # Add a title and labels                                                                                                                                                      
  plt.title('Normalized Stock Prices: AAPL vs META')                                                                                                                            
  plt.xlabel('Date')                                                                                                                                                            
  plt.ylabel('Normalized Price')                                                                                                                                                
  plt.legend()                                                                                                                                                                  
                                                                                                                                                                                
  # Save the plot as an image                                                                                                                                                   
  plt.savefig('normalized_stock_prices.png')                                                                                                                                    
                                                                                                                                                                                
  # Close the plot                                                                                                                                                              
  plt.close()                                                                                                                                                                   

  import matplotlib.pyplot as plt                                                                                                                                               
                                                                                                                                                                                
  # Create a new figure                                                                                                                                                         
  plt.figure(figsize=(14, 7))                                                                                                                                                   
                                                                                                                                                                                
  # Plot the normalized stock prices                                                                                                                                            
  for symbol in symbols:                                                                                                                                                        
      plt.plot(normalized_data.index, normalized_data[symbol], label=symbol)                                                                                                    
                                                                                                                                                                                
  # Add a title and labels                                                                                                                                                      
  plt.title('Normalized Stock Prices: AAPL vs META')                                                                                                                            
  plt.xlabel('Date')                                                                                                                                                            
  plt.ylabel('Normalized Price')                                                                                                                                                
  plt.legend()                                                                                                                                                                  
                                                                                                                                                                                
  # Save the plot as an image                                                                                                                                                   
  plt.savefig('normalized_stock_prices.png')                                                                                                                                    
                                                                                                                                                                                
  # Close the plot                                                                                                                                                              
  plt.close()█                                                                                                                                                                  

  <Figure size 1400x700 with 0 Axes>
  [<matplotlib.lines.Line2D object at 0x0000024DE75D0B90>]
  [<matplotlib.lines.Line2D object at 0x0000024DE7604990>]
  Text(0.5, 1.0, 'Normalized Stock Prices: AAPL vs META')
  Text(0.5, 0, 'Date')
  Text(0, 0.5, 'Normalized Price')
  <matplotlib.legend.Legend object at 0x0000024DE75DAB50>

(.venv) PS D:\interpreter> interpreter -y
> What are the last 10 BBC news headlines?

  To get the last 10 BBC news headlines, we can use web scraping techniques. Python has several libraries for this purpose, such as BeautifulSoup and requests. Here is the     
  plan:

   1 Install necessary Python packages (requests and BeautifulSoup) if they are not already installed.
   2 Fetch the BBC News homepage HTML using requests.
   3 Parse the HTML using BeautifulSoup to find the news headlines.
   4 Extract and return the last 10 news headlines.

  Let's start with the first step, which is to check if the necessary Python packages are installed. If not, we will install them.



  import pkg_resources                                                                                                                                                          
                                                                                                                                                                                
  REQUIRED_PACKAGES = ['beautifulsoup4', 'requests']                                                                                                                            
                                                                                                                                                                                
  for package in REQUIRED_PACKAGES:                                                                                                                                             
      try:                                                                                                                                                                      
          dist = pkg_resources.get_distribution(package)                                                                                                                        
          print('{} ({}) is installed'.format(dist.key, dist.version))                                                                                                          
      except pkg_resources.DistributionNotFound:                                                                                                                                
          print('{} is NOT installed'.format(package))                                                                                                                          


  beautifulsoup4 (4.12.2) is installed
  requests (2.31.0) is installed


  Great! Both 'beautifulsoup4' and 'requests' packages are already installed.

  Now, let's move to the next step of the plan: Fetch the BBC News homepage HTML using requests. We will send a GET request to the BBC News homepage URL and print the status   
  of the response to ensure we are able to connect to the page.

  import requests                                                                                                                                                               
                                                                                                                                                                                
  url = 'https://www.bbc.co.uk/news'                                                                                                                                            
  response = requests.get(url)                                                                                                                                                  
                                                                                                                                                                                
  print('Status code:', response.status_code)                                                                                                                                   

  Status code: 200


  The status code 200 indicates that we successfully fetched the HTML of the BBC News homepage.

  Now, let's move to the next step of the plan: Parse the HTML using BeautifulSoup to find the news headlines. We will parse the HTML and find the elements that contain the    
  news headlines. For this, we need to know the structure of the BBC News homepage. The headlines are usually contained in HTML elements with specific class names. We will     
  try to find these elements and print some of them to verify that we are correctly extracting the headlines.

  from bs4 import BeautifulSoup                                                                                                                                                 
                                                                                                                                                                                
  soup = BeautifulSoup(response.text, 'html.parser')                                                                                                                            
                                                                                                                                                                                
  # BBC News headlines are usually in h3 elements with class 'gs-c-promo-heading__title'                                                                                        
                                                                                                                                                                                
  # Print the first 5 headlines to verify                                                                                                                                       
  for headline in headlines[:5]:                                                                                                                                                
      print(headline.text.strip())                                                                                                                                              

  Russell Brand accused of rape and sexual assault
  Russell Brand accused of rape and sexual assault
  A barren wasteland with a lingering smell of death
  Diamonds and diplomacy: How a US envoy fell from grace
  'Everything has just been completely ripped away'


  We have successfully extracted the news headlines from the BBC News homepage. The headlines printed above are a sample of the headlines we found.

  Now, let's move to the final step of the plan: Extract and return the last 10 news headlines. We will extract the text from the last 10 headline elements and return them.    

  # Get the last 10 headlines                                                                                                                                                   
  last_10_headlines = [headline.text.strip() for headline in headlines[-10:]]                                                                                                   
                                                                                                                                                                                
  last_10_headlines                                                                                                                                                             


  ['How old is too old to lead?', 'The companies staying fully remote', "A 'beach towel revolt' sweeping Greece", 'Sexton breaks record as eight-try Ireland beat Tonga',       
  'Wales struggle past Portugal at World Cup', 'Brighton beat Man Utd as fans boo Ten Hag', 'Barcelona crush Betis to go top', 'Sainz on Singapore pole as angry Verstappen     
  struggles', "'We have a good vibe' - Ten Hag avoids Sancho questioning", 'Newcastle beat Brentford to ease pressure on Howe']

  Here are the last 10 BBC news headlines:

    1 'How old is too old to lead?'
    2 'The companies staying fully remote'
    3 "A 'beach towel revolt' sweeping Greece"
    4 'Sexton breaks record as eight-try Ireland beat Tonga'
    5 'Wales struggle past Portugal at World Cup'
    6 'Brighton beat Man Utd as fans boo Ten Hag'
    7 'Barcelona crush Betis to go top'
    8 'Sainz on Singapore pole as angry Verstappen struggles'
    9 "'We have a good vibe' - Ten Hag avoids Sancho questioning"
   10 'Newcastle beat Brentford to ease pressure on Howe'

> can you crate a pdf file with this 10 BBC news headlines?

  Sure, we can create a PDF file with these headlines. We will use the Python library reportlab for this purpose. Here is the plan:

   1 Install the necessary Python package (reportlab) if it is not already installed.
   2 Create a PDF file using reportlab and add the headlines to it.
   3 Save the PDF file.

  Let's start with the first step, which is to check if the necessary Python package is installed. If not, we will install it.


  REQUIRED_PACKAGES = ['reportlab']                                                                                                                                             
                                                                                                                                                                                
  for package in REQUIRED_PACKAGES:                                                                                                                                             
      try:                                                                                                                                                                      
          dist = pkg_resources.get_distribution(package)                                                                                                                        
          print('{} ({}) is installed'.format(dist.key, dist.version))                                                                                                          
      except pkg_resources.DistributionNotFound:                                                                                                                                
          print('{} is NOT installed'.format(package))                                                                                                                          


  reportlab (4.0.4) is installed


  Great! The 'reportlab' package is already installed.

  Now, let's move to the next step of the plan: Create a PDF file using reportlab and add the headlines to it. We will create a new PDF file, add each headline as a separate   
  paragraph, and then save the PDF file.



  from reportlab.lib.pagesizes import letter                                                                                                                                    
  from reportlab.pdfgen import canvas                                                                                                                                           
  from reportlab.lib.units import inch                                                                                                                                          
                                                                                                                                                                                
  # Create a new PDF file                                                                                                                                                       
  c = canvas.Canvas('BBC_headlines.pdf', pagesize=letter)                                                                                                                       
                                                                                                                                                                                
  # Set the font and size                                                                                                                                                       
  c.setFont('Helvetica', 12)                                                                                                                                                    
                                                                                                                                                                                
  # Add each headline as a separate paragraph                                                                                                                                   
  y = 750  # Start from the top of the page                                                                                                                                     
  for i, headline in enumerate(last_10_headlines, 1):                                                                                                                           
      c.drawString(50, y, f'{i}. {headline}')                                                                                                                                   
      y -= 25  # Move down for the next headline                                                                                                                                
                                                                                                                                                                                
  # Save the PDF file                                                                                                                                                           
  c.save()                                                                                                                                                                      

  The PDF file 'BBC_headlines.pdf' with the last 10 BBC news headlines has been created successfully. You can find it in the current working directory (D:\interpreter).