openseries 1.9.5__py3-none-any.whl → 1.9.7__py3-none-any.whl

openseries/owntypes.py

@@ -12,14 +12,22 @@ from __future__ import annotations
 import datetime as dt
 from enum import Enum
 from pprint import pformat
-from typing import Annotated, ClassVar, Literal, Union
+from typing import TYPE_CHECKING, Annotated, ClassVar, Literal, TypeAlias, TypeVar
 
+from annotated_types import MinLen
 from numpy import datetime64
-from pandas import Timestamp
-from pydantic import BaseModel, Field, StringConstraints, conlist, conset
+from pandas import Series, Timestamp
+from pydantic import BaseModel, Field, StringConstraints
+
+if TYPE_CHECKING:
+    from pandas import Series as _Series
+
+    SeriesFloat = _Series[float]
+else:
+    SeriesFloat = Series
 
 try:
-    from typing import Self  # type: ignore[attr-defined,unused-ignore]
+    from typing import Self
 except ImportError:  # pragma: no cover
     from typing_extensions import Self
 
@@ -27,6 +35,9 @@ except ImportError:  # pragma: no cover
 __all__ = ["Self", "ValueType"]
 
 
+SeriesOrFloat_co = TypeVar("SeriesOrFloat_co", float, SeriesFloat, covariant=True)
+
+
 CountryStringType = Annotated[
     str,
     StringConstraints(
@@ -38,14 +49,11 @@ CountryStringType = Annotated[
         strict=True,
     ),
 ]
-CountryListType = conset(
-    item_type=CountryStringType,
-    min_length=1,
-)
-CountriesType = Union[CountryListType, CountryStringType]  # type: ignore[valid-type]  # noqa: UP007
+CountrySetType: TypeAlias = Annotated[set[CountryStringType], MinLen(1)]
+CountriesType: TypeAlias = CountrySetType | CountryStringType
 
 
-class Countries(BaseModel):  # type: ignore[misc]
+class Countries(BaseModel):
     """Declare Countries."""
 
     countryinput: CountriesType
@@ -64,69 +72,62 @@ CurrencyStringType = Annotated[
 ]
 
 
-class Currency(BaseModel):  # type: ignore[misc]
+class Currency(BaseModel):
     """Declare Currency."""
 
     ccy: CurrencyStringType
 
 
-DateListType = Annotated[
-    list[str],
-    conset(
-        Annotated[
-            str,
-            StringConstraints(
-                pattern=r"^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$",
-                strip_whitespace=True,
-                strict=True,
-                min_length=10,
-                max_length=10,
-            ),
-        ],
-        min_length=1,
+DateStringType = Annotated[
+    str,
+    StringConstraints(
+        pattern=r"^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$",
+        strip_whitespace=True,
+        strict=True,
+        min_length=10,
+        max_length=10,
     ),
 ]
+DateListType: TypeAlias = Annotated[list[DateStringType], MinLen(1)]
 
-ValueListType = Annotated[list[float], conlist(float, min_length=1)]
+ValueListType: TypeAlias = Annotated[list[float], MinLen(1)]
 
 DaysInYearType = Annotated[int, Field(strict=True, ge=1, le=366)]
 
 DateType = str | dt.date | dt.datetime | datetime64 | Timestamp
 
-PlotlyLayoutType = dict[
-    str,
+PlotlyConfigType = (
     str
     | int
     | float
     | bool
     | list[str]
-    | dict[str, str | int | float | bool | list[str]],
-]
+    | dict[str, str | int | float | bool | list[str]]
+)
+
+PlotlyLayoutType = dict[str, PlotlyConfigType]
 
 CaptorLogoType = dict[str, str | float]
 
 LiteralJsonOutput = Literal["values", "tsdf"]
 LiteralTrunc = Literal["before", "after", "both"]
-LiteralLinePlotMode = Literal[
-    "lines",
-    "markers",
-    "lines+markers",
-    "lines+text",
-    "markers+text",
-    "lines+markers+text",
-    None,
-]
+LiteralLinePlotMode = (
+    Literal[
+        "lines",
+        "markers",
+        "lines+markers",
+        "lines+text",
+        "markers+text",
+        "lines+markers+text",
+    ]
+    | None
+)
 LiteralHowMerge = Literal["outer", "inner"]
 LiteralQuantileInterp = Literal["linear", "lower", "higher", "midpoint", "nearest"]
 LiteralBizDayFreq = Literal["B", "BME", "BQE", "BYE"]
-LiteralPandasReindexMethod = Literal[
-    None,
-    "pad",
-    "ffill",
-    "backfill",
-    "bfill",
-    "nearest",
-]
+LiteralPandasReindexMethod = (
+    Literal["pad", "ffill", "backfill", "bfill", "nearest"] | None
+)
 LiteralNanMethod = Literal["fill", "drop"]
 LiteralCaptureRatio = Literal["up", "down", "both"]
 LiteralBarPlotMode = Literal["stack", "group", "overlay", "relative"]

openseries/portfoliotools.py

@@ -16,13 +16,13 @@ from typing import TYPE_CHECKING, cast
 from numpy import (
     append,
     array,
+    einsum,
     float64,
     inf,
     isnan,
     linspace,
     nan,
     sqrt,
-    zeros,
 )
 from numpy import (
     sum as npsum,
@@ -48,12 +48,9 @@ from .owntypes import (
     ValueType,
 )
 from .series import OpenTimeSeries
-
-# noinspection PyProtectedMember
 from .simulation import _random_generator
 
 if TYPE_CHECKING:  # pragma: no cover
-    # noinspection PyUnresolvedReferences
     from collections.abc import Callable
 
     from numpy.typing import NDArray
@@ -106,25 +103,16 @@ def simulate_portfolios(
 
     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
+    cov_matrix = log_ret.cov() * simframe.periods_in_a_year
+    mean_returns = log_ret.mean() * simframe.periods_in_a_year
 
-        vol_arr[x] = sqrt(
-            weights.T @ (log_ret.cov() * simframe.periods_in_a_year @ weights),
-        )
-
-        ret_arr[x] = npsum(log_ret.mean() * weights * simframe.periods_in_a_year)
+    randomizer = _random_generator(seed=seed)
+    all_weights = randomizer.random((num_ports, simframe.item_count))
+    all_weights = all_weights / all_weights.sum(axis=1, keepdims=True)
 
-        sharpe_arr[x] = ret_arr[x] / vol_arr[x]
+    ret_arr = all_weights @ mean_returns
+    vol_arr = sqrt(einsum("ij,jk,ik->i", all_weights, cov_matrix, all_weights))
+    sharpe_arr = ret_arr / vol_arr
 
     simdf = concat(
         [
@@ -137,7 +125,6 @@ def simulate_portfolios(
     return simdf.dropna()
 
 
-# noinspection PyUnusedLocal
 def efficient_frontier(
     eframe: OpenFrame,
     num_ports: int = 5000,
@@ -230,7 +217,7 @@ def efficient_frontier(
             _get_ret_vol_sr(
                 lg_ret=log_ret,
                 weights=weights,
-                per_in_yr=eframe.periods_in_a_year,
+                per_in_yr=copi.periods_in_a_year,
             )[2]
             * -1,
         )
@@ -243,7 +230,7 @@ def efficient_frontier(
             _get_ret_vol_sr(
                 lg_ret=log_ret,
                 weights=weights,
-                per_in_yr=eframe.periods_in_a_year,
+                per_in_yr=copi.periods_in_a_year,
             )[1],
         )
 
@@ -263,7 +250,7 @@ def efficient_frontier(
     optimal = _get_ret_vol_sr(
         lg_ret=log_ret,
         weights=opt_results.x,
-        per_in_yr=eframe.periods_in_a_year,
+        per_in_yr=copi.periods_in_a_year,
     )
 
     frontier_y = linspace(start=frontier_min, stop=frontier_max, num=frontier_points)
@@ -280,7 +267,7 @@ def efficient_frontier(
                     "fun": lambda w, poss_return=possible_return: _diff_return(
                         lg_ret=log_ret,
                         weights=w,
-                        per_in_yr=eframe.periods_in_a_year,
+                        per_in_yr=copi.periods_in_a_year,
                         poss_return=poss_return,
                     ),
                 },
@@ -366,7 +353,7 @@ def constrain_optimized_portfolios(
     if not bounds:
         bounds = tuple((0.0, 1.0) for _ in range(data.item_count))
 
-    front_frame, sim_frame, optimal = efficient_frontier(
+    front_frame, _, _ = efficient_frontier(
         eframe=data,
         num_ports=simulations,
         frontier_points=curve_points,
@@ -375,7 +362,6 @@ def constrain_optimized_portfolios(
     )
 
     condition_least_ret = front_frame.ret > serie.arithmetic_ret
-    # noinspection PyArgumentList
     least_ret_frame = front_frame[condition_least_ret].sort_values(by="stdev")
     least_ret_port: Series[float] = least_ret_frame.iloc[0]
     least_ret_port_name = f"Minimize vol & target return of {portfolioname}"
@@ -386,7 +372,6 @@ def constrain_optimized_portfolios(
     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,
@@ -440,14 +425,13 @@ def prepare_plot_data(
         for wgt, nm in zip(optimized[3:], assets.columns_lvl_zero, strict=True)
     ]
     opt_text = "<br><br>Weights:<br>" + "<br>".join(opt_text_list)
-    vol = cast("Series[float]", assets.vol)
     plotframe = DataFrame(
         data=[
             assets.arithmetic_ret,
-            vol,
+            assets.vol,
             Series(
                 data=[""] * assets.item_count,
-                index=vol.index,
+                index=assets.vol.index,
             ),
         ],
         index=["ret", "stdev", "text"],

openseries/report.py

@@ -75,7 +75,7 @@ def calendar_period_returns(
             cldr.index = Index([d.year for d in cldr.index])
         elif freq.upper() == "BQE":
             cldr.index = Index(
-                [Timestamp(d).to_period("Q").strftime("Q%q %Y") for d in cldr.index]
+                [Timestamp(d).to_period("Q").strftime("Q%q %Y") for d in cldr.index],
             )
         else:
             cldr.index = Index([d.strftime("%b %y") for d in cldr.index])
@@ -264,9 +264,8 @@ def report_html(
         "{:.2f}",
     ]
 
-    # noinspection PyTypeChecker
     rpt_df = copied.all_properties(
-        properties=cast("list[LiteralFrameProps]", properties)
+        properties=cast("list[LiteralFrameProps]", properties),
     )
     alpha_frame = copied.from_deepcopy()
     alpha_frame.to_cumret()
@@ -282,7 +281,9 @@ def report_html(
         ]
     alphas.append("")
     ar = DataFrame(
-        data=alphas, index=copied.tsdf.columns, columns=["Jensen's Alpha"]
+        data=alphas,
+        index=copied.tsdf.columns,
+        columns=["Jensen's Alpha"],
     ).T
     rpt_df = concat([rpt_df, ar])
     ir = copied.info_ratio_func()
@@ -294,7 +295,7 @@ def report_html(
     te_frame.resample("7D")
     with catch_warnings():
         simplefilter("ignore")
-        te = te_frame.tracking_error_func()
+        te: Series[float] | Series[str] = te_frame.tracking_error_func()
     if te.hasnans:
         te = Series(
             data=[""] * te_frame.item_count,
@@ -318,7 +319,7 @@ def report_html(
         with catch_warnings():
             simplefilter("ignore")
             try:
-                cru = crm.capture_ratio_func(ratio="both")
+                cru: Series[float] | Series[str] = crm.capture_ratio_func(ratio="both")
             except ZeroDivisionError as exc:  # pragma: no cover
                 msg = f"Capture ratio calculation error: {exc!s}"  # pragma: no cover
                 logger.warning(msg=msg)  # pragma: no cover
@@ -351,21 +352,18 @@ def report_html(
 
     for item, f in zip(rpt_df.index, formats, strict=False):
         rpt_df.loc[item] = rpt_df.loc[item].apply(
-            lambda x, fmt=f: x if (isinstance(x, str) or x is None) else fmt.format(x),
+            lambda x, fmt=f: str(x)
+            if (isinstance(x, str) or x is None)
+            else fmt.format(x),
         )
 
     rpt_df.index = Index(labels_init)
 
     this_year = copied.last_idx.year
     this_month = copied.last_idx.month
-    ytd = cast("Series[float]", copied.value_ret_calendar_period(year=this_year)).map(
-        "{:.2%}".format
-    )
+    ytd = copied.value_ret_calendar_period(year=this_year).map("{:.2%}".format)
     ytd.name = "Year-to-Date"
-    mtd = cast(
-        "Series[float]",
-        copied.value_ret_calendar_period(year=this_year, month=this_month),
-    ).map(
+    mtd = copied.value_ret_calendar_period(year=this_year, month=this_month).map(
         "{:.2%}".format,
     )
     mtd.name = "Month-to-Date"
@@ -430,7 +428,8 @@ def report_html(
 
     figure.update_layout(fig.get("layout"))
     colorway: list[str] = cast("dict[str, list[str]]", fig["layout"]).get(
-        "colorway", []
+        "colorway",
+        [],
     )
 
     if vertical_legend:
@@ -457,7 +456,7 @@ def report_html(
     figure.update_xaxes(gridcolor="#EEEEEE", automargin=True, tickangle=-45)
     figure.update_yaxes(tickformat=".2%", gridcolor="#EEEEEE", automargin=True)
 
-    if isinstance(title, str):
+    if title:
         figure.update_layout(
             {"title": {"text": f"<b>{title}</b><br>", "font": {"size": 36}}},
         )

openseries/series.py

@@ -15,12 +15,15 @@ from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 if TYPE_CHECKING:  # pragma: no cover
     import datetime as dt
-    from collections.abc import Callable
+
+    from numpy.typing import NDArray
+    from pandas import Timestamp
 
 from numpy import (
     append,
     array,
     cumprod,
+    float64,
     insert,
     isnan,
     log,
@@ -37,7 +40,7 @@ from pandas import (
 )
 from pydantic import field_validator, model_validator
 
-from ._common_model import _CommonModel
+from ._common_model import _calculate_time_factor, _CommonModel
 from .datefixer import _do_resample_to_business_period_ends, date_fix
 from .owntypes import (
     Countries,
@@ -59,9 +62,6 @@ from .owntypes import (
     ValueType,
 )
 
-FieldValidator = cast("Callable[..., Callable[..., Any]]", field_validator)
-ModelValidator = cast("Callable[..., Callable[..., Any]]", model_validator)
-
 logger = getLogger(__name__)
 
 __all__ = ["OpenTimeSeries", "timeseries_chain"]
@@ -69,8 +69,7 @@ __all__ = ["OpenTimeSeries", "timeseries_chain"]
 TypeOpenTimeSeries = TypeVar("TypeOpenTimeSeries", bound="OpenTimeSeries")
 
 
-# noinspection PyUnresolvedReferences,PyNestedDecorators
-class OpenTimeSeries(_CommonModel):
+class OpenTimeSeries(_CommonModel[float]):
     """OpenTimeSeries objects are at the core of the openseries package.
 
     The intended use is to allow analyses of financial timeseries.
@@ -126,24 +125,25 @@ class OpenTimeSeries(_CommonModel):
     isin: str | None = None
     label: str | None = None
 
-    @FieldValidator("domestic", mode="before")
+    @field_validator("domestic", mode="before")
     @classmethod
     def _validate_domestic(cls, value: CurrencyStringType) -> CurrencyStringType:
         """Pydantic validator to ensure domestic field is validated."""
         _ = Currency(ccy=value)
         return value
 
-    @FieldValidator("countries", mode="before")
+    @field_validator("countries", mode="before")
     @classmethod
     def _validate_countries(cls, value: CountriesType) -> CountriesType:
         """Pydantic validator to ensure countries field is validated."""
         _ = Countries(countryinput=value)
         return value
 
-    @FieldValidator("markets", mode="before")
+    @field_validator("markets", mode="before")
     @classmethod
     def _validate_markets(
-        cls, value: list[str] | str | None
+        cls,
+        value: list[str] | str | None,
     ) -> list[str] | str | None:
         """Pydantic validator to ensure markets field is validated."""
         msg = (
@@ -159,7 +159,7 @@ class OpenTimeSeries(_CommonModel):
             raise MarketsNotStringNorListStrError(item_msg)
         raise MarketsNotStringNorListStrError(msg)
 
-    @ModelValidator(mode="after")
+    @model_validator(mode="after")
     def _dates_and_values_validate(self: Self) -> Self:
         """Pydantic validator to ensure dates and values are validated."""
         values_list_length = len(self.values)
@@ -168,9 +168,6 @@ class OpenTimeSeries(_CommonModel):
         if dates_list_length != dates_set_length:
             msg = "Dates are not unique"
             raise ValueError(msg)
-        if values_list_length < 1:
-            msg = "There must be at least 1 value"
-            raise ValueError(msg)
         if (
             (dates_list_length != values_list_length)
             or (len(self.tsdf.index) != self.tsdf.shape[0])
@@ -280,7 +277,7 @@ class OpenTimeSeries(_CommonModel):
                 label, _ = dframe.name
             else:
                 label = dframe.name
-            values = cast("list[float]", dframe.to_numpy().tolist())
+            values = dframe.to_numpy().tolist()
         elif isinstance(dframe, DataFrame):
             values = dframe.iloc[:, column_nmbr].to_list()
             if isinstance(dframe.columns, MultiIndex):
@@ -299,12 +296,11 @@ class OpenTimeSeries(_CommonModel):
                     msg = f"valuetype missing. Adding: {valuetype.value}"
                     logger.warning(msg=msg)
                 else:
-                    valuetype = cast(
-                        "ValueType",
-                        dframe.columns.get_level_values(1).to_numpy()[column_nmbr],
-                    )
+                    valuetype = dframe.columns.get_level_values(1).to_numpy()[
+                        column_nmbr
+                    ]
             else:
-                label = cast("MultiIndex", dframe.columns).to_numpy()[column_nmbr]
+                label = dframe.columns.to_numpy()[column_nmbr]
         else:
             raise TypeError(msg)
 
@@ -475,7 +471,7 @@ class OpenTimeSeries(_CommonModel):
         self.valuetype = ValueType.RTRN
         arrays = [[self.label], [self.valuetype]]
         returns.columns = MultiIndex.from_arrays(
-            arrays=arrays  # type: ignore[arg-type]
+            arrays=arrays,  # type: ignore[arg-type]
         )
         self.tsdf = returns.copy()
         return self
@@ -550,11 +546,16 @@ class OpenTimeSeries(_CommonModel):
             An OpenTimeSeries object
 
         """
-        arr = array(self.values) / divider
+        arr: NDArray[float64] = array(self.values) / divider
 
         deltas = array([i.days for i in self.tsdf.index[1:] - self.tsdf.index[:-1]])
-        arr = cumprod(
-            a=insert(arr=1.0 + deltas * arr[:-1] / days_in_year, obj=0, values=1.0)
+        arr = cast(
+            "NDArray[float64]",
+            cumprod(
+                a=insert(
+                    arr=1.0 + deltas * arr[:-1] / days_in_year, obj=0, values=1.0
+                ),
+            ),
         )
 
         self.dates = [d.strftime("%Y-%m-%d") for d in self.tsdf.index]
@@ -672,32 +673,35 @@ class OpenTimeSeries(_CommonModel):
 
         """
         earlier, later = self.calc_range(
-            months_offset=months_from_last, from_dt=from_date, to_dt=to_date
+            months_offset=months_from_last,
+            from_dt=from_date,
+            to_dt=to_date,
+        )
+        time_factor = _calculate_time_factor(
+            data=self.tsdf.loc[
+                cast("Timestamp", earlier) : cast("Timestamp", later)
+            ].iloc[:, 0],
+            earlier=earlier,
+            later=later,
+            periods_in_a_year_fixed=periods_in_a_year_fixed,
         )
-        if periods_in_a_year_fixed:
-            time_factor = float(periods_in_a_year_fixed)
-        else:
-            how_many = self.tsdf.loc[
-                cast("int", earlier) : cast("int", later),
-                self.tsdf.columns.to_numpy()[0],
-            ].count()
-            fraction = (later - earlier).days / 365.25
-            time_factor = cast("int", how_many) / fraction
 
-        data = self.tsdf.loc[cast("int", earlier) : cast("int", later)].copy()
+        data = self.tsdf.loc[
+            cast("Timestamp", earlier) : cast("Timestamp", later)
+        ].copy()
 
         data[self.label, ValueType.RTRN] = log(
-            data.loc[:, self.tsdf.columns.to_numpy()[0]]
+            data.loc[:, self.tsdf.columns.to_numpy()[0]],
         ).diff()
 
         rawdata = [
-            data.loc[:, cast("int", (self.label, ValueType.RTRN))]
+            data[(self.label, ValueType.RTRN)]
             .iloc[1:day_chunk]
             .std(ddof=dlta_degr_freedms)
             * sqrt(time_factor),
         ]
 
-        for item in data.loc[:, cast("int", (self.label, ValueType.RTRN))].iloc[1:]:
+        for item in data[(self.label, ValueType.RTRN)].iloc[1:]:
             prev = rawdata[-1]
             rawdata.append(
                 sqrt(
@@ -744,7 +748,6 @@ class OpenTimeSeries(_CommonModel):
         ra_df = ra_df.dropna()
 
         prev = self.first_idx
-        # noinspection PyTypeChecker
         dates: list[dt.date] = [prev]
 
         for idx, row in ra_df.iterrows():