openseries 0.12.6__py3-none-any.whl → 0.12.8__py3-none-any.whl

openseries/frame.py

@@ -13,7 +13,7 @@ from string import ascii_letters
 from typing import cast, Dict, List, Tuple, Union
 from dateutil.relativedelta import relativedelta
 from ffn.core import calc_mean_var_weights, calc_inv_vol_weights, calc_erc_weights
-from numpy import cov, cumprod, log, sqrt, square, zeros
+from numpy import cov, cumprod, log, sqrt
 from pandas import (
     concat,
     DataFrame,
@@ -34,7 +34,7 @@ import statsmodels.api as sm
 # noinspection PyProtectedMember
 from statsmodels.regression.linear_model import RegressionResults
 
-from openseries.series import OpenTimeSeries, ValueType
+from openseries.series import OpenTimeSeries, ValueType, ewma_calc
 from openseries.datefixer import date_offset_foll, holiday_calendar
 from openseries.load_plotly import load_plotly_dict
 from openseries.types import (
@@ -92,7 +92,9 @@ class OpenFrame(BaseModel):
         validate_assignment = True
 
     @validator("constituents")
-    def check_labels_unique(cls, tseries: List[OpenTimeSeries]) -> List[OpenTimeSeries]:
+    def check_labels_unique(
+        cls, tseries: List[OpenTimeSeries]
+    ) -> List[OpenTimeSeries]:
         """Pydantic validator ensuring that OpenFrame labels are unique"""
         labls = [x.label for x in tseries]
         if len(set(labls)) != len(labls):
@@ -703,7 +705,9 @@ class OpenFrame(BaseModel):
             )
             time_factor = how_many / fraction
         return Series(
-            data=self.tsdf.loc[cast(int, earlier) : cast(int, later)].pct_change().std()
+            data=self.tsdf.loc[cast(int, earlier) : cast(int, later)]
+            .pct_change()
+            .std()
             * sqrt(time_factor),
             name="Subset Volatility",
             dtype="float64",
@@ -1729,7 +1733,9 @@ class OpenFrame(BaseModel):
                 - self.tsdf.loc[cast(int, earlier) : cast(int, later)]
                 .pct_change()
                 .sum()
-                / len(self.tsdf.loc[cast(int, earlier) : cast(int, later)].pct_change())
+                / len(
+                    self.tsdf.loc[cast(int, earlier) : cast(int, later)].pct_change()
+                )
             )
         else:
             imp_vol = (
@@ -1900,7 +1906,9 @@ class OpenFrame(BaseModel):
         for xerie in self.constituents:
             xerie.tsdf.index = DatetimeIndex(xerie.tsdf.index)
             xerie.tsdf = xerie.tsdf.resample(freq).last()
-            xerie.tsdf.index = [dejt.date() for dejt in DatetimeIndex(xerie.tsdf.index)]
+            xerie.tsdf.index = [
+                dejt.date() for dejt in DatetimeIndex(xerie.tsdf.index)
+            ]
 
         return self
 
@@ -2059,9 +2067,6 @@ class OpenFrame(BaseModel):
             time_factor = how_many / fraction
         else:
             time_factor = periods_in_a_year_fixed
-            how_many = (
-                self.tsdf.loc[cast(int, earlier) : cast(int, later)].count().iloc[0]
-            )
 
         corr_label = (
             self.tsdf.iloc[:, first_column].name[0]
@@ -2076,54 +2081,62 @@ class OpenFrame(BaseModel):
         data = self.tsdf.loc[cast(int, earlier) : cast(int, later)].copy()
 
         for rtn in cols:
-            data[rtn, "Returns"] = data.loc[:, (rtn, ValueType.PRICE)].apply(log).diff()
-            data[rtn, ValueType.EWMA] = zeros(how_many)
-            data.loc[:, (rtn, ValueType.EWMA)].iloc[0] = data.loc[
-                :, (rtn, "Returns")
-            ].iloc[1:day_chunk].std(ddof=dlta_degr_freedms) * sqrt(time_factor)
-
-        data["Cov", ValueType.EWMA] = zeros(how_many)
-        data[corr_label, ValueType.EWMA] = zeros(how_many)
-        data.loc[:, ("Cov", ValueType.EWMA)].iloc[0] = cov(
-            m=data.loc[:, (cols[0], "Returns")].iloc[1:day_chunk].to_numpy(),
-            y=data.loc[:, (cols[1], "Returns")].iloc[1:day_chunk].to_numpy(),
-            ddof=dlta_degr_freedms,
-        )[0][1]
-        data.loc[:, (corr_label, ValueType.EWMA)].iloc[0] = data.loc[
-            :, ("Cov", ValueType.EWMA)
-        ].iloc[0] / (
-            2
-            * data.loc[:, (cols[0], ValueType.EWMA)].iloc[0]
-            * data.loc[:, (cols[1], ValueType.EWMA)].iloc[0]
-        )
+            data[rtn, "Returns"] = (
+                data.loc[:, (rtn, ValueType.PRICE)].apply(log).diff()
+            )
 
-        prev = data.loc[self.first_idx]
-        for indx, row in data.iloc[1:].iterrows():
-            row.loc[cols, ValueType.EWMA] = sqrt(
-                square(row.loc[cols, "Returns"].to_numpy()) * time_factor * (1 - lmbda)
-                + square(prev.loc[cols, ValueType.EWMA].to_numpy()) * lmbda
+        raw_one = [
+            data.loc[:, (cols[0], "Returns")]
+            .iloc[1:day_chunk]
+            .std(ddof=dlta_degr_freedms)
+            * sqrt(time_factor)
+        ]
+        raw_two = [
+            data.loc[:, (cols[1], "Returns")]
+            .iloc[1:day_chunk]
+            .std(ddof=dlta_degr_freedms)
+            * sqrt(time_factor)
+        ]
+        raw_cov = [
+            cov(
+                m=data.loc[:, (cols[0], "Returns")].iloc[1:day_chunk].to_numpy(),
+                y=data.loc[:, (cols[1], "Returns")].iloc[1:day_chunk].to_numpy(),
+                ddof=dlta_degr_freedms,
+            )[0][1]
+        ]
+        raw_corr = [raw_cov[0] / (2 * raw_one[0] * raw_two[0])]
+
+        for _, row in data.iloc[1:].iterrows():
+            tmp_raw_one = ewma_calc(
+                reeturn=row.loc[cols[0], "Returns"],
+                prev_ewma=raw_one[-1],
+                time_factor=time_factor,
+                lmbda=lmbda,
+            )
+            tmp_raw_two = ewma_calc(
+                reeturn=row.loc[cols[1], "Returns"],
+                prev_ewma=raw_two[-1],
+                time_factor=time_factor,
+                lmbda=lmbda,
             )
-            data.loc[indx, (cols, ValueType.EWMA)] = row.loc[cols, ValueType.EWMA]
-            row.loc["Cov", ValueType.EWMA] = (
+            tmp_raw_cov = (
                 row.loc[cols[0], "Returns"]
                 * row.loc[cols[1], "Returns"]
                 * time_factor
                 * (1 - lmbda)
-                + prev.loc["Cov", ValueType.EWMA] * lmbda
-            )
-            data.loc[indx, ("Cov", ValueType.EWMA)] = row.loc["Cov", ValueType.EWMA]
-            row.loc[corr_label, ValueType.EWMA] = row.loc["Cov", ValueType.EWMA] / (
-                2 * row.loc[cols[0], ValueType.EWMA] * row.loc[cols[1], ValueType.EWMA]
+                + raw_cov[-1] * lmbda
             )
-            data.loc[indx, (corr_label, ValueType.EWMA)] = row.loc[
-                corr_label, ValueType.EWMA
-            ]
-            prev = row.copy()
-
-        ewma_df = data.loc[:, (cols + [corr_label], ValueType.EWMA)]
-        ewma_df.columns = ewma_df.columns.droplevel(level=1)
-
-        return ewma_df
+            tmp_raw_corr = tmp_raw_cov / (2 * tmp_raw_one * tmp_raw_two)
+            raw_one.append(tmp_raw_one)
+            raw_two.append(tmp_raw_two)
+            raw_cov.append(tmp_raw_cov)
+            raw_corr.append(tmp_raw_corr)
+
+        return DataFrame(
+            index=cols + [corr_label],
+            columns=data.index,
+            data=[raw_one, raw_two, raw_corr],
+        ).T
 
     def rolling_vol(
         self: "OpenFrame",
@@ -2694,7 +2707,9 @@ class OpenFrame(BaseModel):
                         .add(1)
                         .values
                     )
-                    up_return = uparray.prod() ** (1 / (len(uparray) / time_factor)) - 1
+                    up_return = (
+                        uparray.prod() ** (1 / (len(uparray) / time_factor)) - 1
+                    )
                     upidxarray = (
                         shortdf.pct_change()[shortdf.pct_change().values > 0.0]
                         .add(1)
@@ -2729,7 +2744,9 @@ class OpenFrame(BaseModel):
                         .add(1)
                         .values
                     )
-                    up_return = uparray.prod() ** (1 / (len(uparray) / time_factor)) - 1
+                    up_return = (
+                        uparray.prod() ** (1 / (len(uparray) / time_factor)) - 1
+                    )
                     upidxarray = (
                         shortdf.pct_change()[shortdf.pct_change().values > 0.0]
                         .add(1)
@@ -2815,7 +2832,9 @@ class OpenFrame(BaseModel):
                 )
         else:
             if isinstance(asset, tuple):
-                y_value = log(self.tsdf.loc[:, asset] / self.tsdf.loc[:, asset].iloc[0])
+                y_value = log(
+                    self.tsdf.loc[:, asset] / self.tsdf.loc[:, asset].iloc[0]
+                )
             elif isinstance(asset, int):
                 y_value = log(self.tsdf.iloc[:, asset] / self.tsdf.iloc[0, asset])
             else:
@@ -2999,8 +3018,8 @@ class OpenFrame(BaseModel):
         observations: int = 21,
         periods_in_a_year_fixed: int | None = None,
     ) -> DataFrame:
-        """The Information Ratio equals ( fund return less index return ) divided by the
-        Tracking Error. And the Tracking Error is the standard deviation of the
+        """The Information Ratio equals ( fund return less index return ) divided by
+        the Tracking Error. And the Tracking Error is the standard deviation of the
         difference between the fund and its index returns.
 
         Parameters

openseries/series.py

@@ -20,7 +20,6 @@ from numpy import (
     ndarray,
     sqrt,
     square,
-    zeros,
 )
 from dateutil.relativedelta import relativedelta
 from pandas import (
@@ -86,6 +85,33 @@ def check_if_none(item: Any) -> bool:
         return len(str(item)) == 0
 
 
+def ewma_calc(
+    reeturn: float, prev_ewma: float, time_factor: float, lmbda: float = 0.94
+) -> float:
+    """Helper function for EWMA calculation
+
+    Parameters
+    ----------
+    reeturn : float
+        Return value
+    prev_ewma : float
+        Previous EWMA volatility value
+    time_factor : float
+        Scaling factor to annualize
+    lmbda: float, default: 0.94
+        Scaling factor to determine weighting.
+
+    Returns
+    -------
+    float
+        EWMA volatility value
+    """
+    return cast(
+        float,
+        sqrt(square(reeturn) * time_factor * (1 - lmbda) + square(prev_ewma) * lmbda),
+    )
+
+
 class ValueType(str, Enum):
     """Class defining the different timeseries types within the project"""
 
@@ -287,7 +313,9 @@ class OpenTimeSeries(BaseModel):
                     dframe.columns.get_level_values(1).values[column_nmbr]
                 ):
                     valuetype = ValueType.PRICE
-                    print(f"valuetype missing. Adding '{valuetype.value}' as valuetype")
+                    print(
+                        f"valuetype missing. Adding '{valuetype.value}' as valuetype"
+                    )
                 else:
                     valuetype = dframe.columns.get_level_values(1).values[column_nmbr]
             else:
@@ -324,7 +352,7 @@ class OpenTimeSeries(BaseModel):
         baseccy: str = "SEK",
         local_ccy: bool = True,
     ) -> "OpenTimeSeries":
-        """Creates a timeseries from a series of values accruing with a given fixed rate
+        """Creates a timeseries from values accruing with a given fixed rate return
 
         Providing a date_range of type Pandas DatetimeIndex takes priority over
         providing a combination of days and an end date.
@@ -360,7 +388,9 @@ class OpenTimeSeries(BaseModel):
                 [d.date() for d in date_range(periods=days, end=end_dt, freq="D")]
             )
         elif not isinstance(d_range, DatetimeIndex) and not all([days, end_dt]):
-            raise ValueError("If d_range is not provided both days and end_dt must be.")
+            raise ValueError(
+                "If d_range is not provided both days and end_dt must be."
+            )
 
         deltas = array(
             [
@@ -694,7 +724,9 @@ class OpenTimeSeries(BaseModel):
 
         if (
             self.tsdf.loc[earlier, self.tsdf.columns.values[0]] == 0.0
-            or self.tsdf.loc[cast(int, earlier) : cast(int, later)].lt(0.0).values.any()
+            or self.tsdf.loc[cast(int, earlier) : cast(int, later)]
+            .lt(0.0)
+            .values.any()
         ):
             raise ValueError(
                 "Geometric return cannot be calculated due to an initial "
@@ -763,7 +795,9 @@ class OpenTimeSeries(BaseModel):
         return cast(
             float,
             (
-                self.tsdf.loc[cast(int, earlier) : cast(int, later)].pct_change().mean()
+                self.tsdf.loc[cast(int, earlier) : cast(int, later)]
+                .pct_change()
+                .mean()
                 * time_factor
             ).iloc[0],
         )
@@ -855,7 +889,8 @@ class OpenTimeSeries(BaseModel):
         """
 
         return cast(
-            float, (self.tsdf.pct_change().std() * sqrt(self.periods_in_a_year)).iloc[0]
+            float,
+            (self.tsdf.pct_change().std() * sqrt(self.periods_in_a_year)).iloc[0],
         )
 
     def vol_func(
@@ -2004,21 +2039,26 @@ class OpenTimeSeries(BaseModel):
         data[self.label, "Returns"] = (
             data.loc[:, self.tsdf.columns.values[0]].apply(log).diff()
         )
-        data[self.label, ValueType.EWMA] = zeros(data.iloc[:, 0].count())
-        data.loc[:, (self.label, ValueType.EWMA)].iloc[0] = data.loc[
-            :, (self.label, "Returns")
-        ].iloc[1:day_chunk].std(ddof=dlta_degr_freedms) * sqrt(time_factor)
-
-        prev = data.loc[self.first_idx]
-        for indx, row in data.iloc[1:].iterrows():
-            row.loc[self.label, ValueType.EWMA] = sqrt(
-                square(row.loc[self.label, "Returns"]) * time_factor * (1 - lmbda)
-                + square(prev.loc[self.label, ValueType.EWMA]) * lmbda
+
+        rawdata = [
+            data.loc[:, (self.label, "Returns")]
+            .iloc[1:day_chunk]
+            .std(ddof=dlta_degr_freedms)
+            * sqrt(time_factor)
+        ]
+
+        for item in data.loc[:, (self.label, "Returns")].iloc[1:]:
+            previous = rawdata[-1]
+            rawdata.append(
+                ewma_calc(
+                    reeturn=item,
+                    prev_ewma=previous,
+                    time_factor=time_factor,
+                    lmbda=lmbda,
+                )
             )
-            data.loc[indx, (self.label, ValueType.EWMA)] = row.loc[
-                self.label, ValueType.EWMA
-            ]
-            prev = row.copy()
+
+        data.loc[:, (self.label, ValueType.EWMA)] = rawdata
 
         return data.loc[:, (self.label, ValueType.EWMA)]
 
@@ -2068,7 +2108,9 @@ class OpenTimeSeries(BaseModel):
         """
 
         retdf = (
-            self.tsdf.pct_change().rolling(observations, min_periods=observations).sum()
+            self.tsdf.pct_change()
+            .rolling(observations, min_periods=observations)
+            .sum()
         )
         retdf.columns = [[self.label], ["Rolling returns"]]
 
@@ -2256,7 +2298,9 @@ class OpenTimeSeries(BaseModel):
         """
 
         if lvl_zero is None and lvl_one is None:
-            self.tsdf.columns = MultiIndex.from_arrays([[self.label], [self.valuetype]])
+            self.tsdf.columns = MultiIndex.from_arrays(
+                [[self.label], [self.valuetype]]
+            )
         elif lvl_zero is not None and lvl_one is None:
             self.tsdf.columns = MultiIndex.from_arrays([[lvl_zero], [self.valuetype]])
             self.label = lvl_zero

openseries/sim_price.py

@@ -82,7 +82,9 @@ class ReturnSimulation(BaseModel):
 
         return cast(
             float,
-            (self.results.pct_change().std() * sqrt(self.trading_days_in_year)).iloc[0],
+            (self.results.pct_change().std() * sqrt(self.trading_days_in_year)).iloc[
+                0
+            ],
         )
 
     @classmethod

openseries/stoch_processes.py

@@ -321,7 +321,11 @@ def cox_ingersoll_ross_heston(
     brownian_motion_volatility = nrand.normal(
         loc=0, scale=sqrt_delta_sigma, size=param.all_time
     )
-    meanrev_vol, avg_vol, start_vol = param.heston_a, param.heston_mu, param.heston_vol0
+    meanrev_vol, avg_vol, start_vol = (
+        param.heston_a,
+        param.heston_mu,
+        param.heston_vol0,
+    )
     volatilities: List[float] = [start_vol]
     for hpath in range(1, param.all_time):
         drift = meanrev_vol * (avg_vol - volatilities[-1]) * param.all_delta

{openseries-0.12.6.dist-info → openseries-0.12.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openseries
-Version: 0.12.6
+Version: 0.12.8
 Summary: Package for simple financial time series analysis.
 Home-page: https://github.com/CaptorAB/OpenSeries
 License: BSD-3-Clause
@@ -198,6 +198,9 @@ make lint
 
 ## Table of Contents
 
+- [Basic Usage](#basic-usage)
+- [Development Instructions](#development-instructions)
+- [Testing and Linting / Type-checking](#testing-and-linting--type-checking)
 - [Files / Modules in the project](#files-in-the-project)
 - [Class methods used to construct an OpenTimeSeries](#class-methods-used-to-construct-an-opentimeseries-object)
 - [OpenTimeSeries non-numerical properties](#non-numerical-or-helper-properties-that-apply-only-to-the-opentimeseries-class)
@@ -208,8 +211,6 @@ make lint
 - [Methods for both classes](#methods-that-apply-to-both-the-opentimeseries-and-the-openframe-class)
 - [Numerical properties for both classes](#numerical-properties-available-for-individual-opentimeseries-or-on-all-series-in-an-openframe)
 - [Numerical methods with period arguments for both classes](#methods-below-are-identical-to-the-numerical-properties-above)
-- [Development Instructions](#development-instructions)
-- [Testing and Linting / Type-checking](#testing-and-linting--type-checking)
 
 ### Files in the project
 
@@ -218,9 +219,10 @@ make lint
 | [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.                                         |
 | [datefixer.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/datefixer.py)                       | Date utilities. Please read the docstring of each function for its description.                                                                                                                     |
+| [load_plotly.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/load_plotly.py)                   | Functions to load [Plotly](https://plotly.com/python/) default layout and configuration from local json file.                                                                                       |
 | [plotly_layouts.json](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/plotly_layouts.json)         | [Plotly](https://plotly.com/python/) defaults used in the `plot_bars` and `plot_series` methods.                                                                                                    |
 | [plotly_captor_logo.json](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/plotly_captor_logo.json) | JSON with a link to the Captor logo used in the `plot_bars` and `plot_series` methods.                                                                                                              |
-| [risk.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/risk.py)                                 | Methods used to calculate VaR, CVaR and drawdowns.                                                                                                                                                  |
+| [risk.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/risk.py)                                 | Functions used to calculate VaR, CVaR and drawdowns.                                                                                                                                                |
 | [sim_price.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/sim_price.py)                       | Simulates OpenTimeSeries from different stochastic processes.                                                                                                                                       |
 | [stoch_processes.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/stoch_processes.py)           | Generates stochastic processes used in the `sim_price.py` module.                                                                                                                                   |
 | [types.py](https://github.com/CaptorAB/OpenSeries/blob/master/openseries/types.py)                               | Contains all bespoke typing.                                                                                                                                                                        |

{openseries-0.12.6.dist-info → openseries-0.12.8.dist-info}/RECORD

@@ -1,15 +1,15 @@
 openseries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openseries/datefixer.py,sha256=h4zshiUkJmRmbBgiCCVulxVUa2SO1dRdJMAKLMxE-tc,9970
-openseries/frame.py,sha256=8WBQrGEI0kj4euOFxIFUu6whnuTbZ1KDTsrFVeWdz44,114038
+openseries/frame.py,sha256=wd6DJMJrB9iweDKK_UVxslzXvoZ6oLo-fjkUyv5usCA,113825
 openseries/load_plotly.py,sha256=DfpacL-aL5z-W0Cw7FL4YtDSbgeSI8Q-8DO6940wiJc,1119
 openseries/plotly_captor_logo.json,sha256=pGMuPVu4cEO3ZsCH1wU03hxqbIQkHFNoJUs1k1WK89Y,178
 openseries/plotly_layouts.json,sha256=cRljccbXJYoyUBnl8AYxvHrU1V0lTWbsT8sBkPZdj_g,1349
 openseries/risk.py,sha256=Zk4rSFQSwa2NZ-FQP0ZWjtljwEbI3iwZiskQs6Gm6HY,4793
-openseries/series.py,sha256=qf66j9KJGPrwe6UMlJ6ndE1af2xKvarPWLIif8BR1c4,80586
-openseries/sim_price.py,sha256=q9G_RZZlL9ZKEpYpEtKR-_4s9Z4nK56gpDp2Wcw4RVE,13848
-openseries/stoch_processes.py,sha256=AxaQjSXeEYNZoUiazBR3FA8AsiBucSLnVDfrQTmv_yc,14640
+openseries/series.py,sha256=k5yVSc4_aC3eoYxDLVBFHtx-nb81NIAhl46cfIcPPpw,81253
+openseries/sim_price.py,sha256=dWzmj22nq4TW4BZBwP8Ajtid_g322No6D_m7t5bT8No,13878
+openseries/stoch_processes.py,sha256=6O4C_nC2iBseWggvDDC2gTpTqS5fI5nfjSRpccaazLE,14673
 openseries/types.py,sha256=SffsPIrtSD5JZ4mp-d-k2ymf7U0rjnIUxFbKcLhd4Os,6697
-openseries-0.12.6.dist-info/LICENSE.md,sha256=NJjeq3wyB7EnnHLmsdK1EK6zT00T1eB3FgAmHAPT_vM,1521
-openseries-0.12.6.dist-info/METADATA,sha256=7CXJjwHXDfeJuVG8vL5ym2ECNNIjFzYiOaqd496xuRQ,45698
-openseries-0.12.6.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-openseries-0.12.6.dist-info/RECORD,,
+openseries-0.12.8.dist-info/LICENSE.md,sha256=NJjeq3wyB7EnnHLmsdK1EK6zT00T1eB3FgAmHAPT_vM,1521
+openseries-0.12.8.dist-info/METADATA,sha256=6bVVrATsFnH_dTv_JvjiX_hX3m1ZarNN2SPAi8ORzLo,46043
+openseries-0.12.8.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+openseries-0.12.8.dist-info/RECORD,,