PricingFuture fixes (#232)

Author: nick-young-gs

gs_quant/api/gs/risk_models.py

@@ -170,7 +170,7 @@ def upload_risk_model_data(cls,
             url += '?partialUpload=true'
             if target_universe_size:
                 url += f'&targetUniverseSize={target_universe_size}'
-        return GsSession.current._post(url, model_data)
+        return GsSession.current._post(url, model_data, timeout=85)
 
     @classmethod
     def get_risk_model_data(cls, model_id: str, start_date: dt.date, end_date: dt.date = None,

gs_quant/backtests/generic_engine.py

@@ -345,7 +345,7 @@ def run_backtest(self, strategy, start=None, end=None, frequency='1m', states=No
             # test to see if new trades have been added and calc
             port = []
             for t in backtest.portfolio_dict[d]:
-                if t.name not in list(backtest.results[d].to_frame().index):
+                if t.name not in backtest.results[d].portfolio:
                     port.append(t)
 
             with PricingContext(is_batch=True, csa_term=csa_term, show_progress=show_progress,

gs_quant/base.py

@@ -518,12 +518,6 @@ def location(self):
     def to_dict(self):
         return self.market.to_dict()
 
-    def to_dict(self):
-        return self.market.to_dict()
-
-    def to_dict(self):
-        return self.market.to_dict()
-
 
 class Sentinel:
 

gs_quant/datetime/date.py

@@ -18,8 +18,10 @@
 import numpy as np
 import calendar as cal
 from enum import Enum, IntEnum
+from pytz import timezone
 from typing import Iterable, Optional, Tuple, Union
 from gs_quant.datetime.gscalendar import GsCalendar
+from gs_quant.target.common import PricingLocation
 
 DateOrDates = Union[dt.date, Iterable[dt.date]]
 
@@ -203,6 +205,24 @@ def f():
         raise ValueError('begin must be a date or int')
 
 
+def today(location: Optional[PricingLocation] = None) -> dt.date:
+    if not location:
+        return dt.date.today()
+
+    if location == PricingLocation.LDN:
+        tz = 'Europe/London'
+    elif location == PricingLocation.NYC:
+        tz = 'America/New_York'
+    elif location == PricingLocation.HKG:
+        tz = 'Asia/Hong_Kong'
+    elif location == PricingLocation.TKO:
+        tz = 'Asia/Tokyo'
+    else:
+        raise ValueError(f'Unrecognized timezone {location}')
+
+    return dt.datetime.now(timezone(tz)).date()
+
+
 def has_feb_29(start: dt.date, end: dt.date):
     """
     Determine if date range has a leap day (29Feb)

gs_quant/markets/core.py

@@ -30,7 +30,7 @@
 from gs_quant.base import InstrumentBase, RiskKey, Scenario, get_enum_value
 from gs_quant.common import PricingLocation, RiskMeasure
 from gs_quant.context_base import ContextBaseWithDefault
-from gs_quant.datetime.date import business_day_offset
+from gs_quant.datetime.date import business_day_offset, today
 from gs_quant.risk import CompositeScenario, DataFrameWithInfo, ErrorValue, FloatWithInfo, MarketDataScenario, \
     StringWithInfo
 from gs_quant.risk.results import PricingFuture
@@ -171,16 +171,19 @@ def __init__(self,
             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'))
+        market_data_location = get_enum_value(PricingLocation, market_data_location)
+
+        self.__pricing_date = pricing_date or (
+            self.prior_context.pricing_date if self.prior_context else business_day_offset(
+                today(market_data_location), 0, roll='preceding'))
         self.__csa_term = csa_term
         self.__market_behaviour = market_behaviour
         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_data_location = 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)

gs_quant/markets/markets.py

@@ -173,7 +173,7 @@ def market(self):
 
     @property
     def location(self) -> PricingLocation:
-        return market_location(self.market.location)
+        return market_location(self.__location)
 
 
 class LiveMarket(Market):

gs_quant/markets/portfolio.py

@@ -13,9 +13,9 @@
 specific language governing permissions and limitations
 under the License.
 """
-from dataclasses import dataclass
 import datetime as dt
 import logging
+from dataclasses import dataclass
 from itertools import chain
 from typing import Iterable, Optional, Tuple, Union
 from urllib.parse import quote
@@ -27,7 +27,7 @@
 from gs_quant.api.gs.portfolios import GsPortfolioApi
 from gs_quant.base import InstrumentBase
 from gs_quant.common import RiskMeasure
-from gs_quant.instrument import Instrument
+from gs_quant.instrument import Instrument, AssetType
 from gs_quant.markets import HistoricalPricingContext, OverlayMarket, PricingContext, PositionContext
 from gs_quant.priceable import PriceableImpl
 from gs_quant.risk import ResolvedInstrumentValues
@@ -71,6 +71,31 @@ def __init__(self,
         self.__id = None
         self.__quote_id = None
 
+    def _to_records(self):
+        def get_name(obj, idx):
+            if isinstance(obj, InstrumentBase) and hasattr(obj, 'type_'):
+                type_name = obj.type_.name if isinstance(obj.type_, AssetType) else obj.type_
+            else:
+                type_name = 'Portfolio'
+            return f'{type_name}_{idx}' if obj.name is None else obj.name
+
+        stack = [(None, self)]
+        records = []
+        while stack:
+            temp_records = []
+            parent, portfolio = stack.pop()
+            current_record = {} if len(records) == 0 else records.pop(0)
+            for idx, priceable in enumerate(portfolio.__priceables):
+                path = parent + PortfolioPath(idx) if parent is not None else PortfolioPath(idx)
+                priceable_name = get_name(priceable, idx)
+                if isinstance(priceable, Portfolio):
+                    stack.insert(0, (path, priceable))
+                    temp_records.append({**current_record, f'portfolio_name_{len(path)-1}': priceable_name})
+                else:
+                    temp_records.append({**current_record, 'instrument_name': priceable_name})
+            records.extend(temp_records)
+        return records
+
     def __getitem__(self, item):
         if isinstance(item, (int, slice)):
             return self.__priceables[item]

gs_quant/risk/core.py

@@ -134,7 +134,7 @@ def _to_records(self, extra_dict, display_options: DisplayOptions = None):
         options = display_options if display_options is not None else gs_quant.config.display_options
         show_na = options.show_na
 
-        return [{**extra_dict, 'value': self}] if show_na else [None]
+        return [{**extra_dict, 'value': self}] if show_na else []
 
 
 class ScalarWithInfo(ResultInfo, metaclass=ABCMeta):
@@ -322,7 +322,7 @@ def _to_records(self, extra_dict, display_options: DisplayOptions = None):
             options = display_options if display_options is not None else gs_quant.config.display_options
             show_na = options.show_na
 
-            return [{**extra_dict, 'value': None}] if show_na else [None]
+            return [{**extra_dict, 'value': None}] if show_na else []
 
         return [dict(item, **{**extra_dict}) for item in self.raw_value.to_dict('records')]
 

gs_quant/risk/results.py

@@ -20,15 +20,14 @@
 from concurrent.futures import Future
 from itertools import chain
 from typing import Any, Iterable, Mapping, Optional, Tuple, Union
+import weakref
 
 import pandas as pd
 from gs_quant.base import Priceable, RiskKey, Sentinel, InstrumentBase, is_instance_or_iterable, is_iterable
 from gs_quant.common import RiskMeasure
 from gs_quant.config import DisplayOptions
 from gs_quant.risk import DataFrameWithInfo, ErrorValue, FloatWithInfo, SeriesWithInfo, ResultInfo, \
     ScalarWithInfo, aggregate_results
-from gs_quant.target.common import AssetType
-from more_itertools import unique_everseen
 
 _logger = logging.getLogger(__name__)
 
@@ -128,8 +127,13 @@ class PricingFuture(Future):
 
     def __init__(self, result: Optional[Any] = __RESULT_SENTINEL):
         super().__init__()
+        self.__pricing_context = None
+
         if result is not self.__RESULT_SENTINEL:
             self.set_result(result)
+        else:
+            from gs_quant.markets import PricingContext
+            self.__pricing_context = weakref.ref(PricingContext.current.active_context)
 
     def __add__(self, other):
         if isinstance(other, (int, float)):
@@ -162,9 +166,10 @@ def result(self, timeout=None):
 
         Exception: If the call raised then that exception will be raised.
         """
-        from gs_quant.markets import PricingContext
-        if not self.done() and PricingContext.current.active_context.is_entered:
-            raise RuntimeError('Cannot evaluate results under the same pricing context being used to produce them')
+        if not self.done():
+            pricing_context = self.__pricing_context() if self.__pricing_context else None
+            if pricing_context is not None and pricing_context.is_entered:
+                raise RuntimeError('Cannot evaluate results under the same pricing context being used to produce them')
 
         return super().result(timeout=timeout)
 
@@ -595,51 +600,26 @@ def aggregate(self, allow_mismatch_risk_keys=False) -> Union[float, pd.DataFrame
         else:
             return aggregate_results(self.__results(), allow_mismatch_risk_keys=allow_mismatch_risk_keys)
 
+    def _to_records(self, display_options: DisplayOptions = None):
+        def get_records(rec):
+            temp = []
+            for f in rec.futures:
+                if isinstance(f.result(), ResultInfo) or isinstance(f.result(), MultipleRiskMeasureResult):
+                    temp.append(f.result())
+                else:
+                    temp.extend(get_records(f.result()))
+            return temp
+
+        future_records = get_records(self)
+        portfolio_records = self.__portfolio._to_records()
+        records = []
+        if len(future_records) == len(portfolio_records):
+            for i in range(len(future_records)):
+                records.extend(future_records[i]._to_records({**portfolio_records[i]}, display_options))
+        return records
+
     def to_frame(self, values='default', index='default', columns='default', aggfunc=sum,
                  display_options: DisplayOptions = None):
-        def get_name(obj, idx):
-            if isinstance(obj, InstrumentBase) and hasattr(obj, 'type'):
-                type_name = obj.type.name if isinstance(obj.type, AssetType) else obj.type_
-            else:
-                type_name = 'Portfolio'
-            return f'{type_name}_{idx}' if obj.name is None else obj.name
-
-        def get_df(priceable):
-            portfolio_paths = list(unique_everseen(p.path[:-1] for p in priceable.all_paths if len(p.path) > 1))
-            inst_paths = [p.path for p in priceable.all_paths if len(p.path) == 1]
-            final_records = []
-            if len(portfolio_paths):
-                for portfolio_path in portfolio_paths:
-                    curr_res = self.__result(PortfolioPath(portfolio_path))
-                    portfolio_info = {}
-                    for p_idx, p in enumerate(portfolio_path):
-                        portfolio = self.__result(PortfolioPath(portfolio_path[:p_idx + 1])).__portfolio
-                        portfolio_info[f'portfolio_name_{p_idx}'] = get_name(portfolio, p)
-
-                    records = list(chain.from_iterable((i._to_records(
-                        {**portfolio_info, 'instrument_name': get_name(curr_res.__portfolio[slice_idx], slice_idx)},
-                        display_options) for slice_idx, i in enumerate(curr_res))))
-
-                    records = list(filter(lambda x: x is not None, records))
-                    for rec_idx, rec in enumerate(records):
-                        if 'risk_measure' not in rec:
-                            records[rec_idx]['risk_measure'] = curr_res.risk_measures[0]
-
-                    final_records.extend(records)
-
-            if len(inst_paths):
-                for path in inst_paths:
-                    final_records.extend(self.__result(PortfolioPath(path))._to_records(
-                        {'instrument_name': get_name(priceable[path[0]], path[0])}, display_options))
-
-            final_records = list(filter(lambda x: x is not None, final_records))
-
-            if len(final_records) > 0:
-                final_df = pd.DataFrame.from_records(final_records)
-                if 'risk_measure' not in final_df.columns.values:
-                    final_df['risk_measure'] = self.risk_measures[0]
-                return final_df
-
         def get_default_pivots(ori_cols, has_dates: bool, multi_measures: bool, simple_port: bool) -> tuple:
             portfolio_names = list(filter(lambda x: 'portfolio_name_' in x, ori_cols))
             port_and_inst_names = portfolio_names + ['instrument_name']
@@ -668,9 +648,12 @@ def match(rule_value, check_value) -> bool:
                     return rule_output
             return None, None, None
 
-        ori_df = get_df(self.portfolio)
-
-        if ori_df is None:
+        final_records = self._to_records(display_options=display_options)
+        if len(final_records) > 0:
+            ori_df = pd.DataFrame.from_records(final_records)
+            if 'risk_measure' not in ori_df.columns.values:
+                ori_df['risk_measure'] = self.risk_measures[0]
+        else:
             return
         df_cols = list(ori_df.columns.values)
         # fill n/a values for different sub-portfolio depths

gs_quant/session.py

@@ -14,7 +14,6 @@
 under the License.
 """
 
-
 from abc import abstractmethod
 import backoff
 import certifi
@@ -437,14 +436,26 @@ def __init__(self, environment_or_domain: str, api_version: str = API_VERSION,
     class PassThroughGSSSOSession(KerberosSessionMixin, GsSession):
 
         def __init__(self, environment: str, token, api_version=API_VERSION,
-                     application=DEFAULT_APPLICATION, http_adapter=None):
+                     application=DEFAULT_APPLICATION, http_adapter=None, csrf_token=None):
             domain, verify = self.domain_and_verify(environment)
             GsSession.__init__(self, domain, api_version=api_version, application=application, verify=verify,
                                http_adapter=http_adapter)
 
             self.token = token
+            self.csrf_token = csrf_token
 
         def _authenticate(self):
-            self._handle_cookies(self.token)
+            if not (self.token and self.csrf_token):
+                self._handle_cookies(self.token)
+                return
+
+            cookie = requests.cookies.create_cookie(domain='.gs.com', name='GSSSO', value=self.token)
+            self._session.cookies.set_cookie(cookie)
+            if self.csrf_token:
+                cookie = requests.cookies.create_cookie(domain='.gs.com', name='MARQUEE-CSRF-TOKEN',
+                                                        value=self.csrf_token)
+                self._session.cookies.set_cookie(cookie)
+                self._session.headers.update({'X-MARQUEE-CSRF-TOKEN': self.csrf_token})
+
 except ModuleNotFoundError:
     pass

gs_quant/target/common.py

@@ -3984,6 +3984,7 @@ class RiskMeasureType(EnumBase, Enum):
     Description = 'Description'
     Dollar_Price = 'Dollar Price'
     DV01 = 'DV01'
+    FairPremium = 'FairPremium'
     Fair_Price = 'Fair Price'
     FairVarStrike = 'FairVarStrike'
     FairVolStrike = 'FairVolStrike'
@@ -5703,6 +5704,7 @@ class RiskRequest(Base):
     parameters: Optional[RiskRequestParameters] = field(default=None, metadata=field_metadata)
     request_visible_to_gs: Optional[bool] = field(default=False, metadata=field_metadata)
     use_cache: Optional[bool] = field(default=False, metadata=field_metadata)
+    priority: Optional[int] = field(default=None, metadata=field_metadata)
     name: Optional[str] = field(default=None, metadata=name_metadata)
 
 

gs_quant/target/measures.py

@@ -260,16 +260,16 @@ def __call__(self, aggregation_level=None,  bump_size=None,  currency=None,  fin
 EqAnnualImpliedVol = RiskMeasure(name="EqAnnualImpliedVol", asset_class=AssetClass("Equity"), measure_type=RiskMeasureType("Annual Implied Volatility"), unit=RiskMeasureUnit("Percent"))
 EqAnnualImpliedVol.__doc__ = "Equity Annual Implied Volatility (%)"
 
-EqDelta = RiskMeasure(name="EqDelta", asset_class=AssetClass("Equity"), measure_type=RiskMeasureType("Delta"))
-EqDelta.__doc__ = "Change in Dollar Price (USD present value) due to individual $1 moves in the spot price of underlying equity security"
+EqDelta = RiskMeasureWithCurrencyParameter(name="EqDelta", asset_class=AssetClass("Equity"), measure_type=RiskMeasureType("Delta"))
+EqDelta.__doc__ = "Change in Dollar Price (USD present value) due to individual 1% move in the spot price of underlying equity security"
 
-EqGamma = RiskMeasure(name="EqGamma", asset_class=AssetClass("Equity"), measure_type=RiskMeasureType("Gamma"))
-EqGamma.__doc__ = "Change in EqDelta for a $1 shift in the price of the underlying equity security"
+EqGamma = RiskMeasureWithCurrencyParameter(name="EqGamma", asset_class=AssetClass("Equity"), measure_type=RiskMeasureType("Gamma"))
+EqGamma.__doc__ = "Change in EqDelta for a 1% move in the price of the underlying equity security"
 
 EqSpot = RiskMeasure(name="EqSpot", asset_class=AssetClass("Equity"), measure_type=RiskMeasureType("Spot"))
 EqSpot.__doc__ = "Equity Spot"
 
-EqVega = RiskMeasure(name="EqVega", asset_class=AssetClass("Equity"), measure_type=RiskMeasureType("Vega"))
+EqVega = RiskMeasureWithCurrencyParameter(name="EqVega", asset_class=AssetClass("Equity"), measure_type=RiskMeasureType("Vega"))
 EqVega.__doc__ = "Change in Dollar Price (USD present value) due to individual 1bp moves in the implied volatility of the underlying equity security"
 
 FXAnnualATMImpliedVol = RiskMeasure(name="FXAnnualATMImpliedVol", asset_class=AssetClass("FX"), measure_type=RiskMeasureType("Annual ATM Implied Volatility"), unit=RiskMeasureUnit("Percent"))
@@ -332,6 +332,9 @@ def __call__(self, aggregation_level=None,  bump_size=None,  currency=None,  fin
 FXVega = RiskMeasureWithFiniteDifferenceParameter(name="FXVega", asset_class=AssetClass("FX"), measure_type=RiskMeasureType("Vega"))
 FXVega.__doc__ = "Change in Dollar Price due to a 1 vol move in the implied volatility of ATM instruments used to build the volatility surface"
 
+FairPremium = RiskMeasureWithCurrencyParameter(name="FairPremium", measure_type=RiskMeasureType("FairPremium"))
+FairPremium.__doc__ = "Fair Premium is the instrument present value discounted to the premium settlement date"
+
 FairPrice = RiskMeasure(name="FairPrice", asset_class=AssetClass("Commod"), measure_type=RiskMeasureType("Fair Price"))
 FairPrice.__doc__ = "FairPrice"