In part 1: we will (i) automatically find the Option (of choice) closest to At The Money (ATM) and (ii) calculate its Implied Volatility & Greeks. We focus below on Future (Monthly) Options on the Index '.STOXX50E' (EURO STOXX 50 EUR PRICE INDEX) ('EUREX') and '.SPX' (S&P 500 INDEX), although you can apply the logic below for another index. To find the ATM instrument, we simply and efficiently use the Search API. Usually, the calculation of the Black-Scholes-Merton model's Implied Volatility involves numerical techniques, since it is not a closed equation (unless restricting assumptions that log returns follow a standard normal distribution with mean is zero, $\mu$ = 0, and standard deviation is zero, $\sigma$ = 1, are made). If we used these techniques in calculating each Implied Volatility value on our computer, it would take several seconds - if not minutes - for each data point computed. I have chosen to use the Instrument Pricing Analytics (IPA) service in the Python Refinitiv Data Library instead, as this service allows me to send model specifications (and variables) and receive several (up to 100) computed Implied Volatility values in one go - in a few seconds. Not only does this save a great deal of time, but also many lines of code! Fianlly, we will put it all in one function.

In part 2: We will implement a functionality allowing us to apply all we did in Part 1 to expired options. You'll see, it's not as simple as it seems. We will then put it all in one function using Type Hints. This, in itself, will also be rather new and exciting!

Content

• Code Setup
  •    EUREX Call Options
    • Finding Live Options
    • Function For Expiration Days
    • Function To Find The Next Expiring Option Outside The Next X Day Window
• LSEG Refinitiv Provided Daily Implied Volatility
• Option Price
• Underlying Asset Price
• Opening Times Of Any One Exchange
• Strike Price
• Risk Free Interest Rate
• Annualized Continuous Dividend Rate
• Calculating IV
  • All Trades
    • Delivery Layer
    • Content Layer
  • At Option Trade Only
    • Delivery Layer
    • Content Layer
  • Graphs
    • All Data
      • Overlay
      • 3 Graphs
      • Simple Graph
    • At Trade Data
      • Overlay
      • 3 Graphs
      • SimpleGraph
• Conclusion

Code Setup

Now let's open our session with RD. You can find more information about sessions on EX-4.01.01-Sessions.ipynb.

refinitiv.data used in this code is version 1.3.0
numpy used in this code is version 1.23.1
pandas used in this code is version 1.3.5
pandas_market_calendarspytz used in this code is version 4.1.4
requests used in this code is version 2022.1
plotly used in this code is version 2.28.1

FYI (For Your Information), this is out Python version:

Python 3.10.5

Let's find the current underlying price, then we can pick the option with strike price closest to that, i.e.: the most 'At The Money'; note that this means that the option can be in or out the money, as long as it is the closest to at the money:

4212.59

In this instance, for this Call Option, 'STXE42250L3.EX', the strike price is 4225,
higher than the spot price of our underlying which is 4212.59.
The holder of this 'STXE42250L3.EX' option has the right (but not the obligation) to buy the underlying for 4225,
which, was the price of the underlying to stay the same till expiry (4212.59 on 2023-12-15),
means a loss of (4225 - 4212.59 =) 12.409999999999854.
This option, in this instance, is 'Out-The-Money'.

full_dates: {2022: [datetime.date(2022, 1, 21), datetime.date(2022, 2, 18), datetime.date(2022, 3, 18), datetime.date(2022, 4, 14), datetime.date(2022, 5, 20), datetime.date(2022, 6, 17), datetime.date(2022, 7, 15), datetime.date(2022, 8, 19), datetime.date(2022, 9, 16), datetime.date(2022, 10, 21), datetime.date(2022, 11, 18), datetime.date(2022, 12, 16)]}

full_dates_str_dict: {2022: ['2022-01-21', '2022-02-18', '2022-03-18', '2022-04-14', '2022-05-20', '2022-06-17', '2022-07-15', '2022-08-19', '2022-09-16', '2022-10-21', '2022-11-18', '2022-12-16']}

dates: {2022: [21, 18, 18, 14, 20, 17, 15, 19, 16, 21, 18, 16]}

full_dates_day_dict: {2022: [21, 18, 18, 14, 20, 17, 15, 19, 16, 21, 18, 16]}

'2023-09-27'

[datetime.datetime(2023, 1, 20, 0, 0), datetime.datetime(2023, 2, 17, 0, 0), datetime.datetime(2023, 3, 17, 0, 0), datetime.datetime(2023, 4, 21, 0, 0), datetime.datetime(2023, 5, 19, 0, 0), datetime.datetime(2023, 6, 16, 0, 0), datetime.datetime(2023, 7, 21, 0, 0), datetime.datetime(2023, 8, 18, 0, 0), datetime.datetime(2023, 9, 15, 0, 0), datetime.datetime(2023, 10, 20, 0, 0), datetime.datetime(2023, 11, 17, 0, 0), datetime.datetime(2023, 12, 15, 0, 0)]

datetime.datetime(2023, 10, 20, 0, 0)

'STXE41500J3.EX'

'2023-09-20T10:27:45.460240'

'2023-09-27T10:27:46.761469'

Option Price

Now things are getting tricky. Certain Expiered Options do not have TRDPRC_1 data historically. Some don't have SETTLE. Some have both... The below should capture TRDPRC_1 when it is available, but SETTLE might still be present in these instances. So we will need to build a logic to focus on the series with the most datapoints. Specifically: Get TRDPRC_1. If there are fewer TRDPRC_1 datapoionts than days (i.e.: if there's only daily data for this field), get SETTLE. Same again, if not SETTLE, then get the midpoint between BID and ASK.

Underlying Asset Price

Now let's get data for the underying, which we need to calculate IV:

Note also that one may want to only look at 'At Option Trade' datapoints, i.e.: Implied Volatility when a trade is made for the Option, but not when none is made. For this, we will use the 'At Trade' (AT) dataframes:

'.STOXX50E'

Opening Times Of Any One Exchange

If you are interested in the opening times of any one exchange, you can use the following:

1. we can check the META App to get more information about the RIC. If we take `STXE43750H3.EX` as an example, this RIC has ".EX" which is for the exchange.

2. Use the page EXCHID01 in Workspace (can be opened via Quote app) to look up the list of exchanges. Click on EXCHID07 as it is the page for exchanges ".EA to .FX".

3. From EXCHID07, you will see there's 2 .EX exchanges, Germany and Switzerland. Referencing the additional data from the META app, the RIC's country is Germany, so use DE/EXCH10 page

4. From DE/EXCH10 page, Hours would display the information including the timezone.

5. From there, you can find the exchange info page with trading hours for Options

You may find screens like this:

by searhing 'trading hours' in the Workspace search bar (at the top), then clickin gon Speed Guides. Looking in there, I found the below:

And get the info programatically like this:

' OESX/OSTX 07:30-08:50 08:50-17:30 17:30-20:30 '

There isn't nessesarily a trade every 10 min... However, for the statistical inferences that we will make further in the article, when we will calculate Implied Volatilities and therefore implement the Black Scholes model, we will need 'continuous timeseries' with which to deal. There are several ways to go from discrete time series (like ours, even if we go down to tick data), but for this article, we will 1st focus on making 'buckets' of 10 min. If no trade is made in any 10 min. bucket, we will assume the price to have stayed the same as previously, throughout the exchange's trading hours which are:

• 4am to 8pm ET for OPRA and
• typically 7:30am to 22:00 CET at the Eurex Exchange (EUREX)

thankfully this is simple. Let's stick with the EUREX for now:

Our dataframe started at (Timestamp('2023-09-21 10:40:00+0000', tz='GMT'), Timestamp('2023-09-21 12:40:00+0200', tz='Europe/Berlin')),
and went on continuously till (Timestamp('2023-09-27 08:00:00+0000', tz='GMT'), Timestamp('2023-09-27 10:00:00+0200', tz='Europe/Berlin')),
so out of trading hours rows are removed

Note also that one may want to only look at 'At Option Trade' datapoints, i.e.: Implied Volatility when a trade is made for the Option, but not when none is made. For this, we will use the 'At Trade' (AT) dataframes:

Here, we can see that the EUERX index's exchange opens trading for Options at 8:50am and closes at 17:30. You can look a the TAS app on Workspace to check.

Let's put it all in one data-frame, df. Some datasets will have data going from the time we sort for start all the way to end. Some won't because no trade happened in the past few minutes/hours. We ought to base ourselves on the dataset with values getting closer to end and ffill for the other column. As a result, the following if loop is needed:

Strike Price

4150

Risk-Free Interest Rate

'2023-09-19'

'2023-09-20T10:27:45.460240'

Euribor values are released daily at 11am CET, and it is published as such on Refinitiv:

You might be running your code after the latest Risk Free Rate published, so the most accurate such value after taht would be the latest value, thus the use of `ffill`:

Annualized Continuous Dividend Rate

We are going to assume no dividends.

Calculating IV

On the Developer Portal, one can see documentation about the Instrument Pricing Analytics service that allows access to calculating functions (that use to be called 'AdFin'). This service is accessible via several RESTful endpoints (in a family of endpoints called 'Quantitative Analytics') which can be used via RD. However, while we are going to build towards a Class that will put all our concepts together, I 1st want to showcase the several ways in which we can collect the data we're are after, for (i) all trades & (ii) at option trades only (i.e.: not every trade of the underlying) and (a) using the RD delivery layer & (b) the RD content layer:

Data returned this far was time-stamped in the GMT Time Zone, we need to re-calibrate it to the timezone of our machine:

All Trades

Delivery Layer

Now for the At Trade dataframe:

IPA can only accept up to 100 request at a time. If there are more elements in our request list, we need to 'chunk' it:

This is the cell, next coming up below, that has a rather high chance of failing. This is because there is no error handling of any kind, just in case there are issues on the servers where we are retreiving data. The Content Layer functions do have such error handing steps, and therefore is considerably less likely to fail or run into errors.

Batch of 100 requests no. 1/2 started
Batch of 100 requests no. 1/2 ended
Batch of 100 requests no. 2/2 started
Batch of 100 requests no. 2/2 ended

Content Layer

As may (or may not) have been apparent aboe, the delivery layer does not offer any error hendling management. The server where we're requestig for data may be busy, so we may get unsuccessful messages back. You could build error handing logic yourself, but let's not reinvent the wheel when the RD Python Library exists!

Batch of 100 requests no. 1/2 started
Batch of 100 requests no. 1/2 ended
Batch of 97 requests no. 2/2 started
Batch of 97 requests no. 2/2 ended

At Option Trade Only

Delivery Layer

Batch of 100 requests no. 1/1 started
Batch of 100 requests no. 1/1 ended

Content Layer

Batch of 44 requests no. 1/1 started
Batch of 44 requests no. 1/1 ended

Graphs

All Data

Overlay

3 Graphs

This representation will allow us to see several graphs at different scales stacked above one another. This way, we can see if the change in Implied Volatility is caused by a movement in the underlying or the Option price itself:

Simple Graph

Certain companies are slow to update libraries, dependencies or Python versions. They/You may thus not have access to plotly (the graph library we used above). Matplotlib is rather light and should work, even on machines with old setups:

At Trade Data

Note here that we are now looking only 'At Trade', i.e.: times when the option traded, not the underlying. There are therefore fewer datapoints.

Overpay

Sack of 3 Graphs

This representation will allow us to see several graphs at different scales stacked above one another. This way, we can see if the change in Implied Volatility is caused by a movement in the underlying or the Option price itself:

Simple Graph

Certain companies are slow to update libraries, dependencies or Python versions. They/You may thus not have access to plotly (the graph library we used above). Matplotlib is rather light and should work, even on machines with old setups:

Creating a class with PEP 3107 (a.k.a.: Type Hints)

AHave a look at Part 2, an article using PEP 3107 (and PEP 484) (and some decorators).

Conclusion

As you can see, not only can we use IPA to gather large amounts of bespoke, calculated, values, but be can also portray this insight in a simple, quick and relevent way. The last cell in particular loops through our built fundction to give an updated graph every 5 seconds using 'legacy' technologies that would work in most environments (e.g.: Eikon Codebook).

References

Brilliant: Black-Scholes-Merton

What is the RIC syntax for options in Refinitiv Eikon?

Functions to find Option RICs traded on different exchanges

Eikon Calc Help Page

Making your code faster: Cython and parallel processing in the Jupyter Notebook

Q&A

RIC nomenclature for expired Options on Futures

Expiration Dates for Expired Options API