Bump pytest version (#105)

CHANGELOG.md

@@ -44,6 +44,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix CI job `cron-delete-untagged-images` ([#95](https://github.com/etna-team/etna/pull/95))
 - Rendering table of contents in notebooks ([#1343](https://github.com/tinkoff-ai/etna/pull/1343))
 - Fix formatting of docstrings, fix links from netlify to docs.etna.ai ([#62](https://github.com/etna-team/etna/pull/62))
+- Fix multiple warnings, revert catching warnings during testing ([#105](https://github.com/etna-team/etna/pull/105))
 
 ### Removed
 - FutureMixin ([#58](https://github.com/etna-team/etna/pull/58))

etna/auto/auto.py

@@ -171,7 +171,7 @@ def __init__(
 
     def _top_k(self, summary: pd.DataFrame, k: int) -> List[BasePipeline]:
         metric_name = f"{self.target_metric.name}_{self.metric_aggregation}"
-        df = summary[summary["state"].apply(lambda x: x is optuna.structs.TrialState.COMPLETE)]
+        df = summary[summary["state"].apply(lambda x: x is optuna.trial.TrialState.COMPLETE)]
         df = df.drop_duplicates(subset=["hash"])
         df = df.sort_values(
             by=metric_name,
@@ -768,7 +768,7 @@ def _find_duplicate_trial(trial: Trial, pipeline: BasePipeline) -> Optional[Froz
             pipeline_hash = config_hash(pipeline.to_dict())
 
             for t in trial.study.trials:
-                if t.state != optuna.structs.TrialState.COMPLETE:
+                if t.state != optuna.trial.TrialState.COMPLETE:
                     continue
 
                 if t.user_attrs.get("hash") == pipeline_hash:

etna/commands/forecast_command.py

@@ -27,16 +27,14 @@
 def compute_horizon(horizon: int, forecast_params: Dict[str, Any], tsdataset: TSDataset) -> int:
     """Compute new pipeline horizon if `start_timestamp` presented in `forecast_params`."""
     if "start_timestamp" in forecast_params:
-        freq = tsdataset.freq
-
-        forecast_start_timestamp = pd.Timestamp(forecast_params["start_timestamp"], freq=freq)
+        forecast_start_timestamp = pd.Timestamp(forecast_params["start_timestamp"])
         train_end_timestamp = tsdataset.index.max()
 
         if forecast_start_timestamp <= train_end_timestamp:
             raise ValueError("Parameter `start_timestamp` should greater than end of training dataset!")
 
         delta = determine_num_steps(
-            start_timestamp=train_end_timestamp, end_timestamp=forecast_start_timestamp, freq=freq
+            start_timestamp=train_end_timestamp, end_timestamp=forecast_start_timestamp, freq=tsdataset.freq
         )
 
         horizon += delta - 1
@@ -53,9 +51,9 @@ def update_horizon(pipeline_configs: Dict[str, Any], forecast_params: Dict[str,
 
 
 def filter_forecast(forecast_ts: TSDataset, forecast_params: Dict[str, Any]) -> TSDataset:
-    """Filter out forecasts before `start_timestamp` if `start_timestamp` presented in `forecast_params`.."""
+    """Filter out forecasts before `start_timestamp` if `start_timestamp` presented in `forecast_params`."""
     if "start_timestamp" in forecast_params:
-        forecast_start_timestamp = pd.Timestamp(forecast_params["start_timestamp"], freq=forecast_ts.freq)
+        forecast_start_timestamp = pd.Timestamp(forecast_params["start_timestamp"])
         forecast_ts.df = forecast_ts.df.loc[forecast_start_timestamp:, :]
 
     return forecast_ts

etna/datasets/tsdataset.py

@@ -1240,7 +1240,7 @@ def add_target_components(self, target_components_df: pd.DataFrame):
                     f"Set of target components differs between segments '{self.segments[0]}' and '{segment}'!"
                 )
 
-        components_sum = target_components_df.sum(axis=1, level="segment")
+        components_sum = target_components_df.groupby(axis=1, level="segment").sum()
         if not np.allclose(components_sum.values, self[..., "target"].values):
             raise ValueError("Components don't sum up to target!")
 

etna/datasets/utils.py

@@ -183,7 +183,7 @@ def set_columns_wide(
 
 def match_target_quantiles(features: Set[str]) -> Set[str]:
     """Find quantiles in dataframe columns."""
-    pattern = re.compile("target_\d+\.\d+$")
+    pattern = re.compile(r"target_\d+\.\d+$")
     return {i for i in list(features) if pattern.match(i) is not None}
 
 

etna/models/base.py

@@ -452,8 +452,8 @@ def training_step(self, batch: dict, *args, **kwargs):  # type: ignore
         :
             loss
         """
-        loss, _, _ = self.step(batch, *args, **kwargs)  # type: ignore
-        self.log("train_loss", loss, on_epoch=True)
+        loss, true_target, _ = self.step(batch, *args, **kwargs)  # type: ignore
+        self.log("train_loss", loss, on_epoch=True, batch_size=len(true_target))
         return loss
 
     def validation_step(self, batch: dict, *args, **kwargs):  # type: ignore
@@ -469,8 +469,8 @@ def validation_step(self, batch: dict, *args, **kwargs):  # type: ignore
         :
             loss
         """
-        loss, _, _ = self.step(batch, *args, **kwargs)  # type: ignore
-        self.log("val_loss", loss, on_epoch=True)
+        loss, true_target, _ = self.step(batch, *args, **kwargs)  # type: ignore
+        self.log("val_loss", loss, on_epoch=True, batch_size=len(true_target))
         return loss
 
 

etna/models/sarimax.py

@@ -262,7 +262,7 @@ def _mle_regression_decomposition(self, state: np.ndarray, ssm: SimulationSmooth
 
         if len(exog) > 0:
             # restore parameters for exogenous variabales
-            exog_params = np.linalg.lstsq(a=exog, b=np.squeeze(ssm["obs_intercept"]))[0]
+            exog_params = np.linalg.lstsq(a=exog, b=np.squeeze(ssm["obs_intercept"]), rcond=None)[0]
 
             # estimate exogenous components and append to others
             weighted_exog = exog * exog_params[np.newaxis]

etna/models/tbats.py

@@ -397,7 +397,18 @@ def __init__(
         context: abstract.ContextInterface, optional (default=None)
             For advanced users only. Provide this to override default behaviors
         """
-        self.model = BATS(
+        self.use_box_cox = use_box_cox
+        self.box_cox_bounds = box_cox_bounds
+        self.use_trend = use_trend
+        self.use_damped_trend = use_damped_trend
+        self.seasonal_periods = seasonal_periods
+        self.use_arma_errors = use_arma_errors
+        self.show_warnings = show_warnings
+        self.n_jobs = n_jobs
+        self.multiprocessing_start_method = multiprocessing_start_method
+        self.context = context
+
+        self._model = BATS(
             use_box_cox=use_box_cox,
             box_cox_bounds=box_cox_bounds,
             use_trend=use_trend,
@@ -409,7 +420,7 @@ def __init__(
             multiprocessing_start_method=multiprocessing_start_method,
             context=context,
         )
-        super().__init__(base_model=_TBATSAdapter(self.model))
+        super().__init__(base_model=_TBATSAdapter(self._model))
 
 
 class TBATSModel(
@@ -474,7 +485,18 @@ def __init__(
         context: abstract.ContextInterface, optional (default=None)
             For advanced users only. Provide this to override default behaviors
         """
-        self.model = TBATS(
+        self.use_box_cox = use_box_cox
+        self.box_cox_bounds = box_cox_bounds
+        self.use_trend = use_trend
+        self.use_damped_trend = use_damped_trend
+        self.seasonal_periods = seasonal_periods
+        self.use_arma_errors = use_arma_errors
+        self.show_warnings = show_warnings
+        self.n_jobs = n_jobs
+        self.multiprocessing_start_method = multiprocessing_start_method
+        self.context = context
+
+        self._model = TBATS(
             use_box_cox=use_box_cox,
             box_cox_bounds=box_cox_bounds,
             use_trend=use_trend,
@@ -486,4 +508,4 @@ def __init__(
             multiprocessing_start_method=multiprocessing_start_method,
             context=context,
         )
-        super().__init__(base_model=_TBATSAdapter(self.model))
+        super().__init__(base_model=_TBATSAdapter(self._model))

etna/models/utils.py

@@ -115,7 +115,7 @@ def determine_freq(timestamps: Union[pd.Series, pd.DatetimeIndex]) -> str:
         unable do determine frequency of data
     """
     try:
-        freq = pd.infer_freq(timestamps, warn=False)
+        freq = pd.infer_freq(timestamps)
     except ValueError:
         freq = None
 

etna/transforms/decomposition/change_points_based/base.py

@@ -111,7 +111,7 @@ def _predict_per_interval_model(self, series: pd.Series) -> pd.Series:
         """Apply per-interval detrending to series."""
         if self.intervals is None or self.per_interval_models is None:
             raise ValueError("Transform is not fitted! Fit the Transform before calling transform method.")
-        prediction_series = pd.Series(index=series.index)
+        prediction_series = pd.Series(index=series.index, dtype=float)
         for interval in self.intervals:
             tmp_series = series[interval[0] : interval[1]]
             if tmp_series.empty:

etna/transforms/decomposition/change_points_based/segmentation.py

@@ -90,7 +90,7 @@ def __init__(
             result column name. If not given use ``self.__repr__()``
         """
         self.in_column = in_column
-        self.out_column = out_column if out_column is not None else self.__repr__()
+        self.out_column = out_column
 
         self.change_points_model = (
             change_points_model if change_points_model is not None else self._default_change_points_model
@@ -100,7 +100,7 @@ def __init__(
             transform=_OneSegmentChangePointsSegmentationTransform(
                 in_column=self.in_column,
                 change_points_model=self.change_points_model,
-                out_column=self.out_column,
+                out_column=out_column if out_column is not None else self.__repr__(),
             ),
             required_features=[in_column],
         )

etna/transforms/decomposition/change_points_based/trend.py

@@ -113,7 +113,7 @@ def __init__(
         super().__init__(
             transform=_OneSegmentTrendTransform(
                 in_column=self.in_column,
-                out_column=self.out_column if self.out_column is not None else f"{self.__repr__()}",
+                out_column=self.out_column if self.out_column is not None else self.__repr__(),
                 change_points_model=self.change_points_model,
                 per_interval_model=self.per_interval_model,
             ),

etna/transforms/math/differencing.py

@@ -207,7 +207,7 @@ def _reconstruct_test(self, df: pd.DataFrame, columns_to_inverse: Set[str]) -> p
         for column in columns_to_inverse:
             to_transform = df.loc[:, pd.IndexSlice[segments, column]].copy()
             init_df = self._test_init_df.copy()  # type: ignore
-            init_df.columns.set_levels([column], level="feature", inplace=True)
+            init_df.columns = init_df.columns.set_levels([column], level="feature")
             init_df = init_df[segments]
             to_transform = pd.concat([init_df, to_transform])