import refinitiv.data as rd  # This is LSEG's Data and Analytics' API wrapper, called the Refinitiv Data Library for Python. You can update this library with the comand `!pip install refinitiv-data --upgrade`
from refinitiv.data.content import historical_pricing  # We will use this Python Class in `rd` to show the Implied Volatility data already available before our work.
from refinitiv.data.content import search  # We will use this Python Class in `rd` to fid the instrument we are after, closest to At The Money.
import refinitiv.data.content.ipa.financial_contracts as rdf  # We're going to need this to use the content layer of the RD library and the calculators of greeks and Impl Volat in Instrument Pricing Analytics (IPA) and Exchange Traded Instruments (ETI)
from refinitiv.data.content.ipa.financial_contracts import option  # We're going to need this to use the content layer of the RD library and the calculators of greeks and Impl Volat in IPA & ETI
 
import numpy as np  # We need `numpy` for mathematical and array manipilations.
import pandas as pd  # We need `pandas` for datafame and array manipilations.
import calendar  # We use `calendar` to identify holidays and maturity dates of intruments of interest.
import pytz  # We use `pytz` to manipulate time values aiding `calendar` library. to import its types, you might need to run `!python3 -m pip install types-pytz`
import pandas_market_calendars as mcal  # Used to identify holidays. See `https://github.com/rsheftel/pandas_market_calendars/blob/master/examples/usage.ipynb` for info on this market calendar library
from datetime import datetime, timedelta, timezone  # We use these to manipulate time values
from dateutil.relativedelta import relativedelta  # We use `relativedelta` to manipulate time values aiding `calendar` library.
import requests  # We'll need this to send requests to servers vie a the delivery layer - more on that below
 
# `plotly` is a library used to render interactive graphs:
import plotly.graph_objects as go
import plotly.express as px  # This is just to see the implied vol graph when that field is available
import matplotlib.pyplot as plt  # We use `matplotlib` to just in case users do not have an environment suited to `plotly`.
from IPython.display import clear_output, display  # We use `clear_output` for users who wish to loop graph production on a regular basis. We'll use this to `display` data (e.g.: pandas data-frames).
from plotly import subplots
import plotly

        
        Copy
    

    	
            
try:
    rd.open_session(
        name="desktop.workspace",
        config_name="C:/Example.DataLibrary.Python-main/Configuration/refinitiv-data.config.json")
except:
    rd.open_session()
# For more info on the session, use `rd.get_config().as_dict()`

        
        Copy
    

    	
            
test_df = rd.get_data(
    universe=['DSMF4'],
    fields=["PROV_SYMB"],
    # interval="tick"
    )
test_df

        
        Copy
    

    	
            rd.get_data(universe=["VOD.L"], fields=["TR.RIC"])  # EMAH8^A
        
        Copy
    

    	
            
for i, j in zip(
    ['refinitiv.data', 'numpy', 'pandas', 'pandas_market_calendars' 'pytz', 'requests', 'plotly'],
    [rd, np, pd, mcal, pytz, requests, plotly]):
    print(f"{i} used in this code is version {j.__version__}")

        
        Copy
    

    	
            !python -V
        
        Copy
    

    	
            
response1 = search.Definition(
    view=search.Views.SEARCH_ALL,  # To see what views are available: `help(search.Views)` & `search.metadata.Definition(view = search.Views.SEARCH_ALL).get_data().data.df.to_excel("SEARCH_ALL.xlsx")`
    query=".STOXX50E",
    select="DocumentTitle, RIC, StrikePrice, ExchangeCode, ExpiryDate, UnderlyingAsset, " +
            "UnderlyingAssetName, UnderlyingAssetRIC, ESMAUnderlyingIndexCode, RCSUnderlyingMarket" +
            "UnderlyingQuoteName, UnderlyingQuoteRIC, InsertDateTime, RetireDate",
    filter="RCSAssetCategoryLeaf eq 'Option' and RIC eq 'STX*' and DocumentTitle ne '*Weekly*' " +
    "and CallPutOption eq 'Call' and ExchangeCode eq 'EUX' and " +
    "ExpiryDate ge 2023-11-29 and ExpiryDate lt 2023-12-31",  # ge (greater than or equal to), gt (greater than), lt (less than) and le (less than or equal to). These can only be applied to numeric and date properties.
    top=100).get_data()
search_df1 = response1.data.df
search_df1

        
        Copy
    

    	
            
current_underlying_prc = rd.get_history(
    universe=[search_df1.UnderlyingQuoteRIC[0][0]],
    fields=["TRDPRC_1"],
    interval="tick").iloc[-1][0]
current_underlying_prc

        
        Copy
    

    	
            
optn = search_df1.iloc[(search_df1['StrikePrice']-current_underlying_prc).abs().argsort()[:1]]
optn

        
        Copy
    

    	
            
optn_strk_pr = optn['StrikePrice'].to_list()[0]
opn_RIC = optn['RIC'].to_list()[0]
opn_exp_date_str = str(optn.ExpiryDate.to_list()[0])[:10]
 
if optn_strk_pr > current_underlying_prc:
    optn_explainer_a = str(
        f"higher than the spot price of our underlying which is {current_underlying_prc}")
    optn_explainer_b = str(
        f"a loss of ({optn_strk_pr} - {current_underlying_prc} =) {optn_strk_pr - current_underlying_prc}")
    moneyness = "'Out-The-Money'"
if optn_strk_pr == current_underlying_prc:
    optn_explainer_a = str(
        f"equal to the spot price of our underlying which is {current_underlying_prc}")
    optn_explainer_b = str(
        f"neither a gain or a loss [of ({current_underlying_prc} - {optn_strk_pr} =) {current_underlying_prc - optn_strk_pr}]")
    moneyness = "exactly 'At-The-Money'"
if optn_strk_pr < current_underlying_prc:
    optn_explainer_a = str(
        f"lower than the spot price of our underlying which is {current_underlying_prc}")
    optn_explainer_b = str(
        f"a gain of ({current_underlying_prc} - {optn_strk_pr} =) {current_underlying_prc - optn_strk_pr}")
    moneyness = "'In-The-Money'"
 
print(f"In this instance, for this Call Option, '{opn_RIC}', " +
      f"the strike price is {optn_strk_pr},")
print(f"{optn_explainer_a}.")
print(f"The holder of this '{opn_RIC}' option has the right " +
      f"(but not the obligation) to buy the underlying for {optn_strk_pr}, ")
print(f"which, was the price of the underlying to stay the same till expiry (" +
      f"{current_underlying_prc} on {opn_exp_date_str}),")
print(f"means {optn_explainer_b}.")
print(f"This option, in this instance, is {moneyness}.")

        
        Copy
    

    	
            
def Get_exp_dates(year, days=True, mcal_get_calendar='EUREX'):
    '''
    Get_exp_dates Version 2.0:
 
    This function gets expiration dates for a year for NDX options, which are the 3rd Fridays of each month.
 
    Changes
    ----------------------------------------------
    Changed from Version 1.0 to 2.0: Jonathan Legrand changed Haykaz Aramyan's original code to allow
        (i) function name changed from `get_exp_dates` to `Get_exp_dates`
        (ii) for the function's holiday argument to be changed, allowing for any calendar supported by `mcal.get_calendar` and defaulted to 'EUREX' as opposed to 'CBOE_Index_Options' and
        (iii) for the function to output full date objects as opposed to just days of the month if agument days=True.
 
    Dependencies
    ----------------------------------------------
    Python library 'pandas_market_calendars' version '3.2'.
    pandas_market_calendars as mcal version '4.1.0'.
 
    Parameters
    -----------------------------------------------
    Input:
        year(int): year for which expiration days are requested
 
        mcal_get_calendar(str): String of the calendar for which holidays have to be taken into account. More on this calendar (link to Github checked 2022-10-11): https://github.com/rsheftel/pandas_market_calendars/blob/177e7922c7df5ad249b0d066b5c9e730a3ee8596/pandas_market_calendars/exchange_calendar_cboe.py
            Default: mcal_get_calendar='EUREX'
 
        days(bool): If True, only days of the month is outputed, else it's dataeime objects
            Default: days=True
 
    Output:
        dates(dict): dictionary of expiration days for each month of a specified year in datetime.date format.
    '''
 
    # get CBOE market holidays
    EUREXCal = mcal.get_calendar(mcal_get_calendar)
    holidays = EUREXCal.holidays().holidays
 
    # set calendar starting from Saturday
    c = calendar.Calendar(firstweekday=calendar.SATURDAY)
 
    # get the 3rd Friday of each month
    exp_dates = {}
    for i in range(1, 13):
        monthcal = c.monthdatescalendar(year, i)
        date = monthcal[2][-1]
        # check if found date is an holiday and get the previous date if it is
        if date in holidays:
            date = date + timedelta(-1)
        # append the date to the dictionary
        if year in exp_dates:
            ### Changed from original code from here on by Jonathan Legrand on 2022-10-11
            if days: exp_dates[year].append(date.day)
            else: exp_dates[year].append(date)
        else:
            if days: exp_dates[year] = [date.day]
            else: exp_dates[year] = [date]
    return exp_dates

        
        Copy
    

    	
            
full_dates = Get_exp_dates(2022, days=False)
dates = Get_exp_dates(2022)
full_dates_str_dict = {i: [full_dates[i][j].strftime('%Y-%m-%d')
                        for j in range(len(full_dates[i]))]
                        for i in list(full_dates.keys())}
full_dates_day_dict = {i: [full_dates[i][j].day
                        for j in range(len(full_dates[i]))]
                        for i in list(full_dates.keys())}

        
        Copy
    

    	
            
print(f"full_dates: {full_dates} \n")  # `\n` prints a new line
print(f"full_dates_str_dict: {full_dates_str_dict} \n")
print(f"dates: {dates} \n")
print(f"full_dates_day_dict: {full_dates_day_dict}")

        
        Copy
    

    	
            x = 15
        
        Copy
    

    	
            
time_of_calc_datetime = datetime.now()  # For now, we will focuss on the use-case where we are calculating values for today; later we will allow for it historically for any day going back a few business days.
time_of_calc_str = datetime.now().strftime('%Y-%m-%d')
time_of_calc_str

        
        Copy
    

    	
            
full_dates_at_time_of_calc = Get_exp_dates(
    time_of_calc_datetime.year, days=False)  # `time_of_calc_datetime.year` here is 2023
full_dates_at_time_of_calc_datetime = [
    datetime(i.year, i.month, i.day)
    for i in full_dates_at_time_of_calc[
        list(full_dates_at_time_of_calc.keys())[0]]]
print(full_dates_at_time_of_calc_datetime)

        
        Copy
    

    	
            
expiry_date_of_int = [i for i in full_dates_at_time_of_calc_datetime
                   if i > time_of_calc_datetime + relativedelta(days=x)][0]
expiry_date_of_int

        
        Copy
    

    	
            
response2 = search.Definition(
    view=search.Views.SEARCH_ALL, # To see what views are available: `help(search.Views)` & `search.metadata.Definition(view = search.Views.SEARCH_ALL).get_data().data.df.to_excel("SEARCH_ALL.xlsx")`
    query=".STOXX50E",
    select="DocumentTitle, RIC, StrikePrice, ExchangeCode, ExpiryDate, UnderlyingAsset, " +
            "UnderlyingAssetName, UnderlyingAssetRIC, ESMAUnderlyingIndexCode, RCSUnderlyingMarket" +
            "UnderlyingQuoteName, UnderlyingQuoteRIC, InsertDateTime, RetireDate",
    filter="RCSAssetCategoryLeaf eq 'Option' and RIC eq 'STX*' and DocumentTitle ne '*Weekly*' " +
    "and CallPutOption eq 'Call' and ExchangeCode eq 'EUX' and " +
    f"ExpiryDate ge {(expiry_date_of_int - relativedelta(days=1)).strftime('%Y-%m-%d')} " +
    f"and ExpiryDate lt {(expiry_date_of_int + relativedelta(days=1)).strftime('%Y-%m-%d')}",  # ge (greater than or equal to), gt (greater than), lt (less than) and le (less than or equal to). These can only be applied to numeric and date properties.
    top=10000,
).get_data()
searchDf2 = response2.data.df

        
        Copy
    

    	
            searchDf2
        
        Copy
    

    	
            
closest_atm_optn = searchDf2.iloc[(searchDf2['StrikePrice']-current_underlying_prc).abs().argsort()[:1]]
closest_atm_optn

        
        Copy
    

    	
            
instrument = closest_atm_optn.RIC.values[0]
instrument

        
        Copy
    

    	
            
start = (time_of_calc_datetime - pd.tseries.offsets.BDay(5)).strftime('%Y-%m-%dT%H:%M:%S.%f')  # `datetime.now().isoformat(timespec='minutes')`
start

        
        Copy
    

    	
            
end_date_time = datetime.now()
end = end_date_time.strftime('%Y-%m-%dT%H:%M:%S.%f')  #  e.g.: '2022-09-09T20:00:00.000'
end

        
        Copy
    

    	
            
_ref_daily_imp_vol_df = historical_pricing.events.Definition(
    instrument, fields=['IMP_VOLT'], count=2000).get_data()
_ref_daily_imp_vol_df.data.df.head()
 
try:
    def_daily_imp_vol_df = _ref_daily_imp_vol_df.data.df.drop(['EVENT_TYPE'], axis=1)  # In codebook, this line is needed
except:
    def_daily_imp_vol_df = _ref_daily_imp_vol_df.data.df # If outside of codebook
fig = px.line(
    def_daily_imp_vol_df,
    title = def_daily_imp_vol_df.columns.name + " " + def_daily_imp_vol_df.columns[0])  # This is just to see the implied vol graph when that field is available
fig.show()

        
        Copy
    

    	
            
__optn_mrkt_price_gmt = rd.content.historical_pricing.summaries.Definition(
    universe=instrument,
        start=start,  # Ought to always start at 4 am for OPRA exchanged Options, more info in the article below
        end=end,  # Ought to always end at 8 pm for OPRA exchanged Options, more info in the article below
        interval='PT10M', # `PT1M`
        fields=['TRDPRC_1', 'SETTLE', 'BID', 'ASK']).get_data().data.df # 'LST_TRD_PR', 'CF_LAST', 'CF_CLOSE', 'SETTLE', 'TRDPRC_1', 'BID', 'ASK'
__optn_mrkt_price_gmt_cnt = __optn_mrkt_price_gmt.count()
if __optn_mrkt_price_gmt_cnt.TRDPRC_1 > 0:
    __optn_mrkt_price_gmt = pd.DataFrame(
        data={'TRDPRC_1':
              __optn_mrkt_price_gmt.TRDPRC_1}).dropna()
elif __optn_mrkt_price_gmt_cnt.SETTLE > 0:
    __optn_mrkt_price_gmt = pd.DataFrame(
        data={'SETTLE':
              __optn_mrkt_price_gmt.SETTLE}).dropna()
elif __optn_mrkt_price_gmt_cnt.BID > 0:
    __optn_mrkt_price_gmt = pd.DataFrame(
        data={'MID': (
            __optn_mrkt_price_gmt.BID + __optn_mrkt_price_gmt.ASK)/2}).dropna()
if __optn_mrkt_price_gmt.empty:
    print(f"No data could be found for {instrument}, please check it on Refinitiv Workspace")
 
_optn_mrkt_price_gmt = __optn_mrkt_price_gmt.copy()
_optn_mrkt_price_gmt.columns = [f"Optn {__optn_mrkt_price_gmt.columns[0]} Pr"]
_optn_mrkt_price_gmt.columns.name = instrument
_optn_mrkt_price_gmt

        
        Copy
    

    	
            
underlying = closest_atm_optn.UnderlyingQuoteRIC.values[0][0]
underlying

        
        Copy
    

    	
            
hoursDf = rd.get_data(
    universe=["EUREX22"],
    fields=["ROW80_22"]).iloc[0, 1]
hoursDf

        
        Copy
    

    	
            
optn_mrkt_price_gmt = _optn_mrkt_price_gmt.resample('10Min').mean()  # get a datapoint every 10 min. Could also use `optn_mrkt_price.append(pd.DataFrame([[pd.NA]], columns=optn_mrkt_price.columns, index=[(end_date_time + (datetime.min - end_date_time) % timedelta(minutes=10))]))` as per https://stackoverflow.com/questions/32723150/rounding-up-to-nearest-30-minutes-in-python
optn_mrkt_price_gmt = optn_mrkt_price_gmt[
    optn_mrkt_price_gmt.index.strftime('%Y-%m-%d').isin(
        [i for i in _optn_mrkt_price_gmt.index.strftime(
            '%Y-%m-%d').unique()])]  # Only keep trading days

        
        Copy
    

    	
            
# Get timezone of the exchange where option is traded:
optn_mrkt_price = optn_mrkt_price_gmt.copy()
optn_mrkt_price.index = pd.MultiIndex.from_tuples(
    [(i, j) for i, j in zip(
        optn_mrkt_price_gmt.index,
        optn_mrkt_price_gmt.index.tz_localize('GMT').tz_convert('Europe/Berlin'))],
    names=["gmt", "cet"])
optn_mrkt_price

        
        Copy
    

    	
            
# Get only trading hours
mrkt_exhng_open_time = '8:50'
mrkt_exhng_close_time = '17:30'
optn_mrkt_price_th = optn_mrkt_price.droplevel( # unfortunately, we have to drop levels we just added to apply the useful `between_time` function.
    'gmt').between_time(mrkt_exhng_open_time, mrkt_exhng_close_time)  # Only keep trading hours. Could also be done with `optn_mrkt_price = optn_mrkt_price.loc[(optn_mrkt_price.index.strftime('%H:%M:%S') >= '07:30:00') & (optn_mrkt_price.index.strftime('%H:%M:%S') <= '22:00:00')]`.
optn_mrkt_price_th.index = pd.MultiIndex.from_tuples(
    [(i, j) for i, j in zip(
        optn_mrkt_price_th.index.tz_convert('GMT'),
        optn_mrkt_price_th.index)],
    names=["gmt", "cet"])
optn_mrkt_price_th.fillna(method='ffill', inplace=True)  # Forward Fill to populate NaN values
print(f"Our dataframe started at {str(optn_mrkt_price_th.index[0])}, \n" +
    f"and went on continuously till {str(optn_mrkt_price_th.index[-1])}, \n" +
    f"so out of trading hours rows are removed")
# optn_mrkt_price.columns = [optn_mrkt_price_th.columns[0] + "_OptPr"]
optn_mrkt_price_th

        
        Copy
    

    	
            
# Get timezone of the exchange where option is traded:
AToptn_mrkt_price = _optn_mrkt_price_gmt.copy()
AToptn_mrkt_price.index = pd.MultiIndex.from_tuples(
    [(i, j) for i, j in zip(
        AToptn_mrkt_price.index,
        AToptn_mrkt_price.index.tz_localize('GMT').tz_convert('Europe/Berlin'))],
    names=["gmt", "cet"])
# Get only trading hours
AToptn_mrkt_pr_th = AToptn_mrkt_price.droplevel('gmt').between_time(mrkt_exhng_open_time, mrkt_exhng_close_time)  # Only keep trading hours. Could also be done with `optn_mrkt_price = optn_mrkt_price.loc[(optn_mrkt_price.index.strftime('%H:%M:%S') >= '07:30:00') & (optn_mrkt_price.index.strftime('%H:%M:%S') <= '22:00:00')]`.
AToptn_mrkt_pr_th.index = pd.MultiIndex.from_tuples(
    [(i, j) for i, j in zip(
        AToptn_mrkt_pr_th.index.tz_convert('GMT'),
        AToptn_mrkt_pr_th.index)],
    names=["gmt", "cet"])
AToptn_mrkt_pr_th

        
        Copy
    

    	
            
_undrlying_mrkt_pr_gmt = rd.get_history(
    universe=[underlying],
    fields=["TRDPRC_1"],
    interval="10min",
    start=start,
    end=end)
_undrlying_mrkt_pr_gmt.index = _undrlying_mrkt_pr_gmt.index.tz_localize('GMT')  # This unfortunutally has to be done for the `join` coming up to work.
_undrlying_mrkt_pr_gmt

        
        Copy
    

    	
            
ATdf_th = AToptn_mrkt_pr_th.join(
    _undrlying_mrkt_pr_gmt, how='inner', on=['gmt'])
ATdf_th.rename(
    columns={"TRDPRC_1": 'underlying ' + underlying + ' TRDPRC_1'},
    inplace=True)
ATdf_th.columns.name = instrument
ATdf_th

        
        Copy
    

    	
            
df = optn_mrkt_price_th.join(
    _undrlying_mrkt_pr_gmt, how='left', on=['gmt'])
df.rename(
    columns={"TRDPRC_1": 'underlying ' + underlying + ' TRDPRC_1'},
    inplace=True)
df.fillna(method='ffill', inplace=True)
df.fillna(method='bfill', inplace=True)  # Here we backfill in case `undrlying_mrkt_pr_gmt` didn't have a value for the 1st few rows of `optn_mrkt_price_th`.
df.columns.name = instrument
# df[df['underlying ' + underlying + ' TRDPRC_1'].isna()]  # Checking for NAs
df_th = df.droplevel('gmt').between_time(mrkt_exhng_open_time, mrkt_exhng_close_time)  # Only keep trading hours.
df_th.index = pd.MultiIndex.from_tuples(
    [(i, j) for i, j in zip(df_th.index.tz_convert('GMT'),
                            df_th.index)],
    names=["gmt", "cet"])
df_th

        
        Copy
    

    	
            
strikePrice = closest_atm_optn.StrikePrice.values[0]
strikePrice

        
        Copy
    

    	
            (datetime.strptime(start, '%Y-%m-%dT%H:%M:%S.%f') - timedelta(days=1)).strftime('%Y-%m-%d')
        
        Copy
    

    	
            start
        
        Copy
    

    	
            
_eur_rf_rate = rd.get_history(  # `rd.get_history` provides data in the GMT timezone
    universe=['EURIBOR3MD='],  # USD3MFSR=, USDSOFR=
    fields=['TR.FIXINGVALUE'],
    # Since we will use `dropna()` as a way to select the rows we are after later on in the code, we need to ask for more risk-free data than needed, just in case we don't have enough:
    start=(datetime.strptime(start, '%Y-%m-%dT%H:%M:%S.%f') - timedelta(days=1)).strftime('%Y-%m-%d'),
    end=(datetime.strptime(end, '%Y-%m-%dT%H:%M:%S.%f') + timedelta(days=1)).strftime('%Y-%m-%d'))
_eur_rf_rate

        
        Copy
    

    	
            
eur_rf_rate = _eur_rf_rate.resample('10Min').mean().fillna(method='ffill')
eur_rf_rate.index = eur_rf_rate.index.tz_localize('GMT')  # This unfortunutally has to be done for the `join` coming up to work.
eur_rf_rate.rename(
    columns={"Fixing Value": "EurRfRate"},
    inplace=True)

        
        Copy
    

    	
            
df_th = df_th.join(eur_rf_rate, how='left', on=['gmt'])  # `rd.get_history` provides data in the GMT timezone, and it was used to get `eur_rf_rate`.
df_th.fillna(method='ffill', inplace=True)
df_th.columns.name = instrument
df_th.rename(columns={"Fixing Value": "EurRfRate"},
          inplace=True)
df_th

        
        Copy
    

    	
            
# pd.options.mode.chained_assignment = None  # default='warn'
# AT_undrlying_mrkt_pr_gmt['EurRfRate'] = [pd.NA for i in AT_undrlying_mrkt_pr_gmt.index]
# for i in _eur_rf_rate.index:
#     _i = str(i)[:10]
#     for n, j in enumerate(AT_undrlying_mrkt_pr_gmt.index):
#         if _i in str(j):
#             if len(_eur_rf_rate.loc[i].values) == 2:
#                 AT_undrlying_mrkt_pr_gmt['EurRfRate'].iloc[n] = _eur_rf_rate.loc[i].values[0][0]
#             elif len(_eur_rf_rate.loc[i].values) == 1:
#                 AT_undrlying_mrkt_pr_gmt['EurRfRate'].iloc[n] = _eur_rf_rate.loc[i].values[0]
# ATdf = AT_undrlying_mrkt_pr_gmt.copy()
 
# ATdf = ATdf.fillna(method='ffill')
# ATdf.head(2)

        
        Copy
    

    	
            
request_fields = [  # This is the 'normal' set of fields.
    "MarketValueInDealCcy", "RiskFreeRatePercent",
    "UnderlyingPrice", "PricingModelType",
    "DividendType", "UnderlyingTimeStamp",
    "ReportCcy", "VolatilityType",
    "Volatility", "DeltaPercent",
    "GammaPercent", "RhoPercent",
    "ThetaPercent", "VegaPercent"]
request_fields = sorted([  # This is the 'troubleshooting' set of fields.
    'ErrorMessage', 'InstrumentTag', 'InstrumentCode', 'InstrumentDescription', 'EndDate', 'OptionType', 'ExerciseStyle', 'CallPut', 'DealCcy', 'LotSize', 'LotsUnits', 'UnderlyingRIC', 'UnderlyingCcy', 'ValuationDate', 'MarketDataDate', 'DaysToExpiry', 'YearsToExpiry', 'Strike', 'OptionPrice', 'OptionPriceSide', 'VolatilityType', 'Volatility', 'GammaAmountInDealCcy', 'RhoAmountInDealCcy'])

        
        Copy
    

    	
            
universeL = [
    {
        "instrumentType": "Option",
        "instrumentDefinition": {
            "buySell": "Buy",
            "underlyingType": "Eti",
            "instrumentCode": instrument,
            "strike": str(strikePrice),
          },
          "pricingParameters": {
            "valuationDate": str(  # IPA works on GMT timezone, so let's stick to it.
              df_th.index[i][0]).replace(" ", "T").split("+", 1)[0] + "Z", # optional, date-time # The original `df_th` index provides dates in the form of '2023-06-15 15:40:00+01:00', so here we (i) change spaces with T, (ii) keep only the part of the str before the "+" and (iii) add "Z" at the end. N.B.: Another way to get the right timezone would be `str([i for i in df_th.index[0] if str(i.tz) == 'GMT'][0].replace(" ", "T").split("+", 1)[0] + "Z")`
            "marketValueInDealCcy": str(df_th.iloc[:,0][i]),
            "riskFreeRatePercent": str(df_th['EurRfRate'][i]),
            "underlyingPrice": str(
              df_th['underlying ' + underlying + ' TRDPRC_1'][i]),
            "pricingModelType": "BlackScholes",
            "dividendType": "ImpliedYield",
            "volatilityType": "Implied",
            "underlyingTimeStamp": "Default",
            "reportCcy": "EUR"
          }
        }
      for i in range(len(df_th))]

        
        Copy
    

    	
            
def Chunks(lst, n):
    """Yield successive n-sized chunks from lst."""
    for i in range(0, len(lst), n):
        yield lst[i:i + n]

        
        Copy
    

    	
            
def Fin_Contracts_Chunk_Calls_Delivery_Lay(
        req_univ,
        batch_of=100,
        dl=rd,
        endpoint='https://api.refinitiv.com/data/quantitative-analytics/v1/financial-contracts',
        request_fields=[
            "MarketValueInDealCcy", "RiskFreeRatePercent", "UnderlyingPrice", "PricingModelType",
            "DividendType", "UnderlyingTimeStamp", "ReportCcy", "VolatilityType", "Volatility",
            "DeltaPercent", "GammaPercent", "RhoPercent", "ThetaPercent", "VegaPercent"],
        request_outputs=["Data", "Headers"],
        print_log=True):
 
    def Chunks(lst, n):
        """Yield successive n-sized chunks from lst."""
        for i in range(0, len(lst), n):
            yield lst[i:i + n]
 
    for i, j in enumerate(Chunks(req_univ, batch_of)):
        if print_log:
            print(f"Batch of {batch_of} requests no. {str(i+1)}/{str(len([i for i in Chunks(req_univ, batch_of)]))} started")
        request_definition = dl.delivery.endpoint_request.Definition(
            method=dl.delivery.endpoint_request.RequestMethod.POST,
            url=endpoint,
            body_parameters={
                "fields": request_fields,
                "outputs": request_outputs,
                "universe": j})
        
        resp = request_definition.get_data()
        if resp.is_success:
            headers_name = [h['name'] for h in resp.data.raw['headers']]
            if i == 0:
                resp_df = pd.DataFrame(
                    data=resp.data.raw['data'], columns=headers_name)
            else:
                _resp_df = pd.DataFrame(
                    data=resp.data.raw['data'], columns=headers_name)
                resp_df = _resp_df.append(_resp_df, ignore_index=True)
            if print_log:
                print(f"Batch of {batch_of} requests no. {str(i+1)}/{str(len([i for i in Chunks(req_univ, batch_of)]))} ended")
        else:
            display(resp)
 
    return resp_df

        
        Copy
    

    	
            
response3df = Fin_Contracts_Chunk_Calls_Delivery_Lay(
    req_univ=universeL, request_fields=request_fields)

        
        Copy
    

    	
            response3df.tail(3)
        
        Copy
    

    	
            
def Fin_Contracts_Chunk_Calls_Content_Lay(
        req_univ,
        batch_of=100,
        rdf=rdf,
        request_fields=[
                "MarketValueInDealCcy", "RiskFreeRatePercent", "UnderlyingPrice", "PricingModelType",
                "DividendType", "UnderlyingTimeStamp", "ReportCcy", "VolatilityType", "Volatility",
                "DeltaPercent", "GammaPercent", "RhoPercent", "ThetaPercent", "VegaPercent"],
        print_log=True):
 
    for i, j in enumerate(Chunks(req_univ, batch_of)):
        if print_log:
            print(f"Batch of {len(j)} requests no. {i+1}/{len([i for i in Chunks(req_univ, batch_of)])} started")
        resp = rdf.Definitions(universe=j, fields=request_fields)
        resp = resp.get_data()
        if i == 0:
            resp_df = resp.data.df
        else:
            resp_df = resp_df.append(resp.data.df, ignore_index=True)
        if print_log:
            # print(resp.request_message)
            # print(resp.http_response)
            # print(resp.__dict__)
            print(f"Batch of {len(j)} requests no. {i+1}/{len([i for i in Chunks(req_univ, batch_of)])} ended")
 
    return resp_df

        
        Copy
    

    	
            
CuniverseL = [  # C here is for the fact that we're using the content layer
    option.Definition(
        underlying_type=option.UnderlyingType.ETI,
        buy_sell='Buy',
        instrument_code=instrument,
        strike=float(strikePrice),
        pricing_parameters=option.PricingParameters(
            valuation_date=str(df_th.index[i][0]).replace(" ", "T").split("+", 1)[0] + "Z",  # optional, str # The date at which the instrument is valued. The value is expressed in iso 8601 format: yyyy-mm-ddt[hh]:[mm]:[ss]z (e.g., '2021-01-01t00:00:00z'). by default, marketdatadate is used. If marketdatadate is not specified, the default value is today.
            market_value_in_deal_ccy=float(df_th.iloc[:,0][i]),
            risk_free_rate_percent=float(df_th['EurRfRate'][i]),
            underlying_price=float(df_th[
                'underlying ' + underlying + ' TRDPRC_1'][i]),
            pricing_model_type='BlackScholes',
            volatility_type='Implied',
            underlying_time_stamp='Default',
            report_ccy='EUR'))
    for i in range(len(df_th))]

        
        Copy
    

    	
            
response4df = Fin_Contracts_Chunk_Calls_Content_Lay(
    req_univ=CuniverseL, request_fields=request_fields)

        
        Copy
    

    	
            
pd.set_option('display.max_columns', None)
response4df

        
        Copy
    

    	
            
IPADf = response4df.copy()  # IPA here stands for the service we used to get all the calculated valuse, Instrument Pricint Analitycs.
IPADf.index = df_th.index
IPADf.columns.name = df_th.columns.name
IPADf.rename(inplace=True, columns={
    "Volatility": 'ImpliedVolatility',
    "MarketValueInDealCcy": f"OptnMrktValueInDealCcy-{__optn_mrkt_price_gmt.columns[0]}"})
IPADf

        
        Copy
    

    	
            
response5df = Fin_Contracts_Chunk_Calls_Delivery_Lay(
    req_univ=[{
        "instrumentType": "Option",
        "instrumentDefinition": {
            "buySell": "Buy",
            "underlyingType": "Eti",
            "instrumentCode": instrument,
            "strike": str(strikePrice)},
            "pricingParameters": {
                "valuationDate": str(
                    ATdf_th.index[i][0]).replace(" ", "T").split("+", 1)[0] + "Z", # optional, date-time # The original `dfLocalTimeZone` index provides dates in the form of '2023-06-15 15:40:00+01:00', so here we (i) change spaces with T, (ii) keep only the part of the str before the "+" and (iii) add "Z" at the end.
                "marketValueInDealCcy": str(ATdf_th.iloc[:,0][i]),
                "riskFreeRatePercent": str(ATdf_th['EurRfRate'][i]),
                "underlyingPrice": str(
                    ATdf_th['underlying ' + underlying + ' TRDPRC_1'][i]),
                "pricingModelType": "BlackScholes",
                "dividendType": "ImpliedYield",
                "volatilityType": "Implied",
                "underlyingTimeStamp": "Default",
                "reportCcy": "EUR"}}
        for i in range(len(ATdf_th))],
    request_fields=request_fields)

        
        Copy
    

    	
            response5df.tail(3)
        
        Copy
    

    	
            
response6df = Fin_Contracts_Chunk_Calls_Content_Lay(
    req_univ=[  # C here is for the fact that we're using the content layer
        option.Definition(
            underlying_type=option.UnderlyingType.ETI,
            buy_sell='Buy',
            instrument_code=instrument,
            strike=float(strikePrice),
            pricing_parameters=option.PricingParameters(
                valuation_date=str(
                    ATdf_th.index[i][0]).replace(" ", "T").split("+", 1)[0] + "Z",
                market_value_in_deal_ccy=float(ATdf_th.iloc[:,0][i]),
                risk_free_rate_percent=float(ATdf_th['EurRfRate'][i]),
                underlying_price=float(
                    ATdf_th['underlying ' + underlying + ' TRDPRC_1'][i]),
                pricing_model_type='BlackScholes',
                volatility_type='Implied',
                underlying_time_stamp='Default',
                report_ccy='EUR'))
        for i in range(len(ATdf_th))],
    request_fields=request_fields)

        
        Copy
    

    	
            
ATIPADf = response6df.copy()  # IPA here stands for the service we used to get all the calculated valuse, Instrument Pricint Analitycs.
ATIPADf.index = ATdf_th.index
ATIPADf.columns.name = ATdf_th.columns.name
ATIPADf.rename(inplace=True, columns={
    "Volatility": 'ImpliedVolatility',
    "MarketValueInDealCcy": f"OptnMrktValueInDealCcy-{__optn_mrkt_price_gmt.columns[0]}"})
ATIPADf.head(2)

        
        Copy
    

    	
            
def Get_ooth(
        df,
        tz=None,
        mrkt_exhng_open_time=mrkt_exhng_open_time,
        mrkt_exhng_close_time=mrkt_exhng_close_time):
    """Get_ooth(df, tz=None, mrkt_exhng_open_time=mrkt_exhng_close_time, mrkt_exhng_close_time=mrkt_exhng_close_time))
 
    df (pandas dataframe):
        Must have dates as `pd.Timestamp`s in its index.
    
    returns:
        List of list of two objects: the start second of each weekend day (saturnday 1st, sunday 2nd).
    """
    ooth = []
    for k in range(len(df)-1):
        if len(pd.bdate_range(start=df.index[k], end=df.index[k+1], freq="C", weekmask="Sat Sun")) > 0:
            for saturday in [j for j in pd.bdate_range(start=df.index[k], end=df.index[k+1], freq="C", weekmask="Sat")]:
                # Append with the the first second of that Saturday
                ooth.append([
                    pd.Timestamp(
                        year=saturday.year,
                        month=saturday.month,
                        day=saturday.day,
                        tzinfo=tz),
                    pd.Timestamp(
                        year=saturday.year,
                        month=saturday.month,
                        day=saturday.day,
                        hour=23,
                        minute=59,
                        second=59,
                        tzinfo=tz)])
            for sunday in [j for j in pd.bdate_range(start=df.index[k], end=df.index[k+1], freq="C", weekmask="Sun")]:
                ooth.append([
                    pd.Timestamp(
                        year=sunday.year,
                        month=sunday.month,
                        day=sunday.day,
                        tzinfo=tz),
                    pd.Timestamp(
                        year=sunday.year,
                        month=sunday.month,
                        day=sunday.day,
                        hour=23,
                        minute=59,
                        second=59,
                        tzinfo=tz)])
        else:
            for weekday in [j for j in pd.bdate_range(start=df.index[k], end=df.index[k+1], freq="C", weekmask="Mon Tue Wed Thu Fri")]:
                ooth.append([  # Begining of day till mrkt open.
                    pd.Timestamp(
                        year=weekday.year,
                        month=weekday.month,
                        day=weekday.day,
                        hour=0,
                        minute=0,
                        second=1,
                        tzinfo=tz),
                    pd.Timestamp(
                        year=weekday.year,
                        month=weekday.month,
                        day=weekday.day,
                        hour=int(mrkt_exhng_open_time.split(':')[0]),
                        minute=int(mrkt_exhng_open_time.split(':')[1]),
                        tzinfo=tz)])
                ooth.append([  # Mrkt close to end of day.
                    pd.Timestamp(
                        year=weekday.year,
                        month=weekday.month,
                        day=weekday.day,
                        hour=int(mrkt_exhng_close_time.split(':')[0]),
                        minute=int(mrkt_exhng_close_time.split(':')[1]),
                        tzinfo=tz),
                    pd.Timestamp(
                        year=weekday.year,
                        month=weekday.month,
                        day=weekday.day,
                        hour=23,
                        minute=59,
                        second=59,
                        tzinfo=tz)])
                
    ooth = pd.Series(ooth).drop_duplicates().tolist() # There are duplicates to remove.
 
    return ooth[1:-1] # We do not want to see the out of trading hours before the data starts and ends on the graph.

        
        Copy
    

    	
            
IPADfGraph = IPADf[[
    'ImpliedVolatility', f"OptnMrktValueInDealCcy-{__optn_mrkt_price_gmt.columns[0]}",
    'RiskFreeRatePercent', 'UnderlyingPrice', 'DeltaPercent',
    'GammaPercent', 'RhoPercent', 'ThetaPercent', 'VegaPercent']].droplevel('gmt')

        
        Copy
    

    	
            
display(closest_atm_optn)
 
fig = px.line(IPADfGraph)  # This is just to see the implied vol graph when that field is available
# fig.layout = dict(xaxis=dict(type="category"))
 
# Format Graph: https://plotly.com/python/tick-formatting/
fig.update_layout(
    title=instrument,
    template='plotly_dark')
 
# Make it so that only one line is shown by default: # https://stackoverflow.com/questions/73384807/plotly-express-plot-subset-of-dataframe-columns-by-default-and-the-rest-as-opt
fig.for_each_trace(
    lambda t: t.update(
        visible=True if t.name in IPADfGraph.columns[:1] else "legendonly"))
 
# Add shade in Non Trading Hours
shapes = [
    {'type': "rect", 'xref': 'x', 'yref': 'paper',
     'fillcolor': 'purple', 'opacity': 0.4,
     "line": {"color": "purple", "width": 0},
     'x0': i[0], 'y0': 0,
     'x1': i[1], 'y1': 1}
     for i in Get_ooth(df=IPADfGraph, tz=None)]
 
fig.update_layout(shapes=shapes,)
 
 
fig.show()

        
        Copy
    

    	
            
display(closest_atm_optn)
 
fig = subplots.make_subplots(rows=3, cols=1)
 
fig.add_trace(go.Scatter(
    x=IPADfGraph.index, y=IPADfGraph.ImpliedVolatility,
    name='Op Imp Volatility'), row=1, col=1)
fig.add_trace(go.Scatter(
    y=IPADfGraph[f"OptnMrktValueInDealCcy-{__optn_mrkt_price_gmt.columns[0]}"],
    x=IPADfGraph.index,
    name=f"OptnMrktValueInDealCcy-{__optn_mrkt_price_gmt.columns[0]}"), row=2, col=1)
fig.add_trace(go.Scatter(
    x=IPADfGraph.index, y=IPADf.UnderlyingPrice,
    name=underlying + ' Undrlyg Pr'), row=3, col=1)
 
 
fig.update(layout_xaxis_rangeslider_visible=False)
fig.update_layout(title=IPADfGraph.columns.name)
 
fig.update_layout(
    template='plotly_dark',
    autosize=False,
    width=1300,
    height=500,
    shapes = [ # Adding purple area on out of trading hours
        {'type': "rect", 'xref': 'x', 'yref': 'paper',
        'fillcolor': 'purple', 'opacity': 0.2,
        "line": {"color": "purple", "width": 0},
        'x0': i[0], 'y0': 0,
        'x1': i[1], 'y1': 1}
        for i in Get_ooth(df=IPADfGraph, tz=None)])
 
fig.show()

        
        Copy
    

    	
            
display(closest_atm_optn)
IPADfSimpleGraph = pd.DataFrame(
    data=IPADfGraph.ImpliedVolatility.values,
    index=IPADfGraph.ImpliedVolatility.index)
 
fig, ax = plt.subplots(ncols=1)
 
ax.plot(IPADfSimpleGraph, '.-')
# ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_date))
ax.set_title(
    f"{closest_atm_optn.RIC.values[0]} Implied Volatility At Trade Only")
fig.autofmt_xdate()
 
plt.show()

        
        Copy
    

    	
            
IPADfGraph = ATIPADf[[
    'ImpliedVolatility', f"OptnMrktValueInDealCcy-{__optn_mrkt_price_gmt.columns[0]}",
    'RiskFreeRatePercent', 'UnderlyingPrice', 'DeltaPercent',
    'GammaPercent', 'RhoPercent', 'ThetaPercent', 'VegaPercent']].droplevel('gmt')

        
        Copy
    

    	
            
display(closest_atm_optn)
 
fig = px.line(IPADfGraph)  # This is just to see the implied vol graph when that field is available
# fig.layout = dict(xaxis=dict(type="category"))
 
# Format Graph: https://plotly.com/python/tick-formatting/
fig.update_layout(
    title=instrument,
    template='plotly_dark')
 
# Make it so that only one line is shown by default: # https://stackoverflow.com/questions/73384807/plotly-express-plot-subset-of-dataframe-columns-by-default-and-the-rest-as-opt
fig.for_each_trace(
    lambda t: t.update(
        visible=True if t.name in IPADfGraph.columns[:1] else "legendonly"))
 
# Add shade in Non Trading Hours
shapes = [
    {'type': "rect", 'xref': 'x', 'yref': 'paper',
     'fillcolor': 'purple', 'opacity': 0.4,
     "line": {"color": "purple", "width": 0},
     'x0': i[0], 'y0': 0,
     'x1': i[1], 'y1': 1}
     for i in Get_ooth(df=IPADfGraph, tz=None)]
 
fig.update_layout(shapes=shapes,)
 
 
fig.show()

        
        Copy
    

    	
            
display(closest_atm_optn)
 
fig = subplots.make_subplots(rows=3, cols=1)
 
fig.add_trace(go.Scatter(
    x=IPADfGraph.index, y=IPADfGraph.ImpliedVolatility,
    name='Op Imp Volatility'), row=1, col=1)
fig.add_trace(go.Scatter(
    y=IPADfGraph[f"OptnMrktValueInDealCcy-{__optn_mrkt_price_gmt.columns[0]}"],
    x=IPADfGraph.index,
    name=f"OptnMrktValueInDealCcy-{__optn_mrkt_price_gmt.columns[0]}"), row=2, col=1)
fig.add_trace(go.Scatter(
    x=IPADfGraph.index, y=IPADf.UnderlyingPrice,
    name=underlying + ' Undrlyg Pr'), row=3, col=1)
 
 
fig.update(layout_xaxis_rangeslider_visible=False)
fig.update_layout(title=IPADfGraph.columns.name)
 
fig.update_layout(
    template='plotly_dark',
    autosize=False,
    width=1300,
    height=500,
    shapes = [ # Adding purple area on out of trading hours
        {'type': "rect", 'xref': 'x', 'yref': 'paper',
        'fillcolor': 'purple', 'opacity': 0.2,
        "line": {"color": "purple", "width": 0},
        'x0': i[0], 'y0': 0,
        'x1': i[1], 'y1': 1}
        for i in Get_ooth(df=IPADfGraph, tz=None)])
 
fig.show()

        
        Copy
    

    	
            
display(closest_atm_optn)
IPADfSimpleGraph = pd.DataFrame(
    data=IPADfGraph.ImpliedVolatility.values,
    index=IPADfGraph.ImpliedVolatility.index)
 
fig, ax = plt.subplots(ncols=1)
 
ax.plot(IPADfSimpleGraph, '.-')
# ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_date))
ax.set_title(
    f"{closest_atm_optn.RIC.values[0]} Implied Volatility At Trade Only")
fig.autofmt_xdate()
 
plt.show()

        
        Copy