mainsequence 2.0.0__py3-none-any.whl

mainsequence/virtualfundbuilder/contrib/data_nodes/market_cap.py

@@ -0,0 +1,310 @@
+from mainsequence.tdag.data_nodes import DataNode, APIDataNode, WrapperDataNode
+from mainsequence.client import CONSTANTS, Asset, AssetTranslationTable, AssetTranslationRule, AssetFilter, DoesNotExist
+
+from datetime import datetime, timedelta, tzinfo
+from typing import Optional, List, Union, Dict
+
+import pandas as pd
+import pytz
+
+from mainsequence.tdag.data_nodes import DataNode
+from mainsequence.client import CONSTANTS, Asset, AssetCategory
+
+from mainsequence.virtualfundbuilder.models import VFBConfigBaseModel
+from mainsequence.virtualfundbuilder.resource_factory.signal_factory import WeightsBase, register_signal_class
+from mainsequence.virtualfundbuilder.utils import TIMEDELTA
+import numpy as np
+from pydantic import BaseModel
+
+class SymbolWeight(VFBConfigBaseModel):
+    execution_venue_symbol: str = CONSTANTS.ALPACA_EV_SYMBOL
+    symbol: str
+    weight: float
+
+@register_signal_class(register_in_agent=True)
+class FixedWeights(WeightsBase, DataNode):
+
+    def __init__(self, asset_symbol_weights: List[SymbolWeight], *args, **kwargs):
+        """
+        Args:
+            asset_symbol_weights (List[SymbolWeight]): List of SymbolWeights that map asset symbols to weights
+        """
+        super().__init__(*args, **kwargs)
+        self.asset_symbol_weights = asset_symbol_weights
+
+    def maximum_forward_fill(self):
+        return timedelta(days=200 * 365)  # Always forward-fill to avoid filling the DB
+
+    def get_explanation(self):
+        max_rows = 10
+        symbols = [w.symbol for w in self.asset_symbol_weights]
+        weights = [w.weight for w in self.asset_symbol_weights]
+        info = f"<p>{self.__class__.__name__}: Signal uses fixed weights with the following weights:</p><div style='display: flex;'>"
+
+        for i in range(0, len(symbols), max_rows):
+            info += "<table border='1' style='border-collapse: collapse; margin-right: 20px;'><tr>"
+            info += ''.join(f"<th>{sym}</th>" for sym in symbols[i:i + max_rows])
+            info += "</tr><tr>"
+            info += ''.join(f"<td>{wgt}</td>" for wgt in weights[i:i + max_rows])
+            info += "</tr></table>"
+
+        info += "</div>"
+        return info
+
+    def update(self, latest_value: Union[datetime, None], *args, **kwargs) -> pd.DataFrame:
+        if latest_value is not None:
+            return pd.DataFrame()  # No need to store more than one constant weight
+        latest_value = latest_value or datetime(1985, 1, 1).replace(tzinfo=pytz.utc)
+
+        df = pd.DataFrame([m.model_dump() for m in self.asset_symbol_weights]).rename(columns={'symbol': 'asset_symbol',
+                                                                                               'weight': 'signal_weight'})
+        df = df.set_index(['asset_symbol', 'execution_venue_symbol'])
+
+        signals_weights = pd.concat(
+            [df],
+            axis=0,
+            keys=[latest_value]
+        ).rename_axis(["time_index", "asset_symbol", "execution_venue_symbol"])
+
+        signals_weights = signals_weights.dropna()
+        return signals_weights
+
+
+class AssetMistMatch(Exception):
+    ...
+
+class VolatilityControlConfiguration(BaseModel):
+    target_volatility: float = 0.1
+    ewm_span: int = 21
+    ann_factor: int = 252
+
+
+@register_signal_class(register_in_agent=True)
+class MarketCap(WeightsBase, DataNode):
+    def __init__(self,
+                 volatility_control_configuration: Optional[VolatilityControlConfiguration],
+                 minimum_atvr_ratio: float = .1,
+                 rolling_atvr_volume_windows: List[int] = [60, 360],
+                 frequency_trading_percent: float = .9,
+                 source_frequency: str = "1d",
+                 min_number_of_assets: int = 3,
+                 num_top_assets: Optional[int] = None, *args, **kwargs):
+        """
+        Signal Weights using weighting by Market Capitalization or Equal Weights
+
+        Args:
+            source_frequency (str): Frequency of market cap source.
+            num_top_assets (Optional[int]): Number of largest assets by market cap to use for signals. Leave empty to include all assets.
+        """
+        super().__init__(*args, **kwargs)
+        self.source_frequency = source_frequency
+        self.num_top_assets = num_top_assets or 50000
+        self.minimum_atvr_ratio = minimum_atvr_ratio
+        self.rolling_atvr_volume_windows = rolling_atvr_volume_windows
+        self.frequency_trading_percent = frequency_trading_percent
+        self.min_number_of_assets = min_number_of_assets
+
+        translation_table = "marketcap_translation_table"
+        try:
+            # 1) fetch from server
+            translation_table = AssetTranslationTable.get(unique_identifier=translation_table)
+        except DoesNotExist:
+            self.logger.error(f"Translation table {translation_table} does not exist")
+
+        self.historical_market_cap_ts = WrapperDataNode(translation_table=translation_table)
+        self.volatility_control_configuration = volatility_control_configuration
+
+    def maximum_forward_fill(self):
+        return timedelta(days=1) - TIMEDELTA
+
+    def dependencies(self) -> Dict[str, Union["DataNode", "APIDataNode"]]:
+        return {"historical_market_cap_ts": self.historical_market_cap_ts}
+
+    def get_explanation(self):
+        # Convert the asset universe filter (assumed to be stored in self.asset_universe.asset_filter)
+        # to a formatted JSON string for display.
+        import json
+        windows_str = ", ".join(str(window) for window in self.rolling_atvr_volume_windows)
+        if self.volatility_control_configuration is not None:
+            volatility_details = self.volatility_control_configuration
+            vol_message = f"The strategy uses the following volatility target configuration:\n{volatility_details}\n"
+        else:
+            vol_message = "The strategy does not use volatility control.\n"
+
+        explanation = (
+            "### 1. Dynamic Asset Universe Selection\n\n"
+            f"This strategy dynamically selects assets using a predefined category {self.assets_configuration.assets_category_unique_id} :\n\n"
+
+            "### 2. Market Capitalization Filtering\n\n"
+            f"The strategy retrieves historical market capitalization data and restricts the universe to the top **{self.num_top_assets}** assets. "
+            "This ensures that only the largest and most influential market participants are considered.\n\n"
+
+            "### 3. Liquidity Filtering via Annualized Traded Value Ratio (ATVR)\n\n"
+            f"Liquidity is assessed using the Annualized Traded Value Ratio (ATVR), which compares an asset's annualized median trading volume to its market capitalization. "
+            f"To obtain a robust measure of liquidity, ATVR is computed over multiple rolling windows: **[{windows_str}]** days. "
+            f"An asset must achieve an ATVR of at least **{self.minimum_atvr_ratio:.2f}** in each of these windows to be considered liquid enough.\n\n"
+
+            "### 4. Trading Frequency Filter\n\n"
+            f"In addition, the strategy applies a trading frequency filter over the longest period defined by the rolling windows. "
+            f"Only assets with trading activity on at least **{self.frequency_trading_percent:.2f}** of the days (i.e., {self.frequency_trading_percent * 100:.1f}%) in the longest window are retained.\n\n"
+
+            "### 5. Portfolio Weight Construction\n\n"
+            "After filtering based on market capitalization, liquidity, and trading frequency, the market capitalizations of the remaining assets are normalized on a daily basis. "
+            "This normalization converts raw market values into portfolio weights, which serve as the signal for trading decisions.\n\n"
+
+            "### 6. Data Source Frequency\n\n"
+            f"The strategy uses market data that is updated at a **'{self.source_frequency}'** frequency. This ensures that the signals are generated using the most recent market conditions.\n\n"
+
+            "### 7. Volatility Target\n\n"
+            f"{vol_message}\n\n"
+            "**Summary:**\n"
+            f"This strategy dynamically selects assets using a specific filter, focuses on the top {self.num_top_assets} assets by market capitalization, and evaluates liquidity using ATVR computed over multiple rolling windows ({self.rolling_atvr_volume_windows}). "
+            f"Assets must achieve a minimum ATVR of {self.minimum_atvr_ratio:.2f} in each window and meet a trading frequency requirement of at least {self.frequency_trading_percent * 100:.1f}%. "
+            f"Finally, the market capitalizations of the filtered assets are normalized into portfolio weights, with market data refreshed at a '{self.source_frequency}' frequency."
+        )
+
+        return explanation
+
+    def get_asset_list(self) -> Union[None, list]:
+        asset_category = AssetCategory.get(unique_identifier=self.assets_configuration.assets_category_unique_id)
+
+        asset_list = Asset.filter(id__in=asset_category.assets)
+        return asset_list
+
+    def update(self):
+        """
+        Args:
+            latest_value (Union[datetime, None]): The timestamp of the most recent data point.
+
+        Returns:
+            DataFrame: A DataFrame containing updated signal weights, indexed by time and asset symbol.
+        """
+        asset_list = self.update_statistics.asset_list
+        if len(asset_list) < self.min_number_of_assets:
+            raise AssetMistMatch(f"only {len(asset_list)} in asset_list minum are {self.min_number_of_assets} ")
+
+        unique_identifier_range_market_cap_map = {
+            a.unique_identifier: {
+                "start_date": self.update_statistics[a.unique_identifier],
+                "start_date_operand": ">"
+            }
+            for a in asset_list
+        }
+        # Start Loop on unique identifier
+
+        ms_asset_list = Asset.filter_with_asset_class(exchange_code=None,
+                                                      asset_ticker_group_id__in=[
+                                                          a.asset_ticker_group_id
+                                                          for a in
+                                                          self.update_statistics.asset_list
+                                                      ])
+
+        ms_asset_list = {a.asset_ticker_group_id:a for a in ms_asset_list}
+        asset_list_to_share_class = {a.asset_ticker_group_id:a for a in self.update_statistics.asset_list}
+
+        market_cap_uid_range_map = {
+            ms_asset.get_spot_reference_asset_unique_identifier(): unique_identifier_range_market_cap_map[asset_list_to_share_class[ms_share_class].unique_identifier]
+            for ms_share_class, ms_asset in ms_asset_list.items()
+        }
+
+        market_cap_uid_to_asset_uid = {
+            ms_asset.get_spot_reference_asset_unique_identifier(): asset_list_to_share_class[ms_share_class].unique_identifier
+            for ms_share_class, ms_asset in ms_asset_list.items()
+        }
+
+        mc = self.historical_market_cap_ts.get_df_between_dates(
+            unique_identifier_range_map=market_cap_uid_range_map,
+            great_or_equal=False,
+        )
+        mc = mc[~mc.index.duplicated(keep='first')]
+
+        if mc.shape[0] == 0:
+            self.logger.info("No data in Market Cap historical market cap")
+            return pd.DataFrame()
+
+        mc = mc.reset_index("unique_identifier")
+        mc["unique_identifier"] = mc["unique_identifier"].map(market_cap_uid_to_asset_uid)
+        mc = mc.set_index("unique_identifier", append=True)
+        # ends loop on unique identifier
+        unique_in_mc = mc.index.get_level_values("unique_identifier").unique().shape[0]
+
+        if unique_in_mc != len(asset_list):
+            self.logger.warning("Market Cap and asset_list does not match missing assets will be set to 0")
+
+        # If there is no market cap data, return an empty DataFrame.
+        if mc.shape[0] == 0:
+            return pd.DataFrame()
+
+        # 3. Pivot the market cap data to get a DataFrame with a datetime index and one column per asset.
+        mc_raw = mc.pivot_table(columns="unique_identifier", index="time_index")
+        mc_raw = mc_raw.ffill().bfill()
+
+        # 4. Using the prices dataframe, compute a rolling statistic on volume.
+        # We assume the "volume" column represents the traded volume.
+        # First, pivot prices so that rows are dates and columns are assets.
+        dollar_volume_df = mc_raw["volume"] * mc_raw["price"]
+
+        # 5. Compute the rolling ATVR for each window specified in self.rolling_atv_volume_windows.
+        #    For each window, compute the median traded volume, annualize it and divide by market cap.
+        atvr_dict = {}
+        for window in self.rolling_atvr_volume_windows:
+            # Compute the rolling median of volume over the window.
+            rolling_median = dollar_volume_df.rolling(window=window, min_periods=1).median()
+
+            # Annualize: assume 252 trading days per year.
+            annual_factor = 252 # todo fix when prices are not daily
+            annualized_traded_value = rolling_median * annual_factor
+            # Align with market cap dates.
+            annualized_traded_value = annualized_traded_value.reindex(mc_raw.index).ffill().bfill()
+            # Compute the ATVR.
+            atvr_dict[window] = annualized_traded_value.div(mc_raw["market_cap"])
+
+        # 6. Create a liquidity mask that requires the ATVR to be above the minimum threshold
+        #    for every rolling window.
+        atvr_masks = [atvr_dict[window] >= self.minimum_atvr_ratio for window in self.rolling_atvr_volume_windows]
+        # Combine the masks elementwise and re-wrap the result as a DataFrame with the same index/columns as mc_raw.
+        combined_atvr_mask = pd.DataFrame(
+            np.logical_and.reduce([mask.values for mask in atvr_masks]),
+            index=mc_raw.index,
+            columns=mc_raw.volume.columns
+        )
+
+        # 7. Compute the trading frequency mask.
+        #    For frequency we assume that an asset "traded" on a day if its volume is > 0.
+        #    We use the longest rolling window (e.g. 360 days) for the frequency computation.
+        freq_window = max(self.rolling_atvr_volume_windows)
+        trading_flag = dollar_volume_df.fillna(0) > 0
+        trading_frequency = trading_flag.rolling(window=freq_window, min_periods=1).mean()
+
+        frequency_mask = trading_frequency >= self.frequency_trading_percent
+
+        # 8. Combine the ATVR and frequency masks.
+        liquidity_mask = combined_atvr_mask & frequency_mask
+
+        # 9. (Optional) Select the top assets by market cap.
+        #    For each date, rank assets by market cap and flag those outside the top 'self.num_top_assets'.
+        assets_excluded = mc_raw["market_cap"].rank(axis=1, ascending=False) > self.num_top_assets
+
+        # 10. Apply both the market cap ranking filter and the liquidity filter.
+        filtered_mc = mc_raw["market_cap"].copy()
+        filtered_mc[assets_excluded] = 0  # Exclude assets not in the top by market cap.
+        filtered_mc[~liquidity_mask] = 0  # Exclude assets that do not meet the liquidity criteria.
+
+        # 11. Compute the final weights by normalizing the surviving market caps.
+        weights = filtered_mc.div(filtered_mc.sum(axis=1), axis=0)
+        weights = weights.fillna(0)
+
+        if self.volatility_control_configuration is not None:
+            log_returns = (np.log(mc_raw["price"])).diff()
+
+            ewm_vol = (log_returns * weights).sum(axis=1).ewm(span=self.volatility_control_configuration.ewm_span,
+                                                              adjust=False).std() * np.sqrt(self.volatility_control_configuration.ann_factor)
+
+            scaling_factor = self.volatility_control_configuration.target_volatility / ewm_vol
+            scaling_factor = scaling_factor.clip(upper=1.0)
+            weights = weights.mul(scaling_factor, axis=0)
+
+        # 12. Reshape the weights to a long-form DataFrame if desired.
+        signal_weights = weights.stack().rename("signal_weight").to_frame()
+
+        return signal_weights

mainsequence/virtualfundbuilder/contrib/data_nodes/mock_signal.py

@@ -0,0 +1,78 @@
+from mainsequence.tdag.data_nodes import DataNode
+from datetime import datetime
+import pytz
+import pandas as pd
+from typing import Union
+from mainsequence.virtualfundbuilder.resource_factory.signal_factory import WeightsBase,  register_signal_class
+
+@register_signal_class(register_in_agent=True)
+class MockSignal(WeightsBase, DataNode):
+    """
+    Mock Signal to test strategies. Creates a signal with long/short of ETH and BTC in frequency.
+    """
+    def __init__(self, source_frequency: str = "30min", *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        asset_mapping = {}
+        for tmp_asset_universe in self.asset_universe:
+            execution_venue = tmp_asset_universe.execution_venue_symbol
+            asset_list = tmp_asset_universe.asset_list
+            ev = execution_venue.value
+            asset_mapping[ev] = {
+                a.get_spot_reference_asset_symbol(): a.unique_identifier for a in asset_list
+            }
+            self.asset_1 = asset_list[0]
+            self.asset_2 = asset_list[1]
+        self.asset_mapping = asset_mapping
+        self.source_frequency = source_frequency
+
+    def get_explanation(self):
+        return f"The signal will switch between {self.asset_1.symbol} and {self.asset_2.symbol} randomly every 30 minutes"
+
+    def maximum_forward_fill(self):
+        return self.source_frequency
+
+    def update(self, latest_value: Union[datetime, None], *args, **kwargs) -> pd.DataFrame:
+        """
+        Args:
+            latest_value (Union[datetime, None]): The timestamp of the most recent data point.
+
+        Returns:
+            DataFrame: A DataFrame containing updated signal weights, indexed by time and asset symbol.
+        """
+        if latest_value is None:
+            latest_value = datetime(year=2017, month=1, day=1).replace(tzinfo=pytz.utc)
+
+        current_time = datetime.now(pytz.utc)
+        if (current_time - latest_value) < pd.Timedelta(self.source_frequency):
+            return pd.DataFrame()
+
+        signal_index = pd.date_range(
+            start=latest_value + pd.Timedelta(self.source_frequency), 
+            end=current_time,
+            freq=self.source_frequency
+        )
+        signal_weights = []
+        for ev, asset_map in self.asset_mapping.items():
+            tmp_signal = pd.DataFrame(index=signal_index, columns=self.asset_mapping[ev].values())
+            tmp_signal = pd.concat([tmp_signal], axis=1, keys=[ev])
+            signal_weights.append(tmp_signal)
+        signal_weights = pd.concat(signal_weights, axis=1)
+
+        last_observation = self.get_last_observation()
+        if last_observation is not None:
+            asset_1_weight = -last_observation.query(f"asset_symbol == '{self.asset_1.symbol}'")["signal_weight"].iloc[0]
+        else:
+            asset_1_weight = 1.0
+
+        signal_weights.loc[:, (self.asset_1.execution_venue.symbol, self.asset_1.symbol)] = [
+            asset_1_weight if i % 2 == 0 else -asset_1_weight for i in range(len(signal_weights))
+        ]
+        signal_weights.loc[:, (self.asset_2.execution_venue.symbol, self.asset_2.symbol)] = -signal_weights.loc[
+            :, (self.asset_1.execution_venue.symbol, self.asset_1.symbol)
+        ]
+
+        signal_weights = signal_weights.stack().stack().to_frame(name='signal_weight').astype(float)
+        signal_weights.index.set_names(["time_index", "asset_symbol", "execution_venue_symbol"], inplace=True)
+
+        return signal_weights

mainsequence/virtualfundbuilder/contrib/data_nodes/portfolio_replicator.py

@@ -0,0 +1,269 @@
+import copy
+from datetime import datetime
+from typing import Union, Dict
+from enum import Enum
+
+import numpy as np
+import pandas as pd
+import pytz
+from sklearn.linear_model import ElasticNet, Lasso, LinearRegression
+from tqdm import tqdm
+
+from mainsequence.client import AssetCategory, Asset, MARKETS_CONSTANTS
+from mainsequence.virtualfundbuilder import TIMEDELTA
+from mainsequence.virtualfundbuilder.contrib.prices.data_nodes import get_interpolated_prices_timeseries
+from mainsequence.virtualfundbuilder.resource_factory.signal_factory import WeightsBase, register_signal_class
+from mainsequence.virtualfundbuilder.models import VFBConfigBaseModel
+from mainsequence.tdag.data_nodes import DataNode
+
+
+class TrackingStrategy(Enum):
+    ELASTIC_NET = "elastic_net"
+    LASSO = "lasso"
+
+class TrackingStrategyConfiguration(VFBConfigBaseModel):
+    configuration: Dict = {"alpha": 0, "l1_ratio": 0}
+
+def rolling_pca_betas(X, window, n_components=5, *args, **kwargs):
+    """
+    Perform rolling PCA and return the betas (normalized principal component weights).
+
+    Parameters:
+        X (pd.DataFrame): DataFrame of stock returns or feature data (rows are time, columns are assets).
+        window (int): The size of the rolling window.
+        n_components (int, optional): The number of principal components to extract. Defaults to 5.
+
+    Returns:
+        np.ndarray: An array of normalized PCA weights for each rolling window.
+    """
+    from sklearn.decomposition import PCA
+
+    betas = []
+
+    # Loop over each rolling window
+    for i in tqdm(range(window, len(X)), desc="Performing rolling PCA"):
+        X_window = X.iloc[i - window:i]
+
+        # Perform PCA on the windowed data
+        pca = PCA(n_components=n_components)
+        try:
+            pca.fit(X_window)
+        except Exception as e:
+            raise e
+
+        # Get the eigenvectors (principal components)
+        eigenvectors = pca.components_  # Shape: (n_components, n_assets)
+
+        # Transpose to align weights with assets
+        eigenvectors_transposed = eigenvectors.T  # Shape: (n_assets, n_components)
+
+        # Normalize the eigenvectors so that sum of absolute values = 1 for each component
+        weights_normalized = eigenvectors_transposed / np.sum(np.abs(eigenvectors_transposed), axis=0)
+
+        # Append the normalized weights (betas) for this window
+        betas.append(weights_normalized)
+
+    return np.array(betas)  # Shape: (num_windows, n_assets, n_components)
+
+
+def rolling_lasso_regression(y, X, window, alpha=1.0, *args, **kwargs):
+    """
+    Perform rolling Lasso regression and return the coefficients.
+
+    Parameters:
+        y (pd.Series): Target variable.
+        X (pd.DataFrame): Feature variables.
+        window (int): Size of the rolling window.
+        alpha (float, optional): Regularization strength. Defaults to 1.0.
+
+    Returns:
+        list: List of DataFrames containing the coefficients for each rolling window.
+    """
+    betas = []
+    if alpha == 0:
+        lasso = LinearRegression(fit_intercept=False, positive=True)
+    else:
+        lasso = Lasso(alpha=alpha, fit_intercept=False, positive=True)
+
+    for i in tqdm(range(window, len(y)), desc="Building Lasso regression"):
+        null_xs = X.isnull().sum()
+        null_xs = null_xs[null_xs > 0]
+        symbols_to_zero = None
+        X_window = X.iloc[i - window:i]
+        if null_xs.shape[0] > 0:
+            symbols_to_zero = null_xs.index.to_list()
+            X_window = X_window[[c for c in X_window.columns if c not in symbols_to_zero]]
+        y_window = y.iloc[i - window:i]
+
+        # Fit the Lasso model
+        try:
+            lasso.fit(X_window, y_window)
+        except Exception as e:
+            raise e
+
+        round_betas = pd.DataFrame(
+            lasso.coef_.reshape(1, -1),
+            columns=X_window.columns,
+            index=[X_window.index[-1]],
+        )
+        if symbols_to_zero is not None:
+            round_betas.loc[:, symbols_to_zero] = 0.0
+        # Append the coefficients
+        betas.append(round_betas)
+    return betas
+
+
+def rolling_elastic_net(y, X, window, alpha=1.0, l1_ratio=0.5):
+    """
+    Perform rolling Elastic Net regression and return the coefficients.
+
+    Parameters:
+        y (pd.Series): Target variable.
+        X (pd.DataFrame): Feature variables.
+        window (int): Size of the rolling window.
+        alpha (float, optional): Regularization strength. Defaults to 1.0.
+        l1_ratio (float, optional): The ElasticNet mixing parameter. Defaults to 0.5.
+
+    Returns:
+        np.ndarray: Array of coefficients for each rolling window.
+    """
+    betas = []
+    enet = ElasticNet(alpha=alpha, l1_ratio=l1_ratio, fit_intercept=False)
+
+    for i in tqdm(range(window, len(y)), desc="Building rolling regression"):
+        X_window = X.iloc[i - window:i]
+        y_window = y.iloc[i - window:i]
+
+        # Fit the ElasticNet model
+        enet.fit(X_window, y_window)
+
+        # Save coefficients
+        betas.append(enet.coef_)
+
+    return np.array(betas)
+
+@register_signal_class(register_in_agent=True)
+class ETFReplicator(WeightsBase, DataNode):
+    def __init__(
+        self,
+        etf_ticker: str,
+        tracking_strategy_configuration: TrackingStrategyConfiguration,
+        in_window: int = 60,
+        tracking_strategy: TrackingStrategy = TrackingStrategy.LASSO,
+        *args,
+        **kwargs,
+    ):
+        """
+        Initialize the ETFReplicator.
+
+        Args:
+            etf_ticker (str): Figi of the etf to replicate.
+            tracking_strategy_configuration (TrackingStrategyConfiguration): Configuration parameters for the tracking strategy.
+            in_window (int, optional): The size of the rolling window for regression. Defaults to 60.
+            tracking_strategy (TrackingStrategy, optional): The regression strategy to use for tracking. Defaults to TrackingStrategy.LASSO.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        """
+        super().__init__(*args, **kwargs)
+
+        self.in_window = in_window
+        self.bars_ts = get_interpolated_prices_timeseries(copy.deepcopy(self.assets_configuration))
+        etf_assets_configuration = copy.deepcopy(self.assets_configuration)
+        etf_assets_configuration.assets_category_unique_id = "etfs"
+        self.etf_bars_ts = get_interpolated_prices_timeseries(etf_assets_configuration)
+        self.etf_ticker = etf_ticker
+
+        self.tracking_strategy = tracking_strategy
+        self.tracking_strategy_configuration = tracking_strategy_configuration
+
+    def get_asset_list(self) -> Union[None, list]:
+        asset_category = AssetCategory.get(unique_identifier=self.assets_configuration.assets_category_unique_id)
+        self.price_assets = Asset.filter(id__in=asset_category.assets)
+        self.etf_asset = Asset.get(
+            ticker=self.etf_ticker,
+            exchange_code="US",
+            security_type=MARKETS_CONSTANTS.FIGI_SECURITY_TYPE_ETP,
+            security_market_sector=MARKETS_CONSTANTS.FIGI_MARKET_SECTOR_EQUITY,
+        )
+        return self.price_assets + [self.etf_asset]
+
+    def dependencies(self) -> Dict[str, Union["DataNode", "APIDataNode"]]:
+        return {
+            "bars_ts": self.bars_ts,
+            "etf_bars_ts": self.etf_bars_ts,
+        }
+
+    def get_explanation(self):
+        info = f"""
+        <p>{self.__class__.__name__}: Signal aims to replicate {self.etf_asset.ticker} using a data-driven approach.
+        This strategy will use {self.tracking_strategy} as approximation function with parameters </p>
+        <code>{self.tracking_strategy_configuration}</code>
+        """
+        return info
+
+    def maximum_forward_fill(self):
+        freq = self.assets_configuration.prices_configuration.bar_frequency_id
+        return pd.Timedelta(freq) - TIMEDELTA
+
+    def get_tracking_weights(self, prices: pd.DataFrame) -> pd.DataFrame:
+        prices = prices[~prices[self.etf_asset.unique_identifier].isnull()]
+        prices = prices.pct_change().iloc[1:]
+        prices = prices.replace([np.inf, -np.inf], np.nan)
+
+        y = prices[self.etf_asset.unique_identifier]
+        X = prices.drop(columns=[self.etf_asset.unique_identifier])
+
+        if self.tracking_strategy == TrackingStrategy.ELASTIC_NET:
+            betas = rolling_elastic_net(
+                y, X, window=self.in_window, **self.tracking_strategy_configuration.configuration
+            )
+        elif self.tracking_strategy == TrackingStrategy.LASSO:
+            betas = rolling_lasso_regression(
+                y, X, window=self.in_window, **self.tracking_strategy_configuration.configuration
+            )
+        else:
+            raise NotImplementedError
+
+        try:
+            betas = pd.concat(betas, axis=0)
+        except Exception as e:
+            raise e
+        betas.index.name = "time_index"
+        return betas
+
+    def update(self) -> pd.DataFrame:
+        if self.update_statistics.max_time_index_value:
+            prices_start_date = self.update_statistics.max_time_index_value - pd.Timedelta(days=self.in_window)
+        else:
+            prices_start_date = self.OFFSET_START - pd.Timedelta(days=self.in_window)
+
+        prices = self.bars_ts.get_df_between_dates(
+            start_date=prices_start_date,
+            end_date=None,
+            great_or_equal=True,
+            less_or_equal=True,
+            unique_identifier_list=[a.unique_identifier for a in self.price_assets],
+        )
+        etf_prices = self.etf_bars_ts.get_df_between_dates(
+            start_date=prices_start_date,
+            end_date=None,
+            great_or_equal=True,
+            less_or_equal=True,
+            unique_identifier_list=[self.etf_asset.unique_identifier],
+        )
+
+        prices = pd.concat([prices, etf_prices])
+        prices = prices.reset_index().pivot_table(
+            index="time_index",
+            columns="unique_identifier",
+            values=self.assets_configuration.price_type.value,
+        )
+
+        if prices.shape[0] < self.in_window:
+            self.logger.warning("Not enough prices to run regression")
+            return pd.DataFrame()
+
+        weights = self.get_tracking_weights(prices=prices)
+        weights = weights.unstack().to_frame(name="signal_weight")
+        weights = weights.swaplevel()
+        return weights

mainsequence/virtualfundbuilder/contrib/prices/__init__.py

@@ -0,0 +1 @@
+from .data_nodes import get_interpolated_prices_timeseries