openseries 1.5.7__py3-none-any.whl → 1.7.0__py3-none-any.whl

openseries/frame.py

@@ -1,39 +1,29 @@
 """Defining the OpenFrame class."""
 
-# mypy: disable-error-code="index,assignment"
+# mypy: disable-error-code="index,assignment,arg-type"
 from __future__ import annotations
 
-import datetime as dt
 from copy import deepcopy
 from functools import reduce
-from inspect import stack
 from logging import warning
-from pathlib import Path
-from typing import Callable, Optional, Union, cast
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    import datetime as dt  # pragma: no cover
 
 import statsmodels.api as sm  # type: ignore[import-untyped,unused-ignore]
 from numpy import (
-    append,
     array,
     cov,
     cumprod,
     divide,
-    dot,
-    float64,
-    inf,
     isinf,
-    linspace,
     log,
     nan,
     sqrt,
     square,
     std,
-    zeros,
-)
-from numpy import (
-    sum as npsum,
 )
-from numpy.typing import NDArray
 from pandas import (
     DataFrame,
     DatetimeIndex,
@@ -44,11 +34,7 @@ from pandas import (
     concat,
     merge,
 )
-from plotly.graph_objs import Figure  # type: ignore[import-untyped,unused-ignore]
-from plotly.io import to_html  # type: ignore[import-untyped,unused-ignore]
-from plotly.offline import plot  # type: ignore[import-untyped,unused-ignore]
-from pydantic import DirectoryPath, field_validator
-from scipy.optimize import minimize  # type: ignore[import-untyped,unused-ignore]
+from pydantic import field_validator
 
 # noinspection PyProtectedMember
 from statsmodels.regression.linear_model import (  # type: ignore[import-untyped,unused-ignore]
@@ -56,36 +42,31 @@ from statsmodels.regression.linear_model import (  # type: ignore[import-untyped
 )
 from typing_extensions import Self
 
-from openseries._common_model import _CommonModel
-from openseries.datefixer import do_resample_to_business_period_ends
-from openseries.load_plotly import load_plotly_dict
-from openseries.series import OpenTimeSeries
-from openseries.simulation import random_generator
-from openseries.types import (
+from ._common_model import _CommonModel
+from .datefixer import do_resample_to_business_period_ends
+from .series import OpenTimeSeries
+from .types import (
     CountriesType,
     DaysInYearType,
     LiteralBizDayFreq,
     LiteralCaptureRatio,
     LiteralFrameProps,
     LiteralHowMerge,
-    LiteralLinePlotMode,
     LiteralOlsFitCovType,
     LiteralOlsFitMethod,
     LiteralPandasReindexMethod,
-    LiteralPlotlyJSlib,
-    LiteralPlotlyOutput,
     LiteralPortfolioWeightings,
     LiteralTrunc,
     OpenFramePropertiesList,
     ValueType,
 )
 
+__all__ = ["OpenFrame"]
 
-# noinspection PyUnresolvedReferences
-class OpenFrame(_CommonModel):
 
-    """
-    OpenFrame objects hold OpenTimeSeries in the list constituents.
+# noinspection PyUnresolvedReferences,PyTypeChecker
+class OpenFrame(_CommonModel):
+    """OpenFrame objects hold OpenTimeSeries in the list constituents.
 
     The intended use is to allow comparisons across these timeseries.
 
@@ -105,7 +86,7 @@ class OpenFrame(_CommonModel):
 
     constituents: list[OpenTimeSeries]
     tsdf: DataFrame = DataFrame(dtype="float64")
-    weights: Optional[list[float]] = None
+    weights: list[float] | None = None
 
     # noinspection PyMethodParameters
     @field_validator("constituents")  # type: ignore[misc]
@@ -123,10 +104,9 @@ class OpenFrame(_CommonModel):
     def __init__(
         self: Self,
         constituents: list[OpenTimeSeries],
-        weights: Optional[list[float]] = None,
+        weights: list[float] | None = None,
     ) -> None:
-        """
-        OpenFrame objects hold OpenTimeSeries in the list constituents.
+        """OpenFrame objects hold OpenTimeSeries in the list constituents.
 
         The intended use is to allow comparisons across these timeseries.
 
@@ -163,8 +143,7 @@ class OpenFrame(_CommonModel):
             warning("OpenFrame() was passed an empty list.")
 
     def from_deepcopy(self: Self) -> Self:
-        """
-        Create copy of the OpenFrame object.
+        """Create copy of the OpenFrame object.
 
         Returns
         -------
@@ -178,8 +157,7 @@ class OpenFrame(_CommonModel):
         self: Self,
         how: LiteralHowMerge = "outer",
     ) -> Self:
-        """
-        Merge index of Pandas Dataframes of the constituent OpenTimeSeries.
+        """Merge index of Pandas Dataframes of the constituent OpenTimeSeries.
 
         Parameters
         ----------
@@ -221,10 +199,9 @@ class OpenFrame(_CommonModel):
 
     def all_properties(
         self: Self,
-        properties: Optional[list[LiteralFrameProps]] = None,
+        properties: list[LiteralFrameProps] | None = None,
     ) -> DataFrame:
-        """
-        Calculate chosen timeseries properties.
+        """Calculate chosen timeseries properties.
 
         Parameters
         ----------
@@ -248,8 +225,7 @@ class OpenFrame(_CommonModel):
 
     @property
     def lengths_of_items(self: Self) -> Series[int]:
-        """
-        Number of observations of all constituents.
+        """Number of observations of all constituents.
 
         Returns
         -------
@@ -266,8 +242,7 @@ class OpenFrame(_CommonModel):
 
     @property
     def item_count(self: Self) -> int:
-        """
-        Number of constituents.
+        """Number of constituents.
 
         Returns
         -------
@@ -279,8 +254,7 @@ class OpenFrame(_CommonModel):
 
     @property
     def columns_lvl_zero(self: Self) -> list[str]:
-        """
-        Level 0 values of the MultiIndex columns in the .tsdf DataFrame.
+        """Level 0 values of the MultiIndex columns in the .tsdf DataFrame.
 
         Returns
         -------
@@ -292,8 +266,7 @@ class OpenFrame(_CommonModel):
 
     @property
     def columns_lvl_one(self: Self) -> list[ValueType]:
-        """
-        Level 1 values of the MultiIndex columns in the .tsdf DataFrame.
+        """Level 1 values of the MultiIndex columns in the .tsdf DataFrame.
 
         Returns
         -------
@@ -305,8 +278,7 @@ class OpenFrame(_CommonModel):
 
     @property
     def first_indices(self: Self) -> Series[dt.date]:
-        """
-        The first dates in the timeseries of all constituents.
+        """The first dates in the timeseries of all constituents.
 
         Returns
         -------
@@ -323,8 +295,7 @@ class OpenFrame(_CommonModel):
 
     @property
     def last_indices(self: Self) -> Series[dt.date]:
-        """
-        The last dates in the timeseries of all constituents.
+        """The last dates in the timeseries of all constituents.
 
         Returns
         -------
@@ -341,8 +312,7 @@ class OpenFrame(_CommonModel):
 
     @property
     def span_of_days_all(self: Self) -> Series[int]:
-        """
-        Number of days from the first date to the last for all items in the frame.
+        """Number of days from the first date to the last for all items in the frame.
 
         Returns
         -------
@@ -359,8 +329,7 @@ class OpenFrame(_CommonModel):
         )
 
     def value_to_ret(self: Self) -> Self:
-        """
-        Convert series of values into series of returns.
+        """Convert series of values into series of returns.
 
         Returns
         -------
@@ -368,7 +337,7 @@ class OpenFrame(_CommonModel):
             The returns of the values in the series
 
         """
-        self.tsdf = self.tsdf.pct_change(fill_method=cast(str, None))
+        self.tsdf = self.tsdf.pct_change(fill_method=None)
         self.tsdf.iloc[0] = 0
         new_labels = [ValueType.RTRN] * self.item_count
         arrays = [self.tsdf.columns.get_level_values(0), new_labels]
@@ -376,8 +345,7 @@ class OpenFrame(_CommonModel):
         return self
 
     def value_to_diff(self: Self, periods: int = 1) -> Self:
-        """
-        Convert series of values to series of their period differences.
+        """Convert series of values to series of their period differences.
 
         Parameters
         ----------
@@ -399,8 +367,7 @@ class OpenFrame(_CommonModel):
         return self
 
     def to_cumret(self: Self) -> Self:
-        """
-        Convert series of returns into cumulative series of values.
+        """Convert series of returns into cumulative series of values.
 
         Returns
         -------
@@ -423,14 +390,13 @@ class OpenFrame(_CommonModel):
 
     def resample(
         self: Self,
-        freq: Union[LiteralBizDayFreq, str] = "BME",
+        freq: LiteralBizDayFreq | str = "BME",
     ) -> Self:
-        """
-        Resample the timeseries frequency.
+        """Resample the timeseries frequency.
 
         Parameters
         ----------
-        freq: Union[LiteralBizDayFreq, str], default "BME"
+        freq: LiteralBizDayFreq | str, default "BME"
             The date offset string that sets the resampled frequency
 
         Returns
@@ -457,8 +423,7 @@ class OpenFrame(_CommonModel):
         countries: CountriesType = "SE",
         method: LiteralPandasReindexMethod = "nearest",
     ) -> Self:
-        """
-        Resamples timeseries frequency to the business calendar month end dates.
+        """Resamples timeseries frequency to the business calendar month end dates.
 
         Stubs left in place. Stubs will be aligned to the shortest stub.
 
@@ -478,12 +443,12 @@ class OpenFrame(_CommonModel):
             An OpenFrame object
 
         """
-        head = self.tsdf.loc[self.first_indices.max()].copy()
-        tail = self.tsdf.loc[self.last_indices.min()].copy()
+        head: Series[float] = self.tsdf.loc[self.first_indices.max()].copy()
+        tail: Series[float] = self.tsdf.loc[self.last_indices.min()].copy()
         dates = do_resample_to_business_period_ends(
             data=self.tsdf,
-            head=head,  # type: ignore[arg-type,unused-ignore]
-            tail=tail,  # type: ignore[arg-type,unused-ignore]
+            head=head,
+            tail=tail,
             freq=freq,
             countries=countries,
         )
@@ -502,13 +467,12 @@ class OpenFrame(_CommonModel):
         dlta_degr_freedms: int = 0,
         first_column: int = 0,
         second_column: int = 1,
-        months_from_last: Optional[int] = None,
-        from_date: Optional[dt.date] = None,
-        to_date: Optional[dt.date] = None,
-        periods_in_a_year_fixed: Optional[DaysInYearType] = None,
+        months_from_last: int | None = None,
+        from_date: dt.date | None = None,
+        to_date: dt.date | None = None,
+        periods_in_a_year_fixed: DaysInYearType | None = None,
     ) -> DataFrame:
-        """
-        Exponentially Weighted Moving Average Volatilities and Correlation.
+        """Exponentially Weighted Moving Average Volatilities and Correlation.
 
         Exponentially Weighted Moving Average (EWMA) for Volatilities and
         Correlation. https://www.investopedia.com/articles/07/ewma.asp.
@@ -620,8 +584,7 @@ class OpenFrame(_CommonModel):
 
     @property
     def correl_matrix(self: Self) -> DataFrame:
-        """
-        Correlation matrix.
+        """Correlation matrix.
 
         Returns
         -------
@@ -629,7 +592,7 @@ class OpenFrame(_CommonModel):
             Correlation matrix
 
         """
-        corr_matrix = self.tsdf.pct_change(fill_method=cast(str, None)).corr(
+        corr_matrix = self.tsdf.pct_change(fill_method=None).corr(
             method="pearson",
             min_periods=1,
         )
@@ -642,8 +605,7 @@ class OpenFrame(_CommonModel):
         self: Self,
         new_series: OpenTimeSeries,
     ) -> Self:
-        """
-        To add an OpenTimeSeries object.
+        """To add an OpenTimeSeries object.
 
         Parameters
         ----------
@@ -662,8 +624,7 @@ class OpenFrame(_CommonModel):
         return self
 
     def delete_timeseries(self: Self, lvl_zero_item: str) -> Self:
-        """
-        To delete an OpenTimeSeries object.
+        """To delete an OpenTimeSeries object.
 
         Parameters
         ----------
@@ -693,12 +654,11 @@ class OpenFrame(_CommonModel):
 
     def trunc_frame(
         self: Self,
-        start_cut: Optional[dt.date] = None,
-        end_cut: Optional[dt.date] = None,
+        start_cut: dt.date | None = None,
+        end_cut: dt.date | None = None,
         where: LiteralTrunc = "both",
     ) -> Self:
-        """
-        Truncate DataFrame such that all timeseries have the same time span.
+        """Truncate DataFrame such that all timeseries have the same time span.
 
         Parameters
         ----------
@@ -752,8 +712,7 @@ class OpenFrame(_CommonModel):
         *,
         base_zero: bool = True,
     ) -> None:
-        """
-        Calculate cumulative relative return between two series.
+        """Calculate cumulative relative return between two series.
 
         Parameters
         ----------
@@ -785,14 +744,13 @@ class OpenFrame(_CommonModel):
 
     def tracking_error_func(
         self: Self,
-        base_column: Union[tuple[str, ValueType], int] = -1,
-        months_from_last: Optional[int] = None,
-        from_date: Optional[dt.date] = None,
-        to_date: Optional[dt.date] = None,
-        periods_in_a_year_fixed: Optional[DaysInYearType] = None,
+        base_column: tuple[str, ValueType] | int = -1,
+        months_from_last: int | None = None,
+        from_date: dt.date | None = None,
+        to_date: dt.date | None = None,
+        periods_in_a_year_fixed: DaysInYearType | None = None,
     ) -> Series[float]:
-        """
-        Tracking Error.
+        """Tracking Error.
 
         Calculates Tracking Error which is the standard deviation of the
         difference between the fund and its index returns.
@@ -800,7 +758,7 @@ class OpenFrame(_CommonModel):
 
         Parameters
         ----------
-        base_column: Union[tuple[str, ValueType], int], default: -1
+        base_column: tuple[str, ValueType] | int, default: -1
             Column of timeseries that is the denominator in the ratio.
         months_from_last : int, optional
             number of months offset as positive integer. Overrides use of from_date
@@ -865,8 +823,7 @@ class OpenFrame(_CommonModel):
                 # noinspection PyTypeChecker
                 relative = 1.0 + longdf - shortdf
                 vol = float(
-                    relative.pct_change(fill_method=cast(str, None)).std()
-                    * sqrt(time_factor),
+                    relative.pct_change(fill_method=None).std() * sqrt(time_factor),
                 )
                 terrors.append(vol)
 
@@ -879,14 +836,13 @@ class OpenFrame(_CommonModel):
 
     def info_ratio_func(
         self: Self,
-        base_column: Union[tuple[str, ValueType], int] = -1,
-        months_from_last: Optional[int] = None,
-        from_date: Optional[dt.date] = None,
-        to_date: Optional[dt.date] = None,
-        periods_in_a_year_fixed: Optional[DaysInYearType] = None,
+        base_column: tuple[str, ValueType] | int = -1,
+        months_from_last: int | None = None,
+        from_date: dt.date | None = None,
+        to_date: dt.date | None = None,
+        periods_in_a_year_fixed: DaysInYearType | None = None,
     ) -> Series[float]:
-        """
-        Information Ratio.
+        """Information Ratio.
 
         The Information Ratio equals ( fund return less index return ) divided
         by the Tracking Error. And the Tracking Error is the standard deviation of
@@ -895,7 +851,7 @@ class OpenFrame(_CommonModel):
 
         Parameters
         ----------
-        base_column: Union[tuple[str, ValueType], int], default: -1
+        base_column: tuple[str, ValueType] | int, default: -1
             Column of timeseries that is the denominator in the ratio.
         months_from_last : int, optional
             number of months offset as positive integer. Overrides use of from_date
@@ -960,12 +916,10 @@ class OpenFrame(_CommonModel):
                 # noinspection PyTypeChecker
                 relative = 1.0 + longdf - shortdf
                 ret = float(
-                    relative.pct_change(fill_method=cast(str, None)).mean()
-                    * time_factor,
+                    relative.pct_change(fill_method=None).mean() * time_factor,
                 )
                 vol = float(
-                    relative.pct_change(fill_method=cast(str, None)).std()
-                    * sqrt(time_factor),
+                    relative.pct_change(fill_method=None).std() * sqrt(time_factor),
                 )
                 ratios.append(ret / vol)
 
@@ -979,14 +933,13 @@ class OpenFrame(_CommonModel):
     def capture_ratio_func(  # noqa: C901
         self: Self,
         ratio: LiteralCaptureRatio,
-        base_column: Union[tuple[str, ValueType], int] = -1,
-        months_from_last: Optional[int] = None,
-        from_date: Optional[dt.date] = None,
-        to_date: Optional[dt.date] = None,
-        periods_in_a_year_fixed: Optional[DaysInYearType] = None,
+        base_column: tuple[str, ValueType] | int = -1,
+        months_from_last: int | None = None,
+        from_date: dt.date | None = None,
+        to_date: dt.date | None = None,
+        periods_in_a_year_fixed: DaysInYearType | None = None,
     ) -> Series[float]:
-        """
-        Capture Ratio.
+        """Capture Ratio.
 
         The Up (Down) Capture Ratio is calculated by dividing the CAGR
         of the asset during periods that the benchmark returns are positive (negative)
@@ -1001,7 +954,7 @@ class OpenFrame(_CommonModel):
         ----------
         ratio: LiteralCaptureRatio
             The ratio to calculate
-        base_column: Union[tuple[str, ValueType], int], default: -1
+        base_column: tuple[str, ValueType] | int, default: -1
             Column of timeseries that is the denominator in the ratio.
         months_from_last : int, optional
             number of months offset as positive integer. Overrides use of from_date
@@ -1066,8 +1019,8 @@ class OpenFrame(_CommonModel):
                 ]
                 if ratio == "up":
                     uparray = (
-                        longdf.pct_change(fill_method=cast(str, None))[
-                            shortdf.pct_change(fill_method=cast(str, None)).to_numpy()
+                        longdf.pct_change(fill_method=None)[
+                            shortdf.pct_change(fill_method=None).to_numpy()
                             > loss_limit
                         ]
                         .add(1)
@@ -1075,8 +1028,8 @@ class OpenFrame(_CommonModel):
                     )
                     up_rtrn = uparray.prod() ** (1 / (len(uparray) / time_factor)) - 1
                     upidxarray = (
-                        shortdf.pct_change(fill_method=cast(str, None))[
-                            shortdf.pct_change(fill_method=cast(str, None)).to_numpy()
+                        shortdf.pct_change(fill_method=None)[
+                            shortdf.pct_change(fill_method=None).to_numpy()
                             > loss_limit
                         ]
                         .add(1)
@@ -1088,8 +1041,8 @@ class OpenFrame(_CommonModel):
                     ratios.append(up_rtrn / up_idx_return)
                 elif ratio == "down":
                     downarray = (
-                        longdf.pct_change(fill_method=cast(str, None))[
-                            shortdf.pct_change(fill_method=cast(str, None)).to_numpy()
+                        longdf.pct_change(fill_method=None)[
+                            shortdf.pct_change(fill_method=None).to_numpy()
                             < loss_limit
                         ]
                         .add(1)
@@ -1099,8 +1052,8 @@ class OpenFrame(_CommonModel):
                         downarray.prod() ** (1 / (len(downarray) / time_factor)) - 1
                     )
                     downidxarray = (
-                        shortdf.pct_change(fill_method=cast(str, None))[
-                            shortdf.pct_change(fill_method=cast(str, None)).to_numpy()
+                        shortdf.pct_change(fill_method=None)[
+                            shortdf.pct_change(fill_method=None).to_numpy()
                             < loss_limit
                         ]
                         .add(1)
@@ -1113,8 +1066,8 @@ class OpenFrame(_CommonModel):
                     ratios.append(down_return / down_idx_return)
                 elif ratio == "both":
                     uparray = (
-                        longdf.pct_change(fill_method=cast(str, None))[
-                            shortdf.pct_change(fill_method=cast(str, None)).to_numpy()
+                        longdf.pct_change(fill_method=None)[
+                            shortdf.pct_change(fill_method=None).to_numpy()
                             > loss_limit
                         ]
                         .add(1)
@@ -1122,8 +1075,8 @@ class OpenFrame(_CommonModel):
                     )
                     up_rtrn = uparray.prod() ** (1 / (len(uparray) / time_factor)) - 1
                     upidxarray = (
-                        shortdf.pct_change(fill_method=cast(str, None))[
-                            shortdf.pct_change(fill_method=cast(str, None)).to_numpy()
+                        shortdf.pct_change(fill_method=None)[
+                            shortdf.pct_change(fill_method=None).to_numpy()
                             > loss_limit
                         ]
                         .add(1)
@@ -1133,8 +1086,8 @@ class OpenFrame(_CommonModel):
                         upidxarray.prod() ** (1 / (len(upidxarray) / time_factor)) - 1
                     )
                     downarray = (
-                        longdf.pct_change(fill_method=cast(str, None))[
-                            shortdf.pct_change(fill_method=cast(str, None)).to_numpy()
+                        longdf.pct_change(fill_method=None)[
+                            shortdf.pct_change(fill_method=None).to_numpy()
                             < loss_limit
                         ]
                         .add(1)
@@ -1144,8 +1097,8 @@ class OpenFrame(_CommonModel):
                         downarray.prod() ** (1 / (len(downarray) / time_factor)) - 1
                     )
                     downidxarray = (
-                        shortdf.pct_change(fill_method=cast(str, None))[
-                            shortdf.pct_change(fill_method=cast(str, None)).to_numpy()
+                        shortdf.pct_change(fill_method=None)[
+                            shortdf.pct_change(fill_method=None).to_numpy()
                             < loss_limit
                         ]
                         .add(1)
@@ -1175,21 +1128,20 @@ class OpenFrame(_CommonModel):
 
     def beta(
         self: Self,
-        asset: Union[tuple[str, ValueType], int],
-        market: Union[tuple[str, ValueType], int],
+        asset: tuple[str, ValueType] | int,
+        market: tuple[str, ValueType] | int,
         dlta_degr_freedms: int = 1,
     ) -> float:
-        """
-        Market Beta.
+        """Market Beta.
 
         Calculates Beta as Co-variance of asset & market divided by Variance
         of the market. https://www.investopedia.com/terms/b/beta.asp.
 
         Parameters
         ----------
-        asset: Union[tuple[str, ValueType], int]
+        asset: tuple[str, ValueType] | int
             The column of the asset
-        market: Union[tuple[str, ValueType], int]
+        market: tuple[str, ValueType] | int
             The column of the market against which Beta is measured
         dlta_degr_freedms: int, default: 1
             Variance bias factor taking the value 0 or 1.
@@ -1257,15 +1209,14 @@ class OpenFrame(_CommonModel):
 
     def ord_least_squares_fit(
         self: Self,
-        y_column: Union[tuple[str, ValueType], int],
-        x_column: Union[tuple[str, ValueType], int],
+        y_column: tuple[str, ValueType] | int,
+        x_column: tuple[str, ValueType] | int,
         method: LiteralOlsFitMethod = "pinv",
         cov_type: LiteralOlsFitCovType = "nonrobust",
         *,
         fitted_series: bool = True,
     ) -> OLSResults:
-        """
-        Ordinary Least Squares fit.
+        """Ordinary Least Squares fit.
 
         Performs a linear regression and adds a new column with a fitted line
         using Ordinary Least Squares fit
@@ -1273,9 +1224,9 @@ class OpenFrame(_CommonModel):
 
         Parameters
         ----------
-        y_column: Union[tuple[str, ValueType], int]
+        y_column: tuple[str, ValueType] | int
             The column level values of the dependent variable y
-        x_column: Union[tuple[str, ValueType], int]
+        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
@@ -1328,13 +1279,12 @@ class OpenFrame(_CommonModel):
 
     def jensen_alpha(  # noqa: C901
         self: Self,
-        asset: Union[tuple[str, ValueType], int],
-        market: Union[tuple[str, ValueType], int],
+        asset: tuple[str, ValueType] | int,
+        market: tuple[str, ValueType] | int,
         riskfree_rate: float = 0.0,
         dlta_degr_freedms: int = 1,
     ) -> float:
-        """
-        Jensen's alpha.
+        """Jensen's alpha.
 
         The Jensen's measure, or Jensen's alpha, is a risk-adjusted performance
         measure that represents the average return on a portfolio or investment,
@@ -1345,9 +1295,9 @@ class OpenFrame(_CommonModel):
 
         Parameters
         ----------
-        asset: Union[tuple[str, ValueType], int]
+        asset: tuple[str, ValueType] | int
             The column of the asset
-        market: Union[tuple[str, ValueType], int]
+        market: tuple[str, ValueType] | int
             The column of the market against which Jensen's alpha is measured
         riskfree_rate : float, default: 0.0
             The return of the zero volatility riskfree asset
@@ -1467,10 +1417,9 @@ class OpenFrame(_CommonModel):
     def make_portfolio(
         self: Self,
         name: str,
-        weight_strat: Optional[LiteralPortfolioWeightings] = None,
+        weight_strat: LiteralPortfolioWeightings | None = None,
     ) -> DataFrame:
-        """
-        Calculate a basket timeseries based on the supplied weights.
+        """Calculate a basket timeseries based on the supplied weights.
 
         Parameters
         ----------
@@ -1498,7 +1447,7 @@ class OpenFrame(_CommonModel):
             x == ValueType.RTRN
             for x in self.tsdf.columns.get_level_values(1).to_numpy()
         ):
-            dframe = dframe.pct_change(fill_method=cast(str, None))
+            dframe = dframe.pct_change(fill_method=None)
             dframe.iloc[0] = 0
         if weight_strat:
             if weight_strat == "eq_weights":
@@ -1522,10 +1471,9 @@ class OpenFrame(_CommonModel):
         long_column: int = 0,
         short_column: int = 1,
         observations: int = 21,
-        periods_in_a_year_fixed: Optional[DaysInYearType] = None,
+        periods_in_a_year_fixed: DaysInYearType | None = None,
     ) -> DataFrame:
-        """
-        Calculate rolling Information Ratio.
+        """Calculate rolling Information Ratio.
 
         The Information Ratio equals ( fund return less index return ) divided by
         the Tracking Error. And the Tracking Error is the standard deviation of the
@@ -1567,13 +1515,13 @@ class OpenFrame(_CommonModel):
         )
 
         retseries = (
-            relative.pct_change(fill_method=cast(str, None))
+            relative.pct_change(fill_method=None)
             .rolling(observations, min_periods=observations)
             .sum()
         )
         retdf = retseries.dropna().to_frame()
 
-        voldf = relative.pct_change(fill_method=cast(str, None)).rolling(
+        voldf = relative.pct_change(fill_method=None).rolling(
             observations,
             min_periods=observations,
         ).std() * sqrt(time_factor)
@@ -1591,8 +1539,7 @@ class OpenFrame(_CommonModel):
         observations: int = 21,
         dlta_degr_freedms: int = 1,
     ) -> DataFrame:
-        """
-        Calculate rolling Market Beta.
+        """Calculate rolling Market Beta.
 
         Calculates Beta as Co-variance of asset & market divided by Variance
         of the market. https://www.investopedia.com/terms/b/beta.asp.
@@ -1618,8 +1565,7 @@ class OpenFrame(_CommonModel):
         asset_label = cast(tuple[str, str], self.tsdf.iloc[:, asset_column].name)[0]
         beta_label = f"{asset_label} / {market_label}"
 
-        rolling: DataFrame = self.tsdf.copy()
-        rolling = rolling.pct_change(fill_method=cast(str, None)).rolling(
+        rolling = self.tsdf.pct_change(fill_method=None).rolling(
             observations,
             min_periods=observations,
         )
@@ -1649,8 +1595,7 @@ class OpenFrame(_CommonModel):
         second_column: int = 1,
         observations: int = 21,
     ) -> DataFrame:
-        """
-        Calculate rolling Correlation.
+        """Calculate rolling Correlation.
 
         Calculates correlation between two series. The period with
         at least the given number of observations is the first period calculated.
@@ -1677,11 +1622,11 @@ class OpenFrame(_CommonModel):
         )
         first_series = (
             self.tsdf.iloc[:, first_column]
-            .pct_change(fill_method=cast(str, None))[1:]
+            .pct_change(fill_method=None)[1:]
             .rolling(observations, min_periods=observations)
         )
         second_series = self.tsdf.iloc[:, second_column].pct_change(
-            fill_method=cast(str, None),
+            fill_method=None,
         )[1:]
         corrdf = first_series.corr(other=second_series).dropna().to_frame()
         corrdf.columns = MultiIndex.from_arrays(
@@ -1692,549 +1637,3 @@ class OpenFrame(_CommonModel):
         )
 
         return DataFrame(corrdf)
-
-
-def simulate_portfolios(
-    simframe: OpenFrame,
-    num_ports: int,
-    seed: int,
-) -> DataFrame:
-    """
-    Generate random weights for simulated portfolios.
-
-    Parameters
-    ----------
-    simframe: OpenFrame
-        Return data for portfolio constituents
-    num_ports: int
-        Number of possible portfolios to simulate
-    seed: int
-        The seed for the random process
-
-    Returns
-    -------
-    pandas.DataFrame
-        The resulting data
-
-    """
-    copi = simframe.from_deepcopy()
-
-    if any(
-        x == ValueType.PRICE for x in copi.tsdf.columns.get_level_values(1).to_numpy()
-    ):
-        copi.value_to_ret()
-        log_ret = copi.tsdf.copy()[1:]
-    else:
-        log_ret = copi.tsdf.copy()
-
-    log_ret.columns = log_ret.columns.droplevel(level=1)
-
-    randomizer = random_generator(seed=seed)
-
-    all_weights = zeros((num_ports, simframe.item_count))
-    ret_arr = zeros(num_ports)
-    vol_arr = zeros(num_ports)
-    sharpe_arr = zeros(num_ports)
-
-    for x in range(num_ports):
-        weights = array(randomizer.random(simframe.item_count))
-        weights = weights / npsum(weights)
-        all_weights[x, :] = weights
-
-        vol_arr[x] = sqrt(
-            dot(
-                weights.T,
-                dot(log_ret.cov() * simframe.periods_in_a_year, weights),
-            ),
-        )
-
-        ret_arr[x] = npsum(log_ret.mean() * weights * simframe.periods_in_a_year)
-
-        sharpe_arr[x] = ret_arr[x] / vol_arr[x]
-
-    # noinspection PyUnreachableCode
-    simdf = concat(
-        [
-            DataFrame({"stdev": vol_arr, "ret": ret_arr, "sharpe": sharpe_arr}),
-            DataFrame(all_weights, columns=simframe.columns_lvl_zero),
-        ],
-        axis="columns",
-    )
-    simdf = simdf.replace([inf, -inf], nan)
-    return simdf.dropna()
-
-
-def efficient_frontier(  # noqa: C901
-    eframe: OpenFrame,
-    num_ports: int = 5000,
-    seed: int = 71,
-    upperbounds: float = 1.0,
-    frontier_points: int = 200,
-    *,
-    tweak: bool = True,
-) -> tuple[DataFrame, DataFrame, NDArray[float64]]:
-    """
-    Identify an efficient frontier.
-
-    Parameters
-    ----------
-    eframe: OpenFrame
-        Portfolio data
-    num_ports: int, default: 5000
-        Number of possible portfolios to simulate
-    seed: int, default: 71
-        The seed for the random process
-    upperbounds: float, default: 1.0
-        The largest allowed allocation to a single asset
-    frontier_points: int, default: 200
-        number of points along frontier to optimize
-    tweak: bool, default: True
-        cutting the frontier to exclude multiple points with almost the same risk
-
-    Returns
-    -------
-    tuple[DataFrame, DataFrame, NDArray[float]]
-        The efficient frontier data, simulation data and optimal portfolio
-
-    """
-    if eframe.weights is None:
-        eframe.weights = [1.0 / eframe.item_count] * eframe.item_count
-
-    copi = eframe.from_deepcopy()
-
-    if any(
-        x == ValueType.PRICE for x in copi.tsdf.columns.get_level_values(1).to_numpy()
-    ):
-        copi.value_to_ret()
-        log_ret = copi.tsdf.copy()[1:]
-    else:
-        log_ret = copi.tsdf.copy()
-
-    log_ret.columns = log_ret.columns.droplevel(level=1)
-
-    simulated = simulate_portfolios(simframe=copi, num_ports=num_ports, seed=seed)
-
-    frontier_min = simulated.loc[simulated["stdev"].idxmin()]["ret"]
-    arithmetic_mean = log_ret.mean() * copi.periods_in_a_year
-    frontier_max = 0.0
-    if isinstance(arithmetic_mean, Series):
-        frontier_max = arithmetic_mean.max()
-
-    def _check_sum(weights: NDArray[float64]) -> float64:
-        return cast(float64, npsum(weights) - 1)
-
-    def _get_ret_vol_sr(
-        lg_ret: DataFrame,
-        weights: NDArray[float64],
-        per_in_yr: float,
-    ) -> NDArray[float64]:
-        ret = npsum(lg_ret.mean() * weights) * per_in_yr
-        volatility = sqrt(dot(weights.T, dot(lg_ret.cov() * per_in_yr, weights)))
-        sr = ret / volatility
-        return cast(NDArray[float64], array([ret, volatility, sr]))
-
-    def _diff_return(
-        lg_ret: DataFrame,
-        weights: NDArray[float64],
-        per_in_yr: float,
-        poss_return: float,
-    ) -> float64:
-        return cast(
-            float64,
-            _get_ret_vol_sr(lg_ret=lg_ret, weights=weights, per_in_yr=per_in_yr)[0]
-            - poss_return,
-        )
-
-    def _neg_sharpe(weights: NDArray[float64]) -> float64:
-        return cast(
-            float64,
-            _get_ret_vol_sr(
-                lg_ret=log_ret,
-                weights=weights,
-                per_in_yr=eframe.periods_in_a_year,
-            )[2]
-            * -1,
-        )
-
-    def _minimize_volatility(
-        weights: NDArray[float64],
-    ) -> float64:
-        return cast(
-            float64,
-            _get_ret_vol_sr(
-                lg_ret=log_ret,
-                weights=weights,
-                per_in_yr=eframe.periods_in_a_year,
-            )[1],
-        )
-
-    constraints = {"type": "eq", "fun": _check_sum}
-    bounds = tuple((0, upperbounds) for _ in range(eframe.item_count))
-    init_guess = array(eframe.weights)
-
-    opt_results = minimize(
-        fun=_neg_sharpe,
-        x0=init_guess,
-        method="SLSQP",
-        bounds=bounds,
-        constraints=constraints,
-    )
-
-    optimal = _get_ret_vol_sr(
-        lg_ret=log_ret,
-        weights=opt_results.x,
-        per_in_yr=eframe.periods_in_a_year,
-    )
-
-    frontier_y = linspace(start=frontier_min, stop=frontier_max, num=frontier_points)
-    frontier_x = []
-    frontier_weights = []
-
-    for possible_return in frontier_y:
-        cons = cast(
-            dict[str, Union[str, Callable[[float, NDArray[float64]], float64]]],
-            (
-                {"type": "eq", "fun": _check_sum},
-                {
-                    "type": "eq",
-                    "fun": lambda w, poss_return=possible_return: _diff_return(
-                        lg_ret=log_ret,
-                        weights=w,
-                        per_in_yr=eframe.periods_in_a_year,
-                        poss_return=poss_return,
-                    ),
-                },
-            ),
-        )
-
-        result = minimize(
-            fun=_minimize_volatility,
-            x0=init_guess,
-            method="SLSQP",
-            bounds=bounds,
-            constraints=cons,
-        )
-
-        frontier_x.append(result["fun"])
-        frontier_weights.append(result["x"])
-
-    # noinspection PyUnreachableCode
-    line_df = concat(
-        [
-            DataFrame(data=frontier_weights, columns=eframe.columns_lvl_zero),
-            DataFrame({"stdev": frontier_x, "ret": frontier_y}),
-        ],
-        axis="columns",
-    )
-    line_df["sharpe"] = line_df.ret / line_df.stdev
-
-    limit_small = 0.0001
-    line_df = line_df.mask(line_df.abs() < limit_small, 0.0)
-    line_df["text"] = line_df.apply(
-        lambda c: "<br><br>Weights:<br>"
-        + "<br>".join(
-            [f"{c[nm]:.1%}  {nm}" for nm in eframe.columns_lvl_zero],
-        ),
-        axis="columns",
-    )
-
-    if tweak:
-        limit_tweak = 0.001
-        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")
-
-    return line_df, simulated, append(optimal, opt_results.x)
-
-
-def constrain_optimized_portfolios(
-    data: OpenFrame,
-    serie: OpenTimeSeries,
-    portfolioname: str = "Current Portfolio",
-    simulations: int = 10000,
-    curve_points: int = 200,
-    upper_bound: float = 0.25,
-) -> tuple[OpenFrame, OpenTimeSeries, OpenFrame, OpenTimeSeries]:
-    """
-    Constrain optimized portfolios to those that improve on the current one.
-
-    Parameters
-    ----------
-    data: OpenFrame
-        Portfolio data
-    serie: OpenTimeSeries
-        A
-    portfolioname: str, default: "Current Portfolio"
-        Name of the portfolio
-    simulations: int, default: 10000
-        Number of possible portfolios to simulate
-    curve_points: int, default: 200
-        Number of optimal portfolios on the efficient frontier
-    upper_bound: float, default: 0.25
-        The largest allowed allocation to a single asset
-
-    Returns
-    -------
-    tuple[OpenFrame, OpenTimeSeries, OpenFrame, OpenTimeSeries]
-        The constrained optimal portfolio data
-
-    """
-    lr_frame = data.from_deepcopy()
-    mv_frame = data.from_deepcopy()
-
-    front_frame, sim_frame, optimal = efficient_frontier(
-        eframe=data,
-        num_ports=simulations,
-        frontier_points=curve_points,
-        upperbounds=upper_bound,
-    )
-
-    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_name = f"Minimize vol & target return of {portfolioname}"
-    least_ret_weights = [least_ret_port[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))
-
-    condition_most_vol = front_frame.stdev < serie.vol
-    # noinspection PyArgumentList
-    most_vol_frame = front_frame[condition_most_vol].sort_values(
-        by="ret",
-        ascending=False,
-    )
-    most_vol_port = 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]
-    mv_frame.weights = most_vol_weights
-    resmost = OpenTimeSeries.from_df(mv_frame.make_portfolio(most_vol_port_name))
-
-    return lr_frame, resleast, mv_frame, resmost
-
-
-def prepare_plot_data(
-    assets: OpenFrame,
-    current: OpenTimeSeries,
-    optimized: NDArray[float64],
-) -> DataFrame:
-    """
-    Prepare date to be used as point_frame in the sharpeplot function.
-
-    Parameters
-    ----------
-    assets: OpenFrame
-        Portfolio data with individual assets and a weighted portfolio
-    current: OpenTimeSeries
-        The current or initial portfolio based on given weights
-    optimized: DataFrame
-        Data optimized with the efficient_frontier method
-
-    Returns
-    -------
-    DataFrame
-        The data prepared with mean returns, volatility and weights
-
-    """
-    txt = "<br><br>Weights:<br>" + "<br>".join(
-        [
-            f"{wgt:.1%}  {nm}"
-            for wgt, nm in zip(
-                cast(list[float], assets.weights),
-                assets.columns_lvl_zero,
-            )
-        ],
-    )
-
-    opt_text_list = [
-        f"{wgt:.1%}  {nm}" for wgt, nm in zip(optimized[3:], assets.columns_lvl_zero)
-    ]
-    opt_text = "<br><br>Weights:<br>" + "<br>".join(opt_text_list)
-    vol: Series[float] = assets.vol
-    plotframe = DataFrame(
-        data=[
-            assets.arithmetic_ret,
-            vol,
-            Series(
-                data=[""] * assets.item_count,
-                index=vol.index,
-            ),
-        ],
-        index=["ret", "stdev", "text"],
-    )
-    plotframe.columns = plotframe.columns.droplevel(level=1)
-    plotframe["Max Sharpe Portfolio"] = [optimized[0], optimized[1], opt_text]
-    plotframe[current.label] = [current.arithmetic_ret, current.vol, txt]
-
-    return plotframe
-
-
-def sharpeplot(  # noqa: C901
-    sim_frame: DataFrame = None,
-    line_frame: DataFrame = None,
-    point_frame: DataFrame = None,
-    point_frame_mode: LiteralLinePlotMode = "markers",
-    filename: Optional[str] = None,
-    directory: Optional[DirectoryPath] = None,
-    titletext: Optional[str] = None,
-    output_type: LiteralPlotlyOutput = "file",
-    include_plotlyjs: LiteralPlotlyJSlib = "cdn",
-    *,
-    title: bool = True,
-    add_logo: bool = True,
-    auto_open: bool = True,
-) -> tuple[Figure, str]:
-    """
-    Create scatter plot coloured by Sharpe Ratio.
-
-    Parameters
-    ----------
-    sim_frame: DataFrame, optional
-        Data from the simulate_portfolios method.
-    line_frame: DataFrame, optional
-        Data from the efficient_frontier method.
-    point_frame: DataFrame, optional
-        Data to highlight current and efficient portfolios.
-    point_frame_mode: LiteralLinePlotMode, default: markers
-        Which type of scatter to use.
-    filename: str, optional
-        Name of the Plotly html file
-    directory: DirectoryPath, optional
-        Directory where Plotly html file is saved
-    titletext: str, optional
-        Text for the plot title
-    output_type: LiteralPlotlyOutput, default: "file"
-        Determines output type
-    include_plotlyjs: LiteralPlotlyJSlib, default: "cdn"
-        Determines how the plotly.js library is included in the output
-    title: bool, default: True
-        Whether to add standard plot title
-    add_logo: bool, default: True
-        Whether to add Captor logo
-    auto_open: bool, default: True
-        Determines whether to open a browser window with the plot
-
-    Returns
-    -------
-    Figure
-        The scatter plot with simulated and optimized results
-
-    """
-    returns = []
-    risk = []
-
-    if directory:
-        dirpath = Path(directory).resolve()
-    elif Path.home().joinpath("Documents").exists():
-        dirpath = Path.home().joinpath("Documents")
-    else:
-        dirpath = Path(stack()[1].filename).parent
-
-    if not filename:
-        filename = "sharpeplot.html"
-    plotfile = dirpath.joinpath(filename)
-
-    fig, logo = load_plotly_dict()
-    figure = Figure(fig)
-
-    if sim_frame is not None:
-        returns.extend(list(sim_frame.loc[:, "ret"]))
-        risk.extend(list(sim_frame.loc[:, "stdev"]))
-        figure.add_scatter(
-            x=sim_frame.loc[:, "stdev"],
-            y=sim_frame.loc[:, "ret"],
-            hoverinfo="skip",
-            marker={
-                "size": 10,
-                "opacity": 0.5,
-                "color": sim_frame.loc[:, "sharpe"],
-                "colorscale": "Jet",
-                "reversescale": True,
-                "colorbar": {"thickness": 20, "title": "Ratio<br>ret / vol"},
-            },
-            mode="markers",
-            name="simulated portfolios",
-        )
-    if line_frame is not None:
-        returns.extend(list(line_frame.loc[:, "ret"]))
-        risk.extend(list(line_frame.loc[:, "stdev"]))
-        figure.add_scatter(
-            x=line_frame.loc[:, "stdev"],
-            y=line_frame.loc[:, "ret"],
-            text=line_frame.loc[:, "text"],
-            xhoverformat=".2%",
-            yhoverformat=".2%",
-            hovertemplate="Return %{y}<br>Vol %{x}%{text}",
-            hoverlabel_align="right",
-            line={"width": 2.5, "dash": "solid"},
-            mode="lines",
-            name="Efficient frontier",
-        )
-
-    colorway = cast(dict[str, list[str]], fig["layout"]).get("colorway")[
-        : len(point_frame.columns)
-    ]
-
-    if point_frame is not None:
-        for col, clr in zip(point_frame.columns, colorway):
-            returns.extend([point_frame.loc["ret", col]])
-            risk.extend([point_frame.loc["stdev", col]])
-            figure.add_scatter(
-                x=[point_frame.loc["stdev", col]],
-                y=[point_frame.loc["ret", col]],
-                xhoverformat=".2%",
-                yhoverformat=".2%",
-                hovertext=[point_frame.loc["text", col]],
-                hovertemplate="Return %{y}<br>Vol %{x}%{hovertext}",
-                hoverlabel_align="right",
-                marker={"size": 20, "color": clr},
-                mode=point_frame_mode,
-                name=col,
-                text=col,
-                textfont={"size": 14},
-                textposition="bottom center",
-            )
-
-    figure.update_layout(
-        xaxis={"tickformat": ".1%"},
-        xaxis_title="volatility",
-        yaxis={
-            "tickformat": ".1%",
-            "scaleanchor": "x",
-            "scaleratio": 1,
-        },
-        yaxis_title="annual return",
-        showlegend=False,
-    )
-    if title:
-        if titletext is None:
-            titletext = "<b>Risk and Return</b><br>"
-        figure.update_layout(title={"text": titletext, "font": {"size": 32}})
-
-    if add_logo:
-        figure.add_layout_image(logo)
-
-    if output_type == "file":
-        plot(
-            figure_or_data=figure,
-            filename=str(plotfile),
-            auto_open=auto_open,
-            auto_play=False,
-            link_text="",
-            include_plotlyjs=cast(bool, include_plotlyjs),
-            config=fig["config"],
-            output_type=output_type,
-        )
-        string_output = str(plotfile)
-    else:
-        div_id = filename.split(sep=".")[0]
-        string_output = to_html(
-            fig=figure,
-            config=fig["config"],
-            auto_play=False,
-            include_plotlyjs=cast(bool, include_plotlyjs),
-            full_html=False,
-            div_id=div_id,
-        )
-
-    return figure, string_output