This book relies on the Anaconda distribution of Python. We'll use Jupyter Notebook and Python script files to write the code. Unless specified otherwise, all the code should be written in Jupyter Notebooks.

Download and install the Anaconda distribution of Python. You can do this by going to https://www.anaconda.com/download. Depending on your operating system, the instructions for downloading and installing will vary. Please refer to the Anaconda documentation for detailed instructions.

Anaconda ships with a package manager called conda. Package managers make it easy to install, remove, and update Python packages. There's a great cheat sheet for the conda package manager available at https://docs.conda.io/projects/conda/en/4.6.0/_downloads/52a95608c49671267e40c689e0bc00ca/conda-cheatsheet.pdf.

Once you've installed the Anaconda distribution, open your Terminal on Mac or Linux or the Anaconda Prompt on Windows. If you're a Windows user, make sure to use the Command Prompt instead of the PowerShell prompt. Then follow these steps:

1. Update the conda package manager and follow any instructions to accept license agreements:

   conda update -n base conda -y

2. Create a virtual environment:

   conda create -n my-quant-stack python=3.11 -y

3. After the installation process is complete, activate the environment:

   conda activate my-quant-stack

4. Install Jupyter Notebook using the package manager that ships with Python, pip:

   pip install notebook matplotlib

This will set up a virtual environment using Python 3.11 and install Jupyter Notebook.

This chapter will use two Python libraries to acquire financial market data: the OpenBB Platform and pandas_datareader. The good news is that installing the OpenBB Platform installs many of the libraries you will need to acquire financial market data, including pandas_datareader. As such, there is no need to install the libraries separately.

Install the OpenBB Platform with all extensions and providers (both officially supported and community-maintained ones) using pip:

pip install openbb[all]

This is the easiest way to set up the OpenBB Platform for this book.

To install a single extension:

pip install openbb[charting]
pip install openbb[ta]

Or install a single provider:

pip install openbb[yfinance]

To install the Nightly distribution (this installs all extras by default):

pip install openbb-nightly

This book makes extensive use of Jupyter Notebooks. You can review instructions for using Jupyter Notebook here: https://docs.jupyter.org/en/latest/

You may remember the meme stock hysteria that sent GameStop's stock up 1,744% in January 2021. One of the good things that came from that episode was the GameStonk terminal, now rebranded as OpenBB. OpenBB is one of the most popular open-source finance projects on GitHub for good reason: it provides a single interface to access hundreds of data feeds from one place in a standard way. OpenBB has a command-line interface that is great for manual investment research. But when it's time to get data into Python, you want the OpenBB Platform. This recipe will guide you through the process of using the OpenBB Platform to fetch stock market data.

Getting ready

By now, you should have the OpenBB Platform installed in your virtual environment. If not, go back to the beginning of this chapter and get it set up. The OpenBB Platform is free to use and offers a web-based UI to manage your configuration files, store API keys, and get code walkthroughs and examples. Sign up for a free Hub account at https://my.openbb.co/login. The popular course, Getting Started with Python for Quant Finance, uses the OpenBB Platform exclusively for all the code. Check out https://www.pyquantnews.com/getting-started-with-python-for-quant-finance for information on how to join.

How to do it…

Using the OpenBB Platform involves one import:

1. Import the OpenBB Platform:

   from openbb import obb
   obb.user.preferences.output_type = "dataframe"

2. Use the historical method to download price data for the SPY ETF:

   data = obb.equity.price.historical("SPY", provider="yfinance")

3. Inspect the resulting DataFrame:

   print(data)

4. Running the preceding code generates a pandas DataFrame and prints the data to the screen:

   

   Figure 1.1: Historic price data for SPY

How it works…

The OpenBB Platform follows an easy-to-understand namespace convention. All the methods for acquiring stock price data are methods on openbb.equity.

The historical method accepts a ticker symbol and returns the open, high, low, close, adjusted close, volume, and dividend in a pandas DataFrame. The additional parameters you can specify are as follows:

• start_date: Start date to get data from with
• interval: Interval (in minutes) to get data—that is, 1, 5, 15, 30, 60, or 1,440
• end_date: End date to get data from with
• provider: Source of data extracted

There's more…

An important benefit of using the OpenBB Platform is choosing your data source. By default, the OpenBB Platform will attempt to download data from free sources such as Yahoo! Finance. In most OpenBB Platform calls, you can indicate a different source. To use a source that requires an API key (either free or paid), you can configure it in the OpenBB Hub.

Let's look at some more of the functions of the OpenBB Platform.

Comparison of fundamental data

Not only can the OpenBB Platform download fundamental data in an organized and usable way, but it can also concatenate it in a single Pandas DataFrame for further analysis.

We can use the following code to see the balance sheet metrics from AAPL and MSFT:

obb.equity.fundamental.metrics(
    "AAPL,MSFT",
    provider="yfinance"
)

The output of the preceding snippet is a pandas DataFrame with fundamental data for each ticker that was passed:

Figure 1.2: Balance sheet data for MSFT and AAPL

Building stock screeners

One of the most powerful features of the OpenBB Platform is the custom stock screener. A stock screener allows you to use filters to identify stocks that might be interesting to trade. It uses the Finviz stock screener under the hood and surfaces metrics across a range of stocks based on either pre-built or custom criteria. See the documentation for more on how to use the OpenBB screener functions (https://docs.openbb.co/python/reference/equity/screener):

1. Create an overview screener based on a list of stocks using the default view:

   obb.equity.compare.groups(
       group="industry",
       metric="valuation",
       provider="finviz"
   )

   The output of the preceding snippet is the following pandas DataFrame:

   

   Figure 1.3: Results of a comparison screener between F, GE, and TSLA

2. Create a screener that returns the top gainers from the technology sector based on a preset:

   obb.equity.compare.groups(
       group="technology",
       metric="performance",
       provider="finviz"
   )

   The output of the preceding snippet is the following pandas DataFrame:

   

   Figure 1.4: Results of a screener showing the day's top-gaining stocks

3. Create a screener that presents an overview grouped by sector:

   obb.equity.compare.groups(
       group="sector",
       metric="overview",
       provider="finviz"
   )

   The output of the preceding snippet is the following pandas DataFrame:

   

   Figure 1.5: Results of a screener grouped by sector

See also

For more on OpenBB and the Finviz stock screener, check out the following resources:

• The OpenBB Platform documentation, which contains details on dozens of functions to acquire stock market data for free: https://docs.openbb.co/python/reference/equity
• The Finviz home page, which includes free access to the web-based screener https://finviz.com/
• The top-selling cohort-based course to help beginners get up and running with Python for quant finance, algorithmic trading, and data analysis: https://www.pyquantnews.com/getting-started-with-python-for-quant-finance

Traders use continuous futures data for backtesting trading strategies. Futures traders use the roll from one contract to another as a potential opportunity for profit. The roll is the process of exiting a position in a contract as it expires and entering a position into a contract that expires in the future. Some traders simply pick an expiration date to roll to the next contract, while others use sophisticated techniques involving open interest. This basis trade is persistently one of the most popular trading strategies for futures traders. These traders want control over the data that's used to compute the basis trade, so acquiring individual contract data is important. This recipe will guide you through the process of using the OpenBB Platform to fetch individual futures contract data.

Getting ready

By now, you should have the OpenBB Platform installed in your virtual environment. If not, go back to the beginning of this chapter and get it set up.

How to do it…

We'll use the futures functionality in the OpenBB Platform to download individual futures data for free:

1. Import pandas and the OpenBB Platform:

   import pandas as pd
   from openbb import obb
   obb.user.preferences.output_type = "dataframe"

2. Download the current futures curve for the VIX futures contract from the Chicago Board Options Exchange (CBOE):

   data = obb.derivatives.futures.curve(symbol="VX_EOD")

3. Inspect the resulting DataFrame:

   print(data)

4. Running the preceding code generates the futures curve for the VIX futures contract:

   

   Figure 1.6: Settlement prices for the forward VIX index futures contracts

5. Update the DataFrame index to the expiration dates and plot the settlement prices:

   data.index = pd.to_datetime(data.expiration)
   data.plot()

6. By running the preceding code, we plot the VIX futures curve:

   

   Figure 1.7: VIX futures curve

There's more…

You can use the obb.derivatives.futures.historical method to get historical data for an individual expiration. Stitching together data across a range of years can provide insight into the market's expectation of supply and demand of the underlying commodity:

1. First, create a list containing the year and month expirations you're interested in:

   expirations = [
       "2026-12",
       "2027-12",
       "2028-12",
       "2029-12",
       "2030-12",
   ]

   The preceding code creates a Python list of expiration years and dates in string format.

2. Now, loop through each of the expirations to download the data:

   contracts = []
   for expiration in expirations:
       df = (
           obb
           .derivatives.futures.historical(
               symbol="CL",
               expiration=expiration,
               start_date="2020-01-01",
               end_date="2022-12-31",
               provider="yfinance"
           )
       ).rename(columns={
           "close": expiration
       })
       contracts.append(df[expiration])

3. For each of the contracts, use the OpenBB Platform to download historical futures data for the CL contract between January 1, 2020, and December 31, 2022. Using the pandas rename method, change the column name from "close" to the expiration date. Finally, append the newly created pandas DataFrame to a list of DataFrames:

   historical = (
       pd
       .DataFrame(contracts)
       .transpose()
       .dropna()
   )

4. Concatenate the DataFrames together, swap the columns and rows using the transpose method, and drop any with no data using the dropna method. Inspect the resulting DataFrame:

   print(historical)

5. By printing the DataFrame, we will see the historical settlement prices:

   

   Figure 1.8: Historic settlement prices for the December CL futures contract

   The result is the data between January 2020 and December 2022 for each of the December expirations between 2023 and 2030.

   To visualize the market's expectation of the future supply and demand of the December contract, you can plot the last price:

   historical.iloc[-1].plot()

   Here's the output:

   

   Figure 1.9: Futures curve for the December CL contract

See also

For more on the Platform futures functionality, you can browse the following documentation:

• Documentation on the OpenBB Platform's futures curve method: https://docs.openbb.co/python/reference/derivatives/futures/curve
• Documentation on the OpenBB Platform's historical curve method: https://docs.openbb.co/python/reference/derivatives/futures/historical

Options are exchange-listed derivative contracts that convey the right (but not the obligation) to buy or sell the underlying stock at a certain price on or before a certain expiration date. Options are among the most versatile financial instruments in the market. They allow traders to define their risk profiles before entering trades and express market views not only on the direction of the underlying but also the volatility. While options offer a high degree of flexibility for trading, this feature complicates data collection for research and backtesting.

A single underlying stock can have an array of options contracts with different combinations of strike prices and expiration dates. Collecting and manipulating this data is a challenge. The combination of options contracts for all strikes and expiration dates is commonly referred to as an options chain. There can be thousands of individual options contracts at a given time for a single underlying stock. Not only does the number of individual contracts pose a challenge, but getting price data has historically been expensive. With the introduction of the OpenBB Platform, it is now only a few lines of Python code to download options chains into a pandas DataFrame. This recipe will walk you through acquiring options data using the OpenBB Platform.

Getting ready

By now, you should have the OpenBB Platform installed in your virtual environment. If not, go back to the beginning of this chapter and get it set up.

How to do it…

Similar to how we used the OpenBB Platform for futures data, we can use it for options data too:

1. Import the OpenBB Platform and Matplotlib for visualization:

   from openbb import obb
   obb.user.preferences.output_type = "dataframe"

2. Use the chains method to download the entire options chain:

   chains = obb.derivatives.options.chains(symbol="SPY")

3. Inspect the resulting DataFrame:

   chains.info()

4. By running the preceding code, we'll see the details of the options chain data:

   

   Figure 1.10: Preview of the data downloaded for the SPY options chains

Note that at the time of writing, there are 10,364 options contracts for the SPY Exchange Traded Fund (ETF) that can be downloaded from CBOE (for free).

How it works…

The obb.derivatives.options.chains method downloads the entire options chain and stores it in a pandas DataFrame. The obb.derivatives.options.chains has an additional optional parameter:

• provider: The source from which the data should be downloaded. The default is CBOE. You can also select Tradier, Intrinio, or TMX. Note that for Tradier, Intrinio, and TMX, you need to provide your API key, which can be configured in the OpenBB Hub.

There's more…

You can use the OpenBB Platform to download historical options data for a single contract. To do this, you need the option symbol.

We'll use the obb.equity.price.historical method to get the historical options data for an SPY call option with a strike price of $675 expiring on December 18, 2026:

data = obb.equity.price.historical(
    symbol="SPY261218C00675000",
    provider="yfinance"
)[["close", "volume"]]

The result is a pandas DataFrame with the closing price and volume of the options contract:

Figure 1.11: Closing prices and volume of the SPY options contract

Option Greeks

Options Greeks measures how options prices change given a change in one of the inputs to an options pricing model. For example, delta measures how an option's price changes given a change in the underlying stock price.

Using obb.derivatives.options.chains, the OpenBB Platform returns the most used Greeks, including Delta, Gamma, Theta, Vega, and Rho.

See also

Options are a fascinating and deep topic that is rich with opportunities for trading. You can learn more about options, volatility, and how to analyze both via the OpenBB Platform:

• Free articles, code, and other resources for options trading: https://pyquantnews.com/free-python-resources/options-trading-with-python/
• Learn more about financial options if you're unfamiliar with them: https://en.wikipedia.org/wiki/Option_(finance)
• Documentation on the OpenBB Platform's options methods: https://docs.openbb.co/python/reference/derivatives/options

Diversification is great until the entire market declines in value. That's because the overall market influences all assets. Factors can offset some of these risks by targeting drivers of return not influenced by the market. Common factors are size (large-cap versus small-cap) and style (value versus growth). If you think small-cap stocks will outperform large-cap stocks, then you might want exposure to small-cap stocks. If you think value stocks will outperform growth stocks, then you might want exposure to value stocks. In either case, you want to measure the risk contribution of the factor. Eugene Fama and Kenneth French built the Fama-French three-factor model in 1992. The three Fama-French factors are constructed using six value-weighted portfolios formed on capitalization and book-to-market.

The three factors are as follows:

• Small Minus Big, which represents the differential between the average returns of three small-cap portfolios and three large-cap portfolios
• High Minus Low, which quantifies the difference in average returns between two value-oriented portfolios and two growth-oriented portfolios
• Rm-Rf, which denotes the market's excess return over the risk-free rate

We'll explore how to measure and isolate alpha in Chapter 7, Build Alpha Factors for Stock Portfolios. This recipe will guide you through the process of using pandas_datareader to fetch historical factor data for use in your analysis.

Getting ready

You can install pandas_datareader with pip either in a terminal with this command:

pip install pandas_datareader

Or directly in a Jupyter Notebook cell:

!pip install pandas_datareader

You'll need pandas_datareader to follow along with this recipe.

Note that you'll need pandas version 2 to use pandas_datareader. You can install it with the following command:

pip install --upgrade "pandas<3" "pandas-datareader==0.10.0"

How to do it…

Using the pandas_datareader library, we have access to dozens of investment research factors:

1. Import pandas_datareader:

   import pandas_datareader as pdr

2. Download the monthly factor data starting in January 2000:

   factors = pdr.get_data_famafrench("F-F_Research_Data_Factors")

3. Get a description of the research data factors:

   print(factors["DESCR"])

4. The result is an explanation of the data included in the DataFrame:

   

   Figure 1.12: Preview of the description that is downloaded with factor data

5. Inspect the monthly factor data:

   print(factors[0].head())

6. By running the preceding code, we get a DataFrame containing monthly factor data:

   

   Figure 1.13: Preview of the monthly data downloaded from the Fama-French Data Library

7. Inspect the annual factor data:

   print(factors[1].head())

8. By running the preceding code, we get a DataFrame containing annual factor data:

   

   Figure 1.14: Preview of the annual data downloaded from the Fama-French Data Library

How it works…

Under the hood, pandas_datareader fetches data from the Fama-French Data Library by downloading a compressed CSV file, uncompressing it, and creating a pandas DataFrame.

There are 297 different datasets with different factor data available from the Fama-French Data Library. Here are some popular versions of the Fama-French 3-factor model for different regions:

• Developed_3_Factors
• Developed_ex_US_3_Factors
• Europe_3_Factors
• Japan_3_Factors
• Asia_Pacific_ex_Japan_3_Factors

You can use these in the get_data_famafrench method just like F‑F_Research_Data_Factors.

Some datasets return a dictionary with more than one DataFrame representing data for different time frames, portfolio weighting methodologies, and aggregate statistics. Data for these portfolios can be accessed using numerical keys. For example, the 5_Industry_Portfolios dataset returns eight DataFrames in the dictionary. The first can be accessed using the 0 dictionary key, the second using the 1 dictionary key, and so on. Each dictionary includes a description of the dataset, which can be accessed using the DESCR dictionary key.

There's more…

pandas_datareader can be used to access data from many remote online sources. These include Tiingo, IEX, Alpha Vantage, FRED, Eurostat, and many more. Review the full list of data sources on the documentation page here:https://pandas-datareader.readthedocs.io/en/latest/remote_data.html.

See also

For more details on the factors available in the investment factor research library, take a look at the following resources. For another example of using the Fama-French 3-factor model, see the resources on the PyQuant News website:

• Documentation for all the Fama-French factor data: https://mba.tuck.dartmouth.edu/pages/faculty/ken.french/data_library.html
• Details on the Fama-French 3-factor model: https://mba.tuck.dartmouth.edu/pages/faculty/ken.french/Data_Library/f-f_factors.html
• Code walkthrough for using the Fama-French 3-factor model: https://www.pyquantnews.com/past-pyquant-newsletter-issues

Get this book's PDF version and more

Scan the QR code (or go to packtpub.com/unlock). Search for this book by name, confirm the edition, and then follow the steps on the page.

Note: Keep your invoice handy. Purchases made directly from Packt don't require an invoice.