[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

src/lightning/pytorch/callbacks/model_checkpoint.py

@@ -350,7 +350,6 @@ def on_exception(self, trainer: "pl.Trainer", pl_module: "pl.LightningModule", e
             self._save_last_checkpoint(trainer, monitor_candidates)
             rank_zero_info(f"An exception was raised saved checkpoint to {filepath}")
 
-
     @override
     def state_dict(self) -> dict[str, Any]:
         return {
@@ -441,10 +440,10 @@ def _should_skip_saving_checkpoint(self, trainer: "pl.Trainer") -> bool:
 
     def _should_save_on_exception(self, trainer: "pl.Trainer") -> bool:
         return (
-                self.save_on_exception
-                and not bool(trainer.fast_dev_run)  # disable checkpointing with fast_dev_run
-                and not trainer.sanity_checking  # don't save anything during sanity check
-                and not self._last_global_step_saved == trainer.global_step  # already saved at the last step
+            self.save_on_exception
+            and not bool(trainer.fast_dev_run)  # disable checkpointing with fast_dev_run
+            and not trainer.sanity_checking  # don't save anything during sanity check
+            and self._last_global_step_saved != trainer.global_step  # already saved at the last step
         )
 
     def _should_save_on_train_epoch_end(self, trainer: "pl.Trainer") -> bool:

tests/tests_pytorch/checkpointing/test_model_checkpoint.py

@@ -766,22 +766,30 @@ def test_ckpt_every_n_train_steps(tmp_path):
 
 def test_model_checkpoint_save_on_exception_in_training_step(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in training_step."""
+
     class TroubledModel(BoringModel):
         def training_step(self, batch, batch_idx):
             if batch_idx == 1:
                 raise RuntimeError("Trouble!")
 
     model = TroubledModel()
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     print(os.listdir(tmp_path))
     assert os.path.isfile(tmp_path / "step=1.ckpt")
 
+
 def test_model_checkpoint_save_on_exception_in_validation_step(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in validation_step."""
+
     class TroubledModel(BoringModel):
         def validation_step(self, batch, batch_idx):
             if not trainer.sanity_checking and batch_idx == 0:
@@ -790,40 +798,57 @@ def validation_step(self, batch, batch_idx):
     model = TroubledModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / f"step={epoch_length}.ckpt")
 
 
 def test_model_checkpoint_save_on_exception_in_train_callback_on_train_batch_start(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on train_batch_start."""
+
     class TroublemakerOnTrainBatchStart(Callback):
         def on_train_batch_start(self, trainer, pl_module, batch, batch_idx):
             if batch_idx == 1:
                 raise RuntimeError("Trouble!")
 
     model = BoringModel()
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnTrainBatchStart()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnTrainBatchStart()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / "step=1.ckpt")
 
 
 def test_model_checkpoint_save_on_exception_in_train_callback_on_train_batch_end(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on train_batch_end."""
+
     class TroublemakerOnTrainBatchEnd(Callback):
         def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx):
             if batch_idx == 1:
                 raise RuntimeError("Trouble!")
 
     model = BoringModel()
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnTrainBatchEnd()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnTrainBatchEnd()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
 
@@ -832,6 +857,7 @@ def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx):
 
 def test_model_checkpoint_save_on_exception_in_train_callback_on_train_epoch_start(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on train_epoch_start."""
+
     class TroublemakerOnTrainEpochStart(Callback):
         def on_train_epoch_start(self, trainer, pl_module):
             if trainer.current_epoch == 1:
@@ -840,15 +866,21 @@ def on_train_epoch_start(self, trainer, pl_module):
     model = BoringModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnTrainEpochStart()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnTrainEpochStart()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / f"step={epoch_length}.ckpt")
 
 
 def test_model_checkpoint_save_on_exception_in_train_callback_on_train_epoch_end(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on train_epoch_end."""
+
     class TroublemakerOnTrainEpochEnd(Callback):
         def on_train_epoch_end(self, trainer, pl_module):
             if trainer.current_epoch == 1:
@@ -857,49 +889,67 @@ def on_train_epoch_end(self, trainer, pl_module):
     model = BoringModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnTrainEpochEnd()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnTrainEpochEnd()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
-    assert os.path.isfile(tmp_path / f"step={2*epoch_length}.ckpt")
+    assert os.path.isfile(tmp_path / f"step={2 * epoch_length}.ckpt")
 
 
 def test_model_checkpoint_save_on_exception_in_val_callback(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on validation_batch_start."""
+
     class TroublemakerOnValidationBatchStart(Callback):
         def on_validation_batch_start(self, trainer, pl_module, batch, batch_idx):
-                if not trainer.sanity_checking and batch_idx == 1:
-                    raise RuntimeError("Trouble!")
+            if not trainer.sanity_checking and batch_idx == 1:
+                raise RuntimeError("Trouble!")
 
     model = BoringModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnValidationBatchStart()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnValidationBatchStart()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / f"step={epoch_length}.ckpt")
 
 
 def test_model_checkpoint_save_on_exception_in_val_callback_on_validation_batch_end(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on validation_batch_end."""
+
     class TroublemakerOnValidationBatchEnd(Callback):
         def on_validation_batch_end(self, trainer, pl_module, outputs, batch, batch_idx):
-                if not trainer.sanity_checking and batch_idx == 1:
-                    raise RuntimeError("Trouble!")
+            if not trainer.sanity_checking and batch_idx == 1:
+                raise RuntimeError("Trouble!")
 
     model = BoringModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnValidationBatchEnd()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnValidationBatchEnd()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / f"step={epoch_length}.ckpt")
 
 
 def test_model_checkpoint_save_on_exception_in_val_callback_on_validation_epoch_start(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on validation_epoch_start."""
+
     class TroublemakerOnValidationEpochStart(Callback):
         def on_validation_epoch_start(self, trainer, pl_module):
             if not trainer.sanity_checking and trainer.current_epoch == 0:
@@ -908,15 +958,21 @@ def on_validation_epoch_start(self, trainer, pl_module):
     model = BoringModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnValidationEpochStart()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnValidationEpochStart()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / f"step={epoch_length}.ckpt")
 
 
 def test_model_checkpoint_save_on_exception_in_val_callback_on_validation_epoch_end(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on validation_epoch_end."""
+
     class TroublemakerOnValidationEpochEnd(Callback):
         def on_validation_epoch_end(self, trainer, pl_module):
             if not trainer.sanity_checking and trainer.current_epoch == 0:
@@ -925,14 +981,21 @@ def on_validation_epoch_end(self, trainer, pl_module):
     model = BoringModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnValidationEpochEnd()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnValidationEpochEnd()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / f"step={epoch_length}.ckpt")
 
+
 def test_model_checkpoint_save_on_exception_in_val_callback_on_validation_start(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on validation_start."""
+
     class TroublemakerOnValidationStart(Callback):
         def on_validation_start(self, trainer, pl_module):
             if not trainer.sanity_checking:
@@ -941,14 +1004,21 @@ def on_validation_start(self, trainer, pl_module):
     model = BoringModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnValidationStart()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnValidationStart()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / f"step={epoch_length}.ckpt")
 
+
 def test_model_checkpoint_save_on_exception_in_val_callback_on_validation_end(tmp_path):
     """Test that the checkpoint is saved when an exception is raised in a callback on validation_end."""
+
     class TroublemakerOnValidationEnd(Callback):
         def on_validation_end(self, trainer, pl_module):
             if not trainer.sanity_checking:
@@ -957,8 +1027,13 @@ def on_validation_end(self, trainer, pl_module):
     model = BoringModel()
     epoch_length = 64
     checkpoint_callback = ModelCheckpoint(dirpath=tmp_path, filename="{step}", save_on_exception=True, every_n_epochs=4)
-    trainer = Trainer(default_root_dir=tmp_path, callbacks=[checkpoint_callback, TroublemakerOnValidationEnd()],
-                      max_epochs=5, logger=False, enable_progress_bar=False)
+    trainer = Trainer(
+        default_root_dir=tmp_path,
+        callbacks=[checkpoint_callback, TroublemakerOnValidationEnd()],
+        max_epochs=5,
+        logger=False,
+        enable_progress_bar=False,
+    )
     with pytest.raises(RuntimeError, match="Trouble!"):
         trainer.fit(model)
     assert os.path.isfile(tmp_path / f"step={epoch_length}.ckpt")