questo codice ha un difettuccio, se faccio salva con nome per la seconda volta per lo…
- User
questo codice ha un difettuccio, se faccio salva con nome per la seconda volta per lo stesso file, quando compare la gui di selezione riporta il nome del file inerente all'adempimento, ma dovrebbe comunque riportare il nome file attribuito al primo savataggio
- Assistant
Capito, sembra che tu stia usando una GUI per un "Salva con nome" e vuoi che ogni volta che apri la finestra di dialogo Salva con nome per lo stesso file, venga mostrato il nome del file che hai salvato la prima volta, non il nome "standard" legato ad un'altra variabile o dato.
Senza vedere il codice esatto, ti posso però dare indicazioni generali su come gestire questo comportamento.
Problema comune
Quando apri il dialogo "Salva con nome" più volte, il nome iniziale suggerito è impostato da un valore fisso o variabile non aggiornato, che non tiene conto del nome usato nel primo salvataggio.
Come si risolve in linea generale
-
Memorizza il percorso e nome file appena salvati:
Quando fai il primo salvataggio (sia salva sia "salva con nome"), devi salvare in una variabile (ad es.ultimo_nome_file) il path completo o almeno il file name. -
Quando riapri il dialogo "salva con nome", imposta il valore della finestra con questa variabile
ultimo_nome_file
Se questa variabile è valorizzata (cioè hai salvato già una volta), usa quel nome come nome di default accanto ad esempio al percorso.
Un esempio in Python con Tkinter
Ecco uno scheletro di esempio per chiarire:
import tkinter as tk from tkinter import filedialog class App: def __init__(self, root): self.root = root self.ultimo_nome_file = None # Qui memorizzi il nome salvato btn_salva = tk.Button(root, text="Salva con nome", command=self.salva_con_nome) btn_salva.pack() def salva_con_nome(self): # Usa il nome file usato la prima volta, se c'è initialfile = None if self.ultimo_nome_file is not None: # estraiamo solo il nome file (no percorso) import os initialfile = os.path.basename(self.ultimo_nome_file) # Chiedo il file da salvare, con il nome file di default file_path = filedialog.asksaveasfilename(initialfile=initialfile, defaultextension=".txt", filetypes=[("Text files", "*.txt"), ("All files", "*.*")]) if file_path: # Qui fai salva with open(file_path, "w") as f: f.write("…") # esempio contenuto self.ultimo_nome_file = file_path # aggiorno nome salvato root = tk.Tk() app = App(root) root.mainloop()
Riassumendo
- Prima volta,
ultimo_nome_fileè None → la finestra parte con il nome standard (eventualmente ancora vuoto o "adempimento") - Dopo il primo salvataggio, aggiorno
ultimo_nome_filecon il file salvato - La finestra "Salva con nome" apre con quel nome file preimpostato, sempre quello ultimo usato, non un nome predefinito fisso.
Se vuoi posso darti una mano più precisa se mi posti il tuo codice attuale.
Fammi sapere!
-
- User
questo codice ha un difettuccio, se faccio salva con nome per la seconda volta per lo stesso file, quando compare la gui di selezione riporta il nome del file inerente all'adempimento, ma dovrebbe comunque riportare il nome file attribuito al primo savataggio import time import threading import tkinter as tk from tkinter import ttk, filedialog, messagebox import psutil from pywinauto import Application import win32gui import win32con import win32process import os import ctypes import uuid import sqlite3
Per tray icon
import pystray from PIL import Image, ImageDraw
DB_FILE = 'gestione_aziende_adempimenti.db'
Globals
pid_to_unique_id = {} unique_id_to_save_data = {} handled_hwnds = set() exit_flag = False
Tray icon functions
def create_image(): width = 16 height = 16 color1 = "black" color2 = "white" image = Image.new('RGB', (width, height), color1) dc = ImageDraw.Draw(image) dc.rectangle([(width // 4, height // 4), (width * 3 // 4, height * 3 // 4)], fill=color2) return image
def on_quit(icon, item): global exit_flag exit_flag = True icon.stop()
def setup_tray_icon(): icon = pystray.Icon("SaveAsMonitor") icon.icon = create_image() icon.title = "SaveAs Monitor" icon.menu = pystray.Menu(pystray.MenuItem("Esci", on_quit)) return icon
def hide_window(hwnd): win32gui.ShowWindow(hwnd, win32con.SW_HIDE)
def show_window(hwnd): win32gui.ShowWindow(hwnd, win32con.SW_SHOW)
def bring_to_front(hwnd): try: win32gui.SetForegroundWindow(hwnd) except Exception: pass
DB functions
def fetch_aziende_for_gui(): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT codice, denominazione FROM aziende ORDER BY denominazione") rows = c.fetchall() conn.close() return rows
def fetch_adempimenti_for_gui(): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT codice_adempimento, descrizione, cartella_salvataggio, IFNULL(nome_file,'') FROM adempimenti ORDER BY descrizione") rows = c.fetchall() conn.close() return rows
def fetch_file_by_path(percorso): conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute('SELECT codice_azienda, codice_adempimento FROM files WHERE percorso_file = ?', (percorso,)) row = c.fetchone() conn.close() return row
def inserisci_file_db(codice_azienda, codice_adempimento, percorso_file): conn = sqlite3.connect(DB_FILE) c = conn.cursor() try: c.execute("INSERT INTO files (codice_azienda, codice_adempimento, percorso_file) VALUES (?, ?, ?)", (codice_azienda, codice_adempimento, percorso_file)) conn.commit() except sqlite3.IntegrityError: # Ignora duplicati oppure aggiorna se vuoi pass finally: conn.close()
Custom save GUI
def custom_save_gui(default_ext, file_types, default_name, initial_folder=None): root = tk.Tk() root.title("Salvataggio personalizzato") root.geometry("700x250") root.attributes("-topmost", True)
selezionato = {'full_path': None} cancelled = {'value': True} aziende = fetch_aziende_for_gui() adempimenti = fetch_adempimenti_for_gui() var_azienda = tk.StringVar() var_adempimento = tk.StringVar() var_folder = tk.StringVar() var_filename = tk.StringVar(value=default_name) full_path = None if initial_folder and default_name: full_path = os.path.normpath(os.path.join(initial_folder, default_name)) preselected_azienda_cod = None preselected_adempimento_cod = None if full_path: found = fetch_file_by_path(full_path) if found: preselected_azienda_cod, preselected_adempimento_cod = found def get_azienda_name(cod): for a in aziende: if a[0] == cod: return a[1] return "" def get_adempimento_name(cod): for a in adempimenti: if a[0] == cod: return a[1] return "" var_azienda.set(get_azienda_name(preselected_azienda_cod) if preselected_azienda_cod else (aziende[0][1] if aziende else "")) var_adempimento.set(get_adempimento_name(preselected_adempimento_cod) if preselected_adempimento_cod else (adempimenti[0][1] if adempimenti else "")) def aggiorna_percorso(*args): try: azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get()) codice_az = azienda_selezionata[0] ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get()) codice_ad, descrizione_ad, cartella_salvataggio, nome_file = ademp_selezionato conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT root FROM aziende WHERE codice=?", (codice_az,)) root_path = c.fetchone() conn.close() root_path = root_path[0] if root_path else os.getcwd() full_folder_path = os.path.join(root_path, cartella_salvataggio) os.makedirs(full_folder_path, exist_ok=True) var_folder.set(full_folder_path) filename = nome_file if nome_file.strip() else default_name if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename) except StopIteration: pass def scegli_cartella_manual(): folder_selected = filedialog.askdirectory(initialdir=var_folder.get() or os.getcwd()) if folder_selected: var_folder.set(folder_selected) def conferma(event=None): folder = var_folder.get() filename = var_filename.get() if not folder or not filename: messagebox.showerror("Errore", "Cartella e nome file sono obbligatori") return selezionato['full_path'] = os.path.normpath(os.path.join(folder, filename)) cancelled['value'] = False root.destroy() def on_close(): cancelled['value'] = True root.destroy() tk.Label(root, text="Azienda:").pack(anchor='w', padx=10, pady=(10, 0)) combo_aziende = ttk.Combobox(root, values=[a[1] for a in aziende], textvariable=var_azienda, state='readonly') combo_aziende.pack(fill='x', padx=10) tk.Label(root, text="Adempimento:").pack(anchor='w', padx=10, pady=(10, 0)) combo_adempimenti = ttk.Combobox(root, values=[a[1] for a in adempimenti], textvariable=var_adempimento, state='readonly') combo_adempimenti.pack(fill='x', padx=10) tk.Label(root, text="Cartella di destinazione:").pack(anchor='w', padx=10, pady=(10, 0)) folder_entry = tk.Entry(root, textvariable=var_folder, width=80) folder_entry.pack(side='left', padx=(10, 0), pady=5, fill='x', expand=True) btn_folder = tk.Button(root, text="Scegli cartella", command=scegli_cartella_manual) btn_folder.pack(side='left', padx=10, pady=5) tk.Label(root, text="Nome file:").pack(anchor='w', padx=10, pady=(10, 0)) filename_entry = tk.Entry(root, textvariable=var_filename, width=80) filename_entry.pack(padx=10, pady=5, fill="x") btn_conferma = tk.Button(root, text="Conferma", command=conferma) btn_conferma.pack(pady=10) root.protocol("WM_DELETE_WINDOW", on_close) aggiorna_percorso() var_azienda.trace_add('write', aggiorna_percorso) var_adempimento.trace_add('write', aggiorna_percorso) filename_entry.bind('<Return>', conferma) folder_entry.bind('<Return>', conferma) filename_entry.focus_set() root.focus_force() root.mainloop() if cancelled['value']: return None, None, None return selezionato['full_path'], \ next(a[0] for a in aziende if a[1] == var_azienda.get()), \ next(a[0] for a in adempimenti if a[1] == var_adempimento.get())#---- Funzioni ausiliarie usate dal monitoraggio ----
def click_button_fallback_hwnd(hwnd_button): try: win32gui.SendMessage(hwnd_button, win32con.BM_CLICK, 0, 0) except Exception: pass
def enumerate_child_windows(hwnd): children = [] def enum_proc(child_hwnd, param): param.append(child_hwnd) return True win32gui.EnumChildWindows(hwnd, enum_proc, children) return children
def detect_default_extension(process_name): process_name = process_name.lower() if process_name else ""
mapping = { "winword.exe": ".docx", "excel.exe": ".xlsx", "powerpnt.exe": ".pptx", "onenote.exe": ".one", "msaccess.exe": ".accdb", "outlook.exe": ".pst", "swriter.exe": ".odt", "scalc.exe": ".ods", "simpress.exe": ".odp", "soffice.bin": ".odt", "acrord32.exe": ".pdf", "acrobat.exe": ".pdf", "photoshop.exe": ".psd", "illustrator.exe": ".ai", "chrome.exe": ".html", "firefox.exe": ".html", "msedge.exe": ".html", "opera.exe": ".html", "brave.exe": ".html", "notepad.exe": ".txt", "notepad++.exe": ".txt", "sublime_text.exe": ".txt", "code.exe": ".txt", "vim.exe": ".txt", "mspaint.exe": ".png", "paint.exe": ".png", "gimp.exe": ".xcf", "inkscape.exe": ".svg", "vlc.exe": ".m3u", "audacity.exe": ".aup", "spotify.exe": ".dat", "7z.exe": ".7z", "winrar.exe": ".rar", "winzip.exe": ".zip", "wordpad.exe": ".rtf", "calc.exe": ".txt", } return mapping.get(process_name, ".dat")def wait_for_modal_dialog_closed(pid, parent_hwnd, timeout=30): keywords = ["conferma", "sovrascrivi", "attenzione", "avviso", "replace", "overwrite", "confirm", "already exists"] user32 = ctypes.windll.user32 end_time = time.time() + timeout
while time.time() < end_time and not exit_flag: found = False def enum_windows_callback(hwnd, lParam): if not user32.IsWindowVisible(hwnd): return True style = user32.GetWindowLongW(hwnd, win32con.GWL_STYLE) if not (style & win32con.WS_POPUP): return True owner = user32.GetWindow(hwnd, win32con.GW_OWNER) if owner != parent_hwnd: return True length = user32.GetWindowTextLengthW(hwnd) buffer = ctypes.create_unicode_buffer(length + 1) user32.GetWindowTextW(hwnd, buffer, length + 1) title = buffer.value.lower() for k in keywords: if k in title: nonlocal found found = True return False return True EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_int, ctypes.c_int) user32.EnumWindows(EnumWindowsProc(enum_windows_callback), 0) if not found: return time.sleep(0.3)def is_modal_confirm_window(hwnd, parent_hwnds): user32 = ctypes.windll.user32
if not win32gui.IsWindowVisible(hwnd): return False style = user32.GetWindowLongW(hwnd, win32con.GWL_STYLE) if not (style & win32con.WS_POPUP): return False owner = user32.GetWindow(hwnd, win32con.GW_OWNER) if owner not in parent_hwnds: return False title_length = user32.GetWindowTextLengthW(hwnd) if title_length == 0: return False buffer = ctypes.create_unicode_buffer(title_length + 1) user32.GetWindowTextW(hwnd, buffer, title_length + 1) title = buffer.value.lower() keywords = ["conferma", "sovrascrivi", "attenzione", "avviso", "replace", "overwrite", "confirm", "already exists"] for k in keywords: if k in title: return True return Falsedef enum_save_dialog_windows(windows, save_windows): main_dialog_hwnds = set() for hwnd in windows: if win32gui.IsWindowVisible(hwnd): title = win32gui.GetWindowText(hwnd) if title and ("save as" in title.lower() or "salva con nome" in title.lower()): main_dialog_hwnds.add(hwnd) for hwnd in windows: if hwnd in main_dialog_hwnds: pid = win32process.GetWindowThreadProcessId(hwnd)[1] if not is_modal_confirm_window(hwnd, main_dialog_hwnds): save_windows[hwnd] = pid
def get_unique_id_for_pid(pid): if pid not in pid_to_unique_id: pid_to_unique_id[pid] = str(uuid.uuid4()) return pid_to_unique_id[pid]
def monitor_save_dialog(process_name, app, pid, hwnd): global handled_hwnds, pid_to_unique_id, unique_id_to_save_data
unique_id = get_unique_id_for_pid(pid) print(f"[{process_name}] Monitoraggio HWND {hwnd} PID {pid} con unique_id {unique_id} avviato") gui_shown = False handled_hwnds.add(hwnd) try: dlg = app.window(handle=hwnd) while dlg.exists() and not exit_flag: if not dlg.is_visible(): time.sleep(0.3) continue if not gui_shown: wait_for_modal_dialog_closed(pid, hwnd) hide_window(hwnd) saved_path = unique_id_to_save_data.get(unique_id) ext = detect_default_extension(process_name) default_name = "file" + ext if saved_path: initial_folder = os.path.dirname(saved_path) default_name = os.path.basename(saved_path) if not default_name.lower().endswith(ext.lower()): default_name += ext else: initial_folder = None result = custom_save_gui(ext, [], default_name, initial_folder) if result is None or result[0] is None: selected_path = None codice_az_salvato = None codice_ad_salvato = None else: selected_path, codice_az_salvato, codice_ad_salvato = result gui_shown = True if selected_path is not None: normalized_path = os.path.normpath(selected_path) unique_id_to_save_data[unique_id] = normalized_path show_window(hwnd) bring_to_front(hwnd) time.sleep(0.1) filename_edit = dlg.child_window(class_name="Edit") fixed_path = normalized_path.replace('/', '\\') filename_edit.set_edit_text(fixed_path) children = enumerate_child_windows(hwnd) btn_hwnd = None for ch in children: text = win32gui.GetWindowText(ch) cls = win32gui.GetClassName(ch) if cls == 'Button' and ('salva' in text.lower() or 'save' in text.lower()): btn_hwnd = ch break if btn_hwnd: try: btn = dlg.child_window(handle=btn_hwnd) btn.click_input() wait_for_modal_dialog_closed(pid, hwnd) if codice_az_salvato and codice_ad_salvato: inserisci_file_db(codice_az_salvato, codice_ad_salvato, normalized_path) except Exception as e: print(f"{process_name}: click_input() non riuscito: {e}. Uso fallback BM_CLICK") click_button_fallback_hwnd(btn_hwnd) wait_for_modal_dialog_closed(pid, hwnd) if codice_az_salvato and codice_ad_salvato: inserisci_file_db(codice_az_salvato, codice_ad_salvato, normalized_path) else: print(f"{process_name}: GUI annullata, chiudo finestra dialog") win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0) break time.sleep(0.5) dlg = app.window(handle=hwnd) print(f"[{process_name}] Finestra HWND {hwnd} chiusa, termina monitoraggio") except Exception as e: print(f"{process_name} - Errore monitoraggio dialog: {e}") if hwnd in handled_hwnds: handled_hwnds.remove(hwnd) print(f"{process_name}: HWND {hwnd} rimosso da gestiti")Riporto qui solo il main loop e l'avvio icon tray come nel tuo script originale
def main_loop(): global handled_hwnds, exit_flag, pid_to_unique_id, unique_id_to_save_data pid_to_unique_id = {} unique_id_to_save_data = {} handled_hwnds = set() monitored_hwnds = {}
while not exit_flag: all_hwnds = [] win32gui.EnumWindows(lambda hwnd, param: param.append(hwnd), all_hwnds) save_windows = {} enum_save_dialog_windows(all_hwnds, save_windows) for hwnd in list(monitored_hwnds.keys()): if not win32gui.IsWindow(hwnd) or hwnd not in save_windows: monitored_hwnds.pop(hwnd) if hwnd in handled_hwnds: handled_hwnds.remove(hwnd) for hwnd, pid in save_windows.items(): if hwnd in handled_hwnds: continue try: proc = psutil.Process(pid) proc_name = proc.name() except Exception: proc_name = "sconosciuto" try: app = Application().connect(process=pid) t = threading.Thread(target=monitor_save_dialog, args=(proc_name, app, pid, hwnd), daemon=True) t.start() monitored_hwnds[hwnd] = t print(f"[Main] Avviato monitor PID {pid} HWND {hwnd} ({proc_name})") except Exception as e: print(f"[Main] Errore connessione PID {pid} HWND {hwnd}: {e}") time.sleep(2)E infine, l'avvio
if name == "main": icon = setup_tray_icon() main_thread = threading.Thread(target=main_loop, daemon=True) main_thread.start() icon.run() print("Terminazione in corso...") exit_flag = True main_thread.join(timeout=5) print("Chiusura completata.")
- Assistant
Grazie per il codice completo, ora è più chiara la situazione.
Riassunto del problema
Nel tuo monitoraggio, quando apri la GUI custom
custom_save_guiper la seconda volta per lo stesso file, il campoNome file:nella GUI riporta il nome "classico" legato all'adempimento (es. da DB), anziché il nome del file effettivamente usato nella prima volta (qui memorizzato inunique_id_to_save_data).
Dove si genera il problema
Nel pezzo chiave:
saved_path = unique_id_to_save_data.get(unique_id) ext = detect_default_extension(process_name) default_name = "file" + ext if saved_path: initial_folder = os.path.dirname(saved_path) default_name = os.path.basename(saved_path) if not default_name.lower().endswith(ext.lower()): default_name += ext else: initial_folder = None result = custom_save_gui(ext, [], default_name, initial_folder)All’interno di
custom_save_gui()tu poi fai questa cosa per impostarevar_filename:var_filename = tk.StringVar(value=default_name)Tuttavia, subito dopo nel
aggiorna_percorso()(chiamato all'inizio), sovrascrivivar_filenamecon:filename = nome_file if nome_file.strip() else default_name if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename)Noti che
nome_fileè quel campo preso direttamente dal DB tramite:preselected_adempimento_cod = ... ... ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get()) nome_file = ademp_selezionato[3]Quindi, anche se passi
default_namecome nome file già valorizzato con quello del primo salvataggio, subito dopo nel binding della GUI, questa variabile viene sovrascritta danome_filepreso da DB, tornando così al nome "originale".
Come risolvere
Soluzione 1: Passare il percorso completo del file salvato e far usare quello nella GUI
Nei parametri che chiami
custom_save_gui, passidefault_nameeinitial_folder.Invece di passare semplicemente
default_namepreso daunique_id_to_save_data, potresti passare anche quel percorso come parametro aggiuntivo per il nome file finale da utilizzare senza sovrascrivere inaggiorna_percorso().Oppure modifica il codice di
aggiorna_percorsoper usare come priorità il file salvato precedentemente, e se non c’è allora passa il nome da DB.
Implementazione pratica
Puoi aggiungere un parametro opzionale
saved_full_pathacustom_save_gui(), così:def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None): ...E poi modifica
aggiorna_percorso()in questo modo:def aggiorna_percorso(*args): try: ... ... # Impostiamo filename preferendo il percorso salvato if saved_full_path: filename = os.path.basename(saved_full_path) else: filename = nome_file if nome_file.strip() else default_name if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename) except StopIteration: pass
Modifica nella chiamata dentro
monitor_save_dialogCambia:
result = custom_save_gui(ext, [], default_name, initial_folder)in
result = custom_save_gui(ext, [], default_name, initial_folder, saved_full_path=saved_path)
Riassunto modifiche centrali
# Dentro custom_save_gui aggiungi il parametro saved_full_path: def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None): ... def aggiorna_percorso(*args): ... if saved_full_path: filename = os.path.basename(saved_full_path) else: filename = nome_file if nome_file.strip() else default_name if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename)E nel tuo
monitor_save_dialog:result = custom_save_gui(ext, [], default_name, initial_folder, saved_full_path=saved_path)
Perché questa soluzione funziona?
saved_full_pathrappresenta il percorso del file usato nel primo salvataggio, quindi la GUI lo mostra sempre come nome predefinito.- Solo se non hai effettuato un primo salvataggio (
saved_full_path=None), la GUI usa il nome del file definito in archivio DB (nome_file). - In questo modo eviti che
aggiorna_percorso()sovrascriva il campo "Nome file" ignorando il nome effettivo appena salvato.
Se vuoi posso aiutarti ad applicare queste modifiche direttamente nel tuo codice.
Fammi sapere! - User
cosi poi non funziona più in automatico con il db
- Assistant
Hai ragione: la modifica proposta — ovvero usare sempre il percorso salvato — impedirebbe che la GUI si aggiorni automaticamente se cambi l’adempimento o l’azienda (che serve per ricavare il percorso / nome file dal DB).
Occorre un compromesso:
- se c’è un percorso salvato valido e l’utente non cambia adempimento né azienda, la GUI mostra il nome salvato,
- se invece cambia adempimento o azienda, la GUI deve aggiornarsi in automatico col nome da DB (e cartella da DB).
Come fare?
Passo 1: memorizzare lo stato "iniziale"
All’avvio, quando si inizia la finestra, salvo i codici
preselected_azienda_codepreselected_adempimento_cod.Passo 2: modifica la callback
aggiorna_percorsoin modo che:- se l’azienda o l’adempimento cambiano rispetto a quelli pre-selezionati, allora carico nome file da DB,
- se invece sono quelli originali e c’è un file salvato, uso il nome salvato.
Esempio di implementazione:
All’interno di
custom_save_gui:# all'inizio di custom_save_gui preselected_azienda_cod_orig = preselected_azienda_cod preselected_adempimento_cod_orig = preselected_adempimento_cod saved_full_path = saved_full_path # parametro passato def aggiorna_percorso(*args): try: azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get()) codice_az = azienda_selezionata[0] ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get()) codice_ad, descrizione_ad, cartella_salvataggio, nome_file = ademp_selezionato conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT root FROM aziende WHERE codice=?", (codice_az,)) root_path = c.fetchone() conn.close() root_path = root_path[0] if root_path else os.getcwd() full_folder_path = os.path.join(root_path, cartella_salvataggio) os.makedirs(full_folder_path, exist_ok=True) var_folder.set(full_folder_path) # Se l'azienda o l'adempimento sono cambiati rispetto all'originale, # prendiamo il nome da DB, altrimenti teniamo il nome salvato if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path: filename = nome_file if nome_file.strip() else default_name else: # utilizza il nome del file salvato filename = os.path.basename(saved_full_path) if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename) except StopIteration: pass
In questo modo:
- Alla prima apertura (o se cambio azienda/adempimento), la GUI carica nome e cartella dal DB, quindi aggiornamento automatico;
- Alla seconda apertura per lo stesso file (senza cambiare azienda/adempimento), la GUI mostra il nome salvato la prima volta (exact match);
- Se cambio la selezione nella GUI, allora torna a caricare tutto da DB;
In conclusione
- Lasci invocare
custom_save_guicon parametrosaved_full_path=saved_pathcome suggerito prima; - Dentro
custom_save_gui, modificaaggiorna_percorsocon la logica sopra; - Così non perdi l’aggiornamento automatico dal DB quando si cambiano azienda/adempimento.
Se vuoi, posso prepararti un patch pronta da inserire.
Fammi sapere! - User
con la tua modifica la gui non compare più
- Assistant
Perfetto, grazie per il feedback dettagliato.
Di solito quando la GUI non compare più per una modifica come quella, il motivo più frequente è che la funzione
aggiorna_percorsova in eccezione — e dato che gli errori in tkinter in callback di solito non vengono stampati in console ma interrompono l’esecuzione, la finestra può letteralmente risultare “bloccata” o “mancante”.
Come procedere nel debug?
- Inserisci un blocco try/except interno all’interno della funzione
aggiorna_percorsoper catturare eventuali eccezioni e stamparle, ad esempio così:
def aggiorna_percorso(*args): try: # codice esistente qui sotto... azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get()) codice_az = azienda_selezionata[0] ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get()) codice_ad, descrizione_ad, cartella_salvataggio, nome_file = ademp_selezionato conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT root FROM aziende WHERE codice=?", (codice_az,)) root_path = c.fetchone() conn.close() root_path = root_path[0] if root_path else os.getcwd() full_folder_path = os.path.join(root_path, cartella_salvataggio) os.makedirs(full_folder_path, exist_ok=True) var_folder.set(full_folder_path) if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path: filename = nome_file if nome_file.strip() else default_name else: filename = os.path.basename(saved_full_path) if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename) except Exception as e: print("Errore in aggiorna_percorso:", e)Questo serve a capire se qualche valore è
Noneo c’è qualche errore nell’accesso a variabili.
Altri punti da verificare:
-
Sei certo che le variabili
preselected_azienda_cod_origepreselected_adempimento_cod_origsiano inizializzate correttamente fuori dalla funzione e visibili dentro aaggiorna_percorso?
Se sono variabili locali acustom_save_gui(), dentroaggiorna_percorsopotresti doverle dichiarare connonlocalo passarle via closure correttamente. -
Verifica che il parametro
saved_full_pathsia passato correttamente e non siaNone(o almeno gestito seNone).
Esempio completo di come definire
aggiorna_percorsocon closure di variabili:def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None): ... preselected_azienda_cod_orig = preselected_azienda_cod preselected_adempimento_cod_orig = preselected_adempimento_cod def aggiorna_percorso(*args): try: azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get()) codice_az = azienda_selezionata[0] ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get()) codice_ad, descrizione_ad, cartella_salvataggio, nome_file = ademp_selezionato conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT root FROM aziende WHERE codice=?", (codice_az,)) root_path = c.fetchone() conn.close() root_path = root_path[0] if root_path else os.getcwd() full_folder_path = os.path.join(root_path, cartella_salvataggio) os.makedirs(full_folder_path, exist_ok=True) var_folder.set(full_folder_path) if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path: filename = nome_file if nome_file.strip() else default_name else: filename = os.path.basename(saved_full_path) if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename) except Exception as e: print("Errore in aggiorna_percorso:", e)
Alternativa più sicura: passare le variabili come parametri alle funzioni
Un modo ancora più sicuro è quello di definire
aggiorna_percorsocon tutte le variabili necessarie legate tramite parametri predefiniti, ad esempio:def aggiorna_percorso(*args, aziende=aziende, adempimenti=adempimenti, var_azienda=var_azienda, var_adempimento=var_adempimento, var_folder=var_folder, var_filename=var_filename, default_ext=default_ext, default_name=default_name, saved_full_path=saved_full_path, preselected_azienda_cod_orig=preselected_azienda_cod, preselected_adempimento_cod_orig=preselected_adempimento_cod): try: # corpo funzione ... except Exception as e: print("Errore in aggiorna_percorso:", e)
Probabile causa specifica del blocco:
Il problema più frequente è che
preselected_azienda_codopreselected_adempimento_codsianoNone, quindi la condizione:if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_pathva a dare accesso a variabili
Nonenon paragonabili coerentemente, oppuresaved_full_pathèNonee non trattato.
Ti consiglio quindi:
- Aggiungi stampa di debug sulla prima riga della funzione:
print(f"Debug aggiorna_percorso: azienda={var_azienda.get()}, adempimento={var_adempimento.get()}") print(f"preselected_azienda_cod_orig={preselected_azienda_cod_orig}, preselected_adempimento_cod_orig={preselected_adempimento_cod_orig}") print(f"saved_full_path={saved_full_path}")- E vedi cosa viene stampato prima che la GUI sparisca. Se vedi errore, correggi.
Riassunto
- Inserisci try/except + stampe di debug in
aggiorna_percorso. - Verifica che variabili esterne - specialmente
preselected_azienda_cod_origepreselected_adempimento_cod_orig- siano correttamente definite nel contesto della funzione callback. - Se serve, passale come argomento predefinito a
aggiorna_percorsoper "chiarire" il loro scope. - Se vuoi, incollami errori esatti che vedi in output o comportamenti, ti aiuto a fare debug più preciso.
Se vuoi, ti invio un codice aggiornato completo con queste correzioni per la funzione
custom_save_gui.
Fammi sapere! - Inserisci un blocco try/except interno all’interno della funzione
- User
non compare la nostra gui
- Assistant
Capito, la GUI proprio non compare, quindi probabilmente l’applicazione si blocca prima che
root.mainloop()venga chiamato o la finestra è subito chiusa.
Passi fondamentali per risolvere
Verifica 1 - Eventuali errori silenti
Prima di tutto, assicurati che eventuali eccezioni durante l'inizializzazione della GUI non blocchino l'apertura.
Inserisci all'inizio della funzione
custom_save_gui(subito dopodef custom_save_gui(...)):try: import traceback except ImportError: pass try: # tutto il codice di custom_save_gui dentro questo try root = tk.Tk() # ... resto del codice ... except Exception as e: print("ERRORE in custom_save_gui:", e) try: traceback.print_exc() except Exception: pass return None, None, NoneIn questo modo se c'è un errore durante la creazione della GUI, lo vedrai.
Verifica 2 - Stampo cosa succede all'entrata ed in
aggiorna_percorsoSubito dentro
custom_save_gui:print("custom_save_gui: avviata") print(f"Parametri: default_ext={default_ext}, default_name={default_name}, initial_folder={initial_folder}, saved_full_path={saved_full_path}")E dentro
aggiorna_percorso:def aggiorna_percorso(*args): try: print(f"aggiorna_percorso eseguita: azienda={var_azienda.get()}, adempimento={var_adempimento.get()}") # Resto del codice... except Exception as e: print("Errore in aggiorna_percorso:", e)
Verifica 3 - Controlla come definisci
preselected_azienda_cod_orig, ecc.Nel tuo codice hai:
preselected_azienda_cod = None preselected_adempimento_cod = None # poi eventualmente li valorizzi da DB.Quando usi questi dentro
aggiorna_percorsodevono essere dichiarati come variabili esterne o passati come argomenti.
Per sicurezza fai così incustom_save_gui:preselected_azienda_cod_orig = preselected_azienda_cod preselected_adempimento_cod_orig = preselected_adempimento_codSubito prima di
aggiorna_percorso, così hanno valore definito.
Verifica 4 - Passa tutte le variabili usate nella closure come parametri di default
Questo è il modo più stabile in tkinter per evitare problemi di scope:
def aggiorna_percorso(*args, aziende=aziende, adempimenti=adempimenti, var_azienda=var_azienda, var_adempimento=var_adempimento, var_folder=var_folder, var_filename=var_filename, default_ext=default_ext, default_name=default_name, saved_full_path=saved_full_path, preselected_azienda_cod_orig=preselected_azienda_cod_orig, preselected_adempimento_cod_orig=preselected_adempimento_cod_orig): try: print(f"aggiorna_percorso: azienda={var_azienda.get()}, adempimento={var_adempimento.get()}") # codice già noto precedentemente ... except Exception as e: print("Errore in aggiorna_percorso:", e)
Verifica 5 -
root.attributes("-topmost", True)potrebbe nascondere la finestraIn rari casi il flag
-topmostpuò far aprire finestre "sotto" o problemi di focus.Per debug prova a togliere/modificare:
# root.attributes("-topmost", True)oppure metti dopo
root.focus_force()anche:root.deiconify() root.lift()
Codice esempio minimo con modifica corretta
Ti propongo un esempio minimo e funzionante della parte GUI con gestione
saved_full_pathe debug che puoi incollare e provare standalone dalla tua funzione:def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None): import tkinter as tk from tkinter import ttk, messagebox, filedialog import os import sqlite3 print("custom_save_gui: avviata") print(f"default_ext={default_ext}, default_name={default_name}, initial_folder={initial_folder}, saved_full_path={saved_full_path}") root = tk.Tk() root.title("Salvataggio personalizzato") root.geometry("700x250") # root.attributes("-topmost", True) # Prova a commentare questo se GUI non appare # Dummy dati simulati (sostituisci con fetch tuoi dal DB) aziende = [(1, "Azienda Alfa"), (2, "Azienda Beta")] adempimenti = [ (101, "Adempimento Uno", "cartella1", "nomefile1.txt"), (102, "Adempimento Due", "cartella2", "nomefile2.txt"), ] var_azienda = tk.StringVar(value=aziende[0][1]) var_adempimento = tk.StringVar(value=adempimenti[0][1]) var_folder = tk.StringVar(value=initial_folder or os.getcwd()) var_filename = tk.StringVar(value=default_name) preselected_azienda_cod_orig = aziende[0][0] preselected_adempimento_cod_orig = adempimenti[0][0] def aggiorna_percorso(*args, aziende=aziende, adempimenti=adempimenti, var_azienda=var_azienda, var_adempimento=var_adempimento, var_folder=var_folder, var_filename=var_filename, default_ext=default_ext, default_name=default_name, saved_full_path=saved_full_path, preselected_azienda_cod_orig=preselected_azienda_cod_orig, preselected_adempimento_cod_orig=preselected_adempimento_cod_orig): try: print(f"aggiorna_percorso: azienda={var_azienda.get()}, adempimento={var_adempimento.get()}") azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get()) codice_az = azienda_selezionata[0] ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get()) codice_ad, descrizione_ad, cartella_salvataggio, nome_file = ademp_selezionato full_folder_path = os.path.join(os.getcwd(), cartella_salvataggio) var_folder.set(full_folder_path) if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path: filename = nome_file if nome_file.strip() else default_name else: filename = os.path.basename(saved_full_path) if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename) except Exception as e: print("Errore in aggiorna_percorso:", e) combo_aziende = ttk.Combobox(root, values=[a[1] for a in aziende], textvariable=var_azienda, state='readonly') combo_aziende.pack(padx=10, pady=10, fill='x') combo_adempimenti = ttk.Combobox(root, values=[a[1] for a in adempimenti], textvariable=var_adempimento, state='readonly') combo_adempimenti.pack(padx=10, pady=10, fill='x') tk.Label(root, text="Cartella di destinazione:").pack(anchor='w', padx=10) folder_entry = tk.Entry(root, textvariable=var_folder, width=80) folder_entry.pack(padx=10, pady=5, fill="x") tk.Label(root, text="Nome file:").pack(anchor='w', padx=10) filename_entry = tk.Entry(root, textvariable=var_filename, width=80) filename_entry.pack(padx=10, pady=5, fill="x") btn_conferma = tk.Button(root, text="Conferma", command=root.destroy) btn_conferma.pack(pady=10) var_azienda.trace_add('write', aggiorna_percorso) var_adempimento.trace_add('write', aggiorna_percorso) # Avvio aggiornamento iniziale aggiorna_percorso() filename_entry.focus_set() root.focus_force() root.mainloop() # Qui ritorna valori fittizi per esempio full_path = os.path.normpath(os.path.join(var_folder.get(), var_filename.get())) azienda_cod = next(a[0] for a in aziende if a[1] == var_azienda.get()) ademp_cod = next(a[0] for a in adempimenti if a[1] == var_adempimento.get()) return full_path, azienda_cod, ademp_cod
Prova a eseguire questo codice da solo.
Se funzionerà, allora il problema è altrove nel contesto.
Conclusione
- Inserisci stampe di debug ovunque
- Gestisci eccezioni nel callback della GUI
aggiorna_percorso - Assicurati che i valori usati siano definiti e non None
- Verifica il flag
-topmost - Prova codice ridotto isolato come sopra
Se vuoi, ti aiuto a integrare step by step.
Fammi sapere! - User
preselected_azienda_cod_orig = preselected_azienda_cod preselected_adempimento_cod_orig = preselected_adempimento_cod
se la selezione avviene dopo come lo gestisci
- Assistant
Ottima domanda: se le variabili
preselected_azienda_codepreselected_adempimento_codvengono valorizzate dopo, cioè non subito all’apertura della GUI ma dopo una chiamata a DB o altro, bisogna gestire questo scenario per usare correttamente il "valore originale" di partenza.
Perché serve memorizzare i valori "originali"?
Il meccanismo che ti ho suggerito in precedenza si basa sul confronto dei valori attuali di combo-box con quelli iniziali per decidere se usare il nome passato da salvataggio precedente o il nome da DB:
- Se l’utente non cambia azienda/adempimento: mostri nome salvato
- Se l’utente cambia: mostri nuovo nome da DB
Quindi il valore "originario" va stabilito una volta sola, all’avvio, per poter fare il confronto.
Se la selezione arriva dopo?
Hai alcune opzioni pratiche:
Opzione 1: Memorizza "al volo" al primo aggiornamento
All’avvio della GUI la variabile
preselected_azienda_codpotrebbe essere None.
Inaggiorna_percorsopuoi fare così:# Dentro custom_save_gui, fuori aggiorna_percorso preselected_azienda_cod_orig = None preselected_adempimento_cod_orig = None def aggiorna_percorso(*args): nonlocal preselected_azienda_cod_orig, preselected_adempimento_cod_orig try: azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get()) codice_az = azienda_selezionata[0] ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get()) codice_ad = ademp_selezionato[0] # Se non ancora valorizzati, li imposto ora come valori originali if preselected_azienda_cod_orig is None: preselected_azienda_cod_orig = codice_az if preselected_adempimento_cod_orig is None: preselected_adempimento_cod_orig = codice_ad # Ora proseguo con la logica precedente... if (codice_az != preselected_azienda_cod_orig) or (codice_ad != preselected_adempimento_cod_orig) or not saved_full_path: filename = ademp_selezionato[3] if ademp_selezionato[3].strip() else default_name else: filename = os.path.basename(saved_full_path) if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename) except Exception as e: print("Errore in aggiorna_percorso:", e)Vantaggi:
- La prima volta che la funzione è chiamata
preselected_...vengono settati ai valori correnti della selezione. - I successivi confronti sono comparazioni contro questi valori “a regime”.
- Funziona anche se la selezione prevista arriva dopo qualche secondo (ad esempio caricamenti DB).
Opzione 2: Forzare il valore originario prima di aprire la GUI
Se sai che per esempio
preselected_azienda_codepreselected_adempimento_codpossono arrivare solo dopo una chiamata al DB asincrona o successiva, aspetta di averli prima di aprire la GUI, es:while preselected_azienda_cod is None or preselected_adempimento_cod is None: time.sleep(0.1) # ora avvia custom_save_gui con questi valori già definiti. ... # Oppure passa già dentro custom_save_gui i valori originari come parametro aggiuntivo
Opzione 3: Passa esplicitamente valori originari validi a
custom_save_guiModifica la signature di
custom_save_gui:def custom_save_gui(default_ext, file_types, default_name, initial_folder=None, saved_full_path=None, preselected_azienda_cod_orig=None, preselected_adempimento_cod_orig=None): ...E dentro
aggiorna_percorsoin questo modo:def aggiorna_percorso(*args): ... if preselected_azienda_cod_orig is None: # Se non disponibile prendo valore dalla combinazione corrente (o altra logica) preselected_azienda_cod_orig = codice_az if preselected_adempimento_cod_orig is None: preselected_adempimento_cod_orig = codice_ad # il resto come sopra
Consiglio
Se la selezione predefinita arriva dopo l’apertura GUI, in generale meglio far partire la GUI solo dopo che le informazioni siano disponibili, o almeno passare esplicitamente i valori originali per evitare ambiguità.
Se ciò non è possibile, l’opzione 1 con memorizzazione “al volo” è comunque abbastanza funzionale e semplice da implementare.
Se vuoi posso aiutarti con la modifica del codice completo in base alla soluzione che preferisci. Fammi sapere!
- User
la tua logica non funziona, perche poi richiede anche il percorso. la cosa più sensata è salvare il nome fil in una varibale e qualora si faccia più volte salva con nome usa sempre lo stesso nome per quel file
- Assistant
Perfetto, grazie per la precisazione!
Hai ragione: se il tuo obiettivo è più semplice — ovvero che alla seconda (e successive) chiamate di "salva con nome" per lo stesso file venga riproposto sempre lo stesso nome file usato al primo salvataggio, indipendentemente da azienda o adempimento — allora:
La soluzione più semplice:
-
Mantieni in memoria (ad esempio in
unique_id_to_save_data) il percorso (o solo il nome file) associato a quelunique_id(cioè a quel processo o flusso di lavoro). -
Quando richiami la GUI, se questo valore è presente, passa quel nome/file salvato come valore iniziale da mostrare (in
var_filename). -
Semplicemente evita di sovrascrivere quel valore con il nome preso dal DB.
Esempio di modifica essenziale
In
monitor_save_dialog(), quando chiamicustom_save_gui(), passa:saved_path = unique_id_to_save_data.get(unique_id) # percorso completo default_name = None initial_folder = None if saved_path: initial_folder = os.path.dirname(saved_path) default_name = os.path.basename(saved_path) ext = detect_default_extension(process_name) if not default_name.lower().endswith(ext.lower()): default_name += ext else: ext = detect_default_extension(process_name) default_name = "file" + extQuindi chiami:
result = custom_save_gui(ext, [], default_name, initial_folder)
Nel
custom_save_gui()NON sovrascrivere più il valore
var_filenamedentro la funzioneaggiorna_percorso()!Invece di fare:
filename = nome_file if nome_file.strip() else default_name var_filename.set(filename)fai solo:
# Solo all'avvio (all'inizio di custom_save_gui) var_filename = tk.StringVar(value=default_name) # e in aggiorna_percorso NON modificare più var_filenameO più semplicemente toglie la riga che sovrascrive la variabile con il nome da DB.
Perché funziona?
-
Il nome passato come
default_nameè sempre quello originario salvato (se esiste), quindi la GUI parte sempre da quel nome. -
Non viene più sostituito in automatico in base ad azienda/adempimento.
Codice riassuntivo semplificato in
custom_save_guivar_filename = tk.StringVar(value=default_name) # Impostato solo all'inizio, mai più modificato def aggiorna_percorso(*args): try: # aggiorna solo var_folder e altre cose, ma NON var_filename azienda_selezionata = next(a for a in aziende if a[1] == var_azienda.get()) codice_az = azienda_selezionata[0] ademp_selezionato = next(a for a in adempimenti if a[1] == var_adempimento.get()) cartella_salvataggio = ademp_selezionato[2] conn = sqlite3.connect(DB_FILE) c = conn.cursor() c.execute("SELECT root FROM aziende WHERE codice=?", (codice_az,)) root_path = c.fetchone() conn.close() root_path = root_path[0] if root_path else os.getcwd() full_folder_path = os.path.join(root_path, cartella_salvataggio) os.makedirs(full_folder_path, exist_ok=True) var_folder.set(full_folder_path) except Exception: pass
In sintesi:
-
L’impostazione ed eventuale aggiornamento del nome file è solo all’inizio con il nome già salvato.
-
Successive modifiche alla combo di azienda / adempimento non cambiano il nome file.
Se vuoi posso anche prepararti un esempio di patch completa da integrare.
Dimmi se ti va bene così!
-
- User
COSA FA QUESTA parte di codice : filename = nome_file if nome_file.strip() else default_name if not filename.lower().endswith(default_ext.lower()): filename += default_ext
var_filename.set(filename) - Assistant
Questa parte di codice:
filename = nome_file if nome_file.strip() else default_name if not filename.lower().endswith(default_ext.lower()): filename += default_ext var_filename.set(filename)fa le seguenti cose:
-
Seleziona il nome file da usare (
filename):- Controlla se la variabile
nome_file(solitamente il nome file predefinito preso dal database o da qualche fonte) contiene una stringa non vuota (usando il metodo.strip()che rimuove spazi bianchi agli estremi). - Se
nome_filenon è vuoto, allorafilenameviene impostato anome_file. - Altrimenti (
nome_fileè vuoto o costituito da soli spazi),filenameviene impostato adefault_name(un nome file di default passato alla funzione).
- Controlla se la variabile
-
Verifica ed eventualmente aggiunge l’estensione al nome file:
- Controlla se il nome file (
filename) termina già con l’estensionedefault_ext(ignorando maiuscole/minuscole). - Se non termina con
default_ext, l’estensione viene aggiunta alla fine del nome file.
- Controlla se il nome file (
-
Imposta il valore della variabile Tkinter
var_filename:var_filenameè unaStringVarche controlla il contenuto di un campo di testo (ad es. la casella di testo dove mostrare/modificare il nome del file nella GUI).- Con
var_filename.set(filename)aggiorna quel campo con il nome file appena calcolato.
In sintesi:
- Imposto un nome file da mostrare, scegliendo tra quello “standard” (
nome_file) o uno di default - Controllo che il nome file abbia l’estensione giusta, la aggiungo se manca
- Aggiorno il campo testo della GUI con quel nome file
Se vuoi, posso aiutarti anche a rivedere questa logica per farla più robusta o più adatta al tuo caso d’uso!
-