def __init__(self,
market_data_location: Optional[str] = None,
is_async: bool = False,
is_batch: bool = False,
visible_to_gs: bool = False,
csa_term: Optional[str] = None,
poll_for_batch_results: Optional[bool] = False,
batch_results_timeout: Optional[int] = None):
# TODO we use 23:59:59.999999 as a sentinel value to indicate live pricing for now. Fix this
d = business_day_offset(dt.date.today(), -1, roll='preceding')
super().__init__(pricing_date=dt.date.today(),
market_data_as_of=dt.datetime(d.year, d.month, d.day,
23, 59, 59, 999999),
market_data_location=market_data_location,
is_async=is_async,
is_batch=is_batch,
use_cache=False,
visible_to_gs=visible_to_gs,
csa_term=csa_term,
poll_for_batch_results=poll_for_batch_results,
batch_results_timeout=batch_results_timeout)
def __init__(self,
pricing_date: Optional[dt.date] = None,
market_data_location: Optional[Union[PricingLocation, str]] = None,
is_async: bool = False,
is_batch: bool = False,
use_cache: bool = False,
visible_to_gs: Optional[bool] = None,
csa_term: Optional[str] = None,
timeout: Optional[int] = None,
market: Optional[Market] = None,
show_progress: Optional[bool] = False,
use_server_cache: Optional[bool] = False):
"""
The methods on this class should not be called directly. Instead, use the methods on the instruments,
as per the examples
:param pricing_date: the date for pricing calculations. Default is today
:param market_data_location: the location for sourcing market data ('NYC', 'LDN' or 'HKG' (defaults to LDN)
:param is_async: if True, return (a future) immediately. If False, block (defaults to False)
:param is_batch: use for calculations expected to run longer than 3 mins, to avoid timeouts.
It can be used with is_async=True|False (defaults to False)
:param use_cache: store results in the pricing cache (defaults to False)
:param visible_to_gs: are the contents of risk requests visible to GS (defaults to False)
:param csa_term: the csa under which the calculations are made. Default is local ccy ois index
:param market_data_location: the location for sourcing market data ('NYC', 'LDN' or 'HKG' (defaults to LDN)
:param timeout: the timeout for batch operations
:param show_progress: add a progress bar (tqdm)
:param use_server_cache: cache query results on the GS servers
**Examples**
To change the market data location of the default context:
>>> from gs_quant.markets import PricingContext
>>>
>>> PricingContext.current = PricingContext(market_data_location='LDN')
For a blocking, synchronous request:
>>> from gs_quant.instrument import IRCap
>>> cap = IRCap('5y', 'GBP')
>>>
>>> with PricingContext():
>>> price_f = cap.dollar_price()
>>>
>>> price = price_f.result()
For an asynchronous request:
>>> with PricingContext(is_async=True):
>>> price_f = cap.dollar_price()
>>>
>>> while not price_f.done:
>>> ...
"""
super().__init__()
if market and market_data_location and market.location is not \
get_enum_value(PricingLocation, market_data_location):
raise ValueError('market.location and market_data_location cannot be different')
if pricing_date:
if pricing_date > dt.date.today():
raise ValueError(
'The PricingContext does not support a pricing_date in the future. Please use the RollFwd Scenario '
'to roll the pricing_date to a future date')
if market:
market_date = None
if isinstance(market, OverlayMarket) or isinstance(market, CloseMarket):
market_date = getattr(market, 'date', None) or getattr(market.base_market, 'date', None)
if isinstance(market, RelativeMarket):
market_date = market.from_market.date if market.from_market.date > dt.date.today() \
else market.to_market.date
if market_date:
if market_date > dt.date.today():
raise ValueError(
'The PricingContext does not support a market dated in the future. Please use the RollFwd '
'Scenario to roll the pricing_date to a future date')
if not market_data_location:
if not market:
# use parent context's market_data_location
if self != self.active_context:
market_data_location = self.active_context.market_data_location
# if no parent but there was a context set previously, use that
elif self.prior_context:
market_data_location = self.prior_context.market_data_location
else:
market_data_location = market.location
self.__pricing_date = pricing_date or (self.prior_context.pricing_date if self.prior_context else
business_day_offset(dt.date.today(), 0, roll='preceding'))
self.__csa_term = csa_term
self.__is_async = is_async
self.__is_batch = is_batch
self.__timeout = timeout
self.__use_cache = use_cache
self.__visible_to_gs = visible_to_gs
self.__market_data_location = get_enum_value(PricingLocation, market_data_location)
self.__market = market or CloseMarket(
date=close_market_date(self.__market_data_location, self.__pricing_date) if pricing_date else None,
location=self.__market_data_location if market_data_location else None)
self.__pending = {}
self.__show_progress = show_progress
self._max_concurrent = 1000
self.__use_server_cache = use_server_cache
def __init__(self,
pricing_date: Optional[dt.date] = None,
market_data_location: Optional[Union[PricingLocation,
str]] = None,
is_async: bool = False,
is_batch: bool = False,
use_cache: bool = False,
visible_to_gs: bool = False,
csa_term: Optional[str] = None,
poll_for_batch_results: Optional[bool] = False,
batch_results_timeout: Optional[int] = None,
market: Optional[Market] = None):
"""
The methods on this class should not be called directly. Instead, use the methods on the instruments,
as per the examples
:param pricing_date: the date for pricing calculations. Default is today
:param market_data_location: the location for sourcing market data ('NYC', 'LDN' or 'HKG' (defaults to LDN)
:param is_async: if True, return (a future) immediately. If False, block (defaults to False)
:param is_batch: use for calculations expected to run longer than 3 mins, to avoid timeouts.
It can be used with is_aync=True|False (defaults to False)
:param use_cache: store results in the pricing cache (defaults to False)
:param visible_to_gs: are the contents of risk requests visible to GS (defaults to False)
:param csa_term: the csa under which the calculations are made. Default is local ccy ois index
**Examples**
To change the market data location of the default context:
>>> from gs_quant.markets import PricingContext
>>> import datetime as dt
>>>
>>> PricingContext.current = PricingContext(market_data_location='LDN')
For a blocking, synchronous request:
>>> from gs_quant.instrument import IRCap
>>> cap = IRCap('5y', 'GBP')
>>>
>>> with PricingContext():
>>> price_f = cap.dollar_price()
>>>
>>> price = price_f.result()
For an asynchronous request:
>>> with PricingContext(is_async=True):
>>> price_f = cap.dollar_price()
>>>
>>> while not price_f.done:
>>> ...
"""
super().__init__()
self.__pricing_date = pricing_date or business_day_offset(
dt.date.today(), 0, roll='forward')
self.__csa_term = csa_term
self.__is_async = is_async
self.__is_batch = is_batch
self.__poll_for_batch_results = poll_for_batch_results
self.__batch_results_timeout = batch_results_timeout
self.__use_cache = use_cache
self.__visible_to_gs = visible_to_gs
self.__market = market
self.__lock = Lock()
self.__pending = {}
if self.__market is None:
# Do not use self.__class__.current - it will cause a cycle
default_location = market_data_location or (
self.__class__.path[0].market_data_location
if self.__class__.path else PricingLocation.LDN)
market_data_date = business_day_offset(self.__pricing_date, -1, roll='preceding') if\
self.__pricing_date == dt.date.today() else self.__pricing_date
self.__market = market or ClosingMarket(default_location,
market_data_date)
def _pricing_market_data_as_of(self) -> Tuple[PricingDateAndMarketDataAsOf, ...]:
return tuple(PricingDateAndMarketDataAsOf(d, business_day_offset(d, -1, roll='preceding') if d == dt.date.today() else d) for d in self.__date_range)