nuzzopippo said @ 2024-02-15 11:38:29:

I miei saluti.
A scopo meramente ludico mi sto studiando la libreria fpdf2, finalizzando alla produzione di moduli tabellari con font e stili scelti dall'utente, la scelta dei fonts avviene per "famiglie" di font selezionate in ambiente tkinter.
Nell'approccio con fpdf2 ho constatato che, necessariamente, deve essere fornito "il file" da utilizzare per la composizione dei testi, specifico per lo stile di testo applicato, essendo la libreria non in grado di operare con la generica fornitura di font-family e style.
Ho, pertanto, iniziato a studiarmi una metodologia per identificare files di font soddisfacenti le scelte utente tra quelli registrati nel sistema, correntemente nel solo linux ma che spero, in seguito, di ampliare anche al mondo windows. Al momento provvedo ad estrarre l'intero set di font rilevati nel sistema tramite fc-list (ho trovato scoraggianti fc-match e fcpatterformat non conoscendo i parametri da applicare di volta in volta) in un subprocess e, quindi, utilizzando il modulo python "fontmeta" per estrarne i metadati e selezionare i file tramite i campi "font_family" e "subfamily"
... certamente l'utilizzo di "fontmeta" non è il massimo, limitando i caratteri gestibili ai soli TrueType ed OpenType ma bene o male può andare, in genere i caratteri di altra codifica (p.e. i Type1) hanno corrispondenze in una delle due tipologie, anche se alcuni, tipo il "Gargi" in esempio sotto

...
font_family            : गार्गी
subfamily              : गार्गी
unique_font_identifier : FontForge : Gargi_1.10v : 12-3-2012
full_font_name         : Gargi
version                : Version 2.0 
postscript_name        : Gargi
...

non so proprio come intercettarli, dato i caratteri "esotici" utilizzati nel compilare a detti campi.

Comunque, pur ritenendo tutto sommato veniali le problematiche sopra esposte, mi sono imbattuto in alcune casistiche che mi lasciano perplesso circa le metodologie che sto implementando.

La prima : le "famiglie" di font solitamente sono definite con file specifici per i caratteri "normale", "grassetto", "corsivo" e "grassetto-corsivo", detti stili son definiti nel campo "subfamily" MA NON HANNO una indicazione uniforme, tanto meno mi è riuscito di trovare una specifica delle definizioni.
Al momento, ho definito un insieme di variabili globali

NORMAL = ['Regular', 'Normal', 'Roman', 'Book']
BOLD = ['Bold','Gras']
ITALIC = ['Italic', 'Italique', 'Oblique']

di appoggio che però non sono esaustive, alcune delle definizioni trovate non ho neanche saputo ove porle.
Qui viene la prima domanda: qualcuno di Voi conosce e saprebbe indicarmi una specifica esaustiva per gli stili di testo? ... o almeno suggerire delle integrazioni?

Altra problematica è data dai file stessi, sul mio sistema (ubuntu con aggiornamenti dalla versione 16 alla 22) coesistono versioni multiple di file con della stessa "famiglia" e stile, sparsi in varie directory, di sistema o locali all'user, rispondenti ad una ricerca ... certo, posso applicare il primo trovato od anche utilizzare le directory di sistema, anche se in esse sono presenti più file soddisfacenti contemporaneamente i requisiti (tipo i fonts Microsoft)
La seconda domanda è : qualcuno conosce l'argomento e saprebbe indicarmi la documentaione da consultare (sperando non sia troppo "laboriosa") e/o suggerimenti?
Per eventuali interessati, il modulo di lavoro sviluppato al momento (work.py) è il seguente:

# -*- coding: utf-8 -*-

import subprocess
from fontmeta import FontMeta

NORMAL = ['Regular', 'Normal', 'Roman', 'Book']
BOLD = ['Bold','Gras']
ITALIC = ['Italic', 'Italique', 'Oblique']

def get_fonts_linux_system() -> list:
    ''' Estrae i fonts registrati in un sistema linux '''
    p = subprocess.check_output('fc-list', stderr=subprocess.STDOUT)
    fonts_data = p.decode('UTF-8').splitlines()
    fonts = []
    for f in fonts_data:
        f_name = f.split(':')[0]
        fonts.append(f_name)
    fonts.sort()
    return fonts

def get_data_file(fname: str) -> dict:
    ''' Estrae i metadati di un file TrueType o OpenType '''
    data = None
    try:
        fm_i = FontMeta(fname)
        data = fm_i.get_data()
    except:
        pass
    return data

def get_from_family(fam: str, style: bool=False,
                    bold: bool=False, italic: bool=False) -> list:
    ''' Estrae i font registrati con famiglia e stile selezionati '''
    fonts = get_fonts_linux_system()
    founds = []
    for f in fonts:
        fname = f.rstrip('\n')
        try:
            fm_i = FontMeta(fname)
            data = fm_i.get_data()
            if data['font_family'] == fam:
                passed = False
                if style:
                    stl = data['subfamily']
                    if not bold and not italic:
                        if stl in NORMAL: passed = True
                    elif bold and italic:
                        st = stl.split()
                        if (len(st) == 2 and (st[0] in BOLD or st[0] in ITALIC)
                            and (st[1] in BOLD or st[1] in ITALIC)):
                            passed = True
                    else:
                        if bold:
                            if stl in BOLD: passed = True
                        elif italic:
                            if stl in ITALIC: passed = True
                else:
                    passed = True
                if passed: founds.append(f)                        
        except:
            pass
    return founds

e funziona con la funzione "get_from_family" che richiede l'elenco dei file a "get_fonts_linux_system" per poi processarli singolarmente richiedendo, per ciascuno di essi, i metadati a "get_data_file" per poi valutarne i metadati in base alle opzioni passate quali parametri.

... se qualcuno è interessato alla finestra (tkinter) di test lo faccia sapere che la posto, sono circa 280 righe di codice e non ho ritenuto fosse al momento necessaria.

Grazie dell'attenzione

nuzzopippo said @ 2024-04-29 15:37:53:

trescon said @ 2024-04-29 15:12:35:

.... ho avuto un'idea ora .... e se io invece di avere un notifica facessi aggiornare la mia interfaccia costantemente ??? ogni 30/40 secondi ?? potrei avere dei blocchi ?? rallentamenti ??
In pratica sostituire l'aggionramento che ora faccio io manualmente con un ciclo/timer ??? A cosa potrei andare in contro ??
Potrei trovarmi a non riuscire ad usare l'interfaccia perchè l'aggiornamento è in corso ??

Scusate se intervengo sulla domanda posta a @Daniele.


Le due modalità che ti ho mostrato funzionano entrambe, non Ti vanno bene? Magari è l'uso delle classi che "ostacola"?

In ogni caso, Ti segnalo che puoi anche utilizzare il metodo "after" (ci avevo già accennato) delle finestre tkinter per far si che un metodo/funzione richiami se stesso ogni tot di tempo restando nel ciclo idle di tkinter, con database consistenti o con reti intasate potrebbero succedere dei congelamenti temporanei della gui (motivo per il quale preferisco i thread), comunque potresti provare anche quello, magari Ti va bene.

Quanto su ad integrazione di quanto prima fatto.




Non di meno, pur considerando ottima l'indicazione di @Daniele, la "comunicazione remota" riproporrebbe in ogni caso il problema del refresh della finestra se la view fosse una finestra grafica, entrerebbero comunque in gioco i tempi necessari alla lettura dei dati ed alla comunicazione, temo.

Daniele aka Palmux said @ 2024-02-29 18:22:04:

Beh potresti avere ritardi nella scrittura, ma non credo altri disagi visti gli accessi esigui.

Penserei di implementare un sistema un po' diverso, con il database trasparente per gli utenti. Si accederebbe solo la tua macchina, tramite magari un web-framework alla FastAPI (che è semplicissimo), ricevendo/esponendo/scrivendo le richieste poi dal/al DB. In questo modo potresti gestirti in maniera piuttosto semplice anche le code in entrata e non aver paura di qualche perdita accidentale.

utenti <--> framework <--> database

Però certo, capisco quello che stai pensando, se è una singola riga con 10 valori... beh beh beh disse la pecora, forse la fatica supera il gusto e lascerei il tutto come è adesso.

Ma chissà, vedi tu quanto ti vuoi ancora divertire, sarebbe una cosa non necessaria, ma una scusa per imparare una cosa nuova.

Cya

Ciao Daniele, ho rivisto su tuo suggerimento questo post e sarei d'accordo con te se non fosse per tre motivi :




1- la scrittura, lettura,modifica stato dei messaggi è tutto già funzionante (sono quasi 15 gg che lo testo, solo che quando mi inseriscono un nuovo messaggio mi avvisano perchè io lanci la rilettura del db dalla mia postazione, mi manca solo la notifica !!! :confused




2 - il secondo motivo di disaccordo è che vorrei prima riuscire a fare andare tutto quello che ho fatto prima di imbarcarmi in altre procedure partendo da zero.




3 - la mia macchina non è sempre accesa (se non ci sono è spenta), e quindi il sistema non funzionerebbe.




.... ho avuto un'idea ora .... e se io invece di avere un notifica facessi aggiornare la mia interfaccia costantemente ??? ogni 30/40 secondi ?? potrei avere dei blocchi ?? rallentamenti ??

In pratica sostituire l'aggionramento che ora faccio io manualmente con un ciclo/timer ??? A cosa potrei andare in contro ??

Potrei trovarmi a non riuscire ad usare l'interfaccia perchè l'aggiornamento è in corso ??




Intanto grazie

nuzzopippo said @ 2024-04-24 17:51:03:

trescon said @ 2024-04-24 15:18:35:

... troppo sofisticato x me (almeno a prima vista); appena ho un attimo lo studiero attentamente ed eventualmente ti chiedero' lumi.

Fermo restando che sono a Tua disposizione per quel che posso, ciò che scrivi probabilmente denuncia una qualche pecca nella mia capacità di esposizione, essendo la mia conoscenza tutt'altro che sofisticata ... in fondo, la mia partecipazione ai post's è anche motivata proprio dal bisogno di "carpire" idee e tecniche che non conosco ancora.

Digerisci tranquillamente il codice con calma, poi, se e quando Lo riterrai se ne discute, son certo che si può far di meglio, magari discutendone lo scopriamo assieme il "come".




Ciao

async def controlla():
	for i in range(1, 30):
        print(f"conta: {i}")
        await asyncio.sleep(1)

async def main():
	task = asyncio.create_task(controlla())
	await task

asyncio.run(main())

nuzzopippo said @ 2024-04-22 13:45:25:

trescon said @ 2024-04-21 22:03:24:

Ciao Nuzzopippo, se non ti è di troppo disturbo ..... CERTO che accetto un esempio esemplificato. Sono settimane che sono fermo con il "progetto" perchè non riesco a trovare come incastrare Tkinter con una routine che interviene ogni 4-6 secondi.

Disturbo?, no, nessun disturbo, anzi, mi permette di scrostare la ruggine dal mio cervello di pensionato.




Non so se quello che Ti propongo sia un sistema di "pushing" del tipo indicato da @Palmux, è una metodologia che ho sviluppato nel corso del tempo per applicazioni che non richiedano aggiornamenti frenetici dei dati e si basa su di un oggetto singleton cui è possibile iscrivere dei metodi/funzioni di parti di una propria applicazione agente in thread separati in "gruppi" di osservatori che si scambiano messaggi (liste di dati in realtà) tra di loro.




Puoi vedere qui l'esempio che Ti ho preparato, consiste in una finestra che espone dei messaggi non letti inseriti in un database SQLite3 minimale, più o meno sulla falsa riga di come indicato da @Daniele posts fa, i messaggi sono da inserire esternamente, in una shell SQLite nel caso.

L'applicazione è composta da tre piccoli moduli, ognuno "specializzato" per un compito: comunicazione, lettura dati, esposizione e comando.

L'interazione tra le parti avviene tramite i "messaggi", che ho provato a spiegare, spero mi sia riuscito di essere chiaro.




Se ci sarà bisogno di chiarimenti, a disposizione, se riterrete, Tu e gli esperti, di farmi sapere cosa ne pensate mi farà piacere.

Ciao

nuzzopippo said @ 2024-04-15 10:27:16:

trescon said @ 2024-04-10 22:53:58:

Ciao, il mio problema ora è di far convivere nello stesso script l'interfaccia tkinter (che so essere task monopolizzate) e la routine che devo eseguire ogni 30/60 secondi per vedere se ci sono messaggi nuovi.
Come posso fare a far eseguire il task per la verifica finchè ho l'interfaccia tkinter in esecuzione ?

I Miei saluti.




Segnalo che venerdì scorso, ad un mio tentativo (piuttosto voluminoso) di rispondere al quesito soprastante, si è avuta una anomalia che ha creato un riferimento senza titolo ed a me intestato nella sezione "database", non accessibile e visibile alla pagina di riepilogo delle sezioni, questo perché possano, eventualmente, prendersi provvedimenti inerenti.




Per il problema di @trescon, provo s rispondere ora in maniera succinta.

Hai diverse metodologie a disposizione, la più "immediata" (e forse problematica) è di creare un metodo/funzione che richiami ricorsivamente se stessa ogni tot di tempo utilizzando il metodo "after" delle finestre tkinter.

Personalmente evito di utilizzare la metodologia sopra, nel tempo ho preso l'abitudine, per situazioni non critiche, di utilizzare thread in parallelo, con un protocolli di comunicazione utilizzanti il pattern observer ed un intermediario di tipo singleton per lo smistamento delle comunicazioni, di norma senza l'uso di queue (dato che parlo di sistemi non critici) ... ho cercato di esemplificare in dettaglio ma sono intervenuti i problemi su detti.

Se ritieni Ti bisogni un esempio di tal genere fai sapere che cercherò di implementare un esempio minimale a Tuo uso e vedrò di spiegarlo altrove e poi vedo di renderlo disponibile.




Ciao

Daniele aka Palmux said @ 2024-04-05 08:56:53:

trescon said @ 2024-04-04 17:48:19:

Buonasera, da prove fatte sembre funzionare senza errori di accessi simultanei…. Ora il problema è diverso.
Avendo il db che lavora in solitaria su un Nas, ora sorge il problema di avvisare l’utente destinatario dell’ultimo messaggio inviato al db. (Che è arrivato un nuovo messaggio x lui)

Come posso fare ?

Interrogare ogni tot secondi per verificare la presenza di messaggi nuovi da parte di tutte le postazioni coinvolte?

Come posso fare a capire se il messaggio è nuovo ? Nei campi del db non è previsto un campo ora ma solo la data. (Dovrei fare un confronto con uno stato precedente ….)

Grazie per i suggerimenti che riuscirete a darmi.

Ciao caro, potresti creare uno mini script che verifica la presenza di nuovi messaggi ogni tot tempo e poi, non so come è composto il tuo enviroment, si potrebbe "pushare" chi di dovere con la notifica del nuovo messaggio, ma devi implementare un mini sistema di pushing o magari usare altri servizi già pronti all'uso. Ma forse si sta sparando al moscerino col fucile da elefanti, in effetti potresti fare come hai descritto, lasciare che ogni postazione controlli ogni tot di tempo se ci sono nuovi messaggi, tanto hai poche postazioni se ricordo bene.

Per sapere se il messaggio è letto o meno guarda non impazzire, metti semplicemente uno status che una volta letto cambia lo stato del messaggio, identificando così se è letto o meno. Se non vuoi cambiare le tabelle attuali, aggiungine una con l'id del messaggio ed il suo status, che cambierai a seconda delle attività dell'utente. Metodo semplice ed efficace.

Hai davvero diverse strade davanti a te, devi solo provare a vedere quella più facile da realizzare ed a liberare la fantasia.

Buon divertimento e happy coding.