def get_economic_event_ret_over_custom_event_day(self, data_frame_in, event_dates, name, event, start, end, lagged = False, NYC_cutoff = 10): filter = Filter() #returns event_dates dataframe that is between those dates, returns correct # filtered dataframe them even if index is not a timestamp event_dates = filter.filter_time_series_by_date(start, end, event_dates) data_frame = data_frame_in.copy(deep=True) # because we change the dates! timezone = Timezone() calendar = Calendar() bday = CustomBusinessDay(weekmask='Mon Tue Wed Thu Fri') event_dates_nyc = timezone.convert_index_from_UTC_to_new_york_time(event_dates) average_hour_nyc = numpy.average(event_dates_nyc.index.hour) event_dates = calendar.floor_date(event_dates) # realised is traditionally on later day eg. 3rd Jan realised ON is 2nd-3rd Jan realised # so if Fed meeting is on 2nd Jan later, then we need realised labelled on 3rd (so minus a day) # implied expires on next day eg. 3rd Jan implied ON is 3rd-4th Jan implied # TODO smarter way of adjusting dates, as sometimes events can be before/after 10am NY cut if (lagged and average_hour_nyc >= NYC_cutoff): data_frame.index = data_frame.index - bday elif (not lagged and average_hour_nyc < NYC_cutoff): # ie. implied data_frame.index = data_frame.index + bday # set as New York time and select only those ON vols at the 10am NY cut just before the event data_frame_events = data_frame.ix[event_dates.index] data_frame_events.columns = data_frame.columns.values + '-' + name + ' ' + event return data_frame_events
def get_economic_event_ret_over_custom_event_day(self, data_frame_in, event_dates, name, event, start, end, lagged = False, NYC_cutoff = 10): filter = Filter() event_dates = filter.filter_time_series_by_date(start, end, event_dates) data_frame = data_frame_in.copy(deep=True) # because we change the dates! timezone = Timezone() calendar = Calendar() bday = CustomBusinessDay(weekmask='Mon Tue Wed Thu Fri') event_dates_nyc = timezone.convert_index_from_UTC_to_new_york_time(event_dates) average_hour_nyc = numpy.average(event_dates_nyc.index.hour) event_dates = calendar.floor_date(event_dates) # realised is traditionally on later day eg. 3rd Jan realised ON is 2nd-3rd Jan realised # so if Fed meeting is on 2nd Jan later, then we need realised labelled on 3rd (so minus a day) # implied expires on next day eg. 3rd Jan implied ON is 3rd-4th Jan implied # TODO smarter way of adjusting dates, as sometimes events can be before/after 10am NY cut if (lagged and average_hour_nyc >= NYC_cutoff): data_frame.index = data_frame.index - bday elif (not lagged and average_hour_nyc < NYC_cutoff): # ie. implied data_frame.index = data_frame.index + bday # set as New York time and select only those ON vols at the 10am NY cut just before the event data_frame_events = data_frame.ix[event_dates.index] data_frame_events.columns = data_frame.columns.values + '-' + name + ' ' + event return data_frame_events
def __init__(self, fx_vol_surface=None, premium_output=market_constants.fx_options_premium_output, delta_output=market_constants.fx_options_delta_output): self._calendar = Calendar() self._fx_vol_surface = fx_vol_surface self._fx_forwards_pricer = FXForwardsPricer() self._premium_output = premium_output self._delta_output = delta_output
def __init__(self, market_data_generator=None, fx_forwards_trading_tenor=market_constants.fx_forwards_trading_tenor, roll_days_before=market_constants.fx_forwards_roll_days_before, roll_event=market_constants.fx_forwards_roll_event, construct_via_currency='no', fx_forwards_tenor_for_interpolation=market_constants.fx_forwards_tenor_for_interpolation, base_depos_tenor=data_constants.base_depos_tenor, roll_months=market_constants.fx_forwards_roll_months, output_calculation_fields=market_constants.output_calculation_fields): """Initializes FXForwardsCurve Parameters ---------- market_data_generator : MarketDataGenerator Used for downloading market data fx_forwards_trading_tenor : str What is primary forward contract being used to trade (default - '1M') roll_days_before : int Number of days before roll event to enter into a new forwards contract roll_event : str What constitutes a roll event? ('month-end', 'quarter-end', 'year-end', 'expiry') construct_via_currency : str What currency should we construct the forward via? Eg. if we asked for AUDJPY we can construct it via AUDUSD & JPYUSD forwards, as opposed to AUDJPY forwards (default - 'no') fx_forwards_tenor_for_interpolation : str(list) Which forwards should we use for interpolation base_depos_tenor : str(list) Which base deposits tenors do we need (this is only necessary if we want to start inferring depos) roll_months : int After how many months should we initiate a roll. Typically for trading 1M this should 1, 3M this should be 3 etc. output_calculation_fields : bool Also output additional data should forward expiries etc. alongside total returns indices """ self._market_data_generator = market_data_generator self._calculations = Calculations() self._calendar = Calendar() self._filter = Filter() self._fx_forwards_trading_tenor = fx_forwards_trading_tenor self._roll_days_before = roll_days_before self._roll_event = roll_event self._construct_via_currency = construct_via_currency self._fx_forwards_tenor_for_interpolation = fx_forwards_tenor_for_interpolation self._base_depos_tenor = base_depos_tenor self._roll_months = roll_months self._output_calcultion_fields = output_calculation_fields
def __init__(self, market_data_generator=None, fx_forwards_trading_tenor='1M', roll_date=0, construct_via_currency='no', fx_forwards_tenor=constants.fx_forwards_tenor, base_depos_tenor=constants.base_depos_tenor): self._market_data_generator = market_data_generator self._calculations = Calculations() self._calendar = Calendar() self._fx_forwards_trading_tenor = fx_forwards_trading_tenor self._roll_date = roll_date self._construct_via_currency = construct_via_currency self._fx_forwards_tenor = fx_forwards_tenor self._base_depos_tenor = base_depos_tenor
def __init__(self, market_df=None, quoted_delivery_df=None): self._calendar = Calendar() self._market_df = market_df self._quoted_delivery_df = quoted_delivery_df
class FXForwardsPricer(AbstractPricer): """Prices forwards for odd dates which are not quoted using linear interpolation, eg. if we have forward points for 1W and 1M, and spot date but we want to price a 3W forward, or any arbitrary horizon date that lies in that interval Also calculates the implied deposit rate from FX spot, FX forward points and deposit rate. """ def __init__(self, market_df=None, quoted_delivery_df=None): self._calendar = Calendar() self._market_df = market_df self._quoted_delivery_df = quoted_delivery_df def price_instrument(self, cross, horizon_date, delivery_date, market_df=None, quoted_delivery_df=None, fx_forwards_tenor_for_interpolation=market_constants. fx_forwards_tenor_for_interpolation): """Creates an interpolated outright FX forward (and the associated points), for horizon dates/delivery dates given by the user from FX spot rates and FX forward points. This can be useful when we have an odd/broken date which isn't quoted. Uses linear interpolation between quoted dates to calculate the appropriate interpolated forward. Eg. if we ask for a delivery date in between 1W and 1M, we will interpolate between those. Parameters ---------- cross : str Currency pair horizon_date : DateTimeIndex Horizon dates for forward contracts delivery_date : DateTimeIndex Delivery dates for forward contracts market_df : DataFrame Contains FX spot and FX forward points data quoted_delivery_df : DataFrame (DateTimeIndex) Delivery dates for every quoted forward point fx_forwards_tenor_for_interpolation : str(list) Which forwards to use for interpolation Returns ------- DataFrame """ if market_df is None: market_df = self._market_df if quoted_delivery_df is None: quoted_delivery_df = self._quoted_delivery_df if quoted_delivery_df is None: quoted_delivery_df = self.generate_quoted_delivery( cross, market_df, quoted_delivery_df, fx_forwards_tenor_for_interpolation, cross) # Make horizon date and delivery date pandas DatetimeIndex if isinstance(horizon_date, pd.Timestamp): horizon_date = pd.DatetimeIndex([horizon_date]) delivery_date = pd.DatetimeIndex([delivery_date]) else: horizon_date = pd.DatetimeIndex(horizon_date) delivery_date = pd.DatetimeIndex(delivery_date) # Truncate the market data so covers only the dates where we want to price the forwards market_df = market_df[market_df.index.isin(horizon_date)] quoted_delivery_df = quoted_delivery_df[quoted_delivery_df.index.isin( horizon_date)] cal = cross # Get the spot date (different currency pairs have different conventions for this!) spot_date = self._calendar.get_spot_date_from_horizon_date( horizon_date, cal) # How many days between spot date (typically T+1 or T+2) and delivery date spot_delivery_days_arr = (delivery_date - spot_date).days spot_arr = market_df[cross + '.close'].values quoted_delivery_df, quoted_delivery_days_arr, forwards_points_arr, divisor = \ self._setup_forward_calculation(cross, spot_date, market_df, quoted_delivery_df, fx_forwards_tenor_for_interpolation) interpolated_outright_forwards_arr = _forwards_interpolate_numba( spot_arr, spot_delivery_days_arr, quoted_delivery_days_arr, forwards_points_arr, len(fx_forwards_tenor_for_interpolation)) interpolated_df = pd.DataFrame( index=market_df.index, columns=[ cross + '-interpolated-outright-forward.close', cross + "-interpolated-forward-points.close" ]) interpolated_df[ cross + '-interpolated-outright-forward.close'] = interpolated_outright_forwards_arr interpolated_df[cross + "-interpolated-forward-points.close"] = ( interpolated_outright_forwards_arr - spot_arr) * divisor return interpolated_df def get_day_count_conv(self, currency): if currency in market_constants.currencies_with_365_basis: return 365.0 return 360.0 def get_forwards_divisor(self, currency): # Typically most divisors of forward points are 10000.0 divisor = 10000.0 if currency in market_constants.fx_forwards_points_divisor_100: divisor = 100.0 if currency in market_constants.fx_forwards_points_divisor_1000: divisor = 1000.0 return divisor def _setup_forward_calculation(self, cross, spot_date, market_df, quoted_delivery_df, fx_forwards_tenor): cal = cross # Get the quoted delivery dates for every quoted tenor in our forwards market data # Eg. what's the delivery date for EURUSD SN, 1W etc. quoted_delivery_df = self.generate_quoted_delivery( cross, market_df, quoted_delivery_df, fx_forwards_tenor, cal) # Typically most divisors of forward points are 10000.0 (but JPY is an exception) divisor = self.get_forwards_divisor(cross[3:6]) forwards_points_arr = market_df[[ cross + x + ".close" for x in fx_forwards_tenor ]].values / divisor quoted_delivery_days_arr = np.zeros( (len(quoted_delivery_df.index), len(fx_forwards_tenor))) # Get difference between each quoted point and the spot date (NOT horizon date) # eg. for 1W this is generally 7 days, for 2W it's 14 days etc. for i, tenor in enumerate(fx_forwards_tenor): quoted_delivery_days_arr[:, i] = (pd.DatetimeIndex( quoted_delivery_df[cross + tenor + ".delivery"]) - spot_date).days return quoted_delivery_df, quoted_delivery_days_arr, forwards_points_arr, divisor def generate_quoted_delivery(self, cross, market_df, quoted_delivery_df, fx_forwards_tenor, cal): # Get the quoted delivery dates for every quoted tenor in our forwards market data # Eg. what's the delivery date for EURUSD SN, 1W etc. if quoted_delivery_df is None: quoted_delivery_df = pd.DataFrame( index=market_df.index, columns=[ cross + tenor + ".delivery" for tenor in fx_forwards_tenor ]) for tenor in fx_forwards_tenor: quoted_delivery_df[cross + tenor + ".delivery"] = \ self._calendar.get_delivery_date_from_horizon_date(quoted_delivery_df.index, tenor, cal=cal) return quoted_delivery_df def calculate_implied_depo( self, cross, implied_currency, market_df=None, quoted_delivery_df=None, fx_forwards_tenor=market_constants.fx_forwards_trading_tenor, depo_tenor=None): """Calculates implied deposit rates for a particular currency from spot, forward points and deposit rate for the other currency. Uses the theory of covered interest rate parity. See BIS publication from 2016, Covered interest parity lost: understanding the cross-currency basis downloadable from https://www.bis.org/publ/qtrpdf/r_qt1609e.pdf for an explanation Eg. using EURUSD spot, EURUSD 1W forward points and USDON deposit rate, we can calculate the implied deposit for EUR 1W Parameters ---------- cross : str Currency pair implied_currency : str Currency for which we want to imply deposit market_df : DataFrame With FX spot rate, FX forward points and deposit rates fx_forwards_tenor : str (list) Tenors of forwards where we want to imply deposit depo_tenor : str Deposit rate to use (default - ON) Returns ------- DataFrame """ if market_df is None: market_df = self._market_df if quoted_delivery_df is None: quoted_delivery_df = self._quoted_delivery_df if depo_tenor is None: depo_tenor = fx_forwards_tenor if not (isinstance(depo_tenor, list)): depo_tenor = [depo_tenor] * len(fx_forwards_tenor) cal = cross # Get the spot date (different currency pairs have different conventions for this!) spot_date = self._calendar.get_spot_date_from_horizon_date( market_df.index, cal) quoted_delivery_df, quoted_delivery_days_arr, forwards_points_arr, divisor = \ self._setup_forward_calculation(cross, spot_date, market_df, quoted_delivery_df, fx_forwards_tenor) spot_arr = market_df[cross + '.close'].values outright_forwards_arr = np.vstack( [spot_arr] * len(fx_forwards_tenor)).T + forwards_points_arr base_conv = self.get_day_count_conv(cross[0:3]) terms_conv = self.get_day_count_conv(cross[3:6]) # Infer base currency if implied_currency == cross[0:3]: original_currency = cross[3:6] depo_arr = market_df[[ original_currency + d + '.close' for d in depo_tenor ]].values / 100.0 implied_depo_arr = _infer_base_currency_depo_numba( spot_arr, outright_forwards_arr, depo_arr, quoted_delivery_days_arr, base_conv, terms_conv, len(fx_forwards_tenor)) # for i in range(len(implied_depo_arr)): # for j, tenor in enumerate(fx_forwards_tenor): # implied_depo_arr[i, j] = (((1 + depo_arr[i,j] * (quoted_delivery_days_arr[i, j] / terms_conv)) # / (outright_forwards_arr[i,j] / spot_arr[i])) - 1) \ # / (quoted_delivery_days_arr[i, j] / base_conv) # Infer terms currency if implied_currency == cross[3:6]: original_currency = cross[0:3] depo_arr = market_df[[ original_currency + d + '.close' for d in depo_tenor ]].values / 100.0 implied_depo_arr = _infer_terms_currency_depo_numba( spot_arr, outright_forwards_arr, depo_arr, quoted_delivery_days_arr, base_conv, terms_conv, len(fx_forwards_tenor)) # for i in range(len(implied_depo_arr)): # for j, tenor in enumerate(fx_forwards_tenor): # implied_depo_arr[i,j] = ((outright_forwards_arr[i,j] / spot_arr[i]) * # (1 + depo_arr[i,j] * (quoted_delivery_days_arr[i,j] / base_conv)) - 1) \ # / (quoted_delivery_days_arr[i,j] / terms_conv) return pd.DataFrame(index=market_df.index, columns=[ implied_currency + x + "-implied-depo.close" for x in fx_forwards_tenor ], data=implied_depo_arr * 100.0)
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # # See the License for the specific language governing permissions and limitations under the License. # if __name__ == '__main__': ###### below line CRUCIAL when running Windows, otherwise multiprocessing doesn't work! (not necessary on Linux) from findatapy.util import SwimPool SwimPool() from findatapy.timeseries import Filter, Calendar import pandas as pd import numpy as np calendar = Calendar() filter = Filter() # choose run_example = 0 for everything # run_example = 1 - get holidays for FX, EUR and EURUSD, as well as listing weekends # run_example = 2 - get FX delivery dates and FX option expiries for various tenors # run_example = 3 - get number of days between pandas DatetimeIndex # run_example = 4 - filter time series by EURUSD holidays run_example = 0 if run_example == 1 or run_example == 0: # Get the holidays (which aren't weekends) print( calendar.get_holidays(start_date='01 Jan 1999 00:50',
def calculate_realized_vol(self, asset, spot_df=None, returns_df=None, tenor_label="ON", freq='daily', freq_min_mult=1, hour_of_day=10, minute_of_day=0, field='close', returns_calc='simple', timezone_hour_minute='America/New_York'): """Calculates rolling realized vol with daily cutoffs either using daily spot data or intraday spot data (which is assumed to be in UTC timezone) Parameters ---------- asset : str asset to be calculated spot_df : pd.DataFrame minute spot returns (freq_min_mult should be the same as the frequency and should have timezone set) tenor_label : str tenor to calculate freq_min_mult : int frequency multiply for data (1 = 1 min) hour_of_day : closing time of data in the timezone specified eg. 10 which is 1000 time (default = 10) minute_of_day : closing time of data in the timezone specified eg. 0 which is 0 time (default = 0) field : str By default 'close' returns_calc : str 'simple' calculate simple returns 'log' calculate log returns timezone_hour_minute : str The timezone for the closing hour/minute (default: 'America/New_York') Returns ------- pd.DataFrame of realized volatility """ if returns_df is None: if spot_df is None: if freq == 'daily': spot_df = self._market_df[asset + "." + field] else: spot_df = self._intraday_spot_df[asset + "." + field] if returns_calc == 'simple': returns_df = self._calculations.calculate_returns(spot_df) else: returns_df = self._calculations.calculate_log_returns(spot_df) cal = Calendar() tenor_days = cal.get_business_days_tenor(tenor_label) if freq == 'intraday': # Annualization factor (1440 is number of minutes in the day) mult = int(1440.0 / float(freq_min_mult)) realized_rolling = self._calculations.rolling_volatility( returns_df, tenor_days * mult, obs_in_year=252 * mult) # Convert to NYC time (or whatever timezone hour is specified in) realized_rolling = self._timezone.convert_index_aware_to_alt( realized_rolling, timezone_hour_minute) realized_vol = self._filter.filter_time_series_by_time_of_day( hour_of_day, minute_of_day, realized_rolling) realized_vol = self._timezone.convert_index_aware_to_UTC_time( realized_vol) realized_vol = self._timezone.set_as_no_timezone(realized_vol) elif freq == 'daily': realized_vol = self._calculations.rolling_volatility( spot_df, tenor_days, obs_in_year=252) # Strip the time off the date realized_vol.index = realized_vol.index.date realized_vol = pd.DataFrame(realized_vol) realized_vol.columns = [asset + 'H' + tenor_label + '.close'] return realized_vol
def calculate_vol_risk_premium(self, asset, tenor_label="ON", implied_vol=None, realized_vol=None, field='close', adj_ON_friday=False): """Calculates volatility risk premium given implied and realized quotes (ie. implied - realized) and tenor Calculates both a version which is aligned (VRP), where the implied and realized volatilities cover the same period (note: you will have a gap for recent points, where you can't grab future implied volatilities), and an unaligned version (VRPV), which is the typical one used in the market Parameters ---------- asset : str asset to calculate value for tenor_label : str tenor to calculate implied_vol : pd.DataFrame implied vol quotes where columns are of the form eg. EURUSDV1M.close realized_vol : pd.DataFrame realized vol eg. EURUSDH1M.close field : str the field of the data to use (default: 'close') Returns ------- pd.DataFrame of vrp (both lagged - VRPV & contemporanous - VRP) """ cal = Calendar() tenor_days = cal.get_business_days_tenor(tenor_label) if tenor_label == 'ON' and adj_ON_friday: implied_vol = self.adjust_implied_ON_fri_vol(implied_vol) # Add x business days to implied_vol to make it equivalent to realized_vol (better than "shift") # approximation for options which are not ON or 1W # bday = CustomBusinessDay(weekmask='Mon Tue Wed Thu Fri') implied_vol = implied_vol.copy(deep=True) implied_unaligned = implied_vol.copy(deep=True) cols_to_change = implied_vol.columns.values new_cols = [] for i in range(0, len(cols_to_change)): temp_col = list(cols_to_change[i]) temp_col[6] = 'U' new_cols.append(''.join(temp_col)) implied_vol.columns = new_cols ## Construct volatility risk premium such that implied covers the same period as realized # Add by number of days (note: for overnight tenors/1 week in FX we can add business days like this) # For because they are always +1 business days, +5 business days (exc. national holidays and only including # weekend). For longer dates like 1 month this is an approximation implied_vol.index = [ pd.Timestamp(x) + pd.tseries.offsets.BDay(tenor_days) for x in implied_vol.index ] vrp = implied_vol.join(realized_vol, how='outer') vrp[asset + "VRP" + tenor_label + ".close"] = vrp[asset + "U" + tenor_label + "." + field] \ - vrp[asset + "H" + tenor_label + "." + field] ## Construct "traditional" volatility risk premium, # so implied does not cover the same period as realized volatility vrp = vrp.join(implied_unaligned, how='outer') vrp[asset + "VRPV" + tenor_label + ".close"] = \ vrp[asset + "V" + tenor_label + "." + field] - vrp[asset + "H" + tenor_label + "." + field] return vrp
# See the License for the specific language governing permissions and # limitations under the License. # if __name__ == "__main__": ###### below line CRUCIAL when running Windows, otherwise multiprocessing # doesn"t work! (not necessary on Linux) from findatapy.util import SwimPool; SwimPool() from findatapy.timeseries import Filter, Calendar import pandas as pd calendar = Calendar() filter = Filter() # choose run_example = 0 for everything # run_example = 1 - get holidays for FX, EUR and EURUSD, as well as # listing weekends # run_example = 2 - get FX delivery dates and FX option expiries for # various tenors # run_example = 3 - get number of days between pandas DatetimeIndex # run_example = 4 - filter time series by EURUSD holidays # run_example = 4 - option expiries for USDJPY run_example = 0 if run_example == 1 or run_example == 0: # Get the holidays (which aren"t weekends)
def __init__( self, market_data_generator=None, fx_vol_surface=None, enter_trading_dates=None, fx_options_trading_tenor=market_constants.fx_options_trading_tenor, roll_days_before=market_constants.fx_options_roll_days_before, roll_event=market_constants.fx_options_roll_event, construct_via_currency='no', fx_options_tenor_for_interpolation=market_constants. fx_options_tenor_for_interpolation, base_depos_tenor=data_constants.base_depos_tenor, roll_months=market_constants.fx_options_roll_months, cum_index=market_constants.fx_options_cum_index, strike=market_constants.fx_options_index_strike, contract_type=market_constants.fx_options_index_contract_type, premium_output=market_constants.fx_options_index_premium_output, position_multiplier=1, depo_tenor_for_option=market_constants.fx_options_depo_tenor, freeze_implied_vol=market_constants.fx_options_freeze_implied_vol, tot_label='', cal=None, output_calculation_fields=market_constants. output_calculation_fields): """Initializes FXForwardsCurve Parameters ---------- market_data_generator : MarketDataGenerator Used for downloading market data fx_vol_surface : FXVolSurface We can specify the FX vol surface beforehand if we want fx_options_trading_tenor : str What is primary forward contract being used to trade (default - '1M') roll_days_before : int Number of days before roll event to enter into a new forwards contract roll_event : str What constitutes a roll event? ('month-end', 'quarter-end', 'year-end', 'expiry') cum_index : str In total return index, do we compute in additive or multiplicative way ('add' or 'mult') construct_via_currency : str What currency should we construct the forward via? Eg. if we asked for AUDJPY we can construct it via AUDUSD & JPYUSD forwards, as opposed to AUDJPY forwards (default - 'no') fx_options_tenor_for_interpolation : str(list) Which forwards should we use for interpolation base_depos_tenor : str(list) Which base deposits tenors do we need (this is only necessary if we want to start inferring depos) roll_months : int After how many months should we initiate a roll. Typically for trading 1M this should 1, 3M this should be 3 etc. tot_label : str Postfix for the total returns field cal : str Calendar to use for expiry (if None, uses that of FX pair) output_calculation_fields : bool Also output additional data should forward expiries etc. alongside total returns indices """ self._market_data_generator = market_data_generator self._calculations = Calculations() self._calendar = Calendar() self._filter = Filter() self._fx_vol_surface = fx_vol_surface self._enter_trading_dates = enter_trading_dates self._fx_options_trading_tenor = fx_options_trading_tenor self._roll_days_before = roll_days_before self._roll_event = roll_event self._construct_via_currency = construct_via_currency self._fx_options_tenor_for_interpolation = fx_options_tenor_for_interpolation self._base_depos_tenor = base_depos_tenor self._roll_months = roll_months self._cum_index = cum_index self._contact_type = contract_type self._strike = strike self._premium_output = premium_output self._position_multiplier = position_multiplier self._depo_tenor_for_option = depo_tenor_for_option self._freeze_implied_vol = freeze_implied_vol self._tot_label = tot_label self._cal = cal self._output_calculation_fields = output_calculation_fields
class FXOptionsCurve(object): """Constructs continuous forwards time series total return indices from underlying forwards contracts. """ def __init__( self, market_data_generator=None, fx_vol_surface=None, enter_trading_dates=None, fx_options_trading_tenor=market_constants.fx_options_trading_tenor, roll_days_before=market_constants.fx_options_roll_days_before, roll_event=market_constants.fx_options_roll_event, construct_via_currency='no', fx_options_tenor_for_interpolation=market_constants. fx_options_tenor_for_interpolation, base_depos_tenor=data_constants.base_depos_tenor, roll_months=market_constants.fx_options_roll_months, cum_index=market_constants.fx_options_cum_index, strike=market_constants.fx_options_index_strike, contract_type=market_constants.fx_options_index_contract_type, premium_output=market_constants.fx_options_index_premium_output, position_multiplier=1, depo_tenor_for_option=market_constants.fx_options_depo_tenor, freeze_implied_vol=market_constants.fx_options_freeze_implied_vol, tot_label='', cal=None, output_calculation_fields=market_constants. output_calculation_fields): """Initializes FXForwardsCurve Parameters ---------- market_data_generator : MarketDataGenerator Used for downloading market data fx_vol_surface : FXVolSurface We can specify the FX vol surface beforehand if we want fx_options_trading_tenor : str What is primary forward contract being used to trade (default - '1M') roll_days_before : int Number of days before roll event to enter into a new forwards contract roll_event : str What constitutes a roll event? ('month-end', 'quarter-end', 'year-end', 'expiry') cum_index : str In total return index, do we compute in additive or multiplicative way ('add' or 'mult') construct_via_currency : str What currency should we construct the forward via? Eg. if we asked for AUDJPY we can construct it via AUDUSD & JPYUSD forwards, as opposed to AUDJPY forwards (default - 'no') fx_options_tenor_for_interpolation : str(list) Which forwards should we use for interpolation base_depos_tenor : str(list) Which base deposits tenors do we need (this is only necessary if we want to start inferring depos) roll_months : int After how many months should we initiate a roll. Typically for trading 1M this should 1, 3M this should be 3 etc. tot_label : str Postfix for the total returns field cal : str Calendar to use for expiry (if None, uses that of FX pair) output_calculation_fields : bool Also output additional data should forward expiries etc. alongside total returns indices """ self._market_data_generator = market_data_generator self._calculations = Calculations() self._calendar = Calendar() self._filter = Filter() self._fx_vol_surface = fx_vol_surface self._enter_trading_dates = enter_trading_dates self._fx_options_trading_tenor = fx_options_trading_tenor self._roll_days_before = roll_days_before self._roll_event = roll_event self._construct_via_currency = construct_via_currency self._fx_options_tenor_for_interpolation = fx_options_tenor_for_interpolation self._base_depos_tenor = base_depos_tenor self._roll_months = roll_months self._cum_index = cum_index self._contact_type = contract_type self._strike = strike self._premium_output = premium_output self._position_multiplier = position_multiplier self._depo_tenor_for_option = depo_tenor_for_option self._freeze_implied_vol = freeze_implied_vol self._tot_label = tot_label self._cal = cal self._output_calculation_fields = output_calculation_fields def generate_key(self): from findatapy.market.ioengine import SpeedCache # Don't include any "large" objects in the key return SpeedCache().generate_key(self, [ '_market_data_generator', '_calculations', '_calendar', '_filter' ]) def fetch_continuous_time_series(self, md_request, market_data_generator, fx_vol_surface=None, enter_trading_dates=None, fx_options_trading_tenor=None, roll_days_before=None, roll_event=None, construct_via_currency=None, fx_options_tenor_for_interpolation=None, base_depos_tenor=None, roll_months=None, cum_index=None, strike=None, contract_type=None, premium_output=None, position_multiplier=None, depo_tenor_for_option=None, freeze_implied_vol=None, tot_label=None, cal=None, output_calculation_fields=None): if fx_vol_surface is None: fx_vol_surface = self._fx_vol_surface if enter_trading_dates is None: enter_trading_dates = self._enter_trading_dates if market_data_generator is None: market_data_generator = self._market_data_generator if fx_options_trading_tenor is None: fx_options_trading_tenor = self._fx_options_trading_tenor if roll_days_before is None: roll_days_before = self._roll_days_before if roll_event is None: roll_event = self._roll_event if construct_via_currency is None: construct_via_currency = self._construct_via_currency if fx_options_tenor_for_interpolation is None: fx_options_tenor_for_interpolation = self._fx_options_tenor_for_interpolation if base_depos_tenor is None: base_depos_tenor = self._base_depos_tenor if roll_months is None: roll_months = self._roll_months if strike is None: strike = self._strike if contract_type is None: contract_type = self._contact_type if premium_output is None: premium_output = self._premium_output if position_multiplier is None: position_multiplier = self._position_multiplier if depo_tenor_for_option is None: depo_tenor_for_option = self._depo_tenor_for_option if freeze_implied_vol is None: freeze_implied_vol = self._freeze_implied_vol if tot_label is None: tot_label = self._tot_label if cal is None: cal = self._cal if output_calculation_fields is None: output_calculation_fields = self._output_calculation_fields # Eg. we construct EURJPY via EURJPY directly (note: would need to have sufficient options/forward data for this) if construct_via_currency == 'no': if fx_vol_surface is None: # Download FX spot, FX forwards points and base depos etc. market = Market(market_data_generator=market_data_generator) md_request_download = MarketDataRequest(md_request=md_request) fx_conv = FXConv() # CAREFUL: convert the tickers to correct notation, eg. USDEUR => EURUSD, because our data # should be fetched in correct convention md_request_download.tickers = [ fx_conv.correct_notation(x) for x in md_request.tickers ] md_request_download.category = 'fx-vol-market' md_request_download.fields = 'close' md_request_download.abstract_curve = None md_request_download.fx_options_tenor = fx_options_tenor_for_interpolation md_request_download.base_depos_tenor = base_depos_tenor # md_request_download.base_depos_currencies = [] forwards_market_df = market.fetch_market(md_request_download) else: forwards_market_df = None # Now use the original tickers return self.construct_total_return_index( md_request.tickers, forwards_market_df, fx_vol_surface=fx_vol_surface, enter_trading_dates=enter_trading_dates, fx_options_trading_tenor=fx_options_trading_tenor, roll_days_before=roll_days_before, roll_event=roll_event, fx_options_tenor_for_interpolation= fx_options_tenor_for_interpolation, roll_months=roll_months, cum_index=cum_index, strike=strike, contract_type=contract_type, premium_output=premium_output, position_multiplier=position_multiplier, freeze_implied_vol=freeze_implied_vol, depo_tenor_for_option=depo_tenor_for_option, tot_label=tot_label, cal=cal, output_calculation_fields=output_calculation_fields) else: # eg. we calculate via your domestic currency such as USD, so returns will be in your domestic currency # Hence AUDJPY would be calculated via AUDUSD and JPYUSD (subtracting the difference in returns) total_return_indices = [] for tick in md_request.tickers: base = tick[0:3] terms = tick[3:6] md_request_base = MarketDataRequest(md_request=md_request) md_request_base.tickers = base + construct_via_currency md_request_terms = MarketDataRequest(md_request=md_request) md_request_terms.tickers = terms + construct_via_currency # Construct the base and terms separately (ie. AUDJPY => AUDUSD & JPYUSD) base_vals = self.fetch_continuous_time_series( md_request_base, market_data_generator, fx_vol_surface=fx_vol_surface, enter_trading_dates=enter_trading_dates, fx_options_trading_tenor=fx_options_trading_tenor, roll_days_before=roll_days_before, roll_event=roll_event, fx_options_tenor_for_interpolation= fx_options_tenor_for_interpolation, base_depos_tenor=base_depos_tenor, roll_months=roll_months, cum_index=cum_index, strike=strike, contract_type=contract_type, premium_output=premium_output, position_multiplier=position_multiplier, depo_tenor_for_option=depo_tenor_for_option, freeze_implied_vol=freeze_implied_vol, tot_label=tot_label, cal=cal, output_calculation_fields=output_calculation_fields, construct_via_currency='no') terms_vals = self.fetch_continuous_time_series( md_request_terms, market_data_generator, fx_vol_surface=fx_vol_surface, enter_trading_dates=enter_trading_dates, fx_options_trading_tenor=fx_options_trading_tenor, roll_days_before=roll_days_before, roll_event=roll_event, fx_options_tenor_for_interpolation= fx_options_tenor_for_interpolation, base_depos_tenor=base_depos_tenor, roll_months=roll_months, cum_index=cum_index, strike=strike, contract_type=contract_type, position_multiplier=position_multiplier, depo_tenor_for_option=depo_tenor_for_option, freeze_implied_vol=freeze_implied_vol, tot_label=tot_label, cal=cal, output_calculation_fields=output_calculation_fields, construct_via_currency='no') # Special case for USDUSD case (and if base or terms USD are USDUSD if base + terms == construct_via_currency + construct_via_currency: base_rets = self._calculations.calculate_returns(base_vals) cross_rets = pd.DataFrame(0, index=base_rets.index, columns=base_rets.columns) elif base + construct_via_currency == construct_via_currency + construct_via_currency: cross_rets = -self._calculations.calculate_returns( terms_vals) elif terms + construct_via_currency == construct_via_currency + construct_via_currency: cross_rets = self._calculations.calculate_returns( base_vals) else: base_rets = self._calculations.calculate_returns(base_vals) terms_rets = self._calculations.calculate_returns( terms_vals) cross_rets = base_rets.sub(terms_rets.iloc[:, 0], axis=0) # First returns of a time series will by NaN, given we don't know previous point cross_rets.iloc[0] = 0 cross_vals = self._calculations.create_mult_index(cross_rets) cross_vals.columns = [tick + '-option-tot.close'] total_return_indices.append(cross_vals) return self._calculations.join(total_return_indices, how='outer') def unhedged_asset_fx(self, assets_df, asset_currency, home_curr, start_date, finish_date, spot_df=None): pass def hedged_asset_fx(self, assets_df, asset_currency, home_curr, start_date, finish_date, spot_df=None, total_return_indices_df=None): pass def get_day_count_conv(self, currency): if currency in market_constants.currencies_with_365_basis: return 365.0 return 360.0 def construct_total_return_index(self, cross_fx, market_df, fx_vol_surface=None, enter_trading_dates=None, fx_options_trading_tenor=None, roll_days_before=None, roll_event=None, roll_months=None, cum_index=None, strike=None, contract_type=None, premium_output=None, position_multiplier=None, fx_options_tenor_for_interpolation=None, freeze_implied_vol=None, depo_tenor_for_option=None, tot_label=None, cal=None, output_calculation_fields=None): if fx_vol_surface is None: fx_vol_surface = self._fx_vol_surface if enter_trading_dates is None: enter_trading_dates = self._enter_trading_dates if fx_options_trading_tenor is None: fx_options_trading_tenor = self._fx_options_trading_tenor if roll_days_before is None: roll_days_before = self._roll_days_before if roll_event is None: roll_event = self._roll_event if roll_months is None: roll_months = self._roll_months if cum_index is None: cum_index = self._cum_index if strike is None: strike = self._strike if contract_type is None: contract_type = self._contact_type if premium_output is None: premium_output = self._premium_output if position_multiplier is None: position_multiplier = self._position_multiplier if fx_options_tenor_for_interpolation is None: fx_options_tenor_for_interpolation = self._fx_options_tenor_for_interpolation if freeze_implied_vol is None: freeze_implied_vol = self._freeze_implied_vol if depo_tenor_for_option is None: depo_tenor_for_option = self._depo_tenor_for_option if tot_label is None: tot_label = self._tot_label if cal is None: cal = self._cal if output_calculation_fields is None: output_calculation_fields = self._output_calculation_fields if not (isinstance(cross_fx, list)): cross_fx = [cross_fx] total_return_index_df_agg = [] # Remove columns where there is no data (because these vols typically aren't quoted) if market_df is not None: market_df = market_df.dropna(how='all', axis=1) fx_options_pricer = FXOptionsPricer(premium_output=premium_output) def get_roll_date(horizon_d, expiry_d, asset_hols, month_adj=0): if roll_event == 'month-end': roll_d = horizon_d + CustomBusinessMonthEnd( roll_months + month_adj, holidays=asset_hols) # Special case so always rolls on month end date, if specify 0 days if roll_days_before > 0: return (roll_d - CustomBusinessDay(n=roll_days_before, holidays=asset_hols)) elif roll_event == 'expiry-date': roll_d = expiry_d # Special case so always rolls on expiry date, if specify 0 days if roll_days_before > 0: return (roll_d - CustomBusinessDay(n=roll_days_before, holidays=asset_hols)) return roll_d for cross in cross_fx: if cal is None: cal = cross # Eg. if we specify USDUSD if cross[0:3] == cross[3:6]: total_return_index_df_agg.append( pd.DataFrame(100, index=market_df.index, columns=[cross + "-option-tot.close"])) else: # Is the FX cross in the correct convention old_cross = cross cross = FXConv().correct_notation(cross) # TODO also specification of non-standard crosses like USDGBP if old_cross != cross: pass if fx_vol_surface is None: fx_vol_surface = FXVolSurface( market_df=market_df, asset=cross, tenors=fx_options_tenor_for_interpolation, depo_tenor=depo_tenor_for_option) market_df = fx_vol_surface.get_all_market_data() horizon_date = market_df.index expiry_date = np.zeros(len(horizon_date), dtype=object) roll_date = np.zeros(len(horizon_date), dtype=object) new_trade = np.full(len(horizon_date), False, dtype=bool) exit_trade = np.full(len(horizon_date), False, dtype=bool) has_position = np.full(len(horizon_date), False, dtype=bool) asset_holidays = self._calendar.get_holidays(cal=cross) # If no entry dates specified, assume we just keep rolling if enter_trading_dates is None: # Get first expiry date expiry_date[ 0] = self._calendar.get_expiry_date_from_horizon_date( pd.DatetimeIndex([horizon_date[0]]), fx_options_trading_tenor, cal=cal, asset_class='fx-vol')[0] # For first month want it to expire within that month (for consistency), hence month_adj=0 ONLY here roll_date[0] = get_roll_date(horizon_date[0], expiry_date[0], asset_holidays, month_adj=0) # New trade => entry at beginning AND on every roll new_trade[0] = True exit_trade[0] = False has_position[0] = True # Get all the expiry dates and roll dates # At each "roll/trade" day we need to reset them for the new contract for i in range(1, len(horizon_date)): has_position[i] = True # If the horizon date has reached the roll date (from yesterday), we're done, and we have a # new roll/trade if (horizon_date[i] - roll_date[i - 1]).days >= 0: new_trade[i] = True else: new_trade[i] = False # If we're entering a new trade/contract (and exiting an old trade) we need to get new expiry and roll dates if new_trade[i]: exp = self._calendar.get_expiry_date_from_horizon_date( pd.DatetimeIndex([horizon_date[i]]), fx_options_trading_tenor, cal=cal, asset_class='fx-vol')[0] # Make sure we don't expire on a date in the history where there isn't market data # It is ok for future values to expire after market data (just not in the backtest!) if exp not in market_df.index: exp_index = market_df.index.searchsorted(exp) if exp_index < len(market_df.index): exp_index = min(exp_index, len(market_df.index)) exp = market_df.index[exp_index] expiry_date[i] = exp roll_date[i] = get_roll_date( horizon_date[i], expiry_date[i], asset_holidays) exit_trade[i] = True else: if horizon_date[i] <= expiry_date[i - 1]: # Otherwise use previous expiry and roll dates, because we're still holding same contract expiry_date[i] = expiry_date[i - 1] roll_date[i] = roll_date[i - 1] exit_trade[i] = False else: exit_trade[i] = True else: new_trade[horizon_date.searchsorted( enter_trading_dates)] = True has_position[horizon_date.searchsorted( enter_trading_dates)] = True # Get first expiry date #expiry_date[0] = \ # self._calendar.get_expiry_date_from_horizon_date(pd.DatetimeIndex([horizon_date[0]]), # fx_options_trading_tenor, cal=cal, # asset_class='fx-vol')[0] # For first month want it to expire within that month (for consistency), hence month_adj=0 ONLY here #roll_date[0] = get_roll_date(horizon_date[0], expiry_date[0], asset_holidays, month_adj=0) # New trade => entry at beginning AND on every roll #new_trade[0] = True #exit_trade[0] = False #has_position[0] = True # Get all the expiry dates and roll dates # At each "roll/trade" day we need to reset them for the new contract for i in range(0, len(horizon_date)): # If we're entering a new trade/contract (and exiting an old trade) we need to get new expiry and roll dates if new_trade[i]: exp = \ self._calendar.get_expiry_date_from_horizon_date(pd.DatetimeIndex([horizon_date[i]]), fx_options_trading_tenor, cal=cal, asset_class='fx-vol')[0] # Make sure we don't expire on a date in the history where there isn't market data # It is ok for future values to expire after market data (just not in the backtest!) if exp not in market_df.index: exp_index = market_df.index.searchsorted(exp) if exp_index < len(market_df.index): exp_index = min(exp_index, len(market_df.index)) exp = market_df.index[exp_index] expiry_date[i] = exp # roll_date[i] = get_roll_date(horizon_date[i], expiry_date[i], asset_holidays) # if i > 0: # Makes the assumption we aren't rolling contracts exit_trade[i] = False else: if i > 0: # Check there's valid expiry on previous day (if not then we're not in an option trade here!) if expiry_date[i - 1] == 0: has_position[i] = False else: if horizon_date[i] <= expiry_date[i - 1]: # Otherwise use previous expiry and roll dates, because we're still holding same contract expiry_date[i] = expiry_date[i - 1] # roll_date[i] = roll_date[i - 1] has_position[i] = True if horizon_date[i] == expiry_date[i]: exit_trade[i] = True else: exit_trade[i] = False # Note: may need to add discount factor when marking to market option mtm = np.zeros(len(horizon_date)) calculated_strike = np.zeros(len(horizon_date)) interpolated_option = np.zeros(len(horizon_date)) implied_vol = np.zeros(len(horizon_date)) delta = np.zeros(len(horizon_date)) # For debugging df_temp = pd.DataFrame() df_temp['expiry-date'] = expiry_date df_temp['horizon-date'] = horizon_date df_temp['roll-date'] = roll_date df_temp['new-trade'] = new_trade df_temp['exit-trade'] = exit_trade df_temp['has-position'] = has_position if has_position[0]: # Special case: for first day of history (given have no previous positions) option_values_, spot_, strike_, vol_, delta_, expiry_date_, intrinsic_values_ = \ fx_options_pricer.price_instrument(cross, horizon_date[0], strike, expiry_date[0], contract_type=contract_type, tenor=fx_options_trading_tenor, fx_vol_surface=fx_vol_surface, return_as_df=False) interpolated_option[0] = option_values_ calculated_strike[0] = strike_ implied_vol[0] = vol_ mtm[0] = 0 # Now price options for rest of history # On rolling dates: MTM will be the previous option contract (interpolated) # On non-rolling dates: it will be the current option contract for i in range(1, len(horizon_date)): if exit_trade[i]: # Price option trade being exited option_values_, spot_, strike_, vol_, delta_, expiry_date_, intrinsic_values_ = \ fx_options_pricer.price_instrument(cross, horizon_date[i], calculated_strike[i-1], expiry_date[i-1], contract_type=contract_type, tenor=fx_options_trading_tenor, fx_vol_surface=fx_vol_surface, return_as_df=False) # Store as MTM mtm[i] = option_values_ delta[ i] = 0 # Note: this will get overwritten if there's a new trade calculated_strike[i] = calculated_strike[ i - 1] # Note: this will get overwritten if there's a new trade if new_trade[i]: # Price new option trade being entered option_values_, spot_, strike_, vol_, delta_, expiry_date_, intrinsic_values_ = \ fx_options_pricer.price_instrument(cross, horizon_date[i], strike, expiry_date[i], contract_type=contract_type, tenor=fx_options_trading_tenor, fx_vol_surface=fx_vol_surface, return_as_df=False) calculated_strike[ i] = strike_ # option_output[cross + '-strike.close'].values implied_vol[i] = vol_ interpolated_option[i] = option_values_ delta[i] = delta_ elif has_position[i] and not (exit_trade[i]): # Price current option trade # - strike/expiry the same as yesterday # - other market inputs taken live, closer to expiry calculated_strike[i] = calculated_strike[i - 1] if freeze_implied_vol: frozen_vol = implied_vol[i - 1] else: frozen_vol = None option_values_, spot_, strike_, vol_, delta_, expiry_date_, intrinsic_values_ = \ fx_options_pricer.price_instrument(cross, horizon_date[i], calculated_strike[i], expiry_date[i], vol=frozen_vol, contract_type=contract_type, tenor=fx_options_trading_tenor, fx_vol_surface=fx_vol_surface, return_as_df=False) interpolated_option[i] = option_values_ implied_vol[i] = vol_ mtm[i] = interpolated_option[i] delta[i] = delta_ # Calculate delta hedging P&L spot_rets = (market_df[cross + ".close"] / market_df[cross + ".close"].shift(1) - 1).values if tot_label == '': tot_rets = spot_rets else: tot_rets = ( market_df[cross + "-" + tot_label + ".close"] / market_df[cross + "-" + tot_label + ".close"].shift(1) - 1).values # Remember to take the inverted sign, eg. if call is +20%, we need to -20% of spot to flatten delta # Also invest for whether we are long or short the option delta_hedging_pnl = -np.roll( delta, 1) * tot_rets * position_multiplier delta_hedging_pnl[0] = 0 # Calculate options P&L (given option premium is already percentage, only need to subtract) # Again need to invert if we are short option option_rets = (mtm - np.roll(interpolated_option, 1)) * position_multiplier option_rets[0] = 0 # Calculate option + delta hedging P&L option_delta_rets = delta_hedging_pnl + option_rets if cum_index == 'mult': cum_rets = 100 * np.cumprod(1.0 + option_rets) cum_delta_rets = 100 * np.cumprod(1.0 + delta_hedging_pnl) cum_option_delta_rets = 100 * np.cumprod(1.0 + option_delta_rets) elif cum_index == 'add': cum_rets = 100 + 100 * np.cumsum(option_rets) cum_delta_rets = 100 + 100 * np.cumsum(delta_hedging_pnl) cum_option_delta_rets = 100 + 100 * np.cumsum( option_delta_rets) total_return_index_df = pd.DataFrame( index=horizon_date, columns=[cross + "-option-tot.close"]) total_return_index_df[cross + "-option-tot.close"] = cum_rets if output_calculation_fields: total_return_index_df[ cross + '-interpolated-option.close'] = interpolated_option total_return_index_df[cross + '-mtm.close'] = mtm total_return_index_df[cross + ".close"] = market_df[ cross + ".close"].values total_return_index_df[cross + '-implied-vol.close'] = implied_vol total_return_index_df[cross + '-new-trade.close'] = new_trade total_return_index_df[cross + '.roll-date'] = roll_date total_return_index_df[cross + '-exit-trade.close'] = exit_trade total_return_index_df[cross + '.expiry-date'] = expiry_date total_return_index_df[ cross + '-calculated-strike.close'] = calculated_strike total_return_index_df[cross + '-option-return.close'] = option_rets total_return_index_df[cross + '-spot-return.close'] = spot_rets total_return_index_df[cross + '-tot-return.close'] = tot_rets total_return_index_df[cross + '-delta.close'] = delta total_return_index_df[ cross + '-delta-pnl-return.close'] = delta_hedging_pnl total_return_index_df[ cross + '-delta-pnl-index.close'] = cum_delta_rets total_return_index_df[ cross + '-option-delta-return.close'] = option_delta_rets total_return_index_df[ cross + '-option-delta-tot.close'] = cum_option_delta_rets total_return_index_df_agg.append(total_return_index_df) return self._calculations.join(total_return_index_df_agg, how='outer') def apply_tc_signals_to_total_return_index(self, cross_fx, total_return_index_orig_df, option_tc_bp, spot_tc_bp, signal_df=None, cum_index=None): # TODO signal not implemented yet if cum_index is None: cum_index = self._cum_index total_return_index_df_agg = [] if not (isinstance(cross_fx, list)): cross_fx = [cross_fx] option_tc = option_tc_bp / (2 * 100 * 100) spot_tc = spot_tc_bp / (2 * 100 * 100) total_return_index_df = total_return_index_orig_df.copy() for cross in cross_fx: # p = abs(total_return_index_df[cross + '-roll.close'].shift(1)) * option_tc # q = abs(total_return_index_df[cross + '-delta.close'] - total_return_index_df[cross + '-delta.close'].shift(1)) * spot_tc # Additional columns to include P&L with transaction costs total_return_index_df[cross + '-option-return-with-tc.close'] = \ total_return_index_df[cross + '-option-return.close'] - abs(total_return_index_df[cross + '-new-trade.close'].shift(1)) * option_tc total_return_index_df[cross + '-delta-pnl-return-with-tc.close'] = \ total_return_index_df[cross + '-delta-pnl-return.close'] \ - abs(total_return_index_df[cross + '-delta.close'] - total_return_index_df[cross + '-delta.close'].shift(1)) * spot_tc total_return_index_df[cross + '-option-return-with-tc.close'][0] = 0 total_return_index_df[cross + '-delta-pnl-return-with-tc.close'][0] = 0 total_return_index_df[cross + '-option-delta-return-with-tc.close'] = \ total_return_index_df[cross + '-option-return-with-tc.close'] + total_return_index_df[cross + '-delta-pnl-return-with-tc.close'] if cum_index == 'mult': cum_rets = 100 * np.cumprod(1.0 + total_return_index_df[ cross + '-option-return-with-tc.close'].values) cum_delta_rets = 100 * np.cumprod(1.0 + total_return_index_df[ cross + '-delta-pnl-return-with-tc.close'].values) cum_option_delta_rets = 100 * np.cumprod( 1.0 + total_return_index_df[ cross + '-option-delta-return-with-tc.close'].values) elif cum_index == 'add': cum_rets = 100 + 100 * np.cumsum(total_return_index_df[ cross + '-option-return-with-tc.close'].values) cum_delta_rets = 100 + 100 * np.cumsum(total_return_index_df[ cross + '-delta-pnl-return-with-tc.close'].values) cum_option_delta_rets = 100 + 100 * np.cumsum( total_return_index_df[ cross + '-option-delta-return-with-tc.close'].values) total_return_index_df[cross + "-option-tot-with-tc.close"] = cum_rets total_return_index_df[ cross + '-delta-pnl-index-with-tc.close'] = cum_delta_rets total_return_index_df[ cross + '-option-delta-tot-with-tc.close'] = cum_option_delta_rets total_return_index_df_agg.append(total_return_index_df) return self._calculations.join(total_return_index_df_agg, how='outer')
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # # See the License for the specific language governing permissions and limitations under the License. # if __name__ == '__main__': ###### below line CRUCIAL when running Windows, otherwise multiprocessing doesn't work! (not necessary on Linux) from findatapy.util import SwimPool SwimPool() from findatapy.timeseries import Filter, Calendar, Calculations import pandas as pd calculations = Calculations() calendar = Calendar() filter = Filter() # choose run_example = 0 for everything # run_example = 1 - combine intraday dataframe with daily data dataframe run_example = 0 if run_example == 1 or run_example == 0: df_intraday = pd.DataFrame(index=pd.date_range(start='01 Jan 2020', end='10 Jan 2020', freq='1min'), columns=['ones']) df_intraday['ones'] = 1
class FXForwardsCurve(object): """Constructs continuous forwards time series total return indices from underlying forwards contracts. """ def __init__(self, market_data_generator=None, fx_forwards_trading_tenor=market_constants.fx_forwards_trading_tenor, roll_days_before=market_constants.fx_forwards_roll_days_before, roll_event=market_constants.fx_forwards_roll_event, construct_via_currency='no', fx_forwards_tenor_for_interpolation=market_constants.fx_forwards_tenor_for_interpolation, base_depos_tenor=data_constants.base_depos_tenor, roll_months=market_constants.fx_forwards_roll_months, cum_index=market_constants.fx_forwards_cum_index, output_calculation_fields=market_constants.output_calculation_fields): """Initializes FXForwardsCurve Parameters ---------- market_data_generator : MarketDataGenerator Used for downloading market data fx_forwards_trading_tenor : str What is primary forward contract being used to trade (default - '1M') roll_days_before : int Number of days before roll event to enter into a new forwards contract roll_event : str What constitutes a roll event? ('month-end', 'quarter-end', 'year-end', 'expiry') construct_via_currency : str What currency should we construct the forward via? Eg. if we asked for AUDJPY we can construct it via AUDUSD & JPYUSD forwards, as opposed to AUDJPY forwards (default - 'no') fx_forwards_tenor_for_interpolation : str(list) Which forwards should we use for interpolation base_depos_tenor : str(list) Which base deposits tenors do we need (this is only necessary if we want to start inferring depos) roll_months : int After how many months should we initiate a roll. Typically for trading 1M this should 1, 3M this should be 3 etc. cum_index : str In total return index, do we compute in additive or multiplicative way ('add' or 'mult') output_calculation_fields : bool Also output additional data should forward expiries etc. alongside total returns indices """ self._market_data_generator = market_data_generator self._calculations = Calculations() self._calendar = Calendar() self._filter = Filter() self._fx_forwards_trading_tenor = fx_forwards_trading_tenor self._roll_days_before = roll_days_before self._roll_event = roll_event self._construct_via_currency = construct_via_currency self._fx_forwards_tenor_for_interpolation = fx_forwards_tenor_for_interpolation self._base_depos_tenor = base_depos_tenor self._roll_months = roll_months self._cum_index = cum_index self._output_calcultion_fields = output_calculation_fields def generate_key(self): from findatapy.market.ioengine import SpeedCache # Don't include any "large" objects in the key return SpeedCache().generate_key(self, ['_market_data_generator', '_calculations', '_calendar', '_filter']) def fetch_continuous_time_series(self, md_request, market_data_generator, fx_forwards_trading_tenor=None, roll_days_before=None, roll_event=None, construct_via_currency=None, fx_forwards_tenor_for_interpolation=None, base_depos_tenor=None, roll_months=None, cum_index=None, output_calculation_fields=False): if market_data_generator is None: market_data_generator = self._market_data_generator if fx_forwards_trading_tenor is None: fx_forwards_trading_tenor = self._fx_forwards_trading_tenor if roll_days_before is None: roll_days_before = self._roll_days_before if roll_event is None: roll_event = self._roll_event if construct_via_currency is None: construct_via_currency = self._construct_via_currency if fx_forwards_tenor_for_interpolation is None: fx_forwards_tenor_for_interpolation = self._fx_forwards_tenor_for_interpolation if base_depos_tenor is None: base_depos_tenor = self._base_depos_tenor if roll_months is None: roll_months = self._roll_months if cum_index is None: cum_index = self._cum_index if output_calculation_fields is None: output_calculation_fields # Eg. we construct EURJPY via EURJPY directly (note: would need to have sufficient forward data for this) if construct_via_currency == 'no': # Download FX spot, FX forwards points and base depos etc. market = Market(market_data_generator=market_data_generator) md_request_download = MarketDataRequest(md_request=md_request) fx_conv = FXConv() # CAREFUL: convert the tickers to correct notation, eg. USDEUR => EURUSD, because our data # should be fetched in correct convention md_request_download.tickers = [fx_conv.correct_notation(x) for x in md_request.tickers] md_request_download.category = 'fx-forwards-market' md_request_download.fields = 'close' md_request_download.abstract_curve = None md_request_download.fx_forwards_tenor = fx_forwards_tenor_for_interpolation md_request_download.base_depos_tenor = base_depos_tenor forwards_market_df = market.fetch_market(md_request_download) # Now use the original tickers return self.construct_total_return_index(md_request.tickers, forwards_market_df, fx_forwards_trading_tenor=fx_forwards_trading_tenor, roll_days_before=roll_days_before, roll_event=roll_event, fx_forwards_tenor_for_interpolation=fx_forwards_tenor_for_interpolation, roll_months=roll_months, cum_index=cum_index, output_calculation_fields=output_calculation_fields) else: # eg. we calculate via your domestic currency such as USD, so returns will be in your domestic currency # Hence AUDJPY would be calculated via AUDUSD and JPYUSD (subtracting the difference in returns) total_return_indices = [] for tick in md_request.tickers: base = tick[0:3] terms = tick[3:6] md_request_base = MarketDataRequest(md_request=md_request) md_request_base.tickers = base + construct_via_currency md_request_terms = MarketDataRequest(md_request=md_request) md_request_terms.tickers = terms + construct_via_currency # Construct the base and terms separately (ie. AUDJPY => AUDUSD & JPYUSD) base_vals = self.fetch_continuous_time_series(md_request_base, market_data_generator, fx_forwards_trading_tenor=fx_forwards_trading_tenor, roll_days_before=roll_days_before, roll_event=roll_event, fx_forwards_tenor_for_interpolation=fx_forwards_tenor_for_interpolation, base_depos_tenor=base_depos_tenor, roll_months=roll_months, output_calculation_fields=False, cum_index=cum_index, construct_via_currency='no') terms_vals = self.fetch_continuous_time_series(md_request_terms, market_data_generator, fx_forwards_trading_tenor=fx_forwards_trading_tenor, roll_days_before=roll_days_before, roll_event=roll_event, fx_forwards_tenor_for_interpolation=fx_forwards_tenor_for_interpolation, base_depos_tenor=base_depos_tenor, roll_months=roll_months, cum_index=cum_index, output_calculation_fields=False, construct_via_currency='no') # Special case for USDUSD case (and if base or terms USD are USDUSD if base + terms == construct_via_currency + construct_via_currency: base_rets = self._calculations.calculate_returns(base_vals) cross_rets = pd.DataFrame(0, index=base_rets.index, columns=base_rets.columns) elif base + construct_via_currency == construct_via_currency + construct_via_currency: cross_rets = -self._calculations.calculate_returns(terms_vals) elif terms + construct_via_currency == construct_via_currency + construct_via_currency: cross_rets = self._calculations.calculate_returns(base_vals) else: base_rets = self._calculations.calculate_returns(base_vals) terms_rets = self._calculations.calculate_returns(terms_vals) cross_rets = base_rets.sub(terms_rets.iloc[:, 0], axis=0) # First returns of a time series will by NaN, given we don't know previous point cross_rets.iloc[0] = 0 cross_vals = self._calculations.create_mult_index(cross_rets) cross_vals.columns = [tick + '-forward-tot.close'] total_return_indices.append(cross_vals) return self._calculations.pandas_outer_join(total_return_indices) def unhedged_asset_fx(self, assets_df, asset_currency, home_curr, start_date, finish_date, spot_df=None): pass def hedged_asset_fx(self, assets_df, asset_currency, home_curr, start_date, finish_date, spot_df=None, total_return_indices_df=None): pass def get_day_count_conv(self, currency): if currency in market_constants.currencies_with_365_basis: return 365.0 return 360.0 def construct_total_return_index(self, cross_fx, forwards_market_df, fx_forwards_trading_tenor=None, roll_days_before=None, roll_event=None, roll_months=None, fx_forwards_tenor_for_interpolation=None, cum_index=None, output_calculation_fields=False): if not (isinstance(cross_fx, list)): cross_fx = [cross_fx] if fx_forwards_trading_tenor is None: fx_forwards_trading_tenor = self._fx_forwards_trading_tenor if roll_days_before is None: roll_days_before = self._roll_days_before if roll_event is None: roll_event = self._roll_event if roll_months is None: roll_months = self._roll_months if fx_forwards_tenor_for_interpolation is None: fx_forwards_tenor_for_interpolation = self._fx_forwards_tenor_for_interpolation if cum_index is None: cum_index = self._cum_index total_return_index_df_agg = [] # Remove columns where there is no data (because these points typically aren't quoted) forwards_market_df = forwards_market_df.dropna(how='all', axis=1) fx_forwards_pricer = FXForwardsPricer() def get_roll_date(horizon_d, delivery_d, asset_hols, month_adj=1): if roll_event == 'month-end': roll_d = horizon_d + CustomBusinessMonthEnd(roll_months + month_adj, holidays=asset_hols) elif roll_event == 'delivery-date': roll_d = delivery_d return (roll_d - CustomBusinessDay(n=roll_days_before, holidays=asset_hols)) for cross in cross_fx: # Eg. if we specify USDUSD if cross[0:3] == cross[3:6]: total_return_index_df_agg.append( pd.DataFrame(100, index=forwards_market_df.index, columns=[cross + "-forward-tot.close"])) else: # Is the FX cross in the correct convention old_cross = cross cross = FXConv().correct_notation(cross) horizon_date = forwards_market_df.index delivery_date = [] roll_date = [] new_trade = np.full(len(horizon_date), False, dtype=bool) asset_holidays = self._calendar.get_holidays(cal=cross) # Get first delivery date delivery_date.append( self._calendar.get_delivery_date_from_horizon_date(horizon_date[0], fx_forwards_trading_tenor, cal=cross, asset_class='fx')[0]) # For first month want it to expire within that month (for consistency), hence month_adj=0 ONLY here roll_date.append(get_roll_date(horizon_date[0], delivery_date[0], asset_holidays, month_adj=0)) # New trade => entry at beginning AND on every roll new_trade[0] = True # Get all the delivery dates and roll dates # At each "roll/trade" day we need to reset them for the new contract for i in range(1, len(horizon_date)): # If the horizon date has reached the roll date (from yesterday), we're done, and we have a # new roll/trade if (horizon_date[i] - roll_date[i-1]).days == 0: new_trade[i] = True # else: # new_trade[i] = False # If we're entering a new trade/contract, we need to get new delivery and roll dates if new_trade[i]: delivery_date.append(self._calendar.get_delivery_date_from_horizon_date(horizon_date[i], fx_forwards_trading_tenor, cal=cross, asset_class='fx')[0]) roll_date.append(get_roll_date(horizon_date[i], delivery_date[i], asset_holidays)) else: # Otherwise use previous delivery and roll dates, because we're still holding same contract delivery_date.append(delivery_date[i-1]) roll_date.append(roll_date[i-1]) interpolated_forward = fx_forwards_pricer.price_instrument(cross, horizon_date, delivery_date, market_df=forwards_market_df, fx_forwards_tenor_for_interpolation=fx_forwards_tenor_for_interpolation)[cross + '-interpolated-outright-forward.close'].values # To record MTM prices mtm = np.copy(interpolated_forward) # Note: may need to add discount factor when marking to market forwards? # Special case: for very first trading day # mtm[0] = interpolated_forward[0] # On rolling dates, MTM will be the previous forward contract (interpolated) # otherwise it will be the current forward contract for i in range(1, len(horizon_date)): if new_trade[i]: mtm[i] = fx_forwards_pricer.price_instrument(cross, horizon_date[i], delivery_date[i-1], market_df=forwards_market_df, fx_forwards_tenor_for_interpolation=fx_forwards_tenor_for_interpolation) \ [cross + '-interpolated-outright-forward.close'].values # else: # mtm[i] = interpolated_forward[i] # Eg. if we asked for USDEUR, we first constructed spot/forwards for EURUSD # and then need to invert it if old_cross != cross: mtm = 1.0 / mtm interpolated_forward = 1.0 / interpolated_forward forward_rets = mtm / np.roll(interpolated_forward, 1) - 1.0 forward_rets[0] = 0 if cum_index == 'mult': cum_rets = 100 * np.cumprod(1.0 + forward_rets) elif cum_index == 'add': cum_rets = 100 + 100 * np.cumsum(forward_rets) total_return_index_df = pd.DataFrame(index=horizon_date, columns=[cross + "-forward-tot.close"]) total_return_index_df[cross + "-forward-tot.close"] = cum_rets if output_calculation_fields: total_return_index_df[cross + '-interpolated-outright-forward.close'] = interpolated_forward total_return_index_df[cross + '-mtm.close'] = mtm total_return_index_df[cross + '-roll.close'] = new_trade total_return_index_df[cross + '.roll-date'] = roll_date total_return_index_df[cross + '.delivery-date'] = delivery_date total_return_index_df[cross + '-forward-return.close'] = forward_rets total_return_index_df_agg.append(total_return_index_df) return self._calculations.pandas_outer_join(total_return_index_df_agg)
fx_forwards_tenors = ['1W', '2W', '3W', '1M'] fx_forwards_to_print = ['1W', '2W'] # Get AUDUSD data for spot, forwards + depos md_request = MarketDataRequest(start_date='01 Jan 2020', finish_date='01 Feb 2020', data_source='bloomberg', cut='NYC', category='fx-forwards-market', tickers=cross, cache_algo='cache_algo_return', fx_forwards_tenor=fx_forwards_tenors, base_depos_currencies=[cross[0:3], cross[3:6]]) market_df = market.fetch_market(md_request=md_request) fx_forwards_price = FXForwardsPricer() delivery_dates = Calendar().get_delivery_date_from_horizon_date(market_df.index, "8D", cal=cross) interpolated_forwards_df = fx_forwards_price.price_instrument(cross, market_df.index, delivery_dates, market_df=market_df, fx_forwards_tenor_for_interpolation =['1W', '2W']) interpolated_forwards_df[cross + ".delivery"] = delivery_dates.values print(interpolated_forwards_df) market_cols = [cross + ".close"] for f in fx_forwards_to_print: market_cols.append(cross + f + '.close') print(market_df[market_cols]) if run_example == 2 or run_example == 0:
class FXOptionsPricer(AbstractPricer): """Prices various vanilla FX options, using FinancePy underneath. """ def __init__(self, fx_vol_surface=None, premium_output=market_constants.fx_options_premium_output, delta_output=market_constants.fx_options_delta_output): self._calendar = Calendar() self._fx_vol_surface = fx_vol_surface self._fx_forwards_pricer = FXForwardsPricer() self._premium_output = premium_output self._delta_output = delta_output def price_instrument(self, cross, horizon_date, strike, expiry_date=None, vol=None, notional=1000000, contract_type='european-call', tenor=None, fx_vol_surface=None, premium_output=None, delta_output=None, depo_tenor=None, return_as_df=True): """Prices FX options for horizon dates/expiry dates given by the user from FX spot rates, FX volatility surface and deposit rates. Parameters ---------- cross : str Currency pair horizon_date : DateTimeIndex Horizon dates for options expiry_date : DateTimeIndex expiry dates for options market_df : DataFrame Contains FX spot, FX vol surface quotes, FX forwards and base depos Returns ------- DataFrame """ # if market_df is None: market_df = self._market_df if fx_vol_surface is None: fx_vol_surface = self._fx_vol_surface if premium_output is None: premium_output = self._premium_output if delta_output is None: delta_output = self._delta_output logger = LoggerManager().getLogger(__name__) field = fx_vol_surface._field # Make horizon date and expiry date pandas DatetimeIndex if isinstance(horizon_date, pd.Timestamp): horizon_date = pd.DatetimeIndex([horizon_date]) else: horizon_date = pd.DatetimeIndex(horizon_date) if expiry_date is not None: if isinstance(expiry_date, pd.Timestamp): expiry_date = pd.DatetimeIndex([expiry_date]) else: expiry_date = pd.DatetimeIndex(expiry_date) else: expiry_date = self._calendar.get_expiry_date_from_horizon_date( horizon_date, tenor, cal=cross) # If the strike hasn't been supplied need to work this out if not (isinstance(strike, np.ndarray)): old_strike = strike if isinstance(strike, str): strike = np.empty(len(horizon_date), dtype=object) else: strike = np.empty(len(horizon_date)) strike.fill(old_strike) # If the vol hasn't been supplied need to work this out if not (isinstance(vol, np.ndarray)): if vol is None: vol = np.nan old_vol = vol vol = np.empty(len(horizon_date)) vol.fill(old_vol) option_values = np.zeros(len(horizon_date)) spot = np.zeros(len(horizon_date)) delta = np.zeros(len(horizon_date)) intrinsic_values = np.zeros(len(horizon_date)) def _price_option(contract_type_, contract_type_fin_): for i in range(len(expiry_date)): built_vol_surface = False # If we have a "key strike" need to fit the vol surface if isinstance(strike[i], str): if not (built_vol_surface): fx_vol_surface.build_vol_surface(horizon_date[i]) fx_vol_surface.extract_vol_surface( num_strike_intervals=None) built_vol_surface = True # Delta neutral strike/or whatever strike is quoted as ATM # usually this is ATM delta neutral strike, but can sometimes be ATMF for some Latam # Take the vol directly quoted, rather than getting it from building vol surface if strike[i] == 'atm': strike[i] = fx_vol_surface.get_atm_strike(tenor) vol[i] = fx_vol_surface.get_atm_quoted_vol( tenor) / 100.0 # vol[i] = fx_vol_surface.get_atm_vol(tenor) / 100.0 # interpolated elif strike[i] == 'atms': strike[i] = fx_vol_surface.get_spot( ) # Interpolate vol later elif strike[i] == 'atmf': # Quoted tenor, no need to interpolate strike[i] = float(fx_vol_surface.get_all_market_data()[cross + ".close"][horizon_date[i]]) \ + (float(fx_vol_surface.get_all_market_data()[cross + tenor + ".close"][horizon_date[i]]) \ / self._fx_forwards_pricer.get_forwards_divisor(cross[3:6])) # Interpolate vol later elif strike[i] == '25d-otm': if 'call' in contract_type_: strike[i] = fx_vol_surface.get_25d_call_strike( tenor) vol[i] = fx_vol_surface.get_25d_call_vol( tenor) / 100.0 elif 'put' in contract_type_: strike[i] = fx_vol_surface.get_25d_put_strike( tenor) vol[i] = fx_vol_surface.get_25d_put_vol( tenor) / 100.0 elif strike[i] == '10d-otm': if 'call' in contract_type_: strike[i] = fx_vol_surface.get_10d_call_strike( tenor) vol[i] = fx_vol_surface.get_10d_call_vol( tenor) / 100.0 elif 'put' in contract_type_: strike[i] = fx_vol_surface.get_10d_put_strike( tenor) vol[i] = fx_vol_surface.get_10d_put_vol( tenor) / 100.0 if not (built_vol_surface): try: fx_vol_surface.build_vol_surface(horizon_date[i]) except: logger.warn("Failed to build vol surface for " + str(horizon_date) + ", won't be able to interpolate vol") # fx_vol_surface.extract_vol_surface(num_strike_intervals=None) # If an implied vol hasn't been provided, interpolate that one, fit the vol surface (if hasn't already been # done) if np.isnan(vol[i]): if tenor is None: vol[i] = fx_vol_surface.calculate_vol_for_strike_expiry( strike[i], expiry_date=expiry_date[i], tenor=None) else: vol[i] = fx_vol_surface.calculate_vol_for_strike_expiry( strike[i], expiry_date=None, tenor=tenor) model = FinModelBlackScholes(float(vol[i])) logger.info("Pricing " + contract_type_ + " option, horizon date = " + str(horizon_date[i]) + ", expiry date = " + str(expiry_date[i])) option = FinFXVanillaOption(self._findate(expiry_date[i]), strike[i], cross, contract_type_fin_, notional, cross[0:3]) spot[i] = fx_vol_surface.get_spot() """ FinancePy will return the value in the following dictionary for values {'v': vdf, "cash_dom": cash_dom, "cash_for": cash_for, "pips_dom": pips_dom, "pips_for": pips_for, "pct_dom": pct_dom, "pct_for": pct_for, "not_dom": notional_dom, "not_for": notional_for, "ccy_dom": self._domName, "ccy_for": self._forName} """ option_values[i] = option_values[i] + option.value( self._findate(horizon_date[i]), spot[i], fx_vol_surface.get_dom_discount_curve(), fx_vol_surface.get_for_discount_curve(), model)[premium_output.replace('-', '_')] intrinsic_values[i] = intrinsic_values[i] + option.value( self._findate(expiry_date[i]), spot[i], fx_vol_surface.get_dom_discount_curve(), fx_vol_surface.get_for_discount_curve(), model)[premium_output.replace('-', '_')] """FinancePy returns this dictionary for deltas {"pips_spot_delta": pips_spot_delta, "pips_fwd_delta": pips_fwd_delta, "pct_spot_delta_prem_adj": pct_spot_delta_prem_adj, "pct_fwd_delta_prem_adj": pct_fwd_delta_prem_adj} """ delta[i] = delta[i] + option.delta( self._findate(horizon_date[i]), spot[i], fx_vol_surface.get_dom_discount_curve(), fx_vol_surface.get_for_discount_curve(), model)[delta_output.replace('-', '_')] if contract_type == 'european-call': contract_type_fin = FinOptionTypes.EUROPEAN_CALL _price_option(contract_type, contract_type_fin) elif contract_type == 'european-put': contract_type_fin = FinOptionTypes.EUROPEAN_PUT _price_option(contract_type, contract_type_fin) elif contract_type == 'european-straddle' or contract_type == 'european-strangle': contract_type = 'european-call' contract_type_fin = FinOptionTypes.EUROPEAN_CALL _price_option(contract_type, contract_type_fin) contract_type = 'european-put' contract_type_fin = FinOptionTypes.EUROPEAN_PUT _price_option(contract_type, contract_type_fin) if return_as_df: option_prices_df = pd.DataFrame(index=horizon_date) option_prices_df[cross + '-option-price.' + field] = option_values option_prices_df[cross + '.' + field] = spot option_prices_df[cross + '-strike.' + field] = strike option_prices_df[cross + '-vol.' + field] = vol option_prices_df[cross + '-delta.' + field] = delta option_prices_df[cross + '.expiry-date'] = expiry_date option_prices_df[cross + '-intrinsic-value.' + field] = intrinsic_values return option_prices_df return option_values, spot, strike, vol, delta, expiry_date, intrinsic_values def get_day_count_conv(self, currency): if currency in market_constants.currencies_with_365_basis: return 365.0 return 360.0 def _findate(self, timestamp): return FinDate(timestamp.day, timestamp.month, timestamp.year, hh=timestamp.hour, mm=timestamp.minute, ss=timestamp.second)