openseries 1.9.1__py3-none-any.whl → 1.9.3__py3-none-any.whl

openseries/frame.py

@@ -7,22 +7,17 @@ https://github.com/CaptorAB/openseries/blob/master/LICENSE.md
 SPDX-License-Identifier: BSD-3-Clause
 """
 
-# mypy: disable-error-code="index,assignment,arg-type,no-any-return"
+# mypy: disable-error-code="assignment,no-any-return"
 from __future__ import annotations
 
 from copy import deepcopy
 from functools import reduce
 from logging import getLogger
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Any, cast
 
 if TYPE_CHECKING:  # pragma: no cover
     import datetime as dt
 
-    from statsmodels.regression.linear_model import (  # type: ignore[import-untyped]
-        OLSResults,
-    )
-
-import statsmodels.api as sm  # type: ignore[import-untyped]
 from numpy import (
     array,
     cov,
@@ -31,7 +26,6 @@ from numpy import (
     log,
     nan,
     sqrt,
-    square,
     std,
 )
 from pandas import (
@@ -44,6 +38,7 @@ from pandas import (
     merge,
 )
 from pydantic import field_validator
+from sklearn.linear_model import LinearRegression
 
 from ._common_model import _CommonModel
 from .datefixer import _do_resample_to_business_period_ends
@@ -54,8 +49,6 @@ from .owntypes import (
     LiteralCaptureRatio,
     LiteralFrameProps,
     LiteralHowMerge,
-    LiteralOlsFitCovType,
-    LiteralOlsFitMethod,
     LiteralPandasReindexMethod,
     LiteralPortfolioWeightings,
     LiteralTrunc,
@@ -75,7 +68,7 @@ __all__ = ["OpenFrame"]
 
 
 # noinspection PyUnresolvedReferences,PyTypeChecker
-class OpenFrame(_CommonModel):
+class OpenFrame(_CommonModel):  # type: ignore[misc]
     """OpenFrame objects hold OpenTimeSeries in the list constituents.
 
     The intended use is to allow comparisons across these timeseries.
@@ -133,12 +126,14 @@ class OpenFrame(_CommonModel):
             Object of the class OpenFrame
 
         """
+        copied_constituents = [ts.from_deepcopy() for ts in constituents]
+
         super().__init__(  # type: ignore[call-arg]
-            constituents=constituents,
+            constituents=copied_constituents,
             weights=weights,
         )
 
-        self.constituents = constituents
+        self.constituents = copied_constituents
         self.weights = weights
         self._set_tsdf()
 
@@ -345,10 +340,13 @@ class OpenFrame(_CommonModel):
             The returns of the values in the series
 
         """
-        returns = self.tsdf.ffill().pct_change()
+        returns = self.tsdf.pct_change()
         returns.iloc[0] = 0
-        new_labels = [ValueType.RTRN] * self.item_count
-        arrays = [self.tsdf.columns.get_level_values(0), new_labels]
+        new_labels: list[ValueType] = [ValueType.RTRN] * self.item_count
+        arrays: list[Index[Any], list[ValueType]] = [  # type: ignore[type-arg]
+            self.tsdf.columns.get_level_values(0),
+            new_labels,
+        ]
         returns.columns = MultiIndex.from_arrays(arrays=arrays)
         self.tsdf = returns.copy()
         return self
@@ -370,8 +368,11 @@ class OpenFrame(_CommonModel):
         """
         self.tsdf = self.tsdf.diff(periods=periods)
         self.tsdf.iloc[0] = 0
-        new_labels = [ValueType.RTRN] * self.item_count
-        arrays = [self.tsdf.columns.get_level_values(0), new_labels]
+        new_labels: list[ValueType] = [ValueType.RTRN] * self.item_count
+        arrays: list[Index[Any], list[ValueType]] = [  # type: ignore[type-arg]
+            self.tsdf.columns.get_level_values(0),
+            new_labels,
+        ]
         self.tsdf.columns = MultiIndex.from_arrays(arrays)
         return self
 
@@ -386,7 +387,7 @@ class OpenFrame(_CommonModel):
         """
         vtypes = [x == ValueType.RTRN for x in self.tsdf.columns.get_level_values(1)]
         if not any(vtypes):
-            returns = self.tsdf.ffill().pct_change()
+            returns = self.tsdf.pct_change()
             returns.iloc[0] = 0
         elif all(vtypes):
             returns = self.tsdf.copy()
@@ -398,8 +399,11 @@ class OpenFrame(_CommonModel):
         returns = returns.add(1.0)
         self.tsdf = returns.cumprod(axis=0) / returns.iloc[0]
 
-        new_labels = [ValueType.PRICE] * self.item_count
-        arrays = [self.tsdf.columns.get_level_values(0), new_labels]
+        new_labels: list[ValueType] = [ValueType.PRICE] * self.item_count
+        arrays: list[Index[Any], list[ValueType]] = [  # type: ignore[type-arg]
+            self.tsdf.columns.get_level_values(0),
+            new_labels,
+        ]
         self.tsdf.columns = MultiIndex.from_arrays(arrays)
         return self
 
@@ -484,6 +488,7 @@ class OpenFrame(_CommonModel):
         dlta_degr_freedms: int = 0,
         first_column: int = 0,
         second_column: int = 1,
+        corr_scale: float = 2.0,
         months_from_last: int | None = None,
         from_date: dt.date | None = None,
         to_date: dt.date | None = None,
@@ -506,6 +511,8 @@ class OpenFrame(_CommonModel):
             Column of first timeseries.
         second_column: int, default: 1
             Column of second timeseries.
+        corr_scale: float, default: 2.0
+            Correlation scale factor.
         months_from_last : int, optional
             number of months offset as positive integer. Overrides use of from_date
             and to_date
@@ -548,9 +555,7 @@ class OpenFrame(_CommonModel):
         data = self.tsdf.loc[cast("int", earlier) : cast("int", later)].copy()
 
         for rtn in cols:
-            data[rtn, ValueType.RTRN] = (
-                data.loc[:, (rtn, ValueType.PRICE)].apply(log).diff()
-            )
+            data[rtn, ValueType.RTRN] = log(data.loc[:, (rtn, ValueType.PRICE)]).diff()
 
         raw_one = [
             data.loc[:, (cols[0], ValueType.RTRN)]
@@ -571,34 +576,39 @@ class OpenFrame(_CommonModel):
                 ddof=dlta_degr_freedms,
             )[0][1],
         ]
-        raw_corr = [raw_cov[0] / (2 * raw_one[0] * raw_two[0])]
 
-        for _, row in data.iloc[1:].iterrows():
-            tmp_raw_one = sqrt(
-                square(row.loc[cols[0], ValueType.RTRN]) * time_factor * (1 - lmbda)
-                + square(raw_one[-1]) * lmbda,
-            )
-            tmp_raw_two = sqrt(
-                square(row.loc[cols[1], ValueType.RTRN]) * time_factor * (1 - lmbda)
-                + square(raw_two[-1]) * lmbda,
-            )
-            tmp_raw_cov = (
-                row.loc[cols[0], ValueType.RTRN]
-                * row.loc[cols[1], ValueType.RTRN]
-                * time_factor
-                * (1 - lmbda)
-                + raw_cov[-1] * lmbda
-            )
-            tmp_raw_corr = tmp_raw_cov / (2 * tmp_raw_one * tmp_raw_two)
-            raw_one.append(tmp_raw_one)
-            raw_two.append(tmp_raw_two)
-            raw_cov.append(tmp_raw_cov)
-            raw_corr.append(tmp_raw_corr)
+        r1 = data.loc[:, (cols[0], ValueType.RTRN)]
+        r2 = data.loc[:, (cols[1], ValueType.RTRN)]
+
+        alpha = 1.0 - lmbda
+
+        s1 = (r1.pow(2) * time_factor).copy()
+        s2 = (r2.pow(2) * time_factor).copy()
+        sc = (r1 * r2 * time_factor).copy()
+
+        s1.iloc[0] = float(raw_one[0] ** 2)
+        s2.iloc[0] = float(raw_two[0] ** 2)
+        sc.iloc[0] = float(raw_cov[0])
+
+        m1 = s1.ewm(alpha=alpha, adjust=False).mean()
+        m2 = s2.ewm(alpha=alpha, adjust=False).mean()
+        mc = sc.ewm(alpha=alpha, adjust=False).mean()
+
+        m1v = m1.to_numpy(copy=False)
+        m2v = m2.to_numpy(copy=False)
+        mcv = mc.to_numpy(copy=False)
+
+        vol1 = sqrt(m1v)
+        vol2 = sqrt(m2v)
+        denom = corr_scale * vol1 * vol2
+
+        corr = mcv / denom
+        corr[denom == 0.0] = nan
 
         return DataFrame(
             index=[*cols, corr_label],
             columns=data.index,
-            data=[raw_one, raw_two, raw_corr],
+            data=[vol1, vol2, corr],
         ).T
 
     @property
@@ -611,13 +621,9 @@ class OpenFrame(_CommonModel):
             Correlation matrix
 
         """
-        corr_matrix = (
-            self.tsdf.ffill()
-            .pct_change()
-            .corr(
-                method="pearson",
-                min_periods=1,
-            )
+        corr_matrix = self.tsdf.pct_change().corr(
+            method="pearson",
+            min_periods=1,
         )
         corr_matrix.columns = corr_matrix.columns.droplevel(level=1)
         corr_matrix.index = corr_matrix.index.droplevel(level=1)
@@ -844,7 +850,7 @@ class OpenFrame(_CommonModel):
                 ]
                 relative = 1.0 + longdf - shortdf
                 vol = float(
-                    relative.ffill().pct_change().std() * sqrt(time_factor),
+                    relative.pct_change().std() * sqrt(time_factor),
                 )
                 terrors.append(vol)
 
@@ -936,10 +942,10 @@ class OpenFrame(_CommonModel):
                 ]
                 relative = 1.0 + longdf - shortdf
                 ret = float(
-                    relative.ffill().pct_change().mean() * time_factor,
+                    relative.pct_change().mean() * time_factor,
                 )
                 vol = float(
-                    relative.ffill().pct_change().std() * sqrt(time_factor),
+                    relative.pct_change().std() * sqrt(time_factor),
                 )
                 ratios.append(ret / vol)
 
@@ -1040,18 +1046,16 @@ class OpenFrame(_CommonModel):
                 msg = "ratio must be one of 'up', 'down' or 'both'."
                 if ratio == "up":
                     uparray = (
-                        longdf.ffill()
-                        .pct_change()[
-                            shortdf.ffill().pct_change().to_numpy() > loss_limit
+                        longdf.pct_change()[
+                            shortdf.pct_change().to_numpy() > loss_limit
                         ]
                         .add(1)
                         .to_numpy()
                     )
                     up_rtrn = uparray.prod() ** (1 / (len(uparray) / time_factor)) - 1
                     upidxarray = (
-                        shortdf.ffill()
-                        .pct_change()[
-                            shortdf.ffill().pct_change().to_numpy() > loss_limit
+                        shortdf.pct_change()[
+                            shortdf.pct_change().to_numpy() > loss_limit
                         ]
                         .add(1)
                         .to_numpy()
@@ -1062,9 +1066,8 @@ class OpenFrame(_CommonModel):
                     ratios.append(up_rtrn / up_idx_return)
                 elif ratio == "down":
                     downarray = (
-                        longdf.ffill()
-                        .pct_change()[
-                            shortdf.ffill().pct_change().to_numpy() < loss_limit
+                        longdf.pct_change()[
+                            shortdf.pct_change().to_numpy() < loss_limit
                         ]
                         .add(1)
                         .to_numpy()
@@ -1073,9 +1076,8 @@ class OpenFrame(_CommonModel):
                         downarray.prod() ** (1 / (len(downarray) / time_factor)) - 1
                     )
                     downidxarray = (
-                        shortdf.ffill()
-                        .pct_change()[
-                            shortdf.ffill().pct_change().to_numpy() < loss_limit
+                        shortdf.pct_change()[
+                            shortdf.pct_change().to_numpy() < loss_limit
                         ]
                         .add(1)
                         .to_numpy()
@@ -1087,18 +1089,16 @@ class OpenFrame(_CommonModel):
                     ratios.append(down_return / down_idx_return)
                 elif ratio == "both":
                     uparray = (
-                        longdf.ffill()
-                        .pct_change()[
-                            shortdf.ffill().pct_change().to_numpy() > loss_limit
+                        longdf.pct_change()[
+                            shortdf.pct_change().to_numpy() > loss_limit
                         ]
                         .add(1)
                         .to_numpy()
                     )
                     up_rtrn = uparray.prod() ** (1 / (len(uparray) / time_factor)) - 1
                     upidxarray = (
-                        shortdf.ffill()
-                        .pct_change()[
-                            shortdf.ffill().pct_change().to_numpy() > loss_limit
+                        shortdf.pct_change()[
+                            shortdf.pct_change().to_numpy() > loss_limit
                         ]
                         .add(1)
                         .to_numpy()
@@ -1107,9 +1107,8 @@ class OpenFrame(_CommonModel):
                         upidxarray.prod() ** (1 / (len(upidxarray) / time_factor)) - 1
                     )
                     downarray = (
-                        longdf.ffill()
-                        .pct_change()[
-                            shortdf.ffill().pct_change().to_numpy() < loss_limit
+                        longdf.pct_change()[
+                            shortdf.pct_change().to_numpy() < loss_limit
                         ]
                         .add(1)
                         .to_numpy()
@@ -1118,9 +1117,8 @@ class OpenFrame(_CommonModel):
                         downarray.prod() ** (1 / (len(downarray) / time_factor)) - 1
                     )
                     downidxarray = (
-                        shortdf.ffill()
-                        .pct_change()[
-                            shortdf.ffill().pct_change().to_numpy() < loss_limit
+                        shortdf.pct_change()[
+                            shortdf.pct_change().to_numpy() < loss_limit
                         ]
                         .add(1)
                         .to_numpy()
@@ -1229,16 +1227,13 @@ class OpenFrame(_CommonModel):
         self: Self,
         y_column: tuple[str, ValueType] | int,
         x_column: tuple[str, ValueType] | int,
-        method: LiteralOlsFitMethod = "pinv",
-        cov_type: LiteralOlsFitCovType = "nonrobust",
         *,
         fitted_series: bool = True,
-    ) -> OLSResults:
+    ) -> dict[str, float]:
         """Ordinary Least Squares fit.
 
         Performs a linear regression and adds a new column with a fitted line
         using Ordinary Least Squares fit
-        https://www.statsmodels.org/stable/examples/notebooks/generated/ols.html.
 
         Parameters
         ----------
@@ -1246,50 +1241,50 @@ class OpenFrame(_CommonModel):
             The column level values of the dependent variable y
         x_column: tuple[str, ValueType] | int
             The column level values of the exogenous variable x
-        method: LiteralOlsFitMethod, default: pinv
-            Method to solve least squares problem
-        cov_type: LiteralOlsFitCovType, default: nonrobust
-            Covariance estimator
         fitted_series: bool, default: True
             If True the fit is added as a new column in the .tsdf Pandas.DataFrame
 
         Returns:
         -------
-        OLSResults
-            The Statsmodels regression output
+        dict[str, float]
+            A dictionary with the coefficient, intercept and rsquared outputs.
 
         """
         msg = "y_column should be a tuple[str, ValueType] or an integer."
         if isinstance(y_column, tuple):
-            y_value = self.tsdf.loc[:, y_column]
+            y_value = self.tsdf.loc[:, y_column].to_numpy()
             y_label = cast(
                 "tuple[str, str]",
                 self.tsdf.loc[:, y_column].name,
             )[0]
         elif isinstance(y_column, int):
-            y_value = self.tsdf.iloc[:, y_column]
+            y_value = self.tsdf.iloc[:, y_column].to_numpy()
             y_label = cast("tuple[str, str]", self.tsdf.iloc[:, y_column].name)[0]
         else:
             raise TypeError(msg)
 
         msg = "x_column should be a tuple[str, ValueType] or an integer."
         if isinstance(x_column, tuple):
-            x_value = self.tsdf.loc[:, x_column]
+            x_value = self.tsdf.loc[:, x_column].to_numpy().reshape(-1, 1)
             x_label = cast(
                 "tuple[str, str]",
                 self.tsdf.loc[:, x_column].name,
             )[0]
         elif isinstance(x_column, int):
-            x_value = self.tsdf.iloc[:, x_column]
+            x_value = self.tsdf.iloc[:, x_column].to_numpy().reshape(-1, 1)
             x_label = cast("tuple[str, str]", self.tsdf.iloc[:, x_column].name)[0]
         else:
             raise TypeError(msg)
 
-        results = sm.OLS(y_value, x_value).fit(method=method, cov_type=cov_type)
+        model = LinearRegression(fit_intercept=True)
+        model.fit(x_value, y_value)
         if fitted_series:
-            self.tsdf[y_label, x_label] = results.predict(x_value)
-
-        return cast("OLSResults", results)
+            self.tsdf[y_label, x_label] = model.predict(x_value)
+        return {
+            "coefficient": model.coef_[0],
+            "intercept": model.intercept_,
+            "rsquared": model.score(x_value, y_value),
+        }
 
     def jensen_alpha(
         self: Self,
@@ -1419,7 +1414,7 @@ class OpenFrame(_CommonModel):
             msg = "Mix of series types will give inconsistent results"
             raise MixedValuetypesError(msg)
 
-        covariance = cov(asset_log, market_log, ddof=dlta_degr_freedms)
+        covariance = cov(m=asset_log, y=market_log, ddof=dlta_degr_freedms)
         beta = covariance[0, 1] / covariance[1, 1]
 
         return float(asset_cagr - riskfree_rate - beta * (market_cagr - riskfree_rate))
@@ -1453,7 +1448,7 @@ class OpenFrame(_CommonModel):
 
         vtypes = [x == ValueType.RTRN for x in self.tsdf.columns.get_level_values(1)]
         if not any(vtypes):
-            returns = self.tsdf.ffill().pct_change()
+            returns = self.tsdf.pct_change()
             returns.iloc[0] = 0
         elif all(vtypes):
             returns = self.tsdf.copy()
@@ -1528,14 +1523,11 @@ class OpenFrame(_CommonModel):
         )
 
         retseries = (
-            relative.ffill()
-            .pct_change()
-            .rolling(observations, min_periods=observations)
-            .sum()
+            relative.pct_change().rolling(observations, min_periods=observations).sum()
         )
         retdf = retseries.dropna().to_frame()
 
-        voldf = relative.ffill().pct_change().rolling(
+        voldf = relative.pct_change().rolling(
             observations,
             min_periods=observations,
         ).std() * sqrt(time_factor)
@@ -1581,13 +1573,9 @@ class OpenFrame(_CommonModel):
         asset_label = cast("tuple[str, str]", self.tsdf.iloc[:, asset_column].name)[0]
         beta_label = f"{asset_label} / {market_label}"
 
-        rolling = (
-            self.tsdf.ffill()
-            .pct_change()
-            .rolling(
-                observations,
-                min_periods=observations,
-            )
+        rolling = self.tsdf.pct_change().rolling(
+            observations,
+            min_periods=observations,
         )
 
         rcov = rolling.cov(ddof=dlta_degr_freedms)
@@ -1642,11 +1630,10 @@ class OpenFrame(_CommonModel):
         )
         first_series = (
             self.tsdf.iloc[:, first_column]
-            .ffill()
             .pct_change()[1:]
             .rolling(observations, min_periods=observations)
         )
-        second_series = self.tsdf.iloc[:, second_column].ffill().pct_change()[1:]
+        second_series = self.tsdf.iloc[:, second_column].pct_change()[1:]
         corrdf = first_series.corr(other=second_series).dropna().to_frame()
         corrdf.columns = MultiIndex.from_arrays(
             [
@@ -1656,3 +1643,62 @@ class OpenFrame(_CommonModel):
         )
 
         return DataFrame(corrdf)
+
+    def multi_factor_linear_regression(
+        self: Self,
+        dependent_column: tuple[str, ValueType],
+    ) -> tuple[DataFrame, OpenTimeSeries]:
+        """Perform a multi-factor linear regression.
+
+        This function treats one specified column in the DataFrame as the dependent
+        variable (y) and uses all remaining columns as independent variables (X).
+        It utilizes a scikit-learn LinearRegression model and returns a DataFrame
+        with summary output and an OpenTimeSeries of predicted values.
+
+        Parameters
+        ----------
+        dependent_column: tuple[str, ValueType]
+            A tuple key to select the column in the OpenFrame.tsdf.columns
+            to use as the dependent variable
+
+        Returns:
+        -------
+        tuple[pandas.DataFrame, OpenTimeSeries]
+            - A DataFrame with the R-squared, the intercept
+              and the regression coefficients
+            - An OpenTimeSeries of predicted values
+
+        Raises:
+            KeyError: If the column tuple is not found in the OpenFrame.tsdf.columns
+            ValueError: If not all series are returnseries (ValueType.RTRN)
+        """
+        key_msg = (
+            f"Tuple ({dependent_column[0]}, "
+            f"{dependent_column[1].value}) not found in data."
+        )
+        if dependent_column not in self.tsdf.columns:
+            raise KeyError(key_msg)
+
+        vtype_msg = "All series should be of ValueType.RTRN."
+        if not all(x == ValueType.RTRN for x in self.tsdf.columns.get_level_values(1)):
+            raise MixedValuetypesError(vtype_msg)
+
+        dependent = self.tsdf[dependent_column]
+        factors = self.tsdf.drop(columns=[dependent_column])
+        indx = ["R-square", "Intercept", *factors.columns.droplevel(level=1)]
+
+        model = LinearRegression()
+        model.fit(factors, dependent)
+
+        predictions = OpenTimeSeries.from_arrays(
+            name=f"Predicted {dependent_column[0]}",
+            dates=[date.strftime("%Y-%m-%d") for date in self.tsdf.index],
+            values=list(model.predict(factors)),
+            valuetype=ValueType.RTRN,
+        )
+
+        output = [model.score(factors, dependent), model.intercept_, *model.coef_]
+
+        result = DataFrame(data=output, index=indx, columns=[dependent_column[0]])
+
+        return result, predictions.to_cumret()

openseries/load_plotly.py

@@ -76,7 +76,7 @@ def load_plotly_dict(
     with logofile.open(mode="r", encoding="utf-8") as logo_file:
         logo = load(logo_file)
 
-    if _check_remote_file_existence(url=logo["source"]) is False:
+    if not _check_remote_file_existence(url=logo["source"]):
         msg = f"Failed to add logo image from URL {logo['source']}"
         logger.warning(msg)
         logo = {}

openseries/owntypes.py

@@ -141,21 +141,7 @@ LiteralPlotlyHistogramHistNorm = Literal[
     "density",
     "probability density",
 ]
-LiteralOlsFitMethod = Literal["pinv", "qr"]
 LiteralPortfolioWeightings = Literal["eq_weights", "inv_vol"]
-LiteralOlsFitCovType = Literal[
-    "nonrobust",
-    "fixed scale",
-    "HC0",
-    "HC1",
-    "HC2",
-    "HC3",
-    "HAC",
-    "hac-panel",
-    "hac-groupsum",
-    "cluster",
-]
-
 LiteralMinimizeMethods = Literal[
     "SLSQP",
     "Nelder-Mead",
@@ -181,6 +167,7 @@ LiteralSeriesProps = Literal[
     "downside_deviation",
     "ret_vol_ratio",
     "sortino_ratio",
+    "kappa3_ratio",
     "z_score",
     "skew",
     "kurtosis",
@@ -208,6 +195,7 @@ LiteralFrameProps = Literal[
     "downside_deviation",
     "ret_vol_ratio",
     "sortino_ratio",
+    "kappa3_ratio",
     "z_score",
     "skew",
     "kurtosis",
@@ -238,6 +226,7 @@ class PropertiesList(list[str]):
         "downside_deviation",
         "ret_vol_ratio",
         "sortino_ratio",
+        "kappa3_ratio",
         "omega_ratio",
         "z_score",
         "skew",

openseries/portfoliotools.py

@@ -7,7 +7,7 @@ https://github.com/CaptorAB/openseries/blob/master/LICENSE.md
 SPDX-License-Identifier: BSD-3-Clause
 """
 
-# mypy: disable-error-code="index,assignment"
+# mypy: disable-error-code="assignment"
 from __future__ import annotations
 
 from inspect import stack
@@ -320,7 +320,7 @@ def efficient_frontier(
 
     if tweak:
         limit_tweak = 0.001
-        line_df["stdev_diff"] = line_df.stdev.ffill().pct_change()
+        line_df["stdev_diff"] = line_df.stdev.pct_change()
         line_df = line_df.loc[line_df.stdev_diff.abs() > limit_tweak]
         line_df = line_df.drop(columns="stdev_diff")
 
@@ -378,9 +378,11 @@ def constrain_optimized_portfolios(
     condition_least_ret = front_frame.ret > serie.arithmetic_ret
     # noinspection PyArgumentList
     least_ret_frame = front_frame[condition_least_ret].sort_values(by="stdev")
-    least_ret_port = least_ret_frame.iloc[0]
+    least_ret_port: Series[float] = least_ret_frame.iloc[0]
     least_ret_port_name = f"Minimize vol & target return of {portfolioname}"
-    least_ret_weights = [least_ret_port[c] for c in lr_frame.columns_lvl_zero]
+    least_ret_weights: list[float] = [
+        least_ret_port.loc[c] for c in lr_frame.columns_lvl_zero
+    ]
     lr_frame.weights = least_ret_weights
     resleast = OpenTimeSeries.from_df(lr_frame.make_portfolio(least_ret_port_name))
 
@@ -390,9 +392,11 @@ def constrain_optimized_portfolios(
         by="ret",
         ascending=False,
     )
-    most_vol_port = most_vol_frame.iloc[0]
+    most_vol_port: Series[float] = most_vol_frame.iloc[0]
     most_vol_port_name = f"Maximize return & target risk of {portfolioname}"
-    most_vol_weights = [most_vol_port[c] for c in mv_frame.columns_lvl_zero]
+    most_vol_weights: list[float] = [
+        most_vol_port.loc[c] for c in mv_frame.columns_lvl_zero
+    ]
     mv_frame.weights = most_vol_weights
     resmost = OpenTimeSeries.from_df(mv_frame.make_portfolio(most_vol_port_name))
 
@@ -562,7 +566,7 @@ def sharpeplot(
         )
 
     if point_frame is not None:
-        colorway = cast(
+        colorway = cast(  # type: ignore[index]
             "dict[str, str | int | float | bool | list[str]]",
             fig["layout"],
         ).get("colorway")[: len(point_frame.columns)]