Newsgroup: it.comp.os.linux.sys
Titolo: Chi di voi e' bravo con Python?

Allora, ho installato questo:
http://0pointer.de/lennart/projects/ivam2/
E' un bel programmino che trasforma un pc con una scheda isdn in una 
segreteria telefonica.
Funziona ma ha un piccolo problemino:
Normalmente dovrebbe partire la voce di benvenuto poi il beep e poi dovrebbe 
partire il recording del messaggio, invece qui succede che il recording 
parte "contemporaneamente" al messaggio di benvenuto, quindi quando mi 
arriva l'email con il file mp3 contenete il messaggio vocale, io sento anche 
quello che viene detto nei primi 10 secondi, mentre il messaggio di 
benvenuto dava spiegazioni su come lasciare il messaggio.
Ora, il programma e' scritto in Python e mi piacerebbe fare un po' di debug 
per capire cos'e' che non funziona, purtroppo il Python non lo conosco per 
niente.
Per esempio, mi sapreste dire come faccio ad eseguire comandi di shell da 
dentro il prog python? L'equivalente di system(...) del C insomma, cosi' 
almeno mi creo dei files dove butto dentro qualcosa che mi tracci il flusso 
del programma!
Grazie 1000.

 debug
Credo che questo sia il punto cruciale del problema:
            currentState = STATE_INVALID
            c.playClip(self.getClip(self.welcomeMessage))
            self.currentState = self.STATE_WELCOME
        if self.currentState == self.STATE_WELCOME:
            c.playClip(self.getClip("beep"))
            self.currentState = self.STATE_WELCOME_BEEP
        elif self.currentState == self.STATE_WELCOME_BEEP:
            self.currentState = self.STATE_RECORD
            c.recordClip(self.nextMessageName(), True)
            c.setTimeout(self.recordTime)
In questo spezzone di codice entro con STATE_INVALID, quindi lui esegue 
c.playClip(self.getClip(self.welcomeMessage)) che da il messaggio di 
benvenuto, poi, imposta currentstate a STATE_WELCOME, passa il secondo if ed 
esegue c.playClip(self.getClip("beep")) che da il beep, in fine, imposta 
currentState a STATE_WELCOME_BEEP in modo da far passare l'ultimo if e far 
partire il recording con c.recordClip(self.nextMessageName(), True).
Il problema praticamente e' che (secondo me) self.currentState = 
self.STATE_WELCOME dovrebbe essere eseguito quando finisce 
c.playClip(self.getClip(self.welcomeMessage)) e invece non e' cosi', 
praticamente tutto il blocco di codice che vedete, viene passato tutto in un 
sol boccone, quindi di fatto mentre 
c.playClip(self.getClip(self.welcomeMessage)) sta ancora dettando il 
messaggio di benvenuto.... il programma nel frattempo si e' gia' portato 
all'istruzione c.recordClip(self.nextMessageName(), True), senza aspettare.
Mi chiedevo, come posso fare secondo voi, ad inserire una istruzione che 
costringa il flusso del programma a fermarsi fino a che l'istruzione 
precedente non termina con successo?

 del programma!
f=open('DDD','w')
f.write("Ciao mondo")
f.close()
oppure
from os import system
system(r'''/bin/ls -l >> ./PPP''')
ciao ...
-- 
#include <stdio.h>
int main(void){char c[]={10,65,110,116,111,110,105,111,32,98,97,114,98,111,110,
101,32,60,104,105,110,100,101,109,105,116,64,116,105,115,99,97,108,105,110,101,
116,46,105,116,62,10,10,0};printf("%s",c);return 0;}

 l'istruzione precedente non termina con successo?
Non sono un esperto di programmazione, ho solo giocato un pochino con
python. Una possibilità è vedere come è fatto c.playClip e getClip e
inserire un qualcosa che mi segnali quando è finito il pezzo (prima
ipotesi). Seconda ipotesi che sarebbe più elegante - ma non so se può
funzionare - una cosa del tipo:
 
        while c.playClip(self.getClip("beep")):
            self.currentState = self.STATE_WELCOME_BEEP
        self.currentState = self.STATE_RECORD  
Questa è una specie di 'proof of concept' della seconda ipotesi:
        import time
 
        def riproducimessaggio(qualcosa):
            print 'bar'
            time.sleep(5)
            print qualcosa
        def prova(foo):
            stato = 0
            print stato
            while riproducimessaggio(foo):
                pass
            stato = 2
            print stato
Ora prova a eseguire:
        prova('Ecco !')
vedrai che finchè riproducimessaggio non è trascorso, non viene stampato lo
stato = 2
Ma se posti su it.comp.lang.python sicuramente ti sanno aiutare di più.
-- 
Taekyon

             c.playClip(self.getClip("beep"))  
Nicola
-- 
chi va pian va san e va lontan

 Ma se posti su it.comp.lang.python sicuramente ti sanno aiutare di piů.
Si sto provando anche li.... :-p
Intanto credo di aver capito il problema....
Credo che il programma funzioni correttamente, solo che il "tempo" con cui 
il buffer viene svuotato non corrisponde con il tempo reale con il quale il 
messaggio di benvenuto viene "dettato" al telefono
Praticamente ho messo un po' di print nel programma, e ho verificato che il 
"flusso" e' corretto.
Solo che il programma ci mette mezzo secondo per svuotare il buffer con il 
messaggio di benvenuto, e poi passa avanti, io pero' al telefono ci metto 
8-9 secondi ad ascoltare tutto il messaggio. Praticamente e' come se il 
messaggio venisse sparato in uno "spooler" e popi lo spooler detta il 
messaggio al telefono, solo che il programma ci mette un attimo a sparere il 
messaggio nello spooler, ma al telefono ci vuole un certo tempo per 
ascoltare il messaggio dallo spooler (ovviamente).Tutto qui.
Avrei bisogno quindi di mettere uno sleep, credo, ho provato a farlo ma nei 
log ottengo:
[ttyI0] Child too slow, output buffer overflow, flushing
Perche' secondo voi?
Altrimenti? Altri suggerimenti? 

 debug
Per chiunque sia interessato... ho risolto il problema!
BUFSIZE=128
self.playBuffer = self.playFile.read(self.BUFSIZE)
Questo viene eseguito fino a che playBuffer non si svuota trovando sulla sua 
strada, nel while, questo:
if len(self.playBuffer) == 0:
    self.stopPlayback2()
    return
Ora, playFile e' il modulo che "legge" il messaggio di benvenuto e lo fa 
sentire a chi telefona
Viene istanziato cosi': self.playFile = ivamUtil.magicFile(fname, "rb")
E questo e' ivamUtil con il relativo magicFile
import gzip
def getContents(fn):
    f = file(fn, "r")
    r = f.readline().strip(" \t\r\n")
    f.close()
    return r
def setContents(fn, s):
    f = file(fn, "w")
    f.write("%s\n" % s)
    f.close()
def magicFile(fn, mode):
    f = None
    try:
        f = gzip.open(fn, mode)
        f.read(1)
        f.seek(0)
        return f
    except IOError:
        if not f is None:
            f.close()
    return open(fn, mode)
Succede che con BUFSIZE=128 la routine "legge" il messaggio di benvenuto 
troppo velocemente, quindi il flusso del programma va avanti molto prima che 
io al telefono finisco di sentire 7-8 secondi di messaggio.
Mi e' bastato impostare a "1" il BUFSIZE per fare in modo che la velocita' 
con la quale la macchina legge il file e' vicina a quella "fisica" della 
propagazione del suono :-)
Ora mi chiedo solo.... perche' questo problema si verifica solo a me? Questo 
e' un bel mistero.
Ciao e grazie