skfolio 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

skfolio/pre_selection/_select_k_extremes.py

@@ -0,0 +1,100 @@
+"""Pre-selection SelectKExtremes module"""
+
+# Copyright (c) 2023
+# Author: Hugo Delatte <delatte.hugo@gmail.com>
+# License: BSD 3 clause
+
+import numpy as np
+import numpy.typing as npt
+import sklearn.base as skb
+import sklearn.feature_selection as skf
+import sklearn.utils.validation as skv
+
+import skfolio.typing as skt
+from skfolio.measures import RatioMeasure
+from skfolio.population import Population
+from skfolio.portfolio import Portfolio
+
+
+class SelectKExtremes(skf.SelectorMixin, skb.BaseEstimator):
+    """Transformer for selecting the `k` best or worst assets.
+
+    Keep the `k` best or worst assets according to a given measure.
+
+    Parameters
+    ----------
+    k : int, default=10
+        Number of assets to select. If `k` is higher than the number of assets, all
+        assets are selected.
+
+    measure : Measure, default=RatioMeasure.SHARPE_RATIO
+        The :ref:`measure <measures_ref>` used to sort the assets.
+        The default is `RatioMeasure.SHARPE_RATIO`.
+
+    highest : bool, default=True
+        If this is set to True, the `k` assets with the highest `measure` are selected,
+        otherwise it is the `k` lowest.
+
+    Attributes
+    ----------
+    to_keep_ : ndarray of shape (n_assets, )
+       Boolean array indicating which assets are remaining.
+
+    n_features_in_ : int
+       Number of assets seen during `fit`.
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+       Names of features seen during `fit`. Defined only when `X`
+       has feature names that are all strings.
+    """
+
+    to_keep_: np.ndarray
+
+    def __init__(
+        self,
+        k: int = 10,
+        measure: skt.Measure = RatioMeasure.SHARPE_RATIO,
+        highest: bool = True,
+    ):
+        self.k = k
+        self.measure = measure
+        self.highest = highest
+
+    def fit(self, X: npt.ArrayLike, y=None) -> "SelectKExtremes":
+        """Run the SelectKExtremes transformer and get the appropriate assets.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_observations, n_assets)
+            Price returns of the assets.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : SelectKExtremes
+            Fitted estimator.
+        """
+        X = self._validate_data(X)
+        k = int(self.k)
+        if k <= 0:
+            raise ValueError("`k` must be strictly positive")
+        n_assets = X.shape[1]
+        # Build a population of single assets portfolio
+        population = Population([])
+        for i in range(n_assets):
+            weights = np.zeros(n_assets)
+            weights[i] = 1
+            population.append(Portfolio(X=X, weights=weights))
+
+        selected = population.sort_measure(measure=self.measure, reverse=self.highest)[
+            :k
+        ]
+        selected_idx = [x.nonzero_assets_index[0] for x in selected]
+        self.to_keep_ = np.isin(np.arange(n_assets), selected_idx)
+        return self
+
+    def _get_support_mask(self):
+        skv.check_is_fitted(self)
+        return self.to_keep_

skfolio/pre_selection/_select_non_dominated.py

@@ -0,0 +1,161 @@
+"""Pre-selection SelectNonDominated module"""
+
+# Copyright (c) 2023
+# Author: Hugo Delatte <delatte.hugo@gmail.com>
+# License: BSD 3 clause
+
+import numpy as np
+import numpy.typing as npt
+import sklearn.base as skb
+import sklearn.feature_selection as skf
+import sklearn.utils.validation as skv
+
+import skfolio.typing as skt
+from skfolio.population import Population
+from skfolio.portfolio import Portfolio
+
+
+class SelectNonDominated(skf.SelectorMixin, skb.BaseEstimator):
+    """Transformer for selecting non dominated assets.
+
+    Pre-selection based on the Assets Preselection Process 2 [1]_.
+
+    Good single asset (for example with high return and low risk) is likely to
+    contribute to the final optimized portfolio. Each asset is considered as a portfolio
+    and these assets are ranked using the non-domination sorting method. The selection
+    is based on the ranks assigned to each asset based on their fitness until the number
+    of selected assets reaches the user-defined number.
+
+    Considering only the fitness of individual asset is insufficient because a pair of
+    negatively correlated assets has the potential to reduce the risk. Therefore,
+    negatively correlated pairs of assets are also considered.
+
+    Parameters
+    ----------
+    min_n_assets : int, optional
+        The minimum number of assets to select. If `min_n_assets` is reached before the
+        end of the current non-dominated front, we return the remaining assets of this
+        front. This is because all assets in the same front have same rank.
+        The default (`None`) is to select the first front.
+
+    threshold : float, default=0.0
+        Asset pair with a correlation below this threshold are included in the
+        non-domination sorting. The default value is `0.0`.
+
+    fitness_measures : list[Measure], optional
+        A list of :ref:`measure <measures_ref>` used to compute the portfolio fitness.
+        The fitness is used to compare portfolios in terms of domination, compute the
+        pareto fronts and run the portfolio selection using non-denominated sorting.
+        The default (`None`) is to use the list [PerfMeasure.MEAN, RiskMeasure.VARIANCE]
+
+    Attributes
+    ----------
+    to_keep_ : ndarray of shape (n_assets, )
+        Boolean array indicating which assets are remaining.
+
+    n_features_in_ : int
+        Number of assets seen during `fit`.
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during `fit`. Defined only when `X`
+        has feature names that are all strings.
+
+    References
+    ----------
+    .. [1]  "Large-Scale Portfolio Optimization Using Multi-objective Evolutionary
+        Algorithms and Preselection Methods",
+        B.Y. Qu and Q.Zhou (2017).
+    """
+
+    to_keep_: np.ndarray
+
+    def __init__(
+        self,
+        min_n_assets: int | None = None,
+        threshold: float = -0.5,
+        fitness_measures: list[skt.Measure] | None = None,
+    ):
+        self.min_n_assets = min_n_assets
+        self.threshold = threshold
+        self.fitness_measures = fitness_measures
+
+    def fit(self, X: npt.ArrayLike, y=None):
+        """Run the Non Dominated transformer and get the appropriate assets.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_observations, n_assets)
+            Price returns of the assets.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : SelectNonDominated
+            Fitted estimator.
+        """
+        X = self._validate_data(X)
+        if not -1 <= self.threshold <= 1:
+            raise ValueError("`threshold` must be between -1 and 1")
+        n_assets = X.shape[1]
+
+        if self.min_n_assets is not None and self.min_n_assets >= n_assets:
+            self.to_keep_ = np.full(n_assets, True)
+            return self
+
+        # Build a population of portfolio
+        population = Population([])
+        # Add single assets
+        for i in range(n_assets):
+            weights = np.zeros(n_assets)
+            weights[i] = 1
+            population.append(
+                Portfolio(X=X, weights=weights, fitness_measures=self.fitness_measures)
+            )
+
+        # Add pairs with correlation below threshold with minimum variance
+        # ptf_variance = sigma1^2 w1^2 + sigma2^2 w2^2 + 2 sigma12 w1 w2 (1)
+        # with w1 + w2 = 1
+        # To find the minimum we substitute w2 = 1 - w1 in (1) and differentiate with
+        # respect to w1 and set to zero.
+        # By solving the obtained equation, we get:
+        # w1 = (sigma2^2 - sigma12) / (sigma1^2 + sigma2^2 - 2 sigma12)
+        # w2 = 1 - w1
+
+        corr = np.corrcoef(X.T)
+        covariance = np.cov(X.T)
+        for i, j in zip(*np.triu_indices(n_assets, 1), strict=True):
+            if corr[i, j] < self.threshold:
+                cov = covariance[i, j]
+                var1 = covariance[i, i]
+                var2 = covariance[j, j]
+                weights = np.zeros(n_assets)
+                weights[i] = (var2 - cov) / (var1 + var2 - 2 * cov)
+                weights[j] = 1 - weights[i]
+                population.append(
+                    Portfolio(
+                        X=X, weights=weights, fitness_measures=self.fitness_measures
+                    )
+                )
+
+        fronts = population.non_denominated_sort(
+            first_front_only=self.min_n_assets is None
+        )
+        new_assets_idx = set()
+        i = 0
+        while i < len(fronts):
+            if (
+                self.min_n_assets is not None
+                and len(new_assets_idx) > self.min_n_assets
+            ):
+                break
+            for idx in fronts[i]:
+                new_assets_idx.update(population[idx].nonzero_assets_index)
+            i += 1
+        self.to_keep_ = np.isin(np.arange(n_assets), list(new_assets_idx))
+        return self
+
+    def _get_support_mask(self):
+        skv.check_is_fitted(self)
+        return self.to_keep_

skfolio/pre_selection/_select_non_expiring.py

@@ -0,0 +1,148 @@
+"""pre-selection estimators module"""
+
+# Copyright (c) 2023
+# Author: Hugo Delatte <delatte.hugo@gmail.com>
+# Implementation derived from:
+# Conway-Yu https://github.com/skfolio/skfolio/discussions/60
+# License: BSD 3 clause
+
+import datetime as dt
+
+import numpy as np
+import pandas as pd
+import sklearn.base as skb
+import sklearn.feature_selection as skf
+import sklearn.utils.validation as skv
+
+
+class SelectNonExpiring(skf.SelectorMixin, skb.BaseEstimator):
+    """
+    Transformer to select assets that do not expire within a specified lookahead period
+    after the end of the observation period.
+
+    This transformer removes assets (columns) that have expiration dates within a
+    given lookahead period from the end of the dataset, allowing only assets that
+    remain active beyond this lookahead period to be selected.
+
+    This is useful when an exit strategy is needed before asset expiration, such as
+    for bonds or options with known end dates, or when applying WalkForward
+    cross-validation. It ensures that assets expiring during the test period are
+    excluded, so that only live assets are included in each training and test period.
+
+    Parameters
+    ----------
+    expiration_dates : dict[str, dt.datetime | pd.Timestamp], optional
+        Dictionary with asset names as keys and expiration dates as values.
+        Used to check if each asset expires within the date offset.
+        Assets with no expiration date will be retained by default.
+
+    expiration_lookahead : pd.offsets.BaseOffset | dt.timedelta, optional
+        The lookahead period after the end of the dataset within which assets with
+        expiration dates will be removed.
+
+    Attributes
+    ----------
+    to_keep_ : ndarray of shape (n_assets, )
+       Boolean array indicating which assets are remaining.
+
+    n_features_in_ : int
+       Number of assets seen during `fit`.
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+       Names of features seen during `fit`. Defined only when `X`
+       has feature names that are all strings.
+
+    Notes
+    -----
+    This transformer only supports DataFrames with a DateTime index.
+
+    Examples
+    --------
+    >>> import pandas as pd
+    >>> import datetime as dt
+    >>> from sklearn import set_config
+    >>> set_config(transform_output="pandas")
+    >>> X = pd.DataFrame(
+    ...    {
+    ...        'asset1': [1, 2, 3, 4],
+    ...        'asset2': [2, 3, 4, 5],
+    ...        'asset3': [3, 4, 5, 6],
+    ...        'asset4': [4, 5, 6, 7]
+    ...    }, index=pd.date_range("2023-01-01", periods=4, freq="D")
+    ...)
+    >>> expiration_dates = {
+    ...    'asset1': pd.Timestamp("2023-01-10"),
+    ...    'asset2': pd.Timestamp("2023-01-02"),
+    ...    'asset3': pd.Timestamp("2023-01-06"),
+    ...    'asset4': dt.datetime(2023, 5, 1)
+    ... }
+    >>> selector = SelectNonExpiring(
+    ...    expiration_dates=expiration_dates,
+    ...    expiration_lookahead=pd.DateOffset(days=5)
+    ...)
+    >>> selector.fit_transform(X)
+               asset1  asset4
+    2023-01-01      1      4
+    2023-01-02      2      5
+    2023-01-03      3      6
+    2023-01-04      4      7
+    """
+
+    to_keep_: np.ndarray
+
+    def __init__(
+        self,
+        expiration_dates: dict[str, dt.datetime | pd.Timestamp] | None = None,
+        expiration_lookahead: pd.offsets.BaseOffset | dt.timedelta | None = None,
+    ):
+        self.expiration_dates = expiration_dates
+        self.expiration_lookahead = expiration_lookahead
+
+    def fit(self, X: pd.DataFrame, y=None) -> "SelectNonExpiring":
+        """Run the SelectNonExpiring transformer and get the appropriate assets.
+
+        Parameters
+        ----------
+        X : pd.DataFrame of shape (n_observations, n_assets)
+            Returns of the assets.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : SelectNonExpiring
+            Fitted estimator.
+        """
+        _ = self._validate_data(X, force_all_finite="allow-nan")
+
+        # Validate by allowing NaNs
+        if not hasattr(X, "index") or not isinstance(X.index, pd.DatetimeIndex):
+            raise ValueError(
+                "X must be a DataFrame with an index of type DatetimeIndex"
+            )
+
+        if self.expiration_dates is None:
+            raise ValueError("`expiration_lookahead` must be provided")
+
+        if self.expiration_lookahead is None:
+            raise ValueError("`expiration_lookahead` must be provided")
+
+        # Calculate the cutoff date
+        end_date = X.index[-1]
+        cutoff_date = end_date + self.expiration_lookahead
+        self.to_keep_ = np.array(
+            [
+                self.expiration_dates.get(asset, pd.Timestamp.max) > cutoff_date
+                for asset in X.columns
+            ]
+        )
+
+        return self
+
+    def _get_support_mask(self):
+        skv.check_is_fitted(self)
+        return self.to_keep_
+
+    def _more_tags(self):
+        return {"allow_nan": True}

skfolio/preprocessing/_returns.py

@@ -17,6 +17,7 @@ def prices_to_returns(
     nan_threshold: float = 1,
     join: Literal["left", "right", "inner", "outer", "cross"] = "outer",
     drop_inceptions_nan: bool = True,
+    fill_nan: bool = True,
 ) -> pd.DataFrame | tuple[pd.DataFrame, pd.DataFrame]:
     r"""Transforms a DataFrame of prices to linear or logarithmic returns.
 
@@ -64,11 +65,15 @@ def prices_to_returns(
         this threshold. The default (`1.0`) is to keep all the observations.
 
     drop_inceptions_nan : bool, default=True
-        If this is set to True, observations at the beginning are dropped if any of
+        If set to True, observations at the beginning are dropped if any of
         the asset values are missing, otherwise we keep the NaNs. This is useful when
         you work with a large universe of assets with different inception dates coupled
         with a pre-selection Transformer.
 
+    fill_nan : bool, default=True
+        If set to True, missing prices (NaNs) are forward filled using the previous
+        price. Otherwise, NaNs are kept.
+
     Returns
     -------
     X : DataFrame
@@ -106,7 +111,8 @@ def prices_to_returns(
             df.drop(to_drop, axis=0, inplace=True)
 
     # Forward fill missing values
-    df.ffill(inplace=True)
+    if fill_nan:
+        df.ffill(inplace=True)
     # Drop rows according to drop_inceptions_nan
     # noinspection PyTypeChecker
     df.dropna(how="any" if drop_inceptions_nan else "all", inplace=True)
@@ -114,7 +120,7 @@ def prices_to_returns(
     df.dropna(axis=1, how="all", inplace=True)
 
     # returns
-    all_returns = df.pct_change().iloc[1:]
+    all_returns = df.pct_change(fill_method=None).iloc[1:]
     if log_returns:
         all_returns = np.log1p(all_returns)
 

skfolio/utils/stats.py

@@ -10,9 +10,11 @@ import warnings
 # Statsmodels, Copyright (C) 2006, Jonathan E. Taylor, Licensed under BSD 3 clause.
 from enum import auto
 
+import cvxpy as cp
 import numpy as np
 import scipy.cluster.hierarchy as sch
 import scipy.optimize as sco
+import scipy.sparse.linalg as scl
 import scipy.spatial.distance as scd
 import scipy.special as scs
 from scipy.sparse import csr_matrix
@@ -34,6 +36,7 @@ __all__ = [
     "compute_optimal_n_clusters",
     "rand_weights",
     "rand_weights_dirichlet",
+    "minimize_relative_weight_deviation",
 ]
 
 
@@ -488,3 +491,87 @@ def compute_optimal_n_clusters(distance: np.ndarray, linkage_matrix: np.ndarray)
     # k=0 represents one cluster
     k = np.argmax(gaps) + 2
     return k
+
+
+def minimize_relative_weight_deviation(
+    weights: np.ndarray,
+    min_weights: np.ndarray,
+    max_weights: np.ndarray,
+    solver: str = "CLARABEL",
+    solver_params: dict | None = None,
+) -> np.ndarray:
+    r"""
+    Apply weight constraints to an initial array of weights by minimizing the relative
+    weight deviation of the final weights from the initial weights.
+
+    .. math::
+            \begin{cases}
+            \begin{aligned}
+            &\min_{w} & & \Vert \frac{w - w_{init}}{w_{init}} \Vert_{2}^{2} \\
+            &\text{s.t.} & & \sum_{i=1}^{N} w_{i} = 1 \\
+            & & & w_{min} \leq w_i \leq w_{max}, \quad \forall i
+            \end{aligned}
+            \end{cases}
+
+    Parameters
+    ----------
+    weights : ndarray of shape (n_assets,)
+        Initial weights.
+
+    min_weights : ndarray of shape (n_assets,)
+        Minimum assets weights (weights lower bounds).
+
+    max_weights : ndarray of shape (n_assets,)
+        Maximum assets weights (weights upper bounds).
+
+    solver : str, default="CLARABEL"
+        The solver to use. The default is "CLARABEL" which is written in Rust and has
+        better numerical stability and performance than ECOS and SCS.
+        For more details about available solvers, check the CVXPY documentation:
+        https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver
+
+    solver_params : dict, optional
+        Solver parameters. For example, `solver_params=dict(verbose=True)`.
+        The default (`None`) is to use the CVXPY default.
+        For more details about solver arguments, check the CVXPY documentation:
+        https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options
+    """
+    if not (weights.shape == min_weights.shape == max_weights.shape):
+        raise ValueError("`min_weights` and `max_weights` must have same size")
+
+    if np.any(weights < 0):
+        raise ValueError("Initial weights must be strictly positive")
+
+    if not np.isclose(np.sum(weights), 1.0):
+        raise ValueError("Initial weights must sum to one")
+
+    if np.any(max_weights < min_weights):
+        raise ValueError("`min_weights` must be lower or equal to `max_weights`")
+
+    if np.all((weights >= min_weights) & (weights <= max_weights)):
+        return weights
+
+    if solver_params is None:
+        solver_params = {}
+
+    n = len(weights)
+    w = cp.Variable(n)
+
+    objective = cp.Minimize(cp.norm(w / weights - 1))
+    constraints = [cp.sum(w) == 1, w >= min_weights, w <= max_weights]
+    problem = cp.Problem(objective, constraints)
+
+    try:
+        problem.solve(solver=solver, **solver_params)
+
+        if w.value is None:
+            raise cp.SolverError("No solution found")
+
+    except (cp.SolverError, scl.ArpackNoConvergence):
+        raise cp.SolverError(
+            f"Solver '{solver}' failed. Try another"
+            " solver, or solve with solver_params=dict(verbose=True) for more"
+            " information"
+        ) from None
+
+    return w.value

{skfolio-0.4.2.dist-info → skfolio-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skfolio
-Version: 0.4.2
+Version: 0.5.0
 Summary: Portfolio optimization built on top of scikit-learn
 Author-email: Hugo Delatte <delatte.hugo@gmail.com>
 Maintainer-email: Hugo Delatte <delatte.hugo@gmail.com>
@@ -599,7 +599,7 @@ K-fold Cross-Validation
     # mmp is the predicted MultiPeriodPortfolio object composed of 5 Portfolios (1 per testing fold)
 
     mmp.plot_cumulative_returns()
-    print(mmp.summary()
+    print(mmp.summary())
 
 
 Combinatorial Purged Cross-Validation

{skfolio-0.4.2.dist-info → skfolio-0.5.0.dist-info}/RECORD

@@ -45,9 +45,9 @@ skfolio/optimization/_base.py,sha256=LoRONJP70AwbFpdgqVS_g145pCx0JGkazjWvkQzT_iM
 skfolio/optimization/cluster/__init__.py,sha256=M3xVdYhNKp4e9CB7hzb4yjTxkkNCHh7Mt_KGFFrkOgs,388
 skfolio/optimization/cluster/_nco.py,sha256=J3pPd9XkrAcWaKPSW5vMdtaFpDshBvOdUudbDGQSoNI,16366
 skfolio/optimization/cluster/hierarchical/__init__.py,sha256=YnfcPHvjwB6kcG4hoQqc0NqIJKaG7OjBtmXNbOxCq08,405
-skfolio/optimization/cluster/hierarchical/_base.py,sha256=ioOBsHA-kRFV_Bvl0-PcqLOytjwy6JhAX1UV454Hfss,18079
-skfolio/optimization/cluster/hierarchical/_herc.py,sha256=gFmliW8YJZbbIjHwZ5IqTmTBIt9voLUGCZKdy8RoTvw,17956
-skfolio/optimization/cluster/hierarchical/_hrp.py,sha256=nB3W5Zm1TaKTLyRMqN6irAbXD-y-bL2b78d7VFYASa8,16511
+skfolio/optimization/cluster/hierarchical/_base.py,sha256=l8rJHCH_79FOPdDL2I0dmAWcVWnNkcXHtzt0U-L7BN8,16280
+skfolio/optimization/cluster/hierarchical/_herc.py,sha256=LPtUrvyW9G60OZhMWlZH_GHZHdX8mJHksrYGB-WPRVg,20358
+skfolio/optimization/cluster/hierarchical/_hrp.py,sha256=dn6EKiTJ1wkoFhPdst6vlXnSQvXSYsMtB2zaGNVPpyA,18115
 skfolio/optimization/convex/__init__.py,sha256=F6BPFikTo0B-7JCKazqLGEwM3RkgTNbFm5GAGkaq9Uo,570
 skfolio/optimization/convex/_base.py,sha256=2at6Ll4qHkN_1wvYjl-yXWTbiRJj8fhNS-bfAT88YSw,76055
 skfolio/optimization/convex/_distributionally_robust.py,sha256=tw_UNSDfAXP02khE10hpmcdlz3DQXQD7ttDqFDSHV1E,17811
@@ -60,15 +60,19 @@ skfolio/optimization/ensemble/_stacking.py,sha256=ZoICUnc_MwoXDQAR2kewCg-KIezSOI
 skfolio/optimization/naive/__init__.py,sha256=Dkr55R48urC-jfYN007NTbei16N91Na_EDYLVqzhGgQ,147
 skfolio/optimization/naive/_naive.py,sha256=AhEyYKEUAm-Fjn4p8SHwhp7yE9iF0tRyDZIjKYV4EeU,6390
 skfolio/population/__init__.py,sha256=rsPPMUv95aTK7vmpPeQwF8NzFuBwk6RDo5g4HNaPzNM,80
-skfolio/population/_population.py,sha256=WYT6yTVmarzMH3nj1-rQCvD-X2nH6q9bo928-lenUXs,30426
+skfolio/population/_population.py,sha256=ej45tdk_CcMlNToCsx2VUk2YRktK3k4cRczGBpjlnDE,30427
 skfolio/portfolio/__init__.py,sha256=YYtcAPmA2zeCxFGTXegg2FXcA7py6CxOX7IMTdYuXl0,586
 skfolio/portfolio/_base.py,sha256=EFLsvHoxZmDvGPOKePr6hQGXU7y7TWsALvzYP9qt0fQ,39588
 skfolio/portfolio/_multi_period_portfolio.py,sha256=K2JfEwlPD9iGO58lOdk7WUbWuXZDWw2prPT5T7pOdto,24387
 skfolio/portfolio/_portfolio.py,sha256=gqvCKM6ZVfwZrgixiYdahgbQ1DRNW2LkGHkXOpjleb4,32753
-skfolio/pre_selection/__init__.py,sha256=VtUtDn-U-Mn_xR2k7yfld0Yb0rPhLakEAiBwUyi-4Z8,189
-skfolio/pre_selection/_pre_selection.py,sha256=w84T14nKmzkgzbw5CW_AIlci741lXYxKUwB5pBjhTTI,12163
+skfolio/pre_selection/__init__.py,sha256=_H0jziIOq0nUETFQvjBP4AtKGzdh0EGGSXaECTcUhxY,482
+skfolio/pre_selection/_drop_correlated.py,sha256=EDwRVqmkU-52VXQ-u350PYgjWCI5QnB8CfR1taLWffY,3818
+skfolio/pre_selection/_select_complete.py,sha256=sE9TCitUA5KbEqPssl0qsCBD-oV_5Vx-b-kdU0hsFHI,3885
+skfolio/pre_selection/_select_k_extremes.py,sha256=25FGievaDqlAHAxUmyznAd3LIq_7D3ajaSVD6E7luSI,3061
+skfolio/pre_selection/_select_non_dominated.py,sha256=HLGNS14vgQlg5I5zj-b1QpgCaZROd0FALQSmyXGpK7o,5983
+skfolio/pre_selection/_select_non_expiring.py,sha256=RAWnuW2u7y0ibsimJp5mRM9JQFOn0hHp-mWsp0FLPbs,4995
 skfolio/preprocessing/__init__.py,sha256=15A1bzfPsbfxxXgGP1gstf4R0E_347Wn18z5W5jH-hk,94
-skfolio/preprocessing/_returns.py,sha256=oo1Mm-UCHwq4ECjfmsRxWzzK1EPsuv-EEtnimvv_nXo,4345
+skfolio/preprocessing/_returns.py,sha256=6mdNi7Dun5eNK4LdqKAxP4CCZEVfAEz40HXVrOiAaLA,4561
 skfolio/prior/__init__.py,sha256=jql8NTiWlykPKJUXTOPdqm531mP8Pul1QAR6hXTXA6c,446
 skfolio/prior/_base.py,sha256=u9GLCKJl-Txiem5rIO-qkH3VIyem3taD6T9kMzsYPRY,1941
 skfolio/prior/_black_litterman.py,sha256=W3HbpvkViEiD7AOgpdVmNYTlWKSGDgo9Y3BfSrbMIQ4,10347
@@ -82,10 +86,10 @@ skfolio/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 skfolio/utils/bootstrap.py,sha256=3zY2kO_GQURKEcQMCasJOSByde9Mt2IAi3KJH0_a4mk,3550
 skfolio/utils/equations.py,sha256=MQ1w3VSM2n_j9bTIKAQA716aWKYyUqtw5yM2bU-9t-M,13745
 skfolio/utils/sorting.py,sha256=lSjMvH2L-sSj-06B3MlwBrH1rtjCeGEe4hG894W7TE0,3504
-skfolio/utils/stats.py,sha256=wuOmSt5panMMTw_pFYizLbmrclsE_4PHQfamkzJ5J2s,13937
+skfolio/utils/stats.py,sha256=bzKlF2U7BN2WonwtuwG_cL_16Z3cTAxCAw5pZgbib54,17005
 skfolio/utils/tools.py,sha256=4KrmBR9jOLiI6j0hb27gsPC--OHXo4Sp1xl-6i-k9Tg,20925
-skfolio-0.4.2.dist-info/LICENSE,sha256=F6Gi-ZJX5BlVzYK8R9NcvAkAsKa7KO29xB1OScbrH6Q,1526
-skfolio-0.4.2.dist-info/METADATA,sha256=g_b6XH3HiwSCz8DawgN2HWHKQIZQMBdhVhbY_TOERUo,19610
-skfolio-0.4.2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-skfolio-0.4.2.dist-info/top_level.txt,sha256=NXEaoS9Ms7t32gxkb867nV0OKlU0KmssL7IJBVo0fJs,8
-skfolio-0.4.2.dist-info/RECORD,,
+skfolio-0.5.0.dist-info/LICENSE,sha256=F6Gi-ZJX5BlVzYK8R9NcvAkAsKa7KO29xB1OScbrH6Q,1526
+skfolio-0.5.0.dist-info/METADATA,sha256=yHEHbXE0miG8QngS1WprxyB9QrKnml44TPGScw8SqqM,19611
+skfolio-0.5.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+skfolio-0.5.0.dist-info/top_level.txt,sha256=NXEaoS9Ms7t32gxkb867nV0OKlU0KmssL7IJBVo0fJs,8
+skfolio-0.5.0.dist-info/RECORD,,

{skfolio-0.4.2.dist-info → skfolio-0.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any