Come evitare di trascinare gli argomenti dalla funzione alla funzione

Quando eseguo il layout del codice, mi piace iniziare con una vista di livello piuttosto elevato e quindi iniziare a delegare il calcolo effettivo alla classe o alle funzioni che hanno un po 'più di dettaglio. Poi in queste classi di funzioni, faccio lo stesso, strato per strato, fino a quando non arrivo al fondo dove devo fare l'azione "reale".

Esempio:

def build_table():
    legs = get_legs()
    plate = get_plate()
    return put_together(legs, plate)

def get_legs():
    legs = []
    for i in [0,1,2,3]:
        legs.append(get_leg_from_warehouse())
    return legs

def get_plate():
    plate = get_plate_from_warehouse()
    return finish_plate(plate)

def put_together(legs, plate):
    table = Table()
    for i in [0,1,2,3]:
       table.mount(legs[i])
    table.mount(plate)
    return table

class Table:
    self.component = []
    def mount(self, item):
        self.component.append(item)

In questo modo, trovo facile pensare al layout e nascondere la complessità. Per lo più ho brevi pezzi di codice che sono facili da capire.

Lo svantaggio di questo è che quando scopro che ho bisogno di un'informazione disponibile in cima allo stack più in basso, passo gli argomenti dalla funzione alla funzione. Nell'esempio sopra, potrei raccogliere "viti" in alto, e poi continuare a passarle in una funzione in cui sono effettivamente forate nel legno. Questo fa sì che non sia così facile modificare il codice, e mi chiedevo cosa avrei potuto fare al riguardo. In questo esempio il codice modificato sarà simile a questo:

def build_table():
    legs = get_legs()
    plate = get_plate()
    screws = get_screws()
    return put_together(legs, plate, screws)

def get_legs():
    legs = []
    for i in [0,1,2,3]:
        legs.append(get_leg_from_warehouse())
    return legs

def get_plate():
    plate = get_plate_from_warehouse()
    return finish_plate(plate)

def get_screws():
    drive_to_hardwarestore()
    screws = buy_screws()
    drive_home()
    return screws

def put_together(legs, plate, screws):
    table = Table()
    for i in [0,1,2,3]:
       table.mount(legs[i], screws)
    table.mount(plate, screws)
    return table

class Table:
    self.component = []
    def mount(self, item, screws):
        self.component.append((item, screws.pop()))

Quindi, oltre ad aggiungere il codice per ottenere le viti, ho dovuto modificare 4 righe. Ciò aumenterebbe linearmente con la quantità di livelli.

Come posso refactoring? D'altra parte, come posso evitare questo in primo luogo? Il mio processo di progettazione è "sbagliato"?