Why was this line removed? it seems like useful information to keep.

Suggest to call _set_parameters_impl, (typically used when the internal implementation needs to be separate).

Should be dict or sequence ?

This exception seems like something we should avoid, as-is, it seems fairly harmless.
OTOH, if more similar cases are added here it could easily become a mess.

Suggest to be more specific in this case, this could check the modifier type too for example.

It's not obvious which attribute is expected to fail (although I'd assume setattr(modifier, setting, modifier_parameters)).

Is there any reason the try/except can't be replaced with a call to hasattr?

This is normally preferable as try/except that contain more than a short snippet of code can hide mistakes/errors.

Can be written as: if nested_settings_path:

This isn't a copy and it seems the newly defined variable doesn't serve any purpose, should it be removed.

This can be a tuple (preferred if it's not modified).

Any reason to set the frame to zero instead of 1? (as was done previously).

Suggest to use 1 since it's more common, or add a comment why zero is important.

This exceptions could hide useful information, suggest including the exception when re-raising. eg:

except TypeError as ex:
    raise TypeError(
        "Incorrect operator parameters {!r}, "
        "raised exception {!r}".format(operator.operator_parameters, ex))

Same for _apply_operator_object_mode.

Was this left in on purpose?

Was this left in on purpose?

The check could be inverted, using an early return instead, seeing as the result is to skip all comparison code.

Name is misleading, this raises an exception when not unique.

Could be called: _ensure_unique_test_name_or_raise_error

Enumerate here seems redundant, looping on the value would make more sense.

This block of code reads strangely.

• initializing case to the first test doesn't seem necessary, instead it could be initialized to None, then if count == len_test can be replated with a check for case is None
• count variable isn't needed, index can be used instead.
• enumerate could use a value instead of _ as the value is accessed multiple times.

str() is redundant here.