Riferendo al file allegato all'ultimo post :




nel metodo MainWin.populate, dalla riga 111 definisci :

        self._scales = {'freqsa': [],
                        'mixera': [],
                        'freqsb': [],
                        'mixerb': []}

e nello stesso metodo, dalla riga 145 definisci:

        self._scales = {'freqsb': [],
                        'mixerb': []}

tale seconda definizione va a sostituire la prima, conseguentemente perdi i riferimenti a freqsa e mixera, temo sia questa la fonte di errori sugli indici.

Constato che hai definito una variabile di classe "values" alla riga 67 con concomitante definizione di variabile di modulo "values" alla riga 9 ... fossi in Te eviterei ambiguità di tal genere, comunque, in vari punti del Tuo codice utilizzi la variabile di modulo.




Non procedo oltre nella valutazione, per ragioni di tempo, comunque devi ristrutturare il codice razionalizzando alle esigenze necessarie ed organizzandolo bene e con attenzione, pianifica attentamente ciò che fai.




Ciao

Ciao @Fabio75 ... sempre mixer eh?




Ho sommariamente testato il file da Te allegato nel 2° post, evidentemente manipolato rispetto al primo, ed a parte il doppio lancio della applicazione

if __name__ == '__main__':
    #crea finestra
    app = MainWin()
    app1 = MainWin()
    app.configure(background='black')
    app.geometry("1000x1000+0+0")
    app.resizable(False,False)
    app.configure(background="black")
    app.mainloop()
    app1.populate()

Che Ti darà errore per il "popolamento" di app1 DOPO l'avvio del mainloop (elimina app1, non serve)




Sembra caricare correttamente i dati del mixer salvati (ovviamente nello oggetto "app") ... senza studiarmi attentamente il codice da Te proposto, vorresti aggiornare sulle problematiche che trovi nel file allegato nel secondo post?




Per altro, se posso suggerire, trovo che l'utilizzo di variabili globali a livello di modulo sia un brutto modo di procedere, una classe "dovrebbe" quanto più possibile essere indipendente da fattori esterni, penso sia più opportuno utilizzare variabili di istanza per i dati da gestire e/o parametri nei metodi nel passaggio dati tra un oggetto e l'altro.




Fai sapere

Si, ovvio e concetto che ho ben chiaro ... comunque, essendo mia intenzione vedere cose "nuove" (per me) è solo uno degli aspetti che "vorrei" affrontare. In tal senso trovo il Tuo suggerimento "BeeWare" estremamente interessante, Te ne ringrazio, mi era sconosciuto.




Rimango aperto al altri eventuali suggerimenti, le cose che non conosco sono più numerose delle stelle ;D

I miei saluti




Al fine di familiarizzare con alcuni dei molti aspetti mai guardati ho idea di studiarmi un semplice "scadenziario" disponibile nella rete domestica da terminali vari, tipo computer, cellulari, televisioni e tablet.




Al momento l'idea generale è di un piccolo server dati su, p.e. su raspberry PI, cui accedere tramite un server Apache+flask, e/o direttamente tramite client grafici da pc o periferiche android.




Non prevedo alcuna difficoltà a crearmi direttamente il server dati tramite socket e, p.e. sqlite o postresql, ma non mi dispiacerebbe avere qualche suggerimento su modalità alternative che valga la pena di studiarsi.




Riguardo la parte "Flask", cominciato a guardare un tutorial in merito mi sto guardando bootstrap per affrontarlo meglio e mi sto convincendo a dare una guardata allo HTML5 (sono ferma al 4) ed ai css correnti ... ci sarebbe qualcos'altro che vale la pena di guardare?




Lato Android ... sin ora non me ne sono mai interessato, so che con java ci sono molti strumenti ma non vorrei ritornare a quel linguaggio e restare in ambito python, genericamente ho sentito nominare kivy ma c'è altro che vale la pena di guardare?




Grazie dell'attenzione

Ciao

Bisogna valutare ciò che si può rappresentare ... ho scaricato i Tuoi dati di esempio e devo dire che purtroppo non Ti aiutano tanto per la formattazione incoerente per tipi di dato quanto per la mancanza di normalizzazione dei dati stessi.

Purtroppo, causa trasloco in corso, al momento ho poche opportunità di scrivere e non ho avuto spunto di discutere preventivamente con Te le criticità che i Tuoi dati presentano, ho pertanto provveduto a formattare uniformemente le date (è un fattore rilevante) e ad implementare un abozzo di normalizzazione dei riferimenti a singoli articoli delle varie promozioni che vi riferiscono ... quest'ultima è certamente la condizione che Ti crea più difficoltà. Per ovviare ad essa ho stabilito di unificare i dati per "Codice Prodotto" riferendo i dati associati (non uniformi) al primo trovato ed associando ad esso articolo le promozioni inerenti.

Ovviamente, ho operato su un csv prodotto dai dati, manipolati, da Te forniti, ed ho memorizzato il tutto in una lista di dizionari, stralcio del codice relativo :

        with open(fname) as f:
            data = [x.split(';') for x in f.readlines() if x]
        articles = []
        codes = set([x[8] for x in data[1:]])
        for c in codes:
            values = [x for x in data if x[8] == c]
            if not values:
                pass
            else:
                art = {}
                art['codice'] = values[0][8]
                art['modello'] = values[0][9]
                art['marchio'] = values[0][10]
                art['descrizione'] = values[0][11]
                art['quantita'] = values[0][12]
                art['prezzo'] = f'{max([float(x[15]) for x in values]):.2f}'
                art['promozioni'] = []                
                for d in values:
                    prom = {}
                    prom['codice'] = d[0]
                    prom['competenza'] = d[1]
                    prom['attivo'] = d[2]
                    prom['cumulabile'] = d[3]
                    prom['soggetto'] = d[4]
                    prom['fornitore'] = d[5]
                    prom['inizio'] = d[6]
                    prom['fine'] = d[7]
                    prom['sc%'] = d[13]
                    prom['scv'] = d[14]
                    prom['prezzo'] = f'{float(d[15]):0.2f}'
                    art['promozioni'].append(prom)
                articles.append(art)
        articles.sort(key=lambda x: x['codice'])
        self.articoli = articles

Non sono certo di aver interpretato correttamente i dati ma in fin dei conti è solo un esempio.




L'esempio è composto da due finestre, nella prima una treeview permette di selezionare uno o più articoli mostrando in una seconda treeview le promozioni associate con dati più o meno completi.

Due bottoni di comando permettono di aprire la finestra del "calendario" da Te richiesta impostando per la rappresentazione di un singolo articolo e per più articoli (non esagerare, non ho reso il calendario "scorrevole"), il calendario è mensile ed impostato per il mese corrente nel sistema, uno spinbox Ti permetterà di scorrere tra i mesi, giungendoa marzo-febbraio il calendario Ti mostrerà delle barre color pastello in corrispondenza degli articoli interessati.

Non sto qui a spiegare il procedimento, ci vorrebbe troppo tempo, studiati la classe "Mensile", è quella che provvede alla rappresentazione a barre delle promozioni.




Il codice non lo ho curato eccessivamente, forse qualche bug ci scappa, comunque nel complesso funziona decentemente.




Fai sapere se Ti è utile e che ne pensi ... se qualche altro utente vorrà esporre critiche e suggerimenti saranno ben accetti.




Allego in file del codice (395 righe) ed il csv di test, devono risiedere nella stessa directory




Ciao

beh, ovviamente il discorso può variare in base ai dati da rappresentare ma di per se è possibile realizzarlo in molti modi.

Uno dei più semplici che mi viene in mente è quello di sfruttare il gestore "grid" per generare un header tipo "codice|descrizione!01|02|..." e quindi sfruttare rowspan nel configurare le celle di codice e descrizione in rapporto al numero di offerte da rappresentare per articolo, mentre ilo metodo colspan permetterebbe di unificare le celle dei giorni in cui ricade una singola offerta. delle label diversamente colorate evidenzierebbero i periodi delle offerte, magari corredati da una brevissima descrizione.




Potrebbe anche utilizzarsi un canvas per "disegnare" le cose ma sarebbe un attimino più articolato.

Volendo potrebbe anche realizzarsi un mix di metodologie ibride.




In ogni caso dovresti decidere "cosa" vuoi per davvero visualizzare e valutare le dimensioni necessarie alla rappresentazione prima ancora di iniziare una implementazione, quantità di dati eccedenti lo schermo comportano approcci diversi da quantità per cui una schermata è sufficiente.




Nel caso Tu ritenga di provare qui qualche bozza proponi un set di dati su cui ragionare che vediamo cosa si riesce ad escogitare.




Ciao

Normale? ... suppongo di si, essendo il formato svg usato per grafica vettoriale, da ricerche fatte in giro mi par di capire che per ottenere uno sfondo èer tale formato bisogna crearsi un rettangolo, ma non posso dire di conoscere tale formato di immagine.




Per altro, dalla poca documentazione disponibile e dalla valutazione del codice sorgente di canvas2svg mi sembra proprio che tale opzione non sia prevista ... comunque, è piuttosto semplice* ovviare creando un rettangolo di sfondo che contenga il disegno, questo è un test variando l'ultimo esempio :

import turtle
from canvasvg import saveall


def make_bg(cnv: object, margin: int=10,
            bd_col: str='', bd_size: int=1) -> object:
    '''
    Disegna un rettangolo con funzione di "sfondo" del colore assegnato
    a turtle, si tenga presente che il canvas non lo contiene
    PARAMETRI :
    cnv    : oggetto tkinter.canvas
    margin : margine, in pixel, ripetto al disegno
    bd_col : colore di bordo, se nullo viene ignorato
    bd_size: spessore, in pixwl, del bordo del rettangolo
    '''
    x1, y1, x2, y2 = cnv.bbox('all')
    # bgc = cnv['background']  -- così non va
    bgc = turtle.bgcolor()
    if bd_col:
        rect = cnv.create_rectangle(x1 - margin,
                                    y1 - margin,
                                    x2 + margin,
                                    y2 + margin,
                                    outline = bd_col,
                                    fill = bgc,
                                    width = bd_size)
    else:
        rect = cnv.create_rectangle(x1 - margin,
                                    y1 - margin,
                                    x2 + margin,
                                    y2 + margin,
                                    fill = bgc,
                                    width=0)
    cnv.tag_lower(rect)
    return cnv


# DISEGNA
turtle.bgcolor('yellow')
tart = turtle.Turtle()

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


wdg = turtle.getcanvas()  # recupera lo scrolled_canvas
# disegno pseudo-sfondo con bordo rosso di 2 pixel
wdg = make_bg(wdg, bd_col='red', bd_size=2)

saveall('test_04c.svg', wdg)  # lo salva con 10 pixwel di sfondo trasparente

Spero Ti sia utile




* = semplice, ovviamente, conoscendo python e consultando la documentazione di tkinter, non credo sia pane per i denti di ChatGPT e simili AI che, dopo tutto, sono solo algoritmi euristici (quindi statistici) che seppur fantastici non hanno niente di "intelligente"

Ciao, ho provato il pacchetto svg_turtle, non mi sembra che risolva il Tuo problema, certamente è interessante il formato vettoriale e la trasparenza ma, purtroppo, non riporta completamente le immagini, prova questo esempio :

from svg_turtle import SvgTurtle

# DISEGNA
tart = SvgTurtle()

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


tart.save_as('test_04.svg')                             #la salva

Documentazione pessima e, guardando il codice, decisamente "povero" di opzioni.




Cercando, sempre sul formato svg, ho trovato il modulo "canvasvg", anche questo con documentazione penosa ma ha una funzione interessante "saveall", che salva l'intero contenuto del canvas che riceve quale parametro, oltre a permettere di definire un bordo immagine a piacere, un esempio:

import turtle
from canvasvg import saveall

# DISEGNA
tart = turtle.Turtle()

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


wdg = turtle.getcanvas()  # recupera lo scrolled_canvas

saveall('test_04b.svg', wdg)

Suggerirei di guardare anche quest'ultimo modulo.

beh, il mio voleva essere un semplice "la", mi aspettavo Tu ricorressi alla documentazione di tkinter.canvas per vedere un po' come vanno le cose, in tal caso, consultando la documentazione a proposito di tkinter.canvas.poscript avresti notato che vi sono vari parametri possibili, alcuni tra cui "dovrebbero" riferire alla "tela" del canvas, che ha coordinate proprie non inerenti quelle di visualizzazione dello schermo.

Tra l'altro, tkinter.canvas, ha la proprietà "bbox(namewidget)" che permette di estrarre le coordinate del rettangolo di contenzione di ogni singolo item disegnato (con "all" si ottengono le coordinate di contenzione dell'intero disegno) ... non mi ero impelagato ad approfondire, dato che non hai indicato il codice per ottenere il grafico per Te problematico.




Comunque, stante il Tuo problema, ho guardato un po', calcolandosi le coordinate della tela e valorizzando gli opportuni parametri di postscript riesco ad ottenere il disegno completo anche con gli elementi al di fuori della finestra, per far ciò ho raddoppiato il numero dei triengoli ed implementato le considerazioni sopra, il codice :

import turtle
from PIL import Image
from io import BytesIO

# DISEGNA
tart = turtle.Turtle()

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


wdg = turtle.getcanvas()  # recupera lo scrolled_canvas
# coordinale e dimensioni della sola immagine
x1, y1, x2, y2 = wdg.bbox('all')
w, h = x2 - x1, y2 - y1

# SALVA
# applica i dati calcolati e crea il postscript della sola immagine
ps_data = wdg.postscript(colormode = 'color',
                         x = x1,
                         y = y1,
                         width = w,
                         height = h)
im = Image.open(BytesIO(bytes(ps_data, 'ascii')))  # crea una immagine dai dati
im.save('test_03.png')                             #la salva

ed a me funziona benissimo, provalo e fai sapere.




N.B. : le immagini sono cose complesse, tieni presente che potresti avere altri generi di problemi, tipo sui colori per differenze di palette, ovvero problemi sui pixel, se ricordo bene postscript e Image sono entrambi raw ma ps opera su 96 DPI mentre Image su 72 DPI, convertendo in formati bitmap potrebbero essere introdotti artefatti, corregibili con metodi di proporzionamento vari, gli altri parametri di postscript potrebbero essere d'aiuto.




Ciao

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