Python e il multiprocess

[nickGiard]

Salve a tutti gli utenti di OpenOffice e LibreOffice
Nell'uso di Calc devo sviluppare delle analisi e dei calcoli sulle celle del foglio.
Ho scoperto l'enorme potenzialità velocità e semplicità di affiancare Python al Basic.
in Basic le seguenti istruzioni che riporto se utili a qualcuno, provvedono ad un ponte tra i due ambienti:

Codice: Seleziona tutto

Function LanciaPyFunct(sFilePy , funct , args As Array)
    'sFilePy = "MyPyFunct.py" ' modulo implementato della mia dir LibreOffice/4/user/Scripts/python
    'funct = MPS ' la mia funzione nel modulo MyPyFunct.py
   ' args = Array(par1, par2, ...) i parametri della funzione funct
    sFunctionPy = "vnd.sun.star.script:" & sFilePy & "$" & func & _
            "?language=Python&location=user" 
    oMSPF = createUnoService( _
         "com.sun.star.script.provider.MasterScriptProviderFactory") 
    gScriptProvider = oMSPF.createScriptProvider("") 
    oScript = gScriptProvider.getScript(sFunctionPy)
    pyReturn = oScript.invoke(args, Array(), Array())

Tutto funziona alla perfezione, e poichè l'appetito vien mangiando, ho pensato di implementare il
multiprocessing di python con la funzione pool, semplice da utilizzare. Ad esempio in Python l'esempio
più semplice ,senza parametri, che funziona perfettamente lanciata in un editor di Python

Codice: Seleziona tutto

import multiprocessing
def MP(x): 
    return x * x

def MPS():
    oPool = multiprocessing.Pool() #multiprocessing.
    aResults = oPool.map( MP, (1, 2, 3, 4, 5, 6, 7, 8) )
    oPool.close()
    return aResults # tupla dei quadrati dei numeri
    pass

Lanciata da Basic come LanciaPyFunct(sFilePy , "MPS", Array()) da un errore, sintetizzato:
'Error 1 calling MPS
Type: com.sun.star.uno.RuntimeException
(<class 'AttributeError'>:'module' object has no attribute 'argv' ...

Qualcuno è in grado di esporre qualche considerazione ???
Io ho verificato che lanciando da Python, vengono creati tanti ulteriori processi autonomi python.exe pari ai processori del PC.
Forse LibreOffice non riesce a creare tali processi con un python all'interno del proprio processo ???

Grazie per eventuali approfondimenti
Nicola Giardinelli

[charlie]

Ciao e bentornato sul forum.
Se intanto ti vuoi ripresentare puoi farlo qui: viewforum.php?f=16
Per una panoramica delle regole consulta il Manuale di sopravvivenza.
Sei pregato di usare le opzioni formattazione del codice, grazie.
Buon proseguimento.

[nickGiard]

Grazie Charlie che mi hai sistemato la mail.
Ti confesso che sono piu' avvezzo ad esaminare post che scriverne, per cui ho poca dimestichezza con i formati.
Ne approfitto per segnalare che uso Windows7 64bit con LibreOffice 5.3.
Ti ringrazio in anticipo, se riesci a veicolare questa mia su altre posizioni.
Il tema proposto mi sembra interessante, perchè non ho trovato nulla che approfondisca il multi-threading e il multiprocesso gestito da libreOffice, che pure contiene i rispettivi moduli nella sua distribuzione in C:\Program Files\LibreOffice 5\program\python-core-3.3.0.
Questi aspetti se conosciuti potrebbero aumentare di molto la 'reputazione dello splendido Open-Libre Office
Grazie Nicola

[hubert lambert]

Ciao Nicola,

Non ho mai riuscito a far funzionare il package "multiprocessing" dall'interno di OpenOffice o LibreOffice. Non so dov'è il problema.
Invece il package "threading" funziona bene. Forse sarebbe una soluzione anche per te...
Comunque conosci l'estenzione APSO ?
Saluti.

[nickGiard]

Ciao Hubert
grazie per la tua informazione su "threading", non l'avevo mai provata avendo letto che tale tecnologia in realtà non accelera il tempo complessivo di elaborazione, in quanto il processore suddivide la sua operatività in maniera concorrente tra i Threads. Vedere invece i processi moltiplicarsi col numero dei processori non ti nascondo che mi emoziona, anche se ovviamente poi occorre considerare il tempo di avvio dei processi e della lettura da parte di ciascuno di essi dell'intero modulo che contiene il multiprocessing !!
L'estensione APSO è molto utile per ispezionare gli script python, infatti l'ho installata, sono riuscito a far partire Geany settato come default per python, ma questo non è un debugger e quindi non riesco a fare il debug.
Secondo me sarebbe eccezionale far girare il package "multiprocessing", visto che viene distribuito con LibreOffice, e quindi penso che ci sarà un modo per attivarlo!!!
Ancora grazie per il tuo intervento!
Nicola

[vladboscaneanu]

Salve a tutti.
Volevo solo aggiungere che python per LibreOffice/OpenOffice è un po modificato, non essendo una versione come quella che conosciamo noi.
Ad esempio mancano delle librerie, che dal punto di vista degli sviluppatori non sono necessari, tipo sqlite3 oppure tkinter.
Per quello che riguarda il multiprocess : una delle condizioni, per far girare il modulo multiprocess sarebbe da eseguirlo direttamente dal modulo , non come
parte importata (la famosa condizione if __name__ == 'main' ), vedi la documentazione ufficiale.
Invece se si piazza un file python nella cartella di LibreOffice, (se non sbaglio C:\Program Files\LibreOffice 5\share\Scripts\python ),con il codice:

Codice: Seleziona tutto

def print_name():
    ''' Stampa il __name__ del modulo'''
    model=XSCRIPTCONTEXT.getDesktop().loadComponentFromURL(
            "private:factory/swriter","_blank", 0, ())
    text=model.Text.End.String = __name__

eseguendolo, nel nuovo documento Writer viene fuori non il nome "main", ma "ooo_script_framework"...magia pura.
A questo punto consiglierei come alternativa il modulo multiprocessing.dummy,un altro splendido strumento
che supporta tutte le istruzioni di suo fratello maggiore multiprocessing.
Per lo sviluppo e debug del codice python in LibreOffice, vi consiglio vivamente PyCharm, che nel Runtime mostra le proprietà e tutti
i metodi disponibile.

[hubert lambert]

Ciao vladboscaneanu,

Ad esempio mancano delle librerie, che dal punto di vista degli sviluppatori non sono necessari, tipo sqlite3 oppure tkinter.

Infatti. Altro esempio : il package multiprocessing non contiene il modulo Pool nella versione di LibreOffice.

Per quello che riguarda il multiprocess : una delle condizioni, per far girare il modulo multiprocess sarebbe da eseguirlo direttamente dal modulo , non come
parte importata (la famosa condizione if __name__ == 'main' ), vedi la documentazione ufficiale.
Invece se si piazza un file python nella cartella di LibreOffice, (se non sbaglio C:\Program Files\LibreOffice 5\share\Scripts\python ),con il codice:

Codice: Seleziona tutto

def print_name():
    ''' Stampa il __name__ del modulo'''
    model=XSCRIPTCONTEXT.getDesktop().loadComponentFromURL(
            "private:factory/swriter","_blank", 0, ())
    text=model.Text.End.String = __name__

eseguendolo, nel nuovo documento Writer viene fuori non il nome "main", ma "ooo_script_framework"...magia pura.

Altro esempio ancora, che può anche spiegare il problema: il valore di sys.executable non è "python.exe" ma... "soffice.bin"!

A questo punto consiglierei come alternativa il modulo multiprocessing.dummy,un altro splendido strumento
che supporta tutte le istruzioni di suo fratello maggiore multiprocessing.

Grazie per la dritta, non conoscevo quello .

[nickGiard]

Carissimi
Grazie per gli interventi, che aggiungono tasselli a questo puzzle .
In effetti sarebbe bello trovare una pubblicazione che spiegasse innanzitutto le differenze operative tra threading.py e multiprocessing.pool.py e il multiprocessing usando i threads fornito da multiprocessing.dummy ed i vantaggi in velocità. Mi sono fatto l'idea che Libre Office riesce a far girare dentro il suo processo solo i threads, ma questi essendo comunque concorrenti riescono a velocizzare o no l'elaborazione di grosse quantità di dati ?
Alla fine probabilmente la risposta corretta è che ogni ambiente è progettato per determinati obiettivi e che le 'grosse' elaborazioni ( ad es. leggere ed elaborare un prezzario di opere pubbliche in xml di 20 mila voci ) è bene sia fatto con strumenti idonei quali direttamente in python.
Grazie per l'indicazione di usare multiprocessing.dummy , vedrò di fare dei test.
Saluti da Nicola

[giuserpe]

Ciao nickGiard,
io sviluppo - ma "sviluppo" è una grossa forzatura - un'estensione per LibreOffice che potrebbe interessarti. Si tratta di LeenO Computo Metrico Assistito http://leeno.org.
Ho affrontato la questione multiprocess tempo fa. Qui di seguito un esempio:

Codice: Seleziona tutto

class XPWE_import_th(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        XPWE_import_run()
def XPWE_import(arg=None):
    XPWE_import_th().start()

Non chiedermi di più, rischierei figuracce.
Sto lavorando a LeenO da tre anni, ormai solo in Python. L'intento è di implementare nuove funzionalità e tradurre il vecchio codice Basic lasciando a questo la grafica dei riquadri di diaologo e poco altro.

[giuserpe]

Ciao,
LeenO è "software coperto da licenza LGPL, pertanto liberamente scaricabile ed utilizzabile per tutti gli usi" e in quanto estensione per LibreOffice, viene interpretato direttamente da sorgenti, che rilascio anche su github https://github.com/giuserpe/leeno/branches oltre che sul sito ufficiale delle estensioni per LibreOffice

Per tornare al discorso di nickGiard

Mi sono fatto l'idea che Libre Office riesce a far girare dentro il suo processo solo i threads, ma questi essendo comunque concorrenti riescono a velocizzare o no l'elaborazione di grosse quantità di dati ?

per velocizzare le operazioni in LibreOffice io uso spesso questa macro:

Codice: Seleziona tutto

def dlg_attesa(msg=''):
    '''
    definisce la variabile globale oDialogo_attesa
    che va gestita così negli script:
    
    oDialogo_attesa = dlg_attesa()
    attesa().start() #mostra il dialogo
    ...
    oDialogo_attesa.endExecute() #chiude il dialogo
    '''
    psm = uno.getComponentContext().ServiceManager
    dp = psm.createInstance("com.sun.star.awt.DialogProvider")
    global oDialogo_attesa
    oDialogo_attesa = dp.createDialog("vnd.sun.star.script:UltimusFree2.DlgAttesa?language=Basic&location=application")

    oDialog1Model = oDialogo_attesa.Model # oDialogo_attesa è una variabile generale
    
    sString = oDialogo_attesa.getControl("Label2")
    sString.Text = msg #'ATTENDI...'
    oDialogo_attesa.Title = 'Operazione in corso...'
    sUrl = LeenO_path()+'/icons/attendi.png'
    oDialogo_attesa.getModel().ImageControl1.ImageURL=sUrl
    return oDialogo_attesa

che poi avvio come thread all'inizio e termino alla fine di altre macro in questa maniera:

Codice: Seleziona tutto

def XPWE_in(arg=None):
    oDoc = XSCRIPTCONTEXT.getDocument()
    oDialogo_attesa = dlg_attesa('Caricamento dei dati...')
    [...]
    [righe e righe di codice...]
    [...]
    oDialogo_attesa.endExecute()

Questo metodo ha l'effetto di impedire all'utente di interferire nel foglio di calcolo durante il lavoro della macro.
Ad onor del vero ho la sensazione che non velocizzi un granché, ma almeno previene "incidenti" in corso d'opera.

Più threads che lavorano insieme manomettendo lo stesso file di Calc mi sembra una situazione improbabile, ma potremmo approfondire in discorso...

Nel tempo, poi, mi sono accorto che una netta accelerazione durante operazioni lunghe e laboriose, si ottiene portando al massimo lo zoom di Calc con

Codice: Seleziona tutto

oDoc.CurrentController.ZoomValue = 400

prima di dare il via al lavoro della macro.

In fine ho prodotto una piccola macro che fa questo:

Codice: Seleziona tutto

def refresh(arg=1):
    '''
    Abilita / disabilita il refresh per accelerare le procedure
    '''
    oDoc = XSCRIPTCONTEXT.getDocument()
    if arg == 0:
        oDoc.CurrentController.ZoomValue = 400
        oDoc.enableAutomaticCalculation(False) # blocco il calcolo automatico
        oDoc.addActionLock()
        oDoc.lockControllers #disattiva l'eco a schermo
    elif arg == 1:
        oDoc.CurrentController.ZoomValue = 100
        oDoc.enableAutomaticCalculation(True) # sblocco il calcolo automatico
        oDoc.removeActionLock()
        oDoc.unlockControllers #attiva l'eco a schermo

ma spesso mi limito a combinare solo queste righe:

Codice: Seleziona tutto

oDoc.CurrentController.ZoomValue = 400
oDoc.enableAutomaticCalculation(False) 

Poco a che fare col MULTIPROCESS.

P.S.: Un'ultima cosa che ho sempre trattenuto, ma questa sera il contesto è propizio: OpenOffice si scrive tutto attaccato come LibreOffice.
A voler essere precisini ed anche antipatici va sottolineato che si scrive e si dice Apache OpenOffice che deriva da OpenOffice.org, ma si è allontanato anche di parecchio dallo spirito libero che interpretata questo. Spirito libero che LibreOffice interpreta ancora in pieno proprio per una questione di licenze.

e vabbé, invece che lavorare al nuovo rilascio di LeenO, stasera è andata così...
a presto

[charlie]

Ciao charlie, ....

Altro che "prodotto commerciale". Capisco che hai potuto fraintendere, ma modificando il mio post potresti aver indotto in fraintendimenti anche gli altri avventori...

La presenza di "prezziari" sul sito e la fretta mi hanno indotto in errore. Ho ripristinato il link soppresso e mi scuso con te e con tutti gli altri utenti del forum.

[giuserpe]

Ciao charlie,
bene, allarme rientrato. Grazie.
Sì, infatti i prezzari di cui si parla sono (ma purtroppo spesso sarebbero) open data.

[nickGiard]

Ciao giuserpe
grazie per i tuoi interventi, mi hanno dato degli utili suggerimenti.
La tua architettura per LeenO mi sembra vincente, un'interfaccia LO ed un motore, integrato, in Python.
Nel passato avevo creato un VB.net che agganciava e gestiva Excel e Word, per la mia mania di sviluppare ed automatizzare i computi metrici e la contabilità lavori.
Ora di nuovo tento di fare qualcosa in LibreOffice, senza la pretesa di un prodotto competo ed articolato come mi sembra sia LeenO, che a breve mi riprometto di approfondire.
Resta che il tema di base, come approcciarsi e su quali schemi di sviluppo orientarsi per accelerare l'ambiente, rimane aperto.
Sempre in tema di interazione Basic-Python, e per la mia scelta di mantenere i due ambienti separati, in quanto la cosa era veloce anche in ambiente vb.net-excel, estraggo dal foglio Calc un array bidimensionale con oRg.DataArray, lo passo come parametro alla funzione Python che fa le opportune elaborazioni, restituendo al chiamante un array (tupla di tuple) che viene infine riallocato in Calc.
Buon lavoro con LeenO
Nicola

[nickGiard]

Buon giorno a tutti.
L'argomento LibreOffice Python multiprocess mi sembra sempre interessante e ringrazio per le risposte avute e il tempo dedicato.
Mi sembra importante ora fare una comunicazione: ho appena installato la versione LibreOffice 5.4.5 che porta con se l'aggiornamento a Python 3.5.0, e , sorpresa il modulo multiprocessing.Pool non esiste più!!!!
Forse non era funzionante con LibreOffice ???? Mahh
Un saluto
nickGiard

[vladboscaneanu]

Io c'e l'ho ancora, LibreOffice 6, python 3.5.4
________________________________________________________