Chore: Make release 1.4.45

Author: martinroberson

gs_quant/api/gs/risk.py

@@ -24,11 +24,14 @@
 import time
 from socket import gaierror
 from typing import Iterable, Optional, Union
+import re
+
 
 import msgpack
 from websockets import ConnectionClosed
 
 from gs_quant.api.risk import RiskApi
+from gs_quant.errors import MqValueError
 from gs_quant.risk import RiskRequest
 from gs_quant.target.risk import OptimizationRequest
 from gs_quant.tracing import Tracer, TracingSpan
@@ -333,3 +336,82 @@ def get_pretrade_execution_optimization(cls, optimization_id: str, max_attempts:
         else:
             _logger.info('Optimization is fetched in {:.3f}s.'.format(time.perf_counter() - start))
             return results
+
+    @classmethod
+    def get_liquidity_and_factor_analysis(cls,
+                                          positions: list,
+                                          risk_model: str,
+                                          date: dt.date,
+                                          currency: str = 'USD',
+                                          participation_rate: float = 0.1,
+                                          measures: Optional[list] = None,
+                                          notional: Optional[float] = None,
+                                          time_series_benchmark_ids: Optional[list] = None):
+        """
+        Get liquidity and factor analysis for a portfolio using the /risk/liquidity endpoint.
+
+        :param positions: List of positions with assetId and quantity/weight
+        :param risk_model: Risk model identifier (e.g., 'BARRA_EFM_USALTL', 'AXIOMA_AXUS4S')
+        :param date: Analysis date
+        :param currency: Currency for analysis (default: USD)
+        :param participation_rate: Market participation rate (default: 0.1 = 10%)
+        :param measures: List of measures to include (default: all available measures)
+        :param notional: Optional reference notional
+        :param time_series_benchmark_ids: Optional benchmark IDs for time series comparison
+        :return: Dictionary with liquidity and factor analysis results
+        """
+        if measures is None:
+            measures = [
+                "Time Series Data",
+                "Risk Buckets",
+                "Factor Risk Buckets",
+                "Factor Exposure Buckets",
+                "Exposure Buckets"
+            ]
+
+        payload = {
+            "currency": currency,
+            "date": date.isoformat() if isinstance(date, dt.date) else date,
+            "positions": positions,
+            "participationRate": participation_rate,
+            "riskModel": risk_model,
+            "timeSeriesBenchmarkIds": time_series_benchmark_ids or [],
+            "measures": measures
+        }
+
+        if notional is not None:
+            payload["notional"] = notional
+
+        try:
+            response = cls.get_session()._post('/risk/liquidity', payload)
+
+            if isinstance(response, dict) and 'errorMessage' in response:
+                error_msg = response['errorMessage']
+
+                asset_ids_pattern = (r'Assets with the following ids are missing in marquee:'
+                                     r'\s*\[\s*([^\]]+)\s*\]')
+                asset_ids_match = re.search(asset_ids_pattern, error_msg, re.IGNORECASE)
+                if asset_ids_match:
+                    clean_error_pattern = (r'(Assets with the following ids are missing in '
+                                           r'marquee:\s*\[[^\]]+\])')
+                    clean_error_line = re.search(clean_error_pattern, error_msg, re.IGNORECASE)
+                    if clean_error_line:
+                        clean_message = (f"ERROR: liquidity analysis failed\n"
+                                         f"{clean_error_line.group(1)}")
+                        _logger.error(clean_message)
+                        raise MqValueError(clean_message)
+                    else:
+                        missing_assets = asset_ids_match.group(1).strip()
+                        clean_message = (f"ERROR: liquidity analysis failed\n"
+                                         f"Assets with the following ids are missing in marquee: "
+                                         f"[ {missing_assets} ]")
+                        _logger.error(clean_message)
+                        raise MqValueError(clean_message)
+                else:
+                    _logger.error(f'Liquidity analysis failed: {error_msg}')
+                    raise MqValueError("ERROR: liquidity analysis failed")
+
+            _logger.info('Liquidity analysis completed successfully')
+            return response
+        except Exception:
+            raise

gs_quant/backtests/strategy_systematic.py

@@ -70,7 +70,7 @@ def __init__(self,
                  cash_accrual: bool = True,
                  combine_roll_signal_entries: bool = False,
                  transaction_cost_config: TransactionCostConfig = None,
-                 use_xasset_backtesting_service: bool = False):
+                 use_xasset_backtesting_service: bool = True):
         self.__cost_netting = cost_netting
         self.__currency = get_enum_value(Currency, currency)
         self.__name = name

gs_quant/datetime/relative_date.py

@@ -132,14 +132,14 @@ def __handle_rule(self,
                       exchanges: List[Union[ExchangeCode, str]] = None,
                       holiday_calendar: List[dt.date] = None,
                       **kwargs) -> dt.date:
-        roll = None
+        sign = "+"
         if rule.startswith('-'):
             index = 1
             while index != len(rule) and rule[index].isdigit():
                 index += 1
             number = int(rule[1:index]) * -1 if index < len(rule) else 0
             rule_str = rule[index]
-            roll = "preceding"
+            sign = "-"
         else:
             index = 0
             if not rule[0].isdigit():
@@ -158,6 +158,8 @@ def __handle_rule(self,
         if not rule_str:
             raise MqValueError(f'Invalid rule "{rule}"')
 
+        roll = kwargs.get('roll_convention')
+
         try:
             rule_class = getattr(rules, f'{rule_str}Rule')
             return rule_class(result,
@@ -168,7 +170,8 @@ def __handle_rule(self,
                               exchanges=exchanges,
                               holiday_calendar=holiday_calendar,
                               usd_calendar=kwargs.get('usd_calendar'),
-                              roll=roll).handle()
+                              roll=roll,
+                              sign=sign).handle()
         except AttributeError:
             raise NotImplementedError(f'Rule {rule} not implemented')
 

gs_quant/datetime/rules.py

@@ -18,7 +18,7 @@
 import calendar
 import logging
 from abc import ABC, abstractmethod
-from typing import List, Union
+from typing import List, Union, Optional
 
 from dateutil.relativedelta import relativedelta, FR, SA, SU, TH, TU, WE, MO
 import numpy as np
@@ -38,6 +38,7 @@ class RDateRule(ABC):
     currencies: List[Union[Currency, str]] = None
     exchanges: List[Union[ExchangeCode, str]] = None
     holiday_calendar: List[dt.date] = None
+    sign: Optional[str] = None
 
     def __init__(self, result: dt.date, **params):
         self.result = result
@@ -47,6 +48,8 @@ def __init__(self, result: dt.date, **params):
         self.exchanges = params.get('exchanges')
         self.holiday_calendar = params.get('holiday_calendar')
         self.usd_calendar = params.get('usd_calendar')
+        self.roll = params.get('roll')
+        self.sign = params.get('sign')
         super().__init__()
 
     @abstractmethod
@@ -98,6 +101,9 @@ def add_years(self, holidays: List[dt.date]):
     def is_weekend(d: dt.date):
         return False if d.weekday() < 5 else True  # 5 Sat, 6 Sun
 
+    def roll_convention(self, default=None):
+        return self.roll or default
+
 
 class ARule(RDateRule):
     def handle(self) -> dt.date:
@@ -108,7 +114,7 @@ def handle(self) -> dt.date:
 class bRule(RDateRule):
     def handle(self) -> dt.date:
         holidays = self._get_holidays()
-        roll = 'forward' if self.number <= 0 else 'preceding'
+        roll = self.roll_convention('forward' if self.number <= 0 else 'preceding')
         return self._apply_business_days_logic(holidays, offset=self.number, roll=roll)
 
 
@@ -132,7 +138,7 @@ class gRule(RDateRule):
     def handle(self) -> dt.date:
         self.result = self.result + relativedelta(weeks=self.number)
         holidays = self._get_holidays()
-        return self._apply_business_days_logic(holidays, offset=0)
+        return self._apply_business_days_logic(holidays, offset=0, roll=self.roll_convention('backward'))
 
 
 class NRule(RDateRule):
@@ -161,13 +167,13 @@ def handle(self) -> dt.date:
         while self.week_mask[self.result.isoweekday() - 1] == '0':
             self.result += relativedelta(days=1)
         holidays = self._get_holidays()
-        return self._apply_business_days_logic(holidays, offset=0)
+        return self._apply_business_days_logic(holidays, offset=0, roll=self.roll_convention('backward'))
 
 
 class mRule(RDateRule):
     def handle(self) -> dt.date:
         self.result = self.result + relativedelta(months=self.number)
-        return self._apply_business_days_logic(self._get_holidays(), offset=0, roll='forward')
+        return self._apply_business_days_logic(self._get_holidays(), offset=0, roll=self.roll_convention('forward'))
 
 
 class MRule(RDateRule):
@@ -201,16 +207,9 @@ def handle(self) -> dt.date:
 
 
 class uRule(RDateRule):
-    def __init__(self, result: dt.date, **params):
-        super().__init__(result, **params)
-        self.roll = params.get('roll')
-
     def handle(self) -> dt.date:
         holidays = self._get_holidays()
-        if self.number == 0 and self.roll:
-            roll = self.roll
-        else:
-            roll = 'forward' if self.number <= 0 else 'preceding'
+        roll = 'preceding' if self.sign == "-" and self.number == 0 else 'forward' if self.number <= 0 else 'preceding'
         return self._apply_business_days_logic(holidays, offset=self.number, roll=roll)
 
 
@@ -225,7 +224,7 @@ def handle(self) -> dt.date:
         month_range = calendar.monthrange(self.result.year, self.result.month)
         self.result = self.result.replace(day=month_range[1])
         holidays = self._get_holidays()
-        return self._apply_business_days_logic(holidays, offset=0, roll='backward')
+        return self._apply_business_days_logic(holidays, offset=0, roll=self.roll_convention('backward'))
 
 
 class VRule(RDateRule):
@@ -242,15 +241,16 @@ class wRule(RDateRule):
     def handle(self) -> dt.date:
         self.result = self.result + relativedelta(weeks=self.number)
         holidays = self._get_holidays()
-        return self._apply_business_days_logic(holidays, offset=0)
+        roll = 'forward' if self.number >= 0 else 'backward'
+        return self._apply_business_days_logic(holidays, offset=0, roll=self.roll_convention(roll))
 
 
 class xRule(RDateRule):
     def handle(self) -> dt.date:
         month_range = calendar.monthrange(self.result.year, self.result.month)
         self.result = self.result.replace(day=month_range[1])
         holidays = self._get_holidays()
-        return self._apply_business_days_logic(holidays, offset=0, roll='backward')
+        return self._apply_business_days_logic(holidays, offset=0, roll=self.roll_convention('backward'))
 
 
 class XRule(RDateRule):
@@ -264,7 +264,7 @@ def handle(self) -> dt.date:
         while self.week_mask[self.result.isoweekday() - 1] == '0':
             self.result += relativedelta(days=1)
         holidays = self._get_holidays()
-        return self._apply_business_days_logic(holidays, offset=0)
+        return self._apply_business_days_logic(holidays, offset=0, roll=self.roll_convention('backward'))
 
 
 class ZRule(RDateRule):