def excess_returns_(
price_series: pd.Series,
currency: RiskFreeRateCurrency = RiskFreeRateCurrency.USD
) -> pd.Series:
"""
Calculate excess returns
:param price_series: price series
:param currency: currency for risk-free rate, defaults to USD
:return: excess returns
**Usage**
Given a price series P and risk-free rate R, excess returns E are defined as:
:math:`E_t = E_{t-1} + P_t - P_{t-1} * (1 + R * (D_t - D_{t-1}) / 360)`
The `Actual/360 <https://en.wikipedia.org/wiki/Day_count_convention#Actual/360>`_ day count convention is used.
**Examples**
Get excess returns from a price series.
>>> er = excess_returns(generate_series(100), USD)
"""
return excess_returns(price_series,
Currency(currency.value),
day_count_convention=DayCountConvention.ACTUAL_360)
def sharpe_ratio(series: pd.Series,
currency: RiskFreeRateCurrency,
rolling: int = 0,
curve_type: CurveType = CurveType.PRICES) -> pd.Series:
"""
Calculate Sharpe ratio
:param series: series of prices or excess returns for an asset
:param currency: currency for risk-free rate
:param curve_type: whether input series is of prices or excess returns
:param rolling: rolling window to use
:return: Sharpe ratio
**Usage**
Given a price series and risk-free rate (a number, currency, or cash asset), returns the rolling Sharpe ratio.
For a fixed rate R, excess returns E are calculated as:
:math:`E_t = E_{t-1} + P_t - P_{t-1} * (1 + R * DCF_{t-1,t})`
Subscripts refers to dates in the price series.
P is a point in the price series.
DCF is the day count fraction using the Act/360 convention.
"""
return _get_ratio(series,
Currency(currency.value),
rolling,
day_count_convention=DayCountConvention.ACTUAL_360,
curve_type=curve_type)
def excess_returns_(price_series: pd.Series,
currency: RiskFreeRateCurrency) -> pd.Series:
"""
Calculate excess returns
:param price_series: price series
:param currency: currency for risk-free rate
:return: excess returns
**Usage**
Given a price series P and risk-free rate R, excess returns E are defined as:
:math:`E_t = E_{t-1} + P_t - P_{t-1} * (1 + R * DCF_{t-1,t})`
where DCF is day count fraction between two points
**Examples**
Get excess returns from a price series.
>>> er = excess_returns(generate_series(100), RiskFreeRateCurrency.USD)
"""
return excess_returns(price_series,
Currency(currency.value),
day_count_convention=DayCountConvention.ACTUAL_360)
def _create(self):
# If a priceables portfolio, try resolving to MQ portfolio
if self.__priceables:
self.save()
self.priceables = None
return
# If a positions portfolio, create using MQ API
port = GsPortfolioApi.create_portfolio(
portfolio=MQPortfolio(name=self.name,
currency=self.currency,
entitlements=self.entitlements.to_target()))
PositionedEntity.__init__(self, port.id, EntityType.PORTFOLIO)
Entity.__init__(self, port.id, EntityType.PORTFOLIO)
self.__id = port.id
self._PositionedEntity__entity_type = EntityType.PORTFOLIO
self.entitlements = Entitlements.from_target(port.entitlements)
self.currency = Currency(port.currency)
# If the portfolio contains positions, upload them to the MQ portfolio and schedule reports
if self.position_sets:
position_sets = self.position_sets
self.position_sets = None
self.update_positions(position_sets, False)
self._schedule_first_reports(
[pos_set.date for pos_set in position_sets])
self.position_sets = None
def sharpe_ratio(series: pd.Series,
currency: RiskFreeRateCurrency = RiskFreeRateCurrency.USD,
w: Union[Window, int, str] = None,
curve_type: CurveType = CurveType.PRICES,
method: Interpolate = Interpolate.NAN) -> pd.Series:
"""
Calculate Sharpe ratio
:param series: series of prices or excess returns for an asset
:param currency: currency for risk-free rate, defaults to USD
:param w: Window or int: size of window and ramp up to use. e.g. Window(22, 10) where 22 is the window size
and 10 the ramp up value. If w is a string, it should be a relative date like '1m', '1d', etc.
Window size defaults to length of series.
:param curve_type: whether input series is of prices or excess returns, defaults to prices
:param method: interpolation method (default: nan). Used to calculate returns on dates without data (i.e. weekends)
when window is a relative date. Defaults to no interpolation.
:return: Sharpe ratio
**Usage**
Given a price series P, risk-free rate R, and window of size w returns the rolling
`Sharpe ratio <https://en.wikipedia.org/wiki/Sharpe_ratio>`_ S:
:math:`S_t = \\frac{(E_t / E_{t-w+1})^{365.25 / (D_t - D_{t-w})}-1}{volatility(E, w)_t}`
Excess returns E are defined as:
:math:`E_t = E_{t-1} + P_t - P_{t-1} * (1 + R * (D_t - D_{t-1}) / 360)`
where D is the date for a data point. The
`Actual/360 <https://en.wikipedia.org/wiki/Day_count_convention#Actual/360>`_ day count convention is used.
**Examples**
Get rolling sharpe ratio of a price series (with window of 22).
>>> sr = sharpe_ratio(generate_series(365, END_TODAY), USD, 22, PRICES)
**See also**
:func:`volatility`
"""
return _get_ratio(series,
Currency(currency.value),
w,
day_count_convention=DayCountConvention.ACTUAL_360,
curve_type=curve_type,
interpolation_method=method)
def sharpe_ratio(series: pd.Series,
currency: RiskFreeRateCurrency,
w: Union[Window, int] = None,
curve_type: CurveType = CurveType.PRICES) -> pd.Series:
"""
Calculate Sharpe ratio
:param series: series of prices or excess returns for an asset
:param currency: currency for risk-free rate
:param curve_type: whether input series is of prices or excess returns
:param w: Window or int: size of window and ramp up to use. e.g. Window(22, 10) where 22 is the window size
and 10 the ramp up value.
:return: Sharpe ratio
**Usage**
Given a price series P, risk-free rate R, and window of size w returns the rolling
`Sharpe ratio <https://en.wikipedia.org/wiki/Sharpe_ratio>`_ S:
:math:`S_t = \\frac{(E_t / E_{t-w+1})^{365.25 / (D_t - D_{t-w} - 1)}}{volatility(E, w)_t}`
Excess returns E are defined as:
:math:`E_t = E_{t-1} + P_t - P_{t-1} * (1 + R * DCF_{t-1,t})`
where D is the date for a data point and DCF is day count fraction between two points
**Examples**
Get rolling sharpe ratio of a price series (with window of 252).
>>> sr = sharpe_ratio(generate_series(100), RiskFreeRateCurrency.USD, 252)
**See also**
:func:`volatility`
"""
return _get_ratio(series,
Currency(currency.value),
w,
day_count_convention=DayCountConvention.ACTUAL_360,
curve_type=curve_type)
def swap_rate(asset: Asset,
tenor: str,
benchmark_type: BenchmarkType = None,
floating_index: str = None,
*,
source: str = None,
real_time: bool = False) -> Series:
"""
GS end-of-day Fixed-Floating interest rate swap (IRS) curves across major currencies.
:param asset: asset object loaded from security master
:param tenor: relative date representation of expiration date e.g. 1m
:param benchmark_type: benchmark type e.g. LIBOR
:param floating_index: floating index rate
:param source: name of function caller
:param real_time: whether to retrieve intraday data instead of EOD
:return: swap rate curve
"""
if real_time:
raise NotImplementedError('realtime swap_rate not implemented')
currency = asset.get_identifier(AssetIdentifier.BLOOMBERG_ID)
currency = Currency(currency)
# default benchmark types
if benchmark_type is None:
if currency == Currency.EUR:
benchmark_type = BenchmarkType.EURIBOR
elif currency == Currency.SEK:
benchmark_type = BenchmarkType.STIBOR
else:
benchmark_type = BenchmarkType.LIBOR
over_nights = [BenchmarkType.OIS]
# default floating index
if floating_index is None:
if benchmark_type in over_nights:
floating_index = '1d'
else:
if currency in [Currency.USD]:
floating_index = '3m'
elif currency in [
Currency.GBP, Currency.EUR, Currency.CHF, Currency.SEK
]:
floating_index = '6m'
mdapi_divider = " " if benchmark_type in over_nights else "-"
mdapi_floating_index = BenchmarkType.OIS.value if benchmark_type is BenchmarkType.OIS else floating_index
mdapi = currency.value + mdapi_divider + mdapi_floating_index
rate_mqid = GsAssetApi.map_identifiers(GsIdType.mdapi, GsIdType.id,
[mdapi])[mdapi]
_logger.debug('where tenor=%s, floatingIndex=%s', tenor, floating_index)
q = GsDataApi.build_market_data_query([rate_mqid],
QueryType.SWAP_RATE,
where=FieldFilterMap(tenor=tenor),
source=source,
real_time=real_time)
_logger.debug('q %s', q)
df = _market_data_timed(q)
return Series() if df.empty else df['swapRate']