openseries 1.4.12__py3-none-any.whl → 1.5.1__py3-none-any.whl

openseries/_common_model.py

@@ -1507,7 +1507,7 @@ class _CommonModel(BaseModel):
             Compounded Annual Growth Rate (CAGR)
 
         """
-        zero: float = 0.0
+        zero = 0.0
         earlier, later = self.calc_range(
             months_offset=months_from_last,
             from_dt=from_date,

openseries/_risk.py

@@ -124,9 +124,6 @@ def _calc_inv_vol_weights(returns: DataFrame) -> NDArray[float64]:
     """
     Calculate weights proportional to inverse volatility.
 
-    Source: https://github.com/pmorissette/ffn.
-    Function copied here because of FutureWarning from pandas ^2.1.0
-
     Parameters
     ----------
     returns: pandas.DataFrame

openseries/frame.py

@@ -1,19 +1,35 @@
 """Defining the OpenFrame class."""
+
 # mypy: disable-error-code="index,assignment"
 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 typing import Optional, Union, cast
+from pathlib import Path
+from typing import Callable, Optional, Union, cast
 
 import statsmodels.api as sm  # type: ignore[import-untyped,unused-ignore]
-from ffn.core import (  # type: ignore[import-untyped,unused-ignore]
-    calc_erc_weights,
-    calc_mean_var_weights,
+from numpy import (
+    append,
+    array,
+    cov,
+    cumprod,
+    dot,
+    float64,
+    inf,
+    linspace,
+    log,
+    nan,
+    sqrt,
+    zeros,
+)
+from numpy import (
+    sum as npsum,
 )
-from numpy import array, cov, cumprod, log, sqrt
+from numpy.typing import NDArray
 from pandas import (
     DataFrame,
     DatetimeIndex,
@@ -24,7 +40,11 @@ from pandas import (
     concat,
     merge,
 )
-from pydantic import field_validator
+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]
 
 # noinspection PyProtectedMember
 from statsmodels.regression.linear_model import (  # type: ignore[import-untyped,unused-ignore]
@@ -38,26 +58,30 @@ from openseries._risk import (
     _ewma_calc,
 )
 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 (
     CountriesType,
     DaysInYearType,
     LiteralBizDayFreq,
     LiteralCaptureRatio,
-    LiteralCovMethod,
     LiteralFrameProps,
     LiteralHowMerge,
+    LiteralLinePlotMode,
     LiteralOlsFitCovType,
     LiteralOlsFitMethod,
     LiteralPandasReindexMethod,
+    LiteralPlotlyJSlib,
+    LiteralPlotlyOutput,
     LiteralPortfolioWeightings,
-    LiteralRiskParityMethod,
     LiteralTrunc,
     OpenFramePropertiesList,
     ValueType,
 )
 
 
+# noinspection PyUnresolvedReferences
 class OpenFrame(_CommonModel):
 
     """
@@ -220,7 +244,7 @@ class OpenFrame(_CommonModel):
             prop_list = [
                 getattr(self, x) for x in OpenFramePropertiesList.allowed_strings
             ]
-        return concat(prop_list, axis="columns").T
+        return cast(DataFrame, concat(prop_list, axis="columns").T)
 
     @property
     def lengths_of_items(self: Self) -> Series[int]:
@@ -458,8 +482,8 @@ class OpenFrame(_CommonModel):
         tail = self.tsdf.loc[self.last_indices.min()].copy()
         dates = do_resample_to_business_period_ends(
             data=self.tsdf,
-            head=head,  # type: ignore[arg-type]
-            tail=tail,  # type: ignore[arg-type]
+            head=head,  # type: ignore[arg-type,unused-ignore]
+            tail=tail,  # type: ignore[arg-type,unused-ignore]
             freq=freq,
             countries=countries,
         )
@@ -637,6 +661,7 @@ class OpenFrame(_CommonModel):
 
         """
         self.constituents += [new_series]
+        # noinspection PyUnreachableCode
         self.tsdf = concat([self.tsdf, new_series.tsdf], axis="columns", sort=True)
         return self
 
@@ -841,6 +866,7 @@ class OpenFrame(_CommonModel):
                     :,
                     item,
                 ]
+                # noinspection PyTypeChecker
                 relative = 1.0 + longdf - shortdf
                 vol = float(
                     relative.pct_change(fill_method=cast(str, None)).std()
@@ -935,6 +961,7 @@ class OpenFrame(_CommonModel):
                     :,
                     item,
                 ]
+                # noinspection PyTypeChecker
                 relative = 1.0 + longdf - shortdf
                 ret = float(
                     relative.pct_change(fill_method=cast(str, None)).mean()
@@ -1445,15 +1472,6 @@ class OpenFrame(_CommonModel):
         self: Self,
         name: str,
         weight_strat: Optional[LiteralPortfolioWeightings] = None,
-        initial_weights: Optional[list[float]] = None,
-        risk_weights: Optional[list[float]] = None,
-        risk_parity_method: LiteralRiskParityMethod = "ccd",
-        maximum_iterations: int = 100,
-        tolerance: float = 1e-8,
-        weight_bounds: tuple[float, float] = (0.0, 1.0),
-        riskfree: float = 0.0,
-        covar_method: LiteralCovMethod = "ledoit-wolf",
-        options: Optional[dict[str, int]] = None,
     ) -> DataFrame:
         """
         Calculate a basket timeseries based on the supplied weights.
@@ -1463,25 +1481,7 @@ class OpenFrame(_CommonModel):
         name: str
             Name of the basket timeseries
         weight_strat: LiteralPortfolioWeightings, optional
-            weight calculation from https://github.com/pmorissette/ffn
-        initial_weights: list[float], optional
-            Starting asset weights, default inverse volatility
-        risk_weights: list[float], optional
-            Risk target weights, default equal weight
-        risk_parity_method: LiteralRiskParityMethod, default: ccd
-            Risk parity estimation method
-        maximum_iterations: int, default: 100
-            Maximum iterations in iterative solutions
-        tolerance: float, default: 1e-8
-            Tolerance level in iterative solutions
-        weight_bounds: tuple[float, float], default: (0.0, 1.0)
-            Weigh limits for optimization
-        riskfree: float, default: 0.0
-            Risk-free rate used in utility calculation
-        covar_method: LiteralCovMethod, default: ledoit-wolf
-            Covariance matrix estimation method
-        options: dict, optional
-            options for minimizing, e.g. {'maxiter': 10000 }
+            weight calculation strategies
 
         Returns
         -------
@@ -1507,32 +1507,9 @@ class OpenFrame(_CommonModel):
         if weight_strat:
             if weight_strat == "eq_weights":
                 self.weights = [1.0 / self.item_count] * self.item_count
-            elif weight_strat == "eq_risk":
-                weight_calc = list(
-                    calc_erc_weights(
-                        returns=dframe,
-                        initial_weights=initial_weights,
-                        risk_weights=risk_weights,
-                        risk_parity_method=risk_parity_method,
-                        maximum_iterations=maximum_iterations,
-                        tolerance=tolerance,
-                    ),
-                )
-                self.weights = weight_calc
             elif weight_strat == "inv_vol":
                 weight_calc = list(_calc_inv_vol_weights(returns=dframe))
                 self.weights = weight_calc
-            elif weight_strat == "mean_var":
-                weight_calc = list(
-                    calc_mean_var_weights(
-                        returns=dframe,
-                        weight_bounds=weight_bounds,
-                        rf=riskfree,
-                        covar_method=covar_method,
-                        options=options,
-                    ),
-                )
-                self.weights = weight_calc
             else:
                 msg = "Weight strategy not implemented"
                 raise NotImplementedError(msg)
@@ -1718,3 +1695,546 @@ 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>".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>".join(
+        [
+            f"{wgt:.1%} - {nm}"
+            for wgt, nm in zip(
+                cast(list[float], assets.weights),
+                assets.columns_lvl_zero,
+            )
+        ],
+    )
+
+    opt_text = "<br>".join(
+        [
+            f"{wgt:.1%} - {nm}"
+            for wgt, nm in zip(optimized[3:], assets.columns_lvl_zero)
+        ],
+    )
+    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"],
+            hovertemplate="%{text}<br>Return %{y}<br>Vol %{x}",
+            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]],
+                xhoverformat=".2%",
+                y=[point_frame.loc["ret", col]],
+                yhoverformat=".2%",
+                hovertext=[point_frame.loc["text", col]],
+                hoverinfo="x+y+text+name",
+                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

openseries/series.py

@@ -50,6 +50,7 @@ from openseries.types import (
 TypeOpenTimeSeries = TypeVar("TypeOpenTimeSeries", bound="OpenTimeSeries")
 
 
+# noinspection PyUnresolvedReferences
 class OpenTimeSeries(_CommonModel):
 
     """

openseries/simulation.py

@@ -1,4 +1,5 @@
 """Defining the ReturnSimulation class."""
+
 from __future__ import annotations
 
 import datetime as dt
@@ -6,7 +7,12 @@ from typing import Optional, cast
 
 from numpy import multiply, sqrt
 from numpy.random import PCG64, Generator, SeedSequence
-from pandas import DataFrame, Index, MultiIndex, concat
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    concat,
+)
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -428,7 +434,7 @@ class ReturnSimulation(BaseModel):
         Returns
         -------
         pandas.DataFrame
-            Object based on the simulation(s)
+            The simulation(s) data
 
         """
         d_range = generate_calendar_date_range(

openseries/types.py

@@ -138,8 +138,6 @@ LiteralPlotlyOutput = Literal["file", "div"]
 LiteralPlotlyJSlib = Literal[True, False, "cdn"]
 LiteralOlsFitMethod = Literal["pinv", "qr"]
 LiteralPortfolioWeightings = Literal["eq_weights", "eq_risk", "inv_vol", "mean_var"]
-LiteralCovMethod = Literal["ledoit-wolf", "standard"]
-LiteralRiskParityMethod = Literal["ccd", "slsqp"]
 LiteralOlsFitCovType = Literal[
     "nonrobust",
     "fixed scale",

{openseries-1.4.12.dist-info → openseries-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openseries
-Version: 1.4.12
+Version: 1.5.1
 Summary: Package for analyzing financial timeseries.
 Home-page: https://github.com/CaptorAB/OpenSeries
 License: BSD-3-Clause
@@ -20,7 +20,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Office/Business :: Financial :: Investment
-Requires-Dist: ffn (>=1.0.0,<2.0.0)
 Requires-Dist: holidays (>=0.30,<1.0)
 Requires-Dist: numpy (>=1.23.2,<=2.0.0)
 Requires-Dist: openpyxl (>=3.1.2,<4.0.0)
@@ -29,6 +28,7 @@ Requires-Dist: plotly (>=5.18.0,<6.0.0)
 Requires-Dist: pyarrow (>=14.0.2,<16.0.0)
 Requires-Dist: pydantic (>=2.5.2,<3.0.0)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
+Requires-Dist: requests (>=2.20.0,<3.0.0)
 Requires-Dist: scipy (>=1.11.4,<2.0.0)
 Requires-Dist: statsmodels (>=0.14.0,<1.0.0)
 Project-URL: Repository, https://github.com/CaptorAB/OpenSeries
@@ -43,12 +43,13 @@ width="81" height="100" align="left" float="right"/><br/>
 # OpenSeries
 
 [![PyPI version](https://img.shields.io/pypi/v/openseries.svg)](https://pypi.org/project/openseries/)
-[![Conda version](
-https://anaconda.org/conda-forge/openseries/badges/version.svg)](https://anaconda.org/conda-forge/openseries)
+[![Conda version](https://img.shields.io/conda/vn/conda-forge/openseries.svg)](https://anaconda.org/conda-forge/openseries)
+[![Conda platforms](https://img.shields.io/conda/pn/conda-forge/openseries.svg)](https://anaconda.org/conda-forge/openseries)
 [![Python version](https://img.shields.io/pypi/pyversions/openseries.svg)](https://www.python.org/)
 [![GitHub Action Test Suite](https://github.com/CaptorAB/OpenSeries/actions/workflows/test.yml/badge.svg)](https://github.com/CaptorAB/OpenSeries/actions/workflows/test.yml)
 [![Coverage](https://cdn.jsdelivr.net/gh/CaptorAB/OpenSeries@master/coverage.svg)](https://github.com/CaptorAB/OpenSeries/actions/workflows/test.yml)
 [![Styling, Linting & Type checks](https://github.com/CaptorAB/OpenSeries/actions/workflows/check.yml/badge.svg)](https://github.com/CaptorAB/OpenSeries/actions/workflows/check.yml)
+[![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://beta.ruff.rs/docs/)
 [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
 
@@ -198,11 +199,11 @@ make lint
 
 ### On some files in the project
 
-| File                                                                                                             | Description                                                                                                                                                                                         |
-|:-----------------------------------------------------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| [series.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/series.py)                             | Defines the class _OpenTimeSeries_ for managing and analyzing a single timeseries. The module also defines a function `timeseries_chain` that can be used to chain two timeseries objects together. |
-| [frame.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/frame.py)                               | Defines the class _OpenFrame_ for managing a group of timeseries, and e.g. calculate a portfolio timeseries from a rebalancing strategy between timeseries.                                         |
-| [simulation.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/simulation.py)                     | Defines the class _ReturnSimulation_ to create simulated financial timeseries. Used in the project's test suite                                                                                     |
+| File                                                                                                             | Description                                                                                                                                                                                                                               |
+|:-----------------------------------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [series.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/series.py)                             | Defines the class _OpenTimeSeries_ for managing and analyzing a single timeseries. The module also defines a function `timeseries_chain` that can be used to chain two timeseries objects together.                                       |
+| [frame.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/frame.py)                               | Defines the class _OpenFrame_ for managing a group of timeseries, and e.g. calculate a portfolio timeseries from a rebalancing strategy between timeseries. The module also defines functions to simulate, optimize, and plot portfolios. |
+| [simulation.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/simulation.py)                     | Defines the class _ReturnSimulation_ to create simulated financial timeseries. Used in the project's test suite                                                                                                                           |
 
 ### Class methods used to construct objects.
 
@@ -271,24 +272,24 @@ make lint
 
 ### Methods that apply only to the [OpenFrame](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/frame.py) class.
 
-| Method                  | Applies to  | Description                                                                                                                                                                                                                                                                                   |
-|:------------------------|:------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `merge_series`          | `OpenFrame` | Merges the Pandas Dataframes of the constituent OpenTimeSeries.                                                                                                                                                                                                                               |
-| `trunc_frame`           | `OpenFrame` | Truncates the OpenFrame to a common period.                                                                                                                                                                                                                                                   |
-| `add_timeseries`        | `OpenFrame` | Adds a given OpenTimeSeries to the OpenFrame.                                                                                                                                                                                                                                                 |
-| `delete_timeseries`     | `OpenFrame` | Deletes an OpenTimeSeries from the OpenFrame.                                                                                                                                                                                                                                                 |
-| `relative`              | `OpenFrame` | Calculates a new series that is the relative performance of two others.                                                                                                                                                                                                                       |
-| `make_portfolio`        | `OpenFrame` | Calculates a portfolio timeseries based on the series and weights. Weights can be provided as a list, or a weight strategy can be chosen from *equal weights*, *equal risk*, *inverted volatility* or *minimum variance* as defined in the [ffn](https://github.com/pmorissette/ffn) package. |
-| `ord_least_squares_fit` | `OpenFrame` | Performs a regression and an [Ordinary Least Squares](https://www.statsmodels.org/stable/examples/notebooks/generated/ols.html) fit.                                                                                                                                                          |
-| `beta`                  | `OpenFrame` | Calculates [Beta](https://www.investopedia.com/terms/b/beta.asp) of an asset relative a market.                                                                                                                                                                                               |
-| `jensen_alpha`          | `OpenFrame` | Calculates [Jensen's Alpha](https://www.investopedia.com/terms/j/jensensmeasure.asp) of an asset relative a market.                                                                                                                                                                           |
-| `tracking_error_func`   | `OpenFrame` | Calculates the [tracking errors](https://www.investopedia.com/terms/t/trackingerror.asp) relative to a selected series in the OpenFrame.                                                                                                                                                      |
-| `info_ratio_func`       | `OpenFrame` | Calculates the [information ratios](https://www.investopedia.com/terms/i/informationratio.asp) relative to a selected series in the OpenFrame.                                                                                                                                                |
-| `capture_ratio_func`    | `OpenFrame` | Calculates up, down and up/down [capture ratios](https://www.investopedia.com/terms/d/down-market-capture-ratio.asp) relative to a selected series.                                                                                                                                           |
-| `rolling_info_ratio`    | `OpenFrame` | Returns a pandas.DataFrame with the rolling [information ratio](https://www.investopedia.com/terms/i/informationratio.asp) between two series.                                                                                                                                                |
-| `rolling_beta`          | `OpenFrame` | Returns a pandas.DataFrame with the rolling [Beta](https://www.investopedia.com/terms/b/beta.asp) of an asset relative a market.                                                                                                                                                              |
-| `rolling_corr`          | `OpenFrame` | Calculates and adds a series of rolling [correlations](https://www.investopedia.com/terms/c/correlation.asp) between two other series.                                                                                                                                                        |
-| `ewma_risk`             | `OpenFrame` | Returns a `pandas.DataFrame` with volatility and correlation based on [Exponentially Weighted Moving Average](https://www.investopedia.com/articles/07/ewma.asp).                                                                                                                             |
+| Method                  | Applies to  | Description                                                                                                                                                                        |
+|:------------------------|:------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `merge_series`          | `OpenFrame` | Merges the Pandas Dataframes of the constituent OpenTimeSeries.                                                                                                                    |
+| `trunc_frame`           | `OpenFrame` | Truncates the OpenFrame to a common period.                                                                                                                                        |
+| `add_timeseries`        | `OpenFrame` | Adds a given OpenTimeSeries to the OpenFrame.                                                                                                                                      |
+| `delete_timeseries`     | `OpenFrame` | Deletes an OpenTimeSeries from the OpenFrame.                                                                                                                                      |
+| `relative`              | `OpenFrame` | Calculates a new series that is the relative performance of two others.                                                                                                            |
+| `make_portfolio`        | `OpenFrame` | Calculates a portfolio timeseries based on the series and weights. Weights can be provided as a list, or a weight strategy can be set as *equal weights* or *inverted volatility*. |
+| `ord_least_squares_fit` | `OpenFrame` | Performs a regression and an [Ordinary Least Squares](https://www.statsmodels.org/stable/examples/notebooks/generated/ols.html) fit.                                               |
+| `beta`                  | `OpenFrame` | Calculates [Beta](https://www.investopedia.com/terms/b/beta.asp) of an asset relative a market.                                                                                    |
+| `jensen_alpha`          | `OpenFrame` | Calculates [Jensen's Alpha](https://www.investopedia.com/terms/j/jensensmeasure.asp) of an asset relative a market.                                                                |
+| `tracking_error_func`   | `OpenFrame` | Calculates the [tracking errors](https://www.investopedia.com/terms/t/trackingerror.asp) relative to a selected series in the OpenFrame.                                           |
+| `info_ratio_func`       | `OpenFrame` | Calculates the [information ratios](https://www.investopedia.com/terms/i/informationratio.asp) relative to a selected series in the OpenFrame.                                     |
+| `capture_ratio_func`    | `OpenFrame` | Calculates up, down and up/down [capture ratios](https://www.investopedia.com/terms/d/down-market-capture-ratio.asp) relative to a selected series.                                |
+| `rolling_info_ratio`    | `OpenFrame` | Returns a pandas.DataFrame with the rolling [information ratio](https://www.investopedia.com/terms/i/informationratio.asp) between two series.                                     |
+| `rolling_beta`          | `OpenFrame` | Returns a pandas.DataFrame with the rolling [Beta](https://www.investopedia.com/terms/b/beta.asp) of an asset relative a market.                                                   |
+| `rolling_corr`          | `OpenFrame` | Calculates and adds a series of rolling [correlations](https://www.investopedia.com/terms/c/correlation.asp) between two other series.                                             |
+| `ewma_risk`             | `OpenFrame` | Returns a `pandas.DataFrame` with volatility and correlation based on [Exponentially Weighted Moving Average](https://www.investopedia.com/articles/07/ewma.asp).                  |
 
 ### Methods that apply to both the [OpenTimeSeries](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/series.py) and the [OpenFrame](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/frame.py) class.
 

openseries-1.5.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+openseries/__init__.py,sha256=hA7I5IFk88EnX6eyBbI1KLT_FGcmPIKF49xa5g3T8Yg,41
+openseries/_common_model.py,sha256=whzIHppEGjXqv2C5ZBg7c-QTCC6dHWBjNKX40WV_c6g,72469
+openseries/_risk.py,sha256=JnwAklqs2G3YIp9KTNKbumqs4VgfFIk-eFs0dZ-_jCY,3299
+openseries/datefixer.py,sha256=_HNiPR6S3agwOAk8gl3wIdegR6uDbh-00J1Zgo4GMl8,12423
+openseries/frame.py,sha256=en_GL0_l9OHsZk6AmYin5Pip7geLyTeLZNAZqIR4xcI,73772
+openseries/load_plotly.py,sha256=kIjvJ2H1sIXWsjd-mZclLvj7ebh-4Hdb1dwB2gR9b-Y,1807
+openseries/plotly_captor_logo.json,sha256=F5nhMzEyxKywtjvQqMTKgKRCJQYMDIiBgDSxdte8Clo,178
+openseries/plotly_layouts.json,sha256=ahx8-dL4_RPzvHtBOX0SiL0AH7xQJzNRSDhGrSmU-Og,1429
+openseries/series.py,sha256=jHbJkzFUeGokUJZ1Md4Hx1keSwpNMjPq1r_FDCputIE,28312
+openseries/simulation.py,sha256=_1cYO4VnlRI6khk6Th8ziN5Toz1iry0jFKICHQub3V0,13550
+openseries/types.py,sha256=Qw-ny6IZtdMeuHJF6FvIE0B2stnN3sdqq9fySIKUWK4,7660
+openseries-1.5.1.dist-info/LICENSE.md,sha256=cPUabMxJ6-ziqzqS6aLGkR-ilIOKe_s3Qtyp0ioTmo0,1521
+openseries-1.5.1.dist-info/METADATA,sha256=N1NAZ6l6V2pfc-EZAzF1kVTaLNAg7OrfVr1juoaUPMA,43665
+openseries-1.5.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+openseries-1.5.1.dist-info/RECORD,,

{openseries-1.4.12.dist-info → openseries-1.5.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

openseries-1.4.12.dist-info/RECORD

@@ -1,15 +0,0 @@
-openseries/__init__.py,sha256=hA7I5IFk88EnX6eyBbI1KLT_FGcmPIKF49xa5g3T8Yg,41
-openseries/_common_model.py,sha256=G1Ilih_qNJH2jGcYv60uATc0fZYzo-Vc_VBKl1E6wdg,72476
-openseries/_risk.py,sha256=u5-gP673_XVtCB0UAYoE1Ikw0gUjIaVgnwj142rqk1Q,3417
-openseries/datefixer.py,sha256=_HNiPR6S3agwOAk8gl3wIdegR6uDbh-00J1Zgo4GMl8,12423
-openseries/frame.py,sha256=VI5pX44kf4uygYSJrBZBoSPOLkbx3J5EpY37enMFXXY,58779
-openseries/load_plotly.py,sha256=kIjvJ2H1sIXWsjd-mZclLvj7ebh-4Hdb1dwB2gR9b-Y,1807
-openseries/plotly_captor_logo.json,sha256=F5nhMzEyxKywtjvQqMTKgKRCJQYMDIiBgDSxdte8Clo,178
-openseries/plotly_layouts.json,sha256=ahx8-dL4_RPzvHtBOX0SiL0AH7xQJzNRSDhGrSmU-Og,1429
-openseries/series.py,sha256=ix-kMUy8H1Kuz7ZeqZ_wSOLCq-_zjm2hrJ63Ytadijc,28274
-openseries/simulation.py,sha256=GgBvGdoYyDqjkIlmWwJN3fEhCm952Yv3w8A59XSZwqY,13539
-openseries/types.py,sha256=6Sq8tKH5-tIFq7C8K594vT4yZrLCNZ8H6vc6TGPk0r8,7764
-openseries-1.4.12.dist-info/LICENSE.md,sha256=cPUabMxJ6-ziqzqS6aLGkR-ilIOKe_s3Qtyp0ioTmo0,1521
-openseries-1.4.12.dist-info/METADATA,sha256=mQBTS6jQBiyOz9hps8sAVJ067h-eB9DH2hyQbQUcGa0,45158
-openseries-1.4.12.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-openseries-1.4.12.dist-info/RECORD,,