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

openseries/datefixer.py

@@ -144,7 +144,7 @@ def holiday_calendar(
         for country in countries:
             staging = country_holidays(country=country, years=years)
             countryholidays += list(staging)
-        hols = list(countryholidays)
+        hols = cast("list[dt.date]", list(countryholidays))
     else:
         msg = (
             "Argument countries must be a string country code or "
@@ -154,7 +154,9 @@ def holiday_calendar(
 
     if markets:
         market_hols = market_holidays(
-            startyear=startyear, endyear=endyear, markets=markets
+            startyear=startyear,
+            endyear=endyear,
+            markets=markets,
         )
         dt_mkt_hols = [date_fix(fixerdate=ddate) for ddate in market_hols]
         hols.extend(dt_mkt_hols)

openseries/frame.py

@@ -14,15 +14,14 @@ from functools import reduce
 from logging import getLogger
 from typing import TYPE_CHECKING, Any, cast
 
-if TYPE_CHECKING:  # pragma: no cover
-    import datetime as dt
-
-    from numpy import dtype, int64, ndarray
-
 from numpy import (
     array,
+    asarray,
+    concatenate,
     cov,
+    diff,
     divide,
+    float64,
     isinf,
     log,
     nan,
@@ -38,10 +37,22 @@ from pandas import (
     concat,
     merge,
 )
+
+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
+
+    SeriesFloat = _Series[float]
+else:
+    SeriesFloat = Series
+
 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,
@@ -69,8 +80,7 @@ logger = getLogger(__name__)
 __all__ = ["OpenFrame"]
 
 
-# noinspection PyUnresolvedReferences,PyTypeChecker
-class OpenFrame(_CommonModel):
+class OpenFrame(_CommonModel[SeriesFloat]):
     """OpenFrame objects hold OpenTimeSeries in the list constituents.
 
     The intended use is to allow comparisons across these timeseries.
@@ -93,10 +103,9 @@ class OpenFrame(_CommonModel):
     tsdf: DataFrame = DataFrame(dtype="float64")
     weights: list[float] | None = None
 
-    # noinspection PyMethodParameters
-    @field_validator("constituents")  # type: ignore[misc]
+    @field_validator("constituents")
     def _check_labels_unique(
-        cls: OpenFrame,  # noqa: N805
+        cls: type[OpenFrame],  # noqa: N805
         tseries: list[OpenTimeSeries],
     ) -> list[OpenTimeSeries]:
         """Pydantic validator ensuring that OpenFrame labels are unique."""
@@ -130,7 +139,7 @@ class OpenFrame(_CommonModel):
         """
         copied_constituents = [ts.from_deepcopy() for ts in constituents]
 
-        super().__init__(
+        super().__init__(  # type: ignore[call-arg]
             constituents=copied_constituents,
             weights=weights,
         )
@@ -142,10 +151,12 @@ class OpenFrame(_CommonModel):
     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.")
 
@@ -241,7 +252,7 @@ class OpenFrame(_CommonModel):
 
         """
         return Series(
-            data=[self.tsdf.loc[:, d].count() for d in self.tsdf],
+            data=[self.tsdf[col].count() for col in self.tsdf.columns],
             index=self.tsdf.columns,
             name="observations",
         ).astype(int)
@@ -557,12 +568,14 @@ class OpenFrame(_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,
         )
         if periods_in_a_year_fixed is None:
             fraction = (later - earlier).days / 365.25
             how_many = (
-                self.tsdf.loc[cast("int", earlier) : cast("int", later)]
+                self.tsdf.loc[cast("Timestamp", earlier) : cast("Timestamp", later)]
                 .count()
                 .iloc[0]
             )
@@ -580,33 +593,35 @@ class OpenFrame(_CommonModel):
             cast("tuple[str, str]", self.tsdf.iloc[:, second_column].name)[0],
         ]
 
-        data = self.tsdf.loc[cast("int", earlier) : cast("int", later)].copy()
+        data = self.tsdf.loc[
+            cast("Timestamp", earlier) : cast("Timestamp", later)
+        ].copy()
 
         for rtn in cols:
-            data[rtn, ValueType.RTRN] = log(data.loc[:, (rtn, ValueType.PRICE)]).diff()
+            arr = concatenate([array([nan]), diff(log(data[(rtn, ValueType.PRICE)]))])
+            data[rtn, ValueType.RTRN] = arr
 
         raw_one = [
-            data.loc[:, (cols[0], ValueType.RTRN)]
+            data[(cols[0], ValueType.RTRN)]
             .iloc[1:day_chunk]
             .std(ddof=dlta_degr_freedms)
             * sqrt(time_factor),
         ]
         raw_two = [
-            data.loc[:, (cols[1], ValueType.RTRN)]
+            data[(cols[1], ValueType.RTRN)]
             .iloc[1:day_chunk]
             .std(ddof=dlta_degr_freedms)
             * sqrt(time_factor),
         ]
-        raw_cov = [
-            cov(
-                m=data.loc[:, (cols[0], ValueType.RTRN)].iloc[1:day_chunk].to_numpy(),
-                y=data.loc[:, (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.loc[:, (cols[0], ValueType.RTRN)]
-        r2 = data.loc[:, (cols[1], ValueType.RTRN)]
+        r1 = data[(cols[0], ValueType.RTRN)]
+        r2 = data[(cols[1], ValueType.RTRN)]
 
         alpha = 1.0 - lmbda
 
@@ -838,51 +853,33 @@ class OpenFrame(_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,
         )
-        fraction = (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("int", earlier) : cast("int", later)].loc[
-                :,
-                base_column,
-            ]
-            short_item = base_column
-            short_label = cast(
-                "tuple[str, ValueType]",
-                self.tsdf.loc[:, base_column].name,
-            )[0]
-        elif isinstance(base_column, int):
-            shortdf = cast(
-                "DataFrame",
-                self.tsdf.loc[cast("int", earlier) : cast("int", 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 = float(cast("int64", 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:
             if item == short_item:
                 terrors.append(0.0)
             else:
-                longdf = self.tsdf.loc[cast("int", earlier) : cast("int", later)].loc[
-                    :,
-                    item,
-                ]
+                longdf = self.tsdf.loc[
+                    cast("Timestamp", earlier) : cast("Timestamp", later)
+                ][item]
                 relative = longdf.ffill().pct_change() - shortdf.ffill().pct_change()
                 vol = float(relative.std() * sqrt(time_factor))
                 terrors.append(vol)
@@ -931,56 +928,33 @@ class OpenFrame(_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,
         )
-        fraction = (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("int", earlier) : cast("int", later)].loc[
-                :,
-                base_column,
-            ]
-            short_item = base_column
-            short_label = cast(
-                "tuple[str, str]",
-                self.tsdf.loc[:, base_column].name,
-            )[0]
-        elif isinstance(base_column, int):
-            shortdf = cast(
-                "DataFrame",
-                self.tsdf.loc[cast("int", earlier) : cast("int", 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 = float(shortdf.count() / fraction)  # type: ignore[arg-type]
+        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:
             if item == short_item:
                 ratios.append(0.0)
             else:
-                longdf = self.tsdf.loc[cast("int", earlier) : cast("int", later)].loc[
-                    :,
-                    item,
-                ]
+                longdf = self.tsdf.loc[
+                    cast("Timestamp", earlier) : cast("Timestamp", later)
+                ][item]
                 relative = longdf.ffill().pct_change() - shortdf.ffill().pct_change()
                 ret = float(relative.mean() * time_factor)
                 vol = float(relative.std() * sqrt(time_factor))
@@ -1038,29 +1012,26 @@ class OpenFrame(_CommonModel):
         """
         loss_limit: float = 0.0
         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,
         )
-        fraction = (later - earlier).days / 365.25
+        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("int", earlier) : cast("int", later)].loc[
-                :,
-                base_column,
-            ]
+            shortdf = self.tsdf.loc[
+                cast("Timestamp", earlier) : cast("Timestamp", later)
+            ][base_column]
             short_item = base_column
             short_label = cast(
                 "tuple[str, str]",
-                self.tsdf.loc[:, base_column].name,
+                self.tsdf[base_column].name,
             )[0]
         elif isinstance(base_column, int):
-            shortdf = cast(
-                "DataFrame",
-                self.tsdf.loc[cast("int", earlier) : cast("int", later)].iloc[
-                    :,
-                    base_column,
-                ],
-            )
+            shortdf = self.tsdf.loc[
+                cast("Timestamp", earlier) : cast("Timestamp", later)
+            ].iloc[:, base_column]
             short_item = cast(
                 "tuple[str, ValueType]",
                 self.tsdf.iloc[
@@ -1077,17 +1048,16 @@ class OpenFrame(_CommonModel):
         if periods_in_a_year_fixed:
             time_factor = float(periods_in_a_year_fixed)
         else:
-            time_factor = float(shortdf.count() / fraction)  # type: ignore[arg-type]
+            time_factor = shortdf.count() / fraction
 
         ratios = []
         for item in self.tsdf:
             if item == short_item:
                 ratios.append(0.0)
             else:
-                longdf = self.tsdf.loc[cast("int", earlier) : cast("int", later)].loc[
-                    :,
-                    item,
-                ]
+                longdf = self.tsdf.loc[
+                    cast("Timestamp", earlier) : cast("Timestamp", later)
+                ][item]
                 msg = "ratio must be one of 'up', 'down' or 'both'."
                 if ratio == "up":
                     uparray = (
@@ -1230,38 +1200,33 @@ class OpenFrame(_CommonModel):
         if all(vtypes):
             msg = "asset should be a tuple[str, ValueType] or an integer."
             if isinstance(asset, tuple):
-                y_value = self.tsdf.loc[:, asset]
+                y_value = self.tsdf[asset]
             elif isinstance(asset, int):
-                y_value = cast("DataFrame", self.tsdf.iloc[:, asset])
+                y_value = self.tsdf.iloc[:, asset]
             else:
                 raise TypeError(msg)
 
             msg = "market should be a tuple[str, ValueType] or an integer."
             if isinstance(market, tuple):
-                x_value = self.tsdf.loc[:, market]
+                x_value = self.tsdf[market]
             elif isinstance(market, int):
-                x_value = cast("DataFrame", self.tsdf.iloc[:, market])
+                x_value = self.tsdf.iloc[:, market]
             else:
                 raise TypeError(msg)
         elif not any(vtypes):
             msg = "asset should be a tuple[str, ValueType] or an integer."
             if isinstance(asset, tuple):
-                y_value = self.tsdf.loc[:, asset].ffill().pct_change().iloc[1:]
+                y_value = self.tsdf[asset].ffill().pct_change().iloc[1:]
             elif isinstance(asset, int):
-                y_value = cast(
-                    "DataFrame", self.tsdf.iloc[:, asset].ffill().pct_change().iloc[1:]
-                )
+                y_value = self.tsdf.iloc[:, asset].ffill().pct_change().iloc[1:]
             else:
                 raise TypeError(msg)
             msg = "market should be a tuple[str, ValueType] or an integer."
 
             if isinstance(market, tuple):
-                x_value = self.tsdf.loc[:, market].ffill().pct_change().iloc[1:]
+                x_value = self.tsdf[market].ffill().pct_change().iloc[1:]
             elif isinstance(market, int):
-                x_value = cast(
-                    "DataFrame",
-                    self.tsdf.iloc[:, market].ffill().pct_change().iloc[1:],
-                )
+                x_value = self.tsdf.iloc[:, market].ffill().pct_change().iloc[1:]
             else:
                 raise TypeError(msg)
         else:
@@ -1302,26 +1267,23 @@ class OpenFrame(_CommonModel):
         """
         msg = "y_column should be a tuple[str, ValueType] or an integer."
         if isinstance(y_column, tuple):
-            y_value = self.tsdf.loc[:, y_column].to_numpy()
+            y_value = self.tsdf[y_column].to_numpy()
             y_label = cast(
                 "tuple[str, str]",
-                self.tsdf.loc[:, y_column].name,
+                self.tsdf[y_column].name,
             )[0]
         elif isinstance(y_column, int):
-            y_value = cast(
-                "ndarray[tuple[int, int], dtype[Any]]",
-                self.tsdf.iloc[:, y_column].to_numpy(),
-            )
+            y_value = self.tsdf.iloc[:, y_column].to_numpy()
             y_label = cast("tuple[str, str]", self.tsdf.iloc[:, y_column].name)[0]
         else:
             raise TypeError(msg)
 
         msg = "x_column should be a tuple[str, ValueType] or an integer."
         if isinstance(x_column, tuple):
-            x_value = self.tsdf.loc[:, x_column].to_numpy().reshape(-1, 1)
+            x_value = self.tsdf[x_column].to_numpy().reshape(-1, 1)
             x_label = cast(
                 "tuple[str, str]",
-                self.tsdf.loc[:, x_column].name,
+                self.tsdf[x_column].name,
             )[0]
         elif isinstance(x_column, int):
             x_value = self.tsdf.iloc[:, x_column].to_numpy().reshape(-1, 1)
@@ -1376,45 +1338,40 @@ class OpenFrame(_CommonModel):
         if not any(vtypes):
             msg = "asset should be a tuple[str, ValueType] or an integer."
             if isinstance(asset, tuple):
-                asset_rtn = self.tsdf.loc[:, asset].ffill().pct_change().iloc[1:]
+                asset_rtn = self.tsdf[asset].ffill().pct_change().iloc[1:]
                 asset_rtn_mean = float(asset_rtn.mean() * self.periods_in_a_year)
             elif isinstance(asset, int):
-                asset_rtn = cast(
-                    "DataFrame", self.tsdf.iloc[:, asset].ffill().pct_change().iloc[1:]
-                )
+                asset_rtn = self.tsdf.iloc[:, asset].ffill().pct_change().iloc[1:]
                 asset_rtn_mean = float(asset_rtn.mean() * self.periods_in_a_year)
             else:
                 raise TypeError(msg)
 
             msg = "market should be a tuple[str, ValueType] or an integer."
             if isinstance(market, tuple):
-                market_rtn = self.tsdf.loc[:, market].ffill().pct_change().iloc[1:]
+                market_rtn = self.tsdf[market].ffill().pct_change().iloc[1:]
                 market_rtn_mean = float(market_rtn.mean() * self.periods_in_a_year)
             elif isinstance(market, int):
-                market_rtn = cast(
-                    "DataFrame",
-                    self.tsdf.iloc[:, market].ffill().pct_change().iloc[1:],
-                )
+                market_rtn = self.tsdf.iloc[:, market].ffill().pct_change().iloc[1:]
                 market_rtn_mean = float(market_rtn.mean() * self.periods_in_a_year)
             else:
                 raise TypeError(msg)
         elif all(vtypes):
             msg = "asset should be a tuple[str, ValueType] or an integer."
             if isinstance(asset, tuple):
-                asset_rtn = self.tsdf.loc[:, asset]
+                asset_rtn = self.tsdf[asset]
                 asset_rtn_mean = float(asset_rtn.mean() * self.periods_in_a_year)
             elif isinstance(asset, int):
-                asset_rtn = cast("DataFrame", self.tsdf.iloc[:, asset])
+                asset_rtn = self.tsdf.iloc[:, asset]
                 asset_rtn_mean = float(asset_rtn.mean() * self.periods_in_a_year)
             else:
                 raise TypeError(msg)
 
             msg = "market should be a tuple[str, ValueType] or an integer."
             if isinstance(market, tuple):
-                market_rtn = self.tsdf.loc[:, market]
+                market_rtn = self.tsdf[market]
                 market_rtn_mean = float(market_rtn.mean() * self.periods_in_a_year)
             elif isinstance(market, int):
-                market_rtn = cast("DataFrame", self.tsdf.iloc[:, market])
+                market_rtn = self.tsdf.iloc[:, market]
                 market_rtn_mean = float(market_rtn.mean() * self.periods_in_a_year)
             else:
                 raise TypeError(msg)
@@ -1426,7 +1383,7 @@ class OpenFrame(_CommonModel):
         beta = covariance[0, 1] / covariance[1, 1]
 
         return float(
-            asset_rtn_mean - riskfree_rate - beta * (market_rtn_mean - riskfree_rate)
+            asset_rtn_mean - riskfree_rate - beta * (market_rtn_mean - riskfree_rate),
         )
 
     def make_portfolio(
@@ -1461,7 +1418,7 @@ class OpenFrame(_CommonModel):
             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)
@@ -1612,7 +1569,7 @@ class OpenFrame(_CommonModel):
         rollbeta.index = rollbeta.index.droplevel(level=1)
         rollbeta.columns = MultiIndex.from_arrays([[beta_label], ["Beta"]])
 
-        return cast("DataFrame", rollbeta)
+        return rollbeta
 
     def rolling_corr(
         self: Self,