Non utilizzo turtle ma la Tua domanda mi ha intrigato, partendo dal presupposto che turtle si basa su tkinter, utilizzando la funzione "getcanvas()" di turtle si può estrarre ed utilizzare il canvas in maniera ordinaria.

Neanche "salvare" i contenuti di un canvas è cosa che ordinariamente faccio, però i canvas possono salvare il loro contenuto in formato postscript.

Utilizzando la classe Image di pillow, tali dati possono essere caricati e salvati in uno dei formati supportati da pillow, ti faccio un esempio:

import turtle
from PIL import Image
from io import BytesIO

# DISEGNA
tart = turtle.Turtle()

tart.color('red')
for j in range(180):
    for i in range(4):
        tart.forward(50+j)
        tart.left(90)
    tart.left(4)


wdg = turtle.getcanvas()  # recupera lo scrolled_canvas

# SALVA
ps_data = wdg.postscript(colormode='color')  # memorizza il contenuto come fosse
                                             # un file postscript
im = Image.open(BytesIO(bytes(ps_data, 'ascii')))  # crea una immagine dai dati
im.save('test_02.png')                             #la salva

lo script utilizza turtle per disegnare 180 quadrati in rosso, che nel loro insieme danno una doppia spirale piuttosto carina, poi vengono applicati i concetti sopra detti per creare una immagine png nella cartella di lancio.




Per utilizzare lo script si deve avere pillow installato, magari in un venv, sotto linux funziona tranquillamente, non saprei dire in ambiente windows (non lo uso)




Spero Ti sia utile

Ciao @Trescon ... finalmente un post che non sia di spammer o bot ...




Il Tuo problema deriva certamente da come implementi ed utilizzi le Tue classi, impossibile dare risposte utili dato che non hai fornito praticamente nulla di valido in merito alle Tue implementazioni.

Comunque, penso che il capitolo 9 del manuale Ti possa essere utile, approfondisci particolarmente i capitoli 9.2 e 9.3.1-9.3.5 e fai prove sino ad assimilare la materia.




Il traceback che hai postato indica chiaramente che hai cercato di utilizzare proprietà di oggetti di classe "Conversione_date" come se tali proprietà facessero parte di widget tkinter ... le cose non funzionano così, a meno Tu non abbia creato dei sub-classamenti con classi-madre multiple, tra cui "Conversione_date", cosa che non credo.

Le proprietà di un oggetto istanziato restano di proprietà dell'oggetto stesso, non di quello che lo istanzia, anche se l'oggetto è definito quale variabile di istanza del chiamente ... provo a farTi un esempio ridefinendo lo stralcio di classe da Te postato in modo che scinda una lista di stringhe sulla base del "promo" iniziale

Python 3.12.3 (main, Feb  4 2025, 14:48:35) [GCC 13.3.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
class Conversione_date:
    def __init__(self):
    
        self.file_modificati = []
        self.file_modificati_giornalieri = []
        
    def converti_data_promo(self, data):
        # qui ci sono scariate riche di codice che non utilizzano
        # le variabili "inquisite"
        for d in data:
            if d.startswith("promo"):
                self.file_modificati_giornalieri.append(d)
            else:
                self.file_modificati.append(d)

                
values = ['Televisore', 'lavatrice', 'promo lavatrice', 'cellulare',
          'promo cellulare', 'lavastoviglie', 'piano corruta']
class A:
    def __init__(self):
        self.cvd = Conversione_date()
        self.cvd.converti_data_promo(values)

Istanziando un oggetto di classe "A" noi non potremo riferire direttamente alle liste contenute dalle istanze a Conversione_date

gest = A()
gest.file_modificati_giornalieri
Traceback (most recent call last):
  File "/usr/lib/python3.12/idlelib/run.py", line 580, in runcode
    exec(code, self.locals)
  File "<pyshell#15>", line 1, in <module>
AttributeError: 'A' object has no attribute 'file_modificati_giornalieri'

ma dovremo riferire alla istanza a Conversione_date memorizzata (self.cvd)

gest.cvd.file_modificati_giornalieri
['promo lavatrice', 'promo cellulare']
gest.cvd.file_modificati
['Televisore', 'lavatrice', 'cellulare', 'lavastoviglie', 'piano corruta']

Lo stralcio di traceback da Te proposto indica che sei ricaduto in questo tipo di problema.




Spero Ti sia utile, ciao

Aggiornamento:




A giudicare da quanto letto, partendo da questa pagina, mi son convinto che "adb" esegua un comando alla volta e poi ritorni immediatamente, no vi dovrebbe essere una shell disponibile, quindi la modalità "interattiva" richiesta dallo OP non vale la pena di essere perseguita (ci risparmiamo un po' di thread per lettura/scrittura e relativa queue).

Il mio dispositivo di test dispone di Android 5.0, quindi va a farsi benedire l'accesso in rete riportato nel link, può essere utilizzato solo su usb, approfittando del fatto che deve essere l'unico dispositivo connesso con tale modalità (adb darebbe errore altrimenti), ho verificato che è possibile tranquillamente navigare il file-system del cellulare e copiarsi dei files li depositati, vedere sessione sotto (ridotta per quanto possibile)

Python 3.12.3 (main, Nov  6 2024, 18:32:19) [GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
import subprocess as sp
result = sp.check_output(['adb', 'devices', '-l'])
result
b'List of devices attached\n0123456789ABCDEF       device usb:3-8 product:V10_open_eu model:LG X150 device:v10 transport_id:1\n\n'
result = sp.check_output(['adb', 'shell', 'ls', '-l', '/'])
text = result.decode()
data = text.split('\r\n')
for r in data:
    print(r)

    
drwxr-xr-x root     root              2010-01-01 01:47 acct
drwxrwx--- system   cache             2010-01-01 01:07 cache
lrwxrwxrwx root     root              1970-01-01 01:00 charger -> /sbin/healthd
dr-x------ root     root              2010-01-01 01:47 config
...
-rw-r--r-- root     root        30298 1970-01-01 01:00 file_contexts
lstat '//flex' failed: Permission denied
-rw-r----- root     root         1712 1970-01-01 01:00 fstab.mt6582
...
-rw-r--r-- root     root        11264 1970-01-01 01:00 service_contexts
drwxr-x--x root     sdcard_r          2010-01-01 01:47 storage
dr-xr-xr-x root     root              2010-01-01 01:47 sys
drwxr-xr-x root     root              1970-01-01 01:00 system
...
result = sp.check_output(['adb', 'shell', 'ls', '-l', '/storage'])
text = result.decode()
data = text.split('\r\n')
for r in data:
    print(r)

    
drwxr-xr-x media_rw media_rw          2010-01-01 01:47 emulated
lrwxrwxrwx root     root              2010-01-01 01:47 sdcard0 -> /storage/emulated/legacy
drwxrwx--x root     sdcard_r          1970-01-01 01:00 sdcard1
drwx------ root     root              2010-01-01 01:47 usbotg

result = sp.check_output(['adb', 'shell', 'ls', '-l', '/storage/sdcard1'])
text = result.decode()
data = text.split('\r\n')
for r in data:
    print(r)

    
drwxrwx--x root     sdcard_r          2014-02-03 08:40 Android
drwxrwx--- root     sdcard_r          2014-02-03 08:38 DCIM
drwxrwx--- root     sdcard_r          2014-02-03 08:32 LOST.DIR
drwxrwx--- root     sdcard_r          2016-06-25 12:03 Recording
drwxrwx--- root     sdcard_r          2015-10-25 15:05 bluetooth
drwxrwx--- root     sdcard_r          2020-10-06 17:54 documents
drwxrwx--- root     sdcard_r          2021-05-30 06:32 download
drwxrwx--- root     sdcard_r          2014-02-03 08:32 foursquare
drwxrwx--- root     sdcard_r          2014-06-03 07:49 musica
drwxrwx--- root     sdcard_r          2018-07-30 12:12 video

result = sp.check_output(['adb', 'shell', 'ls', '-l', '/storage/sdcard1/documents'])
text = result.decode()
data = text.split('\r\n')
for r in data:
    print(r)

    
-rwxrwx--- root     sdcard_r  2029923 2016-06-25 22:31 BREAKING DAWN.pdf
-rwxrwx--- root     sdcard_r  1586880 2016-06-25 19:32 ECLIPSE.pdf
-rwxrwx--- root     sdcard_r  1384907 2016-06-25 20:32 NEW MOON.pdf
drwxrwx--- root     sdcard_r          2015-08-15 19:10 Sample Files
-rwxrwx--- root     sdcard_r   624276 2016-06-25 20:33 Stephenie Meyer - MIDNIGHT SUN (cap 1-12)_italiano.pdf
-rwxrwx--- root     sdcard_r  1282329 2016-06-25 20:33 Twilight.pdf


result = sp.check_output(['adb', 'pull', '/storage/sdcard1/documents/ECLIPSE.pdf', '/home/ngiuseppe'])
result
b'/storage/sdcard1/documents/ECLIPSE.pdf: 1 file pulled, 0 skipped. 4.4 MB/s (1586880 bytes in 0.345s)\n'

ho voluto mostrare come son proceduto nella navigazione ed il risultato della copia da cellulare a computer, modalità analoghe dovrebbero funzionare per fare l'inverso.




Spero possa essere utile.

Ciao

Come detto, il mondo Android mi è sconosciuto, cercando in merito ad "adb" ho scoperto che esiste anche per il mondo linux, scusa se inserisco un tip per eventuali linux-users interessati :

può essere installato dal Vostro gestore di pacchetti, in distro debian-based:

NzP:~$ sudo apt install adb

Si tratta dello Android-SDK di google.

Il comando "adb" che avrete disponibile è, essenzialmente, un server, capace di rilevare dispositivi in rete, udb/seriale, etc. il solito "man adb" per le numerose opzioni disponibili.




Se il dispositivo "collegato" non avrà abilitata tra le opzioni dello sviluppatore la modalità "debug USB" esso NON sarà disponibile anche se collegato.




Venendo a python, cercando di muovere i primi passi utilizzando la metodica proposta dallo O.P., utilizzando un vecchio "LG Bello II" molto vecchio, mi è riuscito di vedere il device in questo modo :

import subproces
result = subprocess.check_output(['adb', 'devices'])
                          
result
b'List of devices attached\n0123456789ABCDEF\tunauthorized\n\n'
data = result.decode('utf-8')
data
'List of devices attached\n0123456789ABCDEF\tunauthorized\n\n'
device = data.split('\n')1.split('\t')
print(f'device {device0} - stato {device1}')
device 0123456789ABCDEF - stato unauthorized

mi è riuscito di avere gli stessi risultati tramite Popen, ma senza utilizzo della shell

adb_sh = subprocess.Popen(['adb', 'devices'],
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
out, err = adb_sh.communicate()
out
b'List of devices attached\n0123456789ABCDEF\tunauthorized\n\n'

dato che l'utilizzo della shell scatena una miriade di output, attivando, se ho capito bene, il server

adb_sh = subprocess.Popen(['adb', 'devices'],
                          shell=True,
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
out, err = adb_sh.communicate()
out
b'Android Debug Bridge version 1.0.41\nVersion 34.0.4-debian\nInstalled as
 /usr/lib/android-sdk/platform-tools/adb\nRunning on Linux 6.8.0-50-generic...

rendendo ingestibile l'output.

Non ho ancora ben capito come funziona la shell con adb, l'impressione è che venga chiusa appena eseguito un comando, al momento non ho motivo di pensare che rimanga disponibile un PID, mi riservo di approfondire.




@FaMel 79, Tu sei riuscito a vedere i Tuoi devices? Se la risposta è "NO" prova a sostituire al mio "adb" il pathmane del Tuo eseguibile, oltre, naturalmente, a verificare le impostazioni del Tuo device.

per inviare i comandi si dovrebbe utilizzare "communicate" inviando i comandi come byte (stringa.encode()) e sopra vi è esempio di come recuperare lo standard output e lo standard error.




Al momento è quello che posso, spero Ti sia utile, ciao

Scusa se intervengo solo per porre una domanda, non ho alcuna pratica di interfacciamento con sistemi android ma il quesito mi ha incuriosito.

Domanda : le operazioni di I/O che stai cercando di effettuare sono da un sistema operativo "altro" (tipo windows, linux, etc.) verso un dispositivo android collegato, ovvero direttamente in una applicazione funzionante in un dispositivo android?




Chiarendo tale "ambiguità" scaturiscono linee di ricerca diverse, con risultati, nel primo caso, anche direttamente collegati al quesito, tipo questo, od anche inerenti tools specifici, tipo questo, mentre nel secondo, a giudicare da questo, sembra una problematica tutt'altro che semplice.




Come detto, la Tua domanda mi ha incuriosito, "abd.exe" mi è sconosciuto (uso solo sistemi linux) ma se precisi cosa intendi fare e come si potrebbe cercare qualcosa di specifico al Tuo problema.




Ciao

Oh ... mi fa piacere il Tuo apprezzare, grazie, ma in ogni caso approfondì la problematica, sviluppando tutta una serie di metodi per ricerca e visualizzazione, ma non la risolsi.




Se sei interessato il discorso può anche essere ripreso, comunque la "sensazione" è quella che si finisce in un far west, ove ognuno usa "regole proprie"

beh ... fermo restando che vale comunque la pena di conoscere tutti i gestori di geometria disponibili, l'utilizzo di "place" implica il ricalcolo del posizionamento di ogni singolo widget contenuto in una finestra che lo adotta.

A mio parere, sfruttare le caratteristiche di "elasticità" dei gestori "pack" o "grid" semplifica parecchio la faccenda e riduce di molto il codice necessario (il che è sempre un'ottima cosa), un buon "disegno" preventivo dell'interfaccia e degli "effetti" che si vogliono ottenere sarebbe un buon approccio, poi scegliere il gestore secondo il criterio del minimo codice possibile : semplificherebbe la manutenzione del codice stesso e l'introduzione di bugs nella stesura imho




Ciao

Quindi funziona ... Credo che il "come" lo si possa "decifrare", non che sia poi significativo la mia era solo curiosità, se sei curioso anche Tu potrei provare ad inviarTi un messaggio di prova, magari ci riesco




edit : vedo che sono stato preceduto, ok, funziona, ed ho capito l'indicazione che vedevo : totale dei messaggi scambiati




Curiosità soddisfatta, non ne abuserò, Grazie e ciao



--- Ultima modifica di nuzzopippo in data 2024-12-06 13:10:56 ---

Salve, non sapevo dove porre la domanda, provo qui.



Quando effettuo il login trovo una cartella non visibile in caso di navigazione anonima, essa è denominata "Messaggi privati" con sottotitolo "i tuoi messaggi privati", segna 9 "discussioni" ma accedendovi non ne risulta alcuna.

Me ne sono accorto di recente, di norma effettuo il login giusto per rispondere ad un post e mi disconnetto immediatamente.

Anche se suppongo che sia un abbozzo di qualcosa poi tralasciato mi ha incuriosito e potrebbe esserci qualcosa che non conosco, domande :




1 - Funziona la messaggistica inter-utente?

2 - se si, come?




Grazie dell'attenzione

Grazie del complimento, me ne sento lusingato, cercherò di rispondere alle domande




Allora :

A. Perché hai scelto di utilizzare una classe astratta per il supporto al drag and drop, per esempio non poteva essere migliore l'utilizzo di mixin?

Ho scelto di utilizzare una classe astratta perché il codice di visualizzazione del "drag" è comune a tutte le possibili implementazioni, ciò che cambia sono i metodi di rilascio e ricezione dei dati, per i quali è reso necessario definire i metodi astratti, rispettivamente, "drag_data" e "drop_data" nelle classi reali.

Tal genere di processi mi è facile pianificarli, li conosco e credo che tale mezzo sia utile per far evitare (anche allo scrivente) nei limiti del possibile "mutazioni" di codifica incompatibili tra loro




... le astrazioni sono migliori di "mixin"? Purtroppo al momento non saprei dirlo, è un (anti?)pattern da me ancora non affrontato, posto anche per imparare cose nuove, e credo proprio lo esperimenterò (si tratta di sub-classare più classi contemporaneamente, ho capito giusto?


Comunque, come certo hai già rilevato e che preciso per altri lettori, ho adottato una metodologia diametralmente opposta, i widget tkinter non incapsulano assolutamente nulla delle classi reali che effettuano il drag&drop ma sono le istanze a queste ultime che incapsulano i widget, dei quali sfruttano le caratteristiche per funzionare e modificano a loro uso, eventualmente richiedendo possiedano, anche indirettamente, un qualche metodo specifico per il rilascio/acquisizione dei dati, un esempio in tal senso è la classe "DADComuni", di "test.py" che richiede all'oggetto trasmittente i dati il metodo "get_element()" ed all'oggetto ricevente il metodo "set_comune(data)" (forse un po' troppo specifico) ... questo porta alla seconda domanda :

B. Come garantisci che i dati trascinati e rilasciati siano validi rispetto al tipo specificato?"

è la variabile di istanza "tipe", definita nella classe astratta originale a controllare il tutto, tale controllo è, ovviamente, demandato alla implementazione reale della classe ed è il recettore dei dati che dovrò effettuare il controllo, nella classe DADComuni

    def drop_data(self, descriptor, data: any) -> None:
        if not self._dropable: return
        if descriptor != self.tipe: return
        self.obj.set_comune(data)

Ove il "descriptor" proviene direttamente dalla classe madre, di cui la classe incapsulante un widget origine dei dati è implementazione reale, al rilascio del pulsante del mouse gestito dall'oggetto origine dei dati, che richiama i dati invocando "self.drag_data()" e rilasciandoli alla controparte invocando la proprietà "obj.drop_data(self.tipe, data)" ricevuta quando è stato incapsulato.

Il "tipe" delle due istanze della classe reale per origine/ricezione devono essere uguali o il passaggio verrà interrotto ... ovviamente, a tipi uguali corrisponde una stessa tipologia di dati (un dizionario con chiavi conosciute nel caso), non dimentichiamo che parliamo di una stessa applicazione ... i dati possono essere qualsiasi cosa serva, "tipe" può essere definito a piacere in sede di istanza.




Ho pensato che una tecnica si fatta sia abbastanza semplice ed elastica per essere adottata in numerosi casi, comunque sono pronto ad imparare come far meglio




Ciao e grazie