Bug fixes (#231)

Author: S-Manglik

gs_quant/api/gs/portfolios.py

@@ -184,15 +184,17 @@ def get_positions_data(cls,
                            start_date: dt.date,
                            end_date: dt.date,
                            fields: List[str] = None,
-                           position_type: PositionType = None) -> List[dict]:
+                           position_type: PositionType = None,
+                           include_all_business_days: bool = False) -> List[dict]:
         start_date_str = start_date.isoformat()
         end_date_str = end_date.isoformat()
         url = f'/portfolios/{portfolio_id}/positions/data?startDate={start_date_str}&endDate={end_date_str}'
         if fields is not None:
             url += '&fields='.join([''] + fields)
-
         if position_type is not None:
             url += '&type=' + position_type.value
+        if include_all_business_days:
+            url += '&includeAllBusinessDays=true'
 
         return GsSession.current._get(url)['results']
 

gs_quant/base.py

@@ -195,7 +195,6 @@ def __setattr__(self, key, value):
 
             key = snake_case_key
             value = self.__coerce_value(fld.type, value)
-            self._property_changed(snake_case_key, value)
 
         __setattr__(self, key, value)
 
@@ -247,9 +246,6 @@ def _field_mappings(cls) -> Mapping[str, str]:
             cls.__field_mappings = field_mappings
         return cls.__field_mappings
 
-    def _property_changed(self, prop: str, value):
-        pass
-
     def clone(self, **kwargs):
         """
             Clone this object, overriding specified values
@@ -481,14 +477,6 @@ def metadata(self):
     def metadata(self, value):
         self.__metadata = value
 
-    def _property_changed(self, prop: str, value):
-        try:
-            if self.__resolution_key and prop not in ('valuation_overrides', 'name'):
-                self.unresolve()
-        except AttributeError:
-            # Can happen during init
-            pass
-
     def from_instance(self, instance):
         self.__resolution_key = None
         super().from_instance(instance)
@@ -504,12 +492,6 @@ def resolved(self, values: dict, resolution_key: RiskKey):
         new_instrument.__resolution_key = resolution_key
         return new_instrument
 
-    def unresolve(self):
-        if self.__resolution_key and self.__unresolved:
-            self.from_instance(self.__unresolved)
-            self.__resolution_key = None
-            self.__unresolved = None
-
 
 @dataclass
 class Market(ABC):

gs_quant/entities/entity.py

@@ -451,11 +451,15 @@ def get_positions_data(self,
                            start: dt.date = DateLimit.LOW_LIMIT.value,
                            end: dt.date = dt.date.today(),
                            fields: [str] = None,
-                           position_type: PositionType = PositionType.CLOSE) -> List[Dict]:
+                           position_type: PositionType = PositionType.CLOSE,
+                           include_all_business_days: bool = False) -> List[Dict]:
         if self.positioned_entity_type == EntityType.ASSET:
+            if include_all_business_days:
+                raise MqError('"include_all_business_days" cannot be set to true for assets')
             return GsIndexApi.get_positions_data(self.id, start, end, fields, position_type)
         if self.positioned_entity_type == EntityType.PORTFOLIO:
-            return GsPortfolioApi.get_positions_data(self.id, start, end, fields, position_type)
+            return GsPortfolioApi.get_positions_data(self.id, start, end, fields,
+                                                     position_type, include_all_business_days)
         raise NotImplementedError
 
     def get_position_dates(self) -> Tuple[dt.date, ...]:

gs_quant/instrument/core.py

@@ -360,7 +360,6 @@ def dummy_result(self) -> Union[str, float]:
 
     @dummy_result.setter
     def dummy_result(self, value: Union[str, float]):
-        self._property_changed('dummy_result')
         self.__dummy_result = value
 
     @property

gs_quant/markets/core.py

@@ -138,7 +138,9 @@ def __init__(self,
                 get_enum_value(PricingLocation, market_data_location):
             raise ValueError('market.location and market_data_location cannot be different')
 
-        if not market and pricing_date and pricing_date > dt.date.today():
+        if not market and pricing_date and pricing_date > dt.date.today() + dt.timedelta(5):
+            # We allow a small tolerance to rolling over weekends/holidays
+            # We should use a calendar but not everyone has access
             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')

gs_quant/markets/markets.py

@@ -61,7 +61,7 @@ def close_market_date(_location: Optional[Union[PricingLocation, str]] = None,
     from .core import PricingContext
     date = date or PricingContext.current.pricing_date
 
-    if date == dt.date.today():
+    if date >= dt.date.today():
         # Don't use the calendars argument here as external users do not (yet) have access to that dataset
         date = prev_business_date(date)
 

gs_quant/markets/portfolio_manager.py

@@ -184,6 +184,30 @@ def get_custom_aum(self,
         return [CustomAUMDataPoint(date=dt.datetime.strptime(data['date'], '%Y-%m-%d'),
                                    aum=data['aum']) for data in aum_data]
 
+    def get_aum(self, start_date: dt.date, end_date: dt.date):
+        """
+        Get AUM data for portfolio
+        :param start_date: start date
+        :param end_date: end date
+        :return: dictionary of dates with corresponding AUM values
+         """
+        aum_source = self.get_aum_source()
+        if aum_source == RiskAumSource.Custom_AUM:
+            aum = self.get_custom_aum(start_date=start_date, end_date=end_date)
+            return {aum_point.date.strftime('%Y-%m-%d'): aum_point.aum for aum_point in aum}
+        if aum_source == RiskAumSource.Long:
+            aum = self.get_performance_report().get_long_exposure(start_date=start_date, end_date=end_date)
+            return {row['date']: row['longExposure'] for index, row in aum.iterrows()}
+        if aum_source == RiskAumSource.Short:
+            aum = self.get_performance_report().get_short_exposure(start_date=start_date, end_date=end_date)
+            return {row['date']: row['shortExposure'] for index, row in aum.iterrows()}
+        if aum_source == RiskAumSource.Gross:
+            aum = self.get_performance_report().get_gross_exposure(start_date=start_date, end_date=end_date)
+            return {row['date']: row['grossExposure'] for index, row in aum.iterrows()}
+        if aum_source == RiskAumSource.Net:
+            aum = self.get_performance_report().get_net_exposure(start_date=start_date, end_date=end_date)
+            return {row['date']: row['netExposure'] for index, row in aum.iterrows()}
+
     def upload_custom_aum(self,
                           aum_data: List[CustomAUMDataPoint],
                           clear_existing_data: bool = None):

gs_quant/markets/securities.py

@@ -1549,14 +1549,29 @@ def get_asset_id_type(type_: SecurityIdentifier):
                             values.append(asset_id)
                 elif output_type == "bbg":
                     if SecurityIdentifier.BBG in output_types:
-                        inner[output_type] = output_value
+                        if SecurityIdentifier.BBG.value not in inner:
+                            inner[SecurityIdentifier.BBG.value] = []
+                        inner[SecurityIdentifier.BBG.value].append(output_value)
                     if SecurityIdentifier.BBID in output_types:
-                        inner[SecurityIdentifier.BBID.value] = f"{output_value} {row.get('exchange', '??')}"
+                        exchange = row.get('exchange')
+                        if SecurityIdentifier.BBID.value not in inner:
+                            inner[SecurityIdentifier.BBID.value] = []
+                        if exchange is not None:
+                            inner[SecurityIdentifier.BBID.value].append(f"{output_value} {exchange}")
+                        else:
+                            inner[SecurityIdentifier.BBID.value].append(f"{output_value}")
                     if SecurityIdentifier.BCID in output_types:
-                        inner[SecurityIdentifier.BCID.value] = f"{output_value} {row.get('compositeExchange', '??')}"
+                        composite_exchange = row.get('compositeExchange')
+                        if composite_exchange is not None:
+                            if SecurityIdentifier.BCID.value not in inner:
+                                inner[SecurityIdentifier.BCID.value] = []
+                            inner[SecurityIdentifier.BCID.value].append(f"{output_value} {composite_exchange}")
                 else:
                     if SecurityIdentifier(output_type) in output_types:
-                        inner[output_type] = output_value
+                        if output_type not in inner:
+                            inner[output_type] = []
+                        if output_value not in inner[output_type]:
+                            inner[output_type].append(output_value)
 
                 current += date_delta
 

gs_quant/test/markets/test_pricing_context.py

@@ -17,15 +17,29 @@
 
 import pytest
 from gs_quant import risk
+from gs_quant.common import PayReceive, Currency
 from gs_quant.datetime import business_day_offset
 from gs_quant.instrument import IRSwap
 from gs_quant.markets import PricingContext, CloseMarket, OverlayMarket, MarketDataCoordinate
 from gs_quant.risk import RollFwd
+from gs_quant.target.common import PricingLocation
 from gs_quant.test.utils.test_utils import MockCalc
 
+WEEKEND_DATE = dt.date(2022, 3, 19)
+
+
+@pytest.fixture
+def today_is_saturday(monkeypatch):
+    class MockedDatetime:
+        @classmethod
+        def today(cls):
+            return WEEKEND_DATE
+
+    monkeypatch.setattr(dt, 'date', MockedDatetime)
+
 
 def test_pricing_context(mocker):
-    swap1 = IRSwap('Pay', '1y', 'EUR', name='EUR1y')
+    swap1 = IRSwap(PayReceive.Pay, '1y', Currency.EUR, name='EUR1y')
     future_date = business_day_offset(dt.date.today(), 10, roll='forward')
     with MockCalc(mocker):
         with RollFwd(date='10b', realise_fwd=True):
@@ -47,14 +61,22 @@ def test_pricing_context(mocker):
 
 def test_pricing_dates():
     # May be on weekend but doesn't matter for basic test
-    future_date = dt.date.today() + dt.timedelta(2)
+    future_date = dt.date.today() + dt.timedelta(10)
     yesterday = dt.date.today() - dt.timedelta(1)
     pc = PricingContext(pricing_date=future_date, market=CloseMarket(yesterday))
     assert pc is not None
     with pytest.raises(ValueError, match="pricing_date in the future"):
         PricingContext(pricing_date=future_date)
 
 
+def test_weekend_dates(today_is_saturday):
+    assert dt.date.today() == WEEKEND_DATE  # Check mock worked
+    next_monday = WEEKEND_DATE + dt.timedelta(2)
+    prev_friday = WEEKEND_DATE - dt.timedelta(1)
+    pc = PricingContext(pricing_date=next_monday)
+    assert pc.market == CloseMarket(prev_friday, PricingLocation.LDN)
+
+
 def test_market_data_object():
     coord_val_pair = [
         {'coordinate': {