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

openseries/datefixer.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 import datetime as dt
 from typing import TYPE_CHECKING, cast
 
-import exchange_calendars as exchcal
+import exchange_calendars as exchcal  # type: ignore[import-untyped]
 from dateutil.relativedelta import relativedelta
 from holidays import (
     country_holidays,
@@ -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)
@@ -163,7 +165,7 @@ def holiday_calendar(
         custom_list = (
             [custom_holidays]
             if isinstance(custom_holidays, str)
-            else list(custom_holidays)  # type: ignore[arg-type]
+            else list(custom_holidays)
         )
         hols.extend([date_fix(fixerdate=ddate) for ddate in custom_list])
 
@@ -255,7 +257,7 @@ def date_offset_foll(
         while not is_busday(dates=new_date, busdaycal=calendar):
             new_date += day_delta
 
-    return new_date  # type: ignore[no-any-return]
+    return new_date
 
 
 def get_previous_business_day_before_today(
@@ -505,7 +507,7 @@ def _do_resample_to_business_period_ends(
     dates = DatetimeIndex(
         [copydata.index[0]]
         + [
-            date_offset_foll(  # type: ignore[misc]
+            date_offset_foll(
                 raw_date=dt.date(d.year, d.month, 1)
                 + relativedelta(months=1)
                 - dt.timedelta(days=1),

openseries/frame.py

@@ -7,7 +7,6 @@ https://github.com/CaptorAB/openseries/blob/master/LICENSE.md
 SPDX-License-Identifier: BSD-3-Clause
 """
 
-# mypy: disable-error-code="assignment,no-any-return"
 from __future__ import annotations
 
 from copy import deepcopy
@@ -15,12 +14,11 @@ 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 (
     array,
+    concatenate,
     cov,
+    diff,
     divide,
     isinf,
     log,
@@ -37,8 +35,19 @@ from pandas import (
     concat,
     merge,
 )
+
+if TYPE_CHECKING:  # pragma: no cover
+    import datetime as dt
+
+    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
+from sklearn.linear_model import LinearRegression  # type: ignore[import-untyped]
 
 from ._common_model import _CommonModel
 from .datefixer import _do_resample_to_business_period_ends
@@ -69,7 +78,7 @@ __all__ = ["OpenFrame"]
 
 
 # noinspection PyUnresolvedReferences,PyTypeChecker
-class OpenFrame(_CommonModel):  # type: ignore[misc]
+class OpenFrame(_CommonModel[SeriesFloat]):
     """OpenFrame objects hold OpenTimeSeries in the list constituents.
 
     The intended use is to allow comparisons across these timeseries.
@@ -93,9 +102,9 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
     weights: list[float] | None = None
 
     # noinspection PyMethodParameters
-    @field_validator("constituents")  # type: ignore[misc]
-    def _check_labels_unique(  # type: ignore[misc]
-        cls: OpenFrame,  # noqa: N805
+    @field_validator("constituents")
+    def _check_labels_unique(
+        cls: type[OpenFrame],  # noqa: N805
         tseries: list[OpenTimeSeries],
     ) -> list[OpenTimeSeries]:
         """Pydantic validator ensuring that OpenFrame labels are unique."""
@@ -240,7 +249,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
         """
         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)
@@ -556,12 +565,14 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
         """
         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]
             )
@@ -579,33 +590,36 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             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(),
+                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],
         ]
 
-        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
 
@@ -837,30 +851,30 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
         """
         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, ValueType]",
-                self.tsdf.loc[:, base_column].name,
+                self.tsdf[base_column].name,
             )[0]
         elif isinstance(base_column, int):
-            shortdf = self.tsdf.loc[cast("int", earlier) : cast("int", later)].iloc[
-                :,
-                base_column,
-            ]
-            short_item = self.tsdf.iloc[
-                :,
-                base_column,
-            ].name
+            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
             ]
@@ -870,17 +884,16 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         if periods_in_a_year_fixed:
             time_factor = float(periods_in_a_year_fixed)
         else:
-            time_factor = float(shortdf.count() / fraction)
+            time_factor = shortdf.count() / fraction
 
         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)
@@ -929,30 +942,33 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
         """
         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 = self.tsdf.loc[cast("int", earlier) : cast("int", later)].iloc[
-                :,
-                base_column,
-            ]
-            short_item = self.tsdf.iloc[
-                :,
-                base_column,
-            ].name
+            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
             ]
@@ -962,17 +978,16 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         if periods_in_a_year_fixed:
             time_factor = float(periods_in_a_year_fixed)
         else:
-            time_factor = float(shortdf.count() / fraction)
+            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]
                 relative = longdf.ffill().pct_change() - shortdf.ffill().pct_change()
                 ret = float(relative.mean() * time_factor)
                 vol = float(relative.std() * sqrt(time_factor))
@@ -1030,30 +1045,33 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         """
         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 = self.tsdf.loc[cast("int", earlier) : cast("int", later)].iloc[
-                :,
-                base_column,
-            ]
-            short_item = self.tsdf.iloc[
-                :,
-                base_column,
-            ].name
+            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
             ]
@@ -1063,17 +1081,16 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         if periods_in_a_year_fixed:
             time_factor = float(periods_in_a_year_fixed)
         else:
-            time_factor = float(shortdf.count() / fraction)
+            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 = (
@@ -1216,7 +1233,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         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 = self.tsdf.iloc[:, asset]
             else:
@@ -1224,7 +1241,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
             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 = self.tsdf.iloc[:, market]
             else:
@@ -1232,7 +1249,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         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 = self.tsdf.iloc[:, asset].ffill().pct_change().iloc[1:]
             else:
@@ -1240,7 +1257,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
             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 = self.tsdf.iloc[:, market].ffill().pct_change().iloc[1:]
             else:
@@ -1283,10 +1300,10 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         """
         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 = self.tsdf.iloc[:, y_column].to_numpy()
@@ -1296,10 +1313,10 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
         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)
@@ -1354,7 +1371,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         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 = self.tsdf.iloc[:, asset].ffill().pct_change().iloc[1:]
@@ -1364,7 +1381,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
             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 = self.tsdf.iloc[:, market].ffill().pct_change().iloc[1:]
@@ -1374,7 +1391,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         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 = self.tsdf.iloc[:, asset]
@@ -1384,7 +1401,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
 
             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 = self.tsdf.iloc[:, market]
@@ -1399,7 +1416,7 @@ class OpenFrame(_CommonModel):  # type: ignore[misc]
         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(

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"]
 
 
+Combo_co = TypeVar("Combo_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/plotly_layouts.json

@@ -16,7 +16,7 @@
     ],
     "responsive": true,
     "toImageButtonOptions": {
-      "filename": "captor_plot_image",
+      "filename": "openseries_plot",
       "format": "png"
     }
   },