Ciao,
perdonatemi sono nuove e sto ancora imparando.
Ho questo script che mi crea una gui ereditando e riscrivendo una classe da un altro file creato con wxglade.
Questo primoscript.py ad un certo punto deve lanciare un secondoscript.py che devo girare come root in quanto deve partitizionare un disco. Questo secondo script però voglio che possa interagire con la gui creata dal primo script.
Ossia deve inviare delle stringhe a una wx.TextCtrl appunto creata dal primo script.
Il secondo script viene lanciato dal primo mediante una os.system('secondoscript.py').
Si puo' fare questa cosa ?
nel secondo script o inserito del codice tipo:

import primoscript
primoscript.myframe.TextCtrl.AppendText("ciao ciao")

ma ovviamente non funziona
Qualcuno sa qual'è la tecnica da usare esattamente ?





--- Ultima modifica di Lewis in data 2020-07-21 22:28:34 ---

Ciao e buono studio

La problematica che poni non è per niente chiara, e non si presta a risposta ben definita.

In primo luogo la domanda in titolo "come condividere l'istanza di una medesima classe ?" farebbe pensare Tu stia interagendo a livello di soli script python, se fosse così cosa Ti impedirebbe di utilizzare uno script come sub-processo di un contesto funzionale "unico" (in un solo singolo programma, per chiarire).

Una classe "istanziata" (un oggetto, quindi) può tranquillamente essere parametro di una funzione o di inizializzazione di un altra classe.

Quando, poi, il processo di "partizionamento del disco", fosse in realtà una chiamata al sistema operativo su cui agisce la Tua procedura, sarebbe sempre possibile avviarlo, p.e. con subprocess, ma sarebbe MOLTO legato al sistema operativo in uso e, conseguentemente, dovrebbe rispettarne le modalità.

Dovresti contestualizzare più precisamente il contesto, cosa hai fatto e quali difficoltà incontri.

... per altro, scrivi che stai imparando (come d'altronde anche io), forse lo sai già ma guarda che operare con GUI, chiamate di sistema e, magari anche, con programmazione concorrente, non sono esattamente argomenti da primo impatto, richiedono un bel po' di studio delle basi prima di affrontarli.

Si infatti mi sto rimettendo a studiare le classi perché non le ho veramente capite bene.

Comunque provo a rispiegarmi.

Ho uno script python, chiamiamolo primoscrip.py che costruisce una GIU in wxpython. Questa GUI è stata creata con wxglade il quale ha generato zeroscrip.py che è il vero pezzo di codice che costruisce la GUI.


primoscrip.py importa la classe per costruire la gui da zeroscript.py e aggiunge alcuni metodi.

In questa GUI c'è una wx.TextCtrl che viene riempita di log mediante il metodo primoscript.log.

Ad un certo punto primoscript.py lancia secondoscript.py per partizionare un disco usando os.system('sudo secondoscript.py'). Quindi secondoscript.py gira come root. Quindi mentre la gui è aperta parte anche secondoscrip.py. Io voglio che secondoscript.py possa interagire con la GUI creata da primoscrip.py. Per interagire intendo scrivere dentro la wx.TextCtrl creata da primoscript.py.

Quindi io non voglio una nuova instanza della medesima classe, ma voglio accedere all'instanza già instanziata dal secondo script.

Quindi per chiarire il mio problema non centra nulla col partizionamento, con sudo, con subprocess ecc. Il mio problema è poter accedere ad un metodo di una classe già instanziata dal primo script ma da un secondo script.

E' inutile che posto quello che ho provato perché ho provato in centomila modi diversi... e più semplice che qualcuno mi posti un esempio.

La questione gui quindi per chi ha capito centra solo marginalmente.

Il problema è che questa cosa richiede molti strati di conoscenze diverse, uno sopra l'altro, per essere capita e fatta. Non è proprio una cosa tipo ricettina da copincollare e tutto funziona...


In primo luogo, "importare" qualcosa vuol dire semplicemente aggiungere quel nome alla tabella dei nomi locali utilizzabili. Ma il funzionamento di quel "qualcosa" che importi non è automatico. Ora, tu potresti ovviamente importare una classe... ma una classe non è un'istanza della classe... e quindi non puoi chiamare un metodo della classe e aspettarti che funzioni (a meno che non sia un metodo di classe, specificamente inteso per essere usato anche senza un'istanza... ma non è chiaramente questo il caso).


In secondo luogo, tu potresti pensare di importare un'istanza già funzionante, invece di una classe... Cioè, in un modulo crei l'istanza, la metti a disposizione come nome globale del modulo, e poi importi quel nome da un altro modulo. Questo sarebbe veramente orribile da vedere, ma in teoria potresti farlo (non si fanno queste cose, comunque).


Ma il problema qui è che neppure questo servirebbe a qualcosa. Infatti la tua classe è parte di una gui, e tutte le gui non funzionano a quel modo. Una gui, per essere funzionante, una volta istanziate le sue classi deve avviare il mainloop. E il mainloop è un ciclo "while True" senza fine, che blocca tutto il resto. Quindi non è che puoi importare qualcosa "dal di fuori" del mainloop. E se non avvii il mainloop, l'applicazione non parte.


Con le gui, in genere il modo di procedere per fare cose come quella che vuoi fare tu, è all'incontrario. Lo script principale non può che essere quello della gui. Poi, dall'interno della gui (per esempio, in seguito alla pressione di un pulsante) tu fai partire lo script che esegue l'operazione che vuoi fare. Puoi farlo partire come un processo secondario (con subprocess). Non usare os.system... lo so che su innumerevoli siti (specialmente italiani) ci sono ancora esempi da copiare con os.system... ma os.system è deprecato da dieci anni ormai.


Per quanto riguarda i permessi, tieni conto che non puoi far partire un processo privilegiato da un processo non privilegiato (sarebbe escalation di privilegi, cosa ovviamente non possibile). Cioè, se cerchi di farlo windows chiederà la password. Ma allora tanto vale far partire direttamente lo script della gui come un processo privilegiato... però questa è un po' una scelta.

Grazie della mega risposta e nel frattempo mi sono informato anche altrove e oltre a tutto quello che hai detto la cosa non è fattibile anche da un punto di vista del kernel in quanto un processo non puo' accedere alla memoria di un altro processo. Quindi alla fine ho optato per fare girare il tutto come root. Quindi verifico che il processo stia girando come root e in caso contrario apro una MessageBox di errore.

Grazie.

Beh... certo, i processi hanno memorie separate... ma non è questo il problema. Puoi far comunicare i processi tra loro, è una tecnica standard. Infatti è la tecnica che ti ho suggerito io.


Per quanto riguarda l'escalation dei permessi, come ti dicevo: o la gui non ha privilegi, e al momento di far partire il processo privilegiato tenti l'escalation (in windows con runas, in linux con sudo) e allora il sistema operativo chiede la password all'utente. Oppure parti subito con una gui privilegiata, e allora anche il processo figlio sarà privilegiato.