Struttura della directory e Doctest ... oppure pyunit?

Salve
(premettendo che sono alle prime armi con python o quasi)

vorrei realizzare un simulatore per i microcontrollori pic in python,
sulla scia di gpsim, per imparare
appunto a gestire con python progetti più grandi del semplice script
di shell e imparare
ad impostare un progetto  vero e proprio.

Mi piacerebbe usare doctest perchè l'ho usato in passato e scrivere i
test e la documentazione
prima di scrivere ogni file mi aiuta moltissimo a chiarirmi
ulteriormente le idee su quello che il file in questione deve fare e
su quli saranno i problemi. inoltre mi ritrovo con il codice
documentato prima ancora che il codice sia scritto!!!

Tuttavia inserire il test all'interno della docstring della classe/
funzione che sto scrivendo
è brutto (nel senso che tipicamente il testing+ documentazione è molto
lungo) e mi piacerebbe
poter inserire il testing in un file a parte.
1) però a questo punto il mio modulo rimane senza documentazione!!!
oppure devo ripetere
quello che ho già scritto nel  test anche nella funzione!! e se
devo cambiare qualcosa? devo
modificare 2 file!!!
2) dove metto i file di test? ho pensato a una struttura delle
directory così:

mioprogetto/
-- runtest.py
-- mioprogetto.py
-- test/
---- mioprogetto.test
-- modulo1/
---- __init__.py
---- main.py
---- test/
------ main.test
-- modulo2/
---- __init__.py
---- main.py
----submodulo1/
------ __init__.py
------ main.py
------ test/
--------main.test
----test/
------main.test

così in runtest in pratica gli faccio esplorare tutte le
sottodirectory e
creare suite per unittest con doctest.DocFileSuite
http://docs.python.org/lib/doctest-unittest-api.html

la cosa bella è che se mi servisse il modulo2 in un altro progetto
potrei semplicemente copiare la cartella modulo2 e
mi porterei dietro tuti i test (e la documentazione)
il problema è con gli import, nel senso che non ho capito bene da che
posizione vengono
eseguite le istruzioni contenute nei file *.test, cioè se do un
import main
quale main.py mi carica?

per progetti nidificati è meglio usare pyunit?
però perderei al documentazione.

ho letto qui che altri hanno una struttura delle directory così:

mioprogetto/
-- runtest.py
-- mioprogetto.py
-- modulo1/
---- __init__.py
---- main.py
-- modulo2/
---- __init__.py
---- main.py
----submodulo1/
------ __init__.py
------ main.py
-- test/
----__init__.py
---- mioprogetto.py
---- mioprogetto_modulo1_main.py
---- mioprogetto_modulo2_main.py
---- mioprogetto_modulo2_submodulo1_main.py

è comoda per quanto riguarda il problema degli import penso
e anche per essere esclusa dall'installazione ma
non tiene separato il codice di test dei singoli moduli!
inoltre se il progetto cresce cresce anche il numero di files in
questa directory...

3) poichè la parte di simulazione deve essere "veloce" la mia idea era
di svilupparla
prima in python e poi sostituire mano a mano i moduli più usati dal
codice in moduli C/C++
se io uso la struttura di prima con i vari sottomoduli funziona anche
se le varie sottocartelle
contengono file c?
mi spiego meglio: magari ho realizaato il programma sopra e poi mi
sono reso conto
che devo scrivere modulo1 in c (o c++). per questioni di performance.
ho visto che esiste un progetto chiamato swig che fa questo.
io posso semplicemente scrivere il mio file mail.c, compilarlo con
swig e mettere il file compilato nella
cartella modulo1 e il resto del programma, e i test funzionano come
prima?
conviene separare la parte C del programma da quella python?
oppure è possibile passare da python a un linguaggio compilato in
maniera trasparente?

4) doctest è compatibile con docutils? c'è un modo per raccogliere
tutti i miei file di test e
generare una documentazione (html, pdf)?

Grazie per la pazienza nel leggere il mio lungo messaggio

se avete esempi di progetti con sottomoduli che utilizzano pyunit/
doctest e parti in c inviate pure!!
[ Auf dieses Posting antworten ]