Using contextlib.suppress in place of nested try/else with return statement inside function

Question

I am attempting to abide by flake8 guidelines by using contextlib.suppress in place of a nested try/else within a function that returns a variable. Below is my original function:

def _get_early_stopping_rounds(model, **kwargs) -> int:
    """Returns the number of early stopping rounds."""
    try:
        n_rounds = kwargs["early_stopping_rounds"]
    except Exception:
        try:
            n_rounds = model.get_params()["early_stopping_rounds"]
        except Exception:
            try:
                n_rounds = None
            except Exception:
                pass

    return n_rounds

Example usage:

from xgboost import XGBClassifier

# Define xgb model object
>>> xgb = XGBClassifier(early_stopping_rounds=20)
>>> _get_early_stopping_rounds(xgb)
20

Replacing nested try/else with contextlib.suppress:

from contextlib import suppress

def _get_early_stopping_rounds(model, **kwargs) -> int:
    """Returns the number of early stopping rounds."""
    with suppress(Exception):
        n_rounds = kwargs["early_stopping_rounds"]
        with suppress(Exception):
            n_rounds = model.get_params()["early_stopping_rounds"]
            with suppress(Exception):
                n_rounds = None
    return n_rounds

Example usage:

>>> _get_early_stopping_rounds(xgb)
UnboundLocalError: local variable 'n_rounds' referenced before assignment

I'm not sure that I understand the UnboundLocalError I am receiving. What is the proper approach for using contextlib.suppress inside of a function that returns a variable?

Answer 1

Old question, but I think it's worth answering.

You're receiving an UnboundLocalError because you are trying to use n_rounds when it was never defined. It was never defined because the line where it was defined caused an exception. The exception was suppressed, but the line that caused it wasn't executed (because it couldn't: it ran into an exception), so the variable that was assigned there was not assigned in the end.

There are two possible solutions:

Either don't use suppress():

You can simply use a normal try/except and define what should happen if an exception occurred:

try:
  my_assignment = something["some_key"]
except KeyError:
  my_assignment = "some fallback value"

Then my_assignment will always be defined.

Or assign a value ahead of time

my_assignment = None

with contextlib.suppress(KeyError):
  my_assignment = something["some_key"]

Then my_assignment will always exist at least with a value of None, even if the assignment to something["some_key"] fails.

This option might make type checkers and linters unhappy because they'll see a variable being assigned to twice without being used in the middle. I think that's their issue, since they don't consider the case that the line may be skipped, causing the variable to never be assigned.