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

openseries/frame.py

@@ -16,10 +16,12 @@ from typing import TYPE_CHECKING, Any, cast
 
 from numpy import (
     array,
+    asarray,
     concatenate,
     cov,
     diff,
     divide,
+    float64,
     isinf,
     log,
     nan,
@@ -39,6 +41,7 @@ from pandas import (
 if TYPE_CHECKING:  # pragma: no cover
     import datetime as dt
 
+    from numpy.typing import NDArray
     from pandas import Series as _Series
     from pandas import Timestamp
 
@@ -49,7 +52,7 @@ else:
 from pydantic import field_validator
 from sklearn.linear_model import LinearRegression  # type: ignore[import-untyped]
 
-from ._common_model import _CommonModel
+from ._common_model import _calculate_time_factor, _CommonModel, _get_base_column_data
 from .datefixer import _do_resample_to_business_period_ends
 from .owntypes import (
     DaysInYearType,
@@ -77,7 +80,6 @@ logger = getLogger(__name__)
 __all__ = ["OpenFrame"]
 
 
-# noinspection PyUnresolvedReferences,PyTypeChecker
 class OpenFrame(_CommonModel[SeriesFloat]):
     """OpenFrame objects hold OpenTimeSeries in the list constituents.
 
@@ -101,7 +103,6 @@ class OpenFrame(_CommonModel[SeriesFloat]):
     tsdf: DataFrame = DataFrame(dtype="float64")
     weights: list[float] | None = None
 
-    # noinspection PyMethodParameters
     @field_validator("constituents")
     def _check_labels_unique(
         cls: type[OpenFrame],  # noqa: N805
@@ -150,10 +151,12 @@ class OpenFrame(_CommonModel[SeriesFloat]):
     def _set_tsdf(self: Self) -> None:
         """Set the tsdf DataFrame."""
         if self.constituents is not None and len(self.constituents) != 0:
-            self.tsdf = reduce(
-                lambda left, right: concat([left, right], axis="columns", sort=True),
-                [x.tsdf for x in self.constituents],
-            )
+            if len(self.constituents) == 1:
+                self.tsdf = self.constituents[0].tsdf.copy()
+            else:
+                self.tsdf = concat(
+                    [x.tsdf for x in self.constituents], axis="columns", sort=True
+                )
         else:
             logger.warning("OpenFrame() was passed an empty list.")
 
@@ -610,13 +613,12 @@ class OpenFrame(_CommonModel[SeriesFloat]):
             .std(ddof=dlta_degr_freedms)
             * sqrt(time_factor),
         ]
-        raw_cov = [
-            cov(
-                m=data[(cols[0], ValueType.RTRN)].iloc[1:day_chunk].to_numpy(),
-                y=data[(cols[1], ValueType.RTRN)].iloc[1:day_chunk].to_numpy(),
-                ddof=dlta_degr_freedms,
-            )[0][1],
-        ]
+        rm = data[(cols[0], ValueType.RTRN)].iloc[1:day_chunk]
+        m: NDArray[float64] = asarray(rm, dtype=float64)
+        ry = data[(cols[1], ValueType.RTRN)].iloc[1:day_chunk]
+        y: NDArray[float64] = asarray(ry, dtype=float64)
+
+        raw_cov = [cov(m=m, y=y, ddof=dlta_degr_freedms)[0][1]]
 
         r1 = data[(cols[0], ValueType.RTRN)]
         r2 = data[(cols[1], ValueType.RTRN)]
@@ -855,36 +857,20 @@ class OpenFrame(_CommonModel[SeriesFloat]):
             from_dt=from_date,
             to_dt=to_date,
         )
-        fraction: float = (later - earlier).days / 365.25
 
-        msg = "base_column should be a tuple[str, ValueType] or an integer."
-        if isinstance(base_column, tuple):
-            shortdf = self.tsdf.loc[
-                cast("Timestamp", earlier) : cast("Timestamp", later)
-            ][base_column]
-            short_item = base_column
-            short_label = cast(
-                "tuple[str, ValueType]",
-                self.tsdf[base_column].name,
-            )[0]
-        elif isinstance(base_column, int):
-            shortdf = self.tsdf.loc[
-                cast("Timestamp", earlier) : cast("Timestamp", later)
-            ].iloc[:, base_column]
-            short_item = cast(
-                "tuple[str, ValueType]",
-                self.tsdf.iloc[:, base_column].name,
-            )
-            short_label = cast("tuple[str, str]", self.tsdf.iloc[:, base_column].name)[
-                0
-            ]
-        else:
-            raise TypeError(msg)
+        shortdf, short_item, short_label = _get_base_column_data(
+            self=self,
+            base_column=base_column,
+            earlier=earlier,
+            later=later,
+        )
 
-        if periods_in_a_year_fixed:
-            time_factor = float(periods_in_a_year_fixed)
-        else:
-            time_factor = shortdf.count() / fraction
+        time_factor = _calculate_time_factor(
+            data=shortdf,
+            earlier=earlier,
+            later=later,
+            periods_in_a_year_fixed=periods_in_a_year_fixed,
+        )
 
         terrors = []
         for item in self.tsdf:
@@ -946,39 +932,20 @@ class OpenFrame(_CommonModel[SeriesFloat]):
             from_dt=from_date,
             to_dt=to_date,
         )
-        fraction: float = (later - earlier).days / 365.25
 
-        msg = "base_column should be a tuple[str, ValueType] or an integer."
-        if isinstance(base_column, tuple):
-            shortdf = self.tsdf.loc[
-                cast("Timestamp", earlier) : cast("Timestamp", later)
-            ][base_column]
-            short_item = base_column
-            short_label = cast(
-                "tuple[str, str]",
-                self.tsdf[base_column].name,
-            )[0]
-        elif isinstance(base_column, int):
-            shortdf = self.tsdf.loc[
-                cast("Timestamp", earlier) : cast("Timestamp", later)
-            ].iloc[:, base_column]
-            short_item = cast(
-                "tuple[str, ValueType]",
-                self.tsdf.iloc[
-                    :,
-                    base_column,
-                ].name,
-            )
-            short_label = cast("tuple[str, str]", self.tsdf.iloc[:, base_column].name)[
-                0
-            ]
-        else:
-            raise TypeError(msg)
+        shortdf, short_item, short_label = _get_base_column_data(
+            self=self,
+            base_column=base_column,
+            earlier=earlier,
+            later=later,
+        )
 
-        if periods_in_a_year_fixed:
-            time_factor = float(periods_in_a_year_fixed)
-        else:
-            time_factor = shortdf.count() / fraction
+        time_factor = _calculate_time_factor(
+            data=shortdf,
+            earlier=earlier,
+            later=later,
+            periods_in_a_year_fixed=periods_in_a_year_fixed,
+        )
 
         ratios = []
         for item in self.tsdf:
@@ -1451,7 +1418,7 @@ class OpenFrame(_CommonModel[SeriesFloat]):
             returns = self.tsdf.ffill().pct_change()
             returns.iloc[0] = 0
         elif all(vtypes):
-            returns = self.tsdf.copy()
+            returns = self.tsdf
         else:
             msg = "Mix of series types will give inconsistent results"
             raise MixedValuetypesError(msg)

openseries/owntypes.py

@@ -35,7 +35,7 @@ except ImportError:  # pragma: no cover
 __all__ = ["Self", "ValueType"]
 
 
-Combo_co = TypeVar("Combo_co", float, SeriesFloat, covariant=True)
+SeriesOrFloat_co = TypeVar("SeriesOrFloat_co", float, SeriesFloat, covariant=True)
 
 
 CountryStringType = Annotated[

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,
                     ),
                 },
@@ -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,

openseries/report.py

@@ -264,7 +264,6 @@ def report_html(
         "{:.2f}",
     ]
 
-    # noinspection PyTypeChecker
     rpt_df = copied.all_properties(
         properties=cast("list[LiteralFrameProps]", properties),
     )
@@ -353,7 +352,9 @@ 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)

openseries/series.py

@@ -15,7 +15,6 @@ 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
@@ -41,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,
@@ -63,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"]
@@ -73,7 +69,6 @@ __all__ = ["OpenTimeSeries", "timeseries_chain"]
 TypeOpenTimeSeries = TypeVar("TypeOpenTimeSeries", bound="OpenTimeSeries")
 
 
-# noinspection PyUnresolvedReferences,PyNestedDecorators
 class OpenTimeSeries(_CommonModel[float]):
     """OpenTimeSeries objects are at the core of the openseries package.
 
@@ -130,21 +125,21 @@ class OpenTimeSeries(_CommonModel[float]):
     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,
@@ -164,7 +159,7 @@ class OpenTimeSeries(_CommonModel[float]):
             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)
@@ -282,7 +277,7 @@ class OpenTimeSeries(_CommonModel[float]):
                 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):
@@ -301,12 +296,11 @@ class OpenTimeSeries(_CommonModel[float]):
                     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)
 
@@ -472,7 +466,6 @@ class OpenTimeSeries(_CommonModel[float]):
             The returns of the values in the series
 
         """
-        # noinspection PyCallingNonCallable
         returns = self.tsdf.ffill().pct_change()
         returns.iloc[0] = 0
         self.valuetype = ValueType.RTRN
@@ -684,16 +677,14 @@ class OpenTimeSeries(_CommonModel[float]):
             from_dt=from_date,
             to_dt=to_date,
         )
-        if periods_in_a_year_fixed:
-            time_factor = float(periods_in_a_year_fixed)
-        else:
-            how_many = (
-                self.tsdf.loc[cast("Timestamp", earlier) : cast("Timestamp", later)]
-                .count()
-                .iloc[0]
-            )
-            fraction = (later - earlier).days / 365.25
-            time_factor = how_many / fraction
+        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,
+        )
 
         data = self.tsdf.loc[
             cast("Timestamp", earlier) : cast("Timestamp", later)
@@ -757,7 +748,6 @@ class OpenTimeSeries(_CommonModel[float]):
         ra_df = ra_df.dropna()
 
         prev = self.first_idx
-        # noinspection PyTypeChecker
         dates: list[dt.date] = [prev]
 
         for idx, row in ra_df.iterrows():
@@ -878,7 +868,6 @@ def timeseries_chain(
 
     dates.extend([x.strftime("%Y-%m-%d") for x in new.tsdf.index])
 
-    # noinspection PyTypeChecker
     return back.__class__(
         timeseries_id=new.timeseries_id,
         instrument_id=new.instrument_id,

openseries/simulation.py

@@ -9,7 +9,13 @@ SPDX-License-Identifier: BSD-3-Clause
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+from functools import cached_property
+from typing import TYPE_CHECKING, TypedDict, cast
+
+try:
+    from typing import Unpack
+except ImportError:
+    from typing_extensions import Unpack
 
 if TYPE_CHECKING:
     import datetime as dt  # pragma: no cover
@@ -41,6 +47,14 @@ from .owntypes import (
 __all__ = ["ReturnSimulation"]
 
 
+class _JumpParams(TypedDict, total=False):
+    """TypedDict for jump diffusion parameters."""
+
+    jumps_lamda: NonNegativeFloat
+    jumps_sigma: NonNegativeFloat
+    jumps_mu: float
+
+
 def _random_generator(seed: int | None) -> Generator:
     """Make a Numpy Random Generator object.
 
@@ -60,6 +74,58 @@ def _random_generator(seed: int | None) -> Generator:
     return Generator(bit_generator=bg)
 
 
+def _create_base_simulation(
+    cls: type[ReturnSimulation],
+    returns: DataFrame,
+    number_of_sims: PositiveInt,
+    trading_days: PositiveInt,
+    trading_days_in_year: DaysInYearType,
+    mean_annual_return: float,
+    mean_annual_vol: PositiveFloat,
+    seed: int | None = None,
+    **kwargs: Unpack[_JumpParams],
+) -> ReturnSimulation:
+    """Common logic for creating simulations.
+
+    Parameters
+    ----------
+    cls: type[ReturnSimulation]
+        The ReturnSimulation class
+    returns: pandas.DataFrame
+        The calculated returns data
+    number_of_sims: PositiveInt
+        Number of simulations to generate
+    trading_days: PositiveInt
+        Number of trading days to simulate
+    trading_days_in_year: DaysInYearType
+        Number of trading days used to annualize
+    mean_annual_return: float
+        Mean annual return
+    mean_annual_vol: PositiveFloat
+        Mean annual volatility
+    seed: int, optional
+        Seed for random process initiation
+    **kwargs
+        Additional keyword arguments for jump parameters
+
+    Returns:
+    -------
+    ReturnSimulation
+        A ReturnSimulation instance
+
+    """
+    return cls(
+        number_of_sims=number_of_sims,
+        trading_days=trading_days,
+        trading_days_in_year=trading_days_in_year,
+        mean_annual_return=mean_annual_return,
+        mean_annual_vol=mean_annual_vol,
+        dframe=returns,
+        seed=seed,
+        **kwargs,
+    )
+
+
 class ReturnSimulation(BaseModel):
     """The class ReturnSimulation allows for simulating financial timeseries.
 
@@ -105,7 +171,7 @@ class ReturnSimulation(BaseModel):
         revalidate_instances="always",
     )
 
-    @property
+    @cached_property
     def results(self: Self) -> DataFrame:
         """Simulation data.
 
@@ -197,13 +263,14 @@ class ReturnSimulation(BaseModel):
             size=(number_of_sims, trading_days),
         )
 
-        return cls(
+        return _create_base_simulation(
+            cls=cls,
+            returns=DataFrame(data=returns, dtype="float64"),
             number_of_sims=number_of_sims,
             trading_days=trading_days,
             trading_days_in_year=trading_days_in_year,
             mean_annual_return=mean_annual_return,
             mean_annual_vol=mean_annual_vol,
-            dframe=DataFrame(data=returns, dtype="float64"),
             seed=seed,
         )
 
@@ -255,13 +322,14 @@ class ReturnSimulation(BaseModel):
             - 1
         )
 
-        return cls(
+        return _create_base_simulation(
+            cls=cls,
+            returns=DataFrame(data=returns, dtype="float64"),
             number_of_sims=number_of_sims,
             trading_days=trading_days,
             trading_days_in_year=trading_days_in_year,
             mean_annual_return=mean_annual_return,
             mean_annual_vol=mean_annual_vol,
-            dframe=DataFrame(data=returns, dtype="float64"),
             seed=seed,
         )
 
@@ -317,13 +385,14 @@ class ReturnSimulation(BaseModel):
 
         returns = drift + wiener
 
-        return cls(
+        return _create_base_simulation(
+            cls=cls,
+            returns=DataFrame(data=returns, dtype="float64"),
             number_of_sims=number_of_sims,
             trading_days=trading_days,
             trading_days_in_year=trading_days_in_year,
             mean_annual_return=mean_annual_return,
             mean_annual_vol=mean_annual_vol,
-            dframe=DataFrame(data=returns, dtype="float64"),
             seed=seed,
         )
 
@@ -404,17 +473,18 @@ class ReturnSimulation(BaseModel):
 
         returns[:, 0] = 0.0
 
-        return cls(
+        return _create_base_simulation(
+            cls=cls,
+            returns=DataFrame(data=returns, dtype="float64"),
             number_of_sims=number_of_sims,
             trading_days=trading_days,
             trading_days_in_year=trading_days_in_year,
             mean_annual_return=mean_annual_return,
             mean_annual_vol=mean_annual_vol,
+            seed=seed,
             jumps_lamda=jumps_lamda,
             jumps_sigma=jumps_sigma,
             jumps_mu=jumps_mu,
-            dframe=DataFrame(data=returns, dtype="float64"),
-            seed=seed,
         )
 
     def to_dataframe(
@@ -465,15 +535,17 @@ class ReturnSimulation(BaseModel):
             )
             return sdf
 
-        fdf = DataFrame()
-        for item in range(self.number_of_sims):
-            sdf = self.dframe.iloc[item].T.to_frame()
-            sdf.index = Index(d_range)
-            sdf.columns = MultiIndex.from_arrays(
-                [
-                    [f"{name}_{item}"],
-                    [ValueType.RTRN],
-                ],
+        df_list = [
+            DataFrame(
+                data=self.dframe.iloc[item].values,
+                index=Index(d_range),
+                columns=MultiIndex.from_arrays(
+                    [
+                        [f"{name}_{item}"],
+                        [ValueType.RTRN],
+                    ],
+                ),
             )
-            fdf = concat([fdf, sdf], axis="columns", sort=True)
-        return fdf
+            for item in range(self.number_of_sims)
+        ]
+        return concat(df_list, axis="columns", sort=True)