openseries 1.9.2__py3-none-any.whl → 1.9.4__py3-none-any.whl

openseries/frame.py

@@ -7,13 +7,13 @@ 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
@@ -26,7 +26,6 @@ from numpy import (
     log,
     nan,
     sqrt,
-    square,
     std,
 )
 from pandas import (
@@ -58,6 +57,7 @@ from .owntypes import (
     NoWeightsError,
     OpenFramePropertiesList,
     RatioInputError,
+    ResampleDataLossError,
     Self,
     ValueType,
 )
@@ -127,12 +127,14 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             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()
 
@@ -341,8 +343,11 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         """
         returns = self.tsdf.ffill().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
@@ -364,8 +369,11 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         """
         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
 
@@ -392,8 +400,11 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         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
 
@@ -414,12 +425,27 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             An OpenFrame object
 
         """
+        vtypes = [x == ValueType.RTRN for x in self.tsdf.columns.get_level_values(1)]
+        if not any(vtypes):
+            value_type = ValueType.PRICE
+        elif all(vtypes):
+            value_type = ValueType.RTRN
+        else:
+            msg = "Mix of series types will give inconsistent results"
+            raise MixedValuetypesError(msg)
+
         self.tsdf.index = DatetimeIndex(self.tsdf.index)
-        self.tsdf = self.tsdf.resample(freq).last()
+        if value_type == ValueType.PRICE:
+            self.tsdf = self.tsdf.resample(freq).last()
+        else:
+            self.tsdf = self.tsdf.resample(freq).sum()
         self.tsdf.index = Index(d.date() for d in DatetimeIndex(self.tsdf.index))
         for xerie in self.constituents:
             xerie.tsdf.index = DatetimeIndex(xerie.tsdf.index)
-            xerie.tsdf = xerie.tsdf.resample(freq).last()
+            if value_type == ValueType.PRICE:
+                xerie.tsdf = xerie.tsdf.resample(freq).last()
+            else:
+                xerie.tsdf = xerie.tsdf.resample(freq).sum()
             xerie.tsdf.index = Index(
                 dejt.date() for dejt in DatetimeIndex(xerie.tsdf.index)
             )
@@ -448,6 +474,15 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             An OpenFrame object
 
         """
+        vtypes = [x == ValueType.RTRN for x in self.tsdf.columns.get_level_values(1)]
+        if any(vtypes):
+            msg = (
+                "Do not run resample_to_business_period_ends on return series. "
+                "The operation will pick the last data point in the sparser series. "
+                "It will not sum returns and therefore data will be lost."
+            )
+            raise ResampleDataLossError(msg)
+
         for xerie in self.constituents:
             dates = _do_resample_to_business_period_ends(
                 data=xerie.tsdf,
@@ -478,6 +513,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         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,
@@ -500,6 +536,8 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             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
@@ -517,7 +555,9 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             Series volatilities and correlation
 
         """
-        earlier, later = self.calc_range(months_from_last, from_date, to_date)
+        earlier, later = self.calc_range(
+            months_offset=months_from_last, from_dt=from_date, to_dt=to_date
+        )
         if periods_in_a_year_fixed is None:
             fraction = (later - earlier).days / 365.25
             how_many = (
@@ -542,9 +582,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         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)]
@@ -565,34 +603,39 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
                 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
@@ -793,7 +836,9 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             Tracking Errors
 
         """
-        earlier, later = self.calc_range(months_from_last, from_date, to_date)
+        earlier, later = self.calc_range(
+            months_offset=months_from_last, from_dt=from_date, to_dt=to_date
+        )
         fraction = (later - earlier).days / 365.25
 
         msg = "base_column should be a tuple[str, ValueType] or an integer."
@@ -836,10 +881,8 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
                     :,
                     item,
                 ]
-                relative = 1.0 + longdf - shortdf
-                vol = float(
-                    relative.ffill().pct_change().std() * sqrt(time_factor),
-                )
+                relative = longdf.ffill().pct_change() - shortdf.ffill().pct_change()
+                vol = float(relative.std() * sqrt(time_factor))
                 terrors.append(vol)
 
         return Series(
@@ -885,7 +928,9 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             Information Ratios
 
         """
-        earlier, later = self.calc_range(months_from_last, from_date, to_date)
+        earlier, later = self.calc_range(
+            months_offset=months_from_last, from_dt=from_date, to_dt=to_date
+        )
         fraction = (later - earlier).days / 365.25
 
         msg = "base_column should be a tuple[str, ValueType] or an integer."
@@ -928,13 +973,9 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
                     :,
                     item,
                 ]
-                relative = 1.0 + longdf - shortdf
-                ret = float(
-                    relative.ffill().pct_change().mean() * time_factor,
-                )
-                vol = float(
-                    relative.ffill().pct_change().std() * sqrt(time_factor),
-                )
+                relative = longdf.ffill().pct_change() - shortdf.ffill().pct_change()
+                ret = float(relative.mean() * time_factor)
+                vol = float(relative.std() * sqrt(time_factor))
                 ratios.append(ret / vol)
 
         return Series(
@@ -988,7 +1029,9 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
         """
         loss_limit: float = 0.0
-        earlier, later = self.calc_range(months_from_last, from_date, to_date)
+        earlier, later = self.calc_range(
+            months_offset=months_from_last, from_dt=from_date, to_dt=to_date
+        )
         fraction = (later - earlier).days / 365.25
 
         msg = "base_column should be a tuple[str, ValueType] or an integer."
@@ -1169,10 +1212,8 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             Beta as Co-variance of x & y divided by Variance of x
 
         """
-        if all(
-            x_value == ValueType.RTRN
-            for x_value in self.tsdf.columns.get_level_values(1).to_numpy()
-        ):
+        vtypes = [x == ValueType.RTRN for x in self.tsdf.columns.get_level_values(1)]
+        if all(vtypes):
             msg = "asset should be a tuple[str, ValueType] or an integer."
             if isinstance(asset, tuple):
                 y_value = self.tsdf.loc[:, asset]
@@ -1188,33 +1229,27 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
                 x_value = self.tsdf.iloc[:, market]
             else:
                 raise TypeError(msg)
-        else:
+        elif not any(vtypes):
             msg = "asset should be a tuple[str, ValueType] or an integer."
             if isinstance(asset, tuple):
-                y_value = log(
-                    self.tsdf.loc[:, asset] / self.tsdf.loc[:, asset].iloc[0],
-                )
+                y_value = self.tsdf.loc[:, asset].ffill().pct_change().iloc[1:]
             elif isinstance(asset, int):
-                y_value = log(
-                    self.tsdf.iloc[:, asset] / cast("float", self.tsdf.iloc[0, asset]),
-                )
+                y_value = self.tsdf.iloc[:, asset].ffill().pct_change().iloc[1:]
             else:
                 raise TypeError(msg)
-
             msg = "market should be a tuple[str, ValueType] or an integer."
+
             if isinstance(market, tuple):
-                x_value = log(
-                    self.tsdf.loc[:, market] / self.tsdf.loc[:, market].iloc[0],
-                )
+                x_value = self.tsdf.loc[:, market].ffill().pct_change().iloc[1:]
             elif isinstance(market, int):
-                x_value = log(
-                    self.tsdf.iloc[:, market]
-                    / cast("float", self.tsdf.iloc[0, market]),
-                )
+                x_value = self.tsdf.iloc[:, market].ffill().pct_change().iloc[1:]
             else:
                 raise TypeError(msg)
+        else:
+            msg = "Mix of series types will give inconsistent results"
+            raise MixedValuetypesError(msg)
 
-        covariance = cov(y_value, x_value, ddof=dlta_degr_freedms)
+        covariance = cov(m=y_value, y=x_value, ddof=dlta_degr_freedms)
         beta = covariance[0, 1] / covariance[1, 1]
 
         return float(beta)
@@ -1315,105 +1350,57 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             Jensen's alpha
 
         """
-        full_year = 1.0
         vtypes = [x == ValueType.RTRN for x in self.tsdf.columns.get_level_values(1)]
         if not any(vtypes):
             msg = "asset should be a tuple[str, ValueType] or an integer."
             if isinstance(asset, tuple):
-                asset_log = log(
-                    self.tsdf.loc[:, asset] / self.tsdf.loc[:, asset].iloc[0],
-                )
-                if self.yearfrac > full_year:
-                    asset_cagr = (
-                        self.tsdf.loc[:, asset].iloc[-1]
-                        / self.tsdf.loc[:, asset].iloc[0]
-                    ) ** (1 / self.yearfrac) - 1
-                else:
-                    asset_cagr = (
-                        self.tsdf.loc[:, asset].iloc[-1]
-                        / self.tsdf.loc[:, asset].iloc[0]
-                        - 1
-                    )
+                asset_rtn = self.tsdf.loc[:, asset].ffill().pct_change().iloc[1:]
+                asset_rtn_mean = float(asset_rtn.mean() * self.periods_in_a_year)
             elif isinstance(asset, int):
-                asset_log = log(
-                    self.tsdf.iloc[:, asset] / cast("float", self.tsdf.iloc[0, asset]),
-                )
-                if self.yearfrac > full_year:
-                    asset_cagr = (
-                        cast("float", self.tsdf.iloc[-1, asset])
-                        / cast("float", self.tsdf.iloc[0, asset])
-                    ) ** (1 / self.yearfrac) - 1
-                else:
-                    asset_cagr = (
-                        cast("float", self.tsdf.iloc[-1, asset])
-                        / cast("float", self.tsdf.iloc[0, asset])
-                        - 1
-                    )
+                asset_rtn = self.tsdf.iloc[:, asset].ffill().pct_change().iloc[1:]
+                asset_rtn_mean = float(asset_rtn.mean() * self.periods_in_a_year)
             else:
                 raise TypeError(msg)
 
             msg = "market should be a tuple[str, ValueType] or an integer."
             if isinstance(market, tuple):
-                market_log = log(
-                    self.tsdf.loc[:, market] / self.tsdf.loc[:, market].iloc[0],
-                )
-                if self.yearfrac > full_year:
-                    market_cagr = (
-                        self.tsdf.loc[:, market].iloc[-1]
-                        / self.tsdf.loc[:, market].iloc[0]
-                    ) ** (1 / self.yearfrac) - 1
-                else:
-                    market_cagr = (
-                        self.tsdf.loc[:, market].iloc[-1]
-                        / self.tsdf.loc[:, market].iloc[0]
-                        - 1
-                    )
+                market_rtn = self.tsdf.loc[:, market].ffill().pct_change().iloc[1:]
+                market_rtn_mean = float(market_rtn.mean() * self.periods_in_a_year)
             elif isinstance(market, int):
-                market_log = log(
-                    self.tsdf.iloc[:, market]
-                    / cast("float", self.tsdf.iloc[0, market]),
-                )
-                if self.yearfrac > full_year:
-                    market_cagr = (
-                        cast("float", self.tsdf.iloc[-1, market])
-                        / cast("float", self.tsdf.iloc[0, market])
-                    ) ** (1 / self.yearfrac) - 1
-                else:
-                    market_cagr = (
-                        cast("float", self.tsdf.iloc[-1, market])
-                        / cast("float", self.tsdf.iloc[0, market])
-                        - 1
-                    )
+                market_rtn = self.tsdf.iloc[:, market].ffill().pct_change().iloc[1:]
+                market_rtn_mean = float(market_rtn.mean() * self.periods_in_a_year)
             else:
                 raise TypeError(msg)
         elif all(vtypes):
             msg = "asset should be a tuple[str, ValueType] or an integer."
             if isinstance(asset, tuple):
-                asset_log = self.tsdf.loc[:, asset]
-                asset_cagr = asset_log.mean()
+                asset_rtn = self.tsdf.loc[:, asset]
+                asset_rtn_mean = float(asset_rtn.mean() * self.periods_in_a_year)
             elif isinstance(asset, int):
-                asset_log = self.tsdf.iloc[:, asset]
-                asset_cagr = asset_log.mean()
+                asset_rtn = self.tsdf.iloc[:, asset]
+                asset_rtn_mean = float(asset_rtn.mean() * self.periods_in_a_year)
             else:
                 raise TypeError(msg)
 
             msg = "market should be a tuple[str, ValueType] or an integer."
             if isinstance(market, tuple):
-                market_log = self.tsdf.loc[:, market]
-                market_cagr = market_log.mean()
+                market_rtn = self.tsdf.loc[:, market]
+                market_rtn_mean = float(market_rtn.mean() * self.periods_in_a_year)
             elif isinstance(market, int):
-                market_log = self.tsdf.iloc[:, market]
-                market_cagr = market_log.mean()
+                market_rtn = self.tsdf.iloc[:, market]
+                market_rtn_mean = float(market_rtn.mean() * self.periods_in_a_year)
             else:
                 raise TypeError(msg)
         else:
             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_rtn, y=market_rtn, ddof=dlta_degr_freedms)
         beta = covariance[0, 1] / covariance[1, 1]
 
-        return float(asset_cagr - riskfree_rate - beta * (market_cagr - riskfree_rate))
+        return float(
+            asset_rtn_mean - riskfree_rate - beta * (market_rtn_mean - riskfree_rate)
+        )
 
     def make_portfolio(
         self: Self,
@@ -1647,3 +1634,62 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         )
 
         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

@@ -167,6 +167,7 @@ LiteralSeriesProps = Literal[
     "downside_deviation",
     "ret_vol_ratio",
     "sortino_ratio",
+    "kappa3_ratio",
     "z_score",
     "skew",
     "kurtosis",
@@ -194,6 +195,7 @@ LiteralFrameProps = Literal[
     "downside_deviation",
     "ret_vol_ratio",
     "sortino_ratio",
+    "kappa3_ratio",
     "z_score",
     "skew",
     "kurtosis",
@@ -224,6 +226,7 @@ class PropertiesList(list[str]):
         "downside_deviation",
         "ret_vol_ratio",
         "sortino_ratio",
+        "kappa3_ratio",
         "omega_ratio",
         "z_score",
         "skew",
@@ -373,3 +376,7 @@ class IncorrectArgumentComboError(Exception):
 
 class PropertiesInputValidationError(Exception):
     """Raised when duplicate strings are provided."""
+
+
+class ResampleDataLossError(Exception):
+    """Raised when user attempts to run resample_to_business_period_ends on returns."""

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
@@ -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)]

openseries/report.py

@@ -7,7 +7,7 @@ https://github.com/CaptorAB/openseries/blob/master/LICENSE.md
 SPDX-License-Identifier: BSD-3-Clause
 """
 
-# mypy: disable-error-code="assignment,index,arg-type"
+# mypy: disable-error-code="assignment"
 from __future__ import annotations
 
 from inspect import stack
@@ -68,9 +68,7 @@ def calendar_period_returns(
     """
     copied = data.from_deepcopy()
     copied.resample_to_business_period_ends(freq=freq)
-    vtypes = [x == ValueType.RTRN for x in copied.tsdf.columns.get_level_values(1)]
-    if not any(vtypes):
-        copied.value_to_ret()
+    copied.value_to_ret()
     cldr = copied.tsdf.iloc[1:].copy()
     if relabel:
         if freq.upper() == "BYE":
@@ -244,7 +242,7 @@ def report_html(
             x=bdf.index,
             y=bdf.iloc[:, item],
             hovertemplate="%{y:.2%}<br>%{x}",
-            name=bdf.iloc[:, item].name[0],
+            name=bdf.iloc[:, item].name[0],  # type: ignore[index]
             showlegend=False,
             row=2,
             col=1,
@@ -265,7 +263,7 @@ def report_html(
     ]
 
     # noinspection PyTypeChecker
-    rpt_df = data.all_properties(properties=properties)
+    rpt_df = data.all_properties(properties=properties)  # type: ignore[arg-type]
     alpha_frame = data.from_deepcopy()
     alpha_frame.to_cumret()
     with catch_warnings():