L'aumento di un'eccezione non correlata per convenienza è accettabile? [duplicare]

Diciamo che ho una funzione che restituisce un set di dati. Prima tenta di leggerlo e se fallisce viene richiesto da un'API e poi scritto:

def get_dataset():
    try:
        df = pd.read_csv('dataset.csv')
    except FileNotFoundError:
        df = pd.DataFrame(api.get_dataset())
        df.to_csv('dataset.csv')
    return df

Ora potremmo voler forzare la richiesta e aggiornare il file CSV, quindi passiamo un flag. Per essere più concisi con il codice, possiamo usare un trucco economico per forzare l'esecuzione del blocco tranne:

def get_dataset(force_udpate=False):
    try:
        if force_update:
            raise FileNotFoundError
        df = pd.read_csv('dataset.csv')
    except FileNotFoundError:
        df = pd.DataFrame(api.get_dataset())
        df.to_csv('dataset.csv')
    return df

Ovviamente questo sembra male, perché un FileNotFoundError non è realmente applicabile. Ma se non lo facessimo, dovremmo rompere il principio di DRY:

def get_dataset(force_update=False):
    if force_update:
        df = pd.DataFrame(api.get_dataset())
        df.to_csv('dataset.csv')
        return df
    try:
        df = pd.read_csv('dataset.csv')
    except FileNotFoundError:
        df = pd.DataFrame(api.get_dataset())
        df.to_csv('dataset.csv')
    return df

O introdurre una funzione locale, sporcando un po 'l'intera funzione:

def get_dataset(force_update=False):
    def request_and_write():
        d = pd.DataFrame(api.get_dataset())
        d.to_csv('dataset.csv')
        return d

    if force_udpate:
        return request_and_write()
    try:
        df = pd.read_csv('dataset.csv')
    except FileNotFoundError:
        df = request_and_write()
    return df

Questa pratica discutibile è accettabile per motivi di semplicità e chiarezza del codice?