Quale eccezione dovrei sollevare su combinazioni di argomenti errati / illegali in Python?

Mi chiedevo quali fossero le migliori pratiche per indicare combinazioni di argomenti non valide in Python. Mi sono imbattuto in alcune situazioni in cui hai una funzione del genere:

def import_to_orm(name, save=False, recurse=False):
    """
    :param name: Name of some external entity to import.
    :param save: Save the ORM object before returning.
    :param recurse: Attempt to import associated objects as well. Because you
        need the original object to have a key to relate to, save must be
        `True` for recurse to be `True`.
    :raise BadValueError: If `recurse and not save`.
    :return: The ORM object.
    """
    pass

L'unico fastidio è che ogni pacchetto ha il suo, di solito leggermente diverso BadValueError. So che in Java esiste java.lang.IllegalArgumentException- è chiaro che tutti creeranno i propri BadValueErrorin Python o esiste un altro metodo preferito?

Vorrei solo aumentare ValueError , a meno che tu non abbia bisogno di un'eccezione più specifica ..

def import_to_orm(name, save=False, recurse=False):
    if recurse and not save:
        raise ValueError("save must be True if recurse is True")

Non ha davvero senso farlo class BadValueError(ValueError):pass: la tua classe personalizzata è identica in uso a ValueError , quindi perché non usarla?

Vorrei ereditare da ValueError

class IllegalArgumentError(ValueError):
    pass

A volte è meglio creare le tue eccezioni, ma ereditarne una incorporata, che è il più vicino possibile a ciò che desideri.

Se devi rilevare questo errore specifico, è utile avere un nome.

Penso che il modo migliore per gestirlo sia il modo in cui lo stesso Python lo gestisce. Python genera un TypeError. Per esempio:

$ python -c 'print(sum())'
Traceback (most recent call last):
File "<string>", line 1, in <module>
TypeError: sum expected at least 1 arguments, got 0

Il nostro sviluppatore junior ha appena trovato questa pagina in una ricerca su Google per "argomenti sbagliati sull'eccezione di Python" e sono sorpreso che la risposta ovvia (per me) non sia mai stata suggerita nel decennio da quando è stata posta questa domanda.

Ho visto principalmente il builtin ValueErrorusato in questa situazione.

Dipende da quale sia il problema con gli argomenti.

Se l'argomento ha il tipo sbagliato, sollevare un TypeError. Ad esempio, quando ottieni una stringa anziché uno di quei booleani.

if not isinstance(save, bool):
    raise TypeError(f"Argument save must be of type bool, not {type(save)}")

Si noti, tuttavia, che in Python raramente effettuiamo controlli come questo. Se l'argomento non è valido, una funzione più approfondita probabilmente ci farà lamentare. E se controlliamo solo il valore booleano, forse un utente del codice in seguito lo inserirà semplicemente in una stringa sapendo che le stringhe non vuote sono sempre True. Potrebbe salvargli un cast.

Se gli argomenti hanno valori non validi, aumentare ValueError. Questo sembra più appropriato nel tuo caso:

if recurse and not save:
    raise ValueError("If recurse is True, save should be True too")

O in questo caso specifico, avere un valore True di recurse implica un valore True di save. Dal momento che considererei questo un recupero da un errore, potresti anche lamentarti nel registro.

if recurse and not save:
    logging.warning("Bad arguments in import_to_orm() - if recurse is True, so should save be")
    save = True

Non sono sicuro che sono d'accordo con l'eredità dal ValueError- la mia interpretazione della documentazione è che ValueErrorè solo suppone che sia sollevata dal builtins ... ereditando da esso o sollevare da soli sembra errato.

Generato quando un'operazione o una funzione incorporata riceve un argomento che ha il tipo giusto ma un valore inappropriato e la situazione non è descritta da un'eccezione più precisa come IndexError.

- Documentazione ValueError

Concordo con il suggerimento di Markus di presentare la propria eccezione, ma il testo dell'eccezione dovrebbe chiarire che il problema si trova nell'elenco degli argomenti, non i singoli valori dell'argomento. Proporrei:

class BadCallError(ValueError):
    pass

Utilizzato quando mancano gli argomenti delle parole chiave richiesti per la chiamata specifica o i valori degli argomenti sono individualmente validi ma incoerenti tra loro. ValueErrorsarebbe comunque giusto quando un argomento specifico è giusto, ma fuori range.

Non dovrebbe essere un'eccezione standard in Python?

In generale, vorrei che lo stile Python fosse un po 'più nitido nel distinguere input errati in una funzione (errore del chiamante) da risultati negativi all'interno della funzione (errore mio). Quindi potrebbe esserci anche un BadArgumentError per distinguere gli errori di valore negli argomenti dagli errori di valore nei locali.