Controllo della versione per il codice che contiene gli esercizi degli studenti

Question

Controllo della versione per il codice che contiene gli esercizi degli studenti

#1 da (7 voti)
#2 da (1 voti)

7

Ho un progetto Python piuttosto consistente che ho sviluppato come sforzo educativo. La versione del codice che deve essere data agli studenti ha esercizi in tutto, sotto forma di codice che ho cancellato e sostituito con un'eccezione. Per essere precisi:

    def mk_eq_term(i):
        # raise ExerciseError("BitBlaster::bitblast_EQ_Core")
        return PL.And(val,PL.Iff(le.bits[i],re.bits[i]))

L'ultima riga è il codice reale; la seconda riga è ciò che deve essere nel codice dato agli studenti, una volta non commentato. Non sono un esperto di controllo della versione (in effetti, al momento, non uso il controllo di revisione), ma la mia lettura sull'argomento indica che questo caso d'uso non è ottimale. Sembra che dovrò mantenere due rami separati e che qualsiasi modifica che apporterò alla versione "produzione" dovrà essere riconciliata con la versione "educativa", anche se non mi aspetto o non intendo apportare modifiche al codice base che modificherà le soluzioni degli esercizi.

Qual è la soluzione migliore per mantenere qualcosa del genere?

version-control python

posta Syzygy 02.01.2015 - 04:54

fonte

2 risposte

Leggi altre domande sui tag version-control python

Come utilizzare gli oggetti mock [C ++] senza passarli come argomenti alle funzioni Riutilizzo del codice in C ++, tramite ereditarietà o composizione multipla? O…?

score 7 · Answer 1

Quando usi git come controllo della versione puoi.

usa il tuo codice completo come trunk.
ramo della versione per studenti.
continua dev su trunk.
unisci il tronco nel ramo.
fai nuovi aggiustamenti per il codice modificato nel ramo studenti.

Tutti i cambiamenti nel ramo studenti continueranno, git prenderà solo nuove modifiche dal tronco e le aggiungerà al ramo, Probabilmente vedrai dei conflitti quando cambi il codice sul bagagliaio che hai modificato anche sul ramo, ma quelli dovrebbero essere facili da risolvere. Nella maggior parte dei casi, se non in tutti, si desidera prendere la versione del trunk, quindi apportare le nuove regolazioni al ramo.

score 1 · Answer 2

Il controllo della versione è davvero lo strumento sbagliato per questo. (Naturalmente, dovresti ancora usare il controllo di versione per il tuo codice!)

Non hai linee di sviluppo separate ma correlate tra loro per il tuo codice. Invece, quello che hai sono due pezzi di codice completamente diversi.

Tuttavia, questi diversi pezzi di codice sono correlati in modo tale che uno può essere (semi) automaticamente derivato dall'altro. Quindi, questo è quello che dovresti fare.

Usa un tipo di linguaggio di manipolazione o di pre-elaborazione o strumenti di manipolazione del testo (sed, awk, il preprocessore C, T4, ...) per generare la versione dello studente dalla versione master.

Questo può essere semplice come usare il preprocessore C qualcosa del genere:

def mk_eq_term(i):
#ifdef STUDENT
    raise ExerciseError("BitBlaster::bitblast_EQ_Core")
#else
    return PL.And(val,PL.Iff(le.bits[i],re.bits[i]))
#endif

Potresti anche usare il modulo ast di Python per manipolare l'Abstract Syntax Tree per il codice e qualcosa di simile a la Meta libreria per riscriverla di nuovo:

Di ', hai scritto la tua funzione nel modo seguente:

def mk_eq_term(i):
    """BitBlaster::bitblast_EQ_Core"""

    return PL.And(val,PL.Iff(le.bits[i],re.bits[i]))

Quindi potresti utilizzare il seguente script per trasformare tutte le funzioni nelle loro versioni per studenti in questo modo:

from ast import *
class RewriteFunctions(NodeTransformer):
    def visit_FunctionDef(self, node):
        exception = get_docstring(node)
        if not exception: return node
        node.body = [Raise(Call(Name('ExerciseError', Load()), [Str(exception)], [], None, None), None, None)]
        return node

tree = parse(code) # assuming code contains the Python code to rewrite
RewriteFunctions().visit(tree)
fix_missing_locations(tree)

A questo punto, hai un AST con tutte le funzioni che hanno docstring modificato in modo che l'unica istruzione nel loro corpo sollevi un'eccezione il cui nome è il contenuto della docstring.

Ovviamente, dovrai ancora eseguire la spunta di AST in Python source, ci sono varie librerie di terze parti per farlo.