estrarre parametri da una funzione

[maresama]

inspect serve quando una funzione viene usata. (so benissimo come funziona e l'ho usata, ed è molto utile)
Ma il problema è diverso: estrarre i parametri da una stringa contenente la funzione:
es: da "ff(par1,par2=2, par3='aaa,bbb,ccc',par4=[aaa,bb,cc])"
-> [par1.
par2=2,
par3='aaa,bbb,ccc',
par4=[aaa,bb,cc]
]
ossia una lista con i parametri suddivisi (l'ho scritta così per una maggiore leggibilità)
Grazie. Ciao

[maresama]

C'è qualcosa che non va nel forum? o sbaglio qualcosa?

ieri sera ho scritto una risposta però se vado a leggere i post non la trovo
ho pensato: forse non ho dato il comando per scrivere
vado per riscriverla.... e la trovo come ultimo post (l'ho copiata e riportata qua sotto)
come è possibile?
perchè non me la da come ultima quando vado a leggere normalmente? (nb: ho provato più volte: nei post non c'è ma se vado a rispondere compare)
Ora invio il post e poi vado nuovamente a vedere

risposta a RAI:
inspect serve quando una funzione viene usata. (so benissimo come funziona e l'ho usata, ed è molto utile)
Ma il problema è diverso: estrarre i parametri da una stringa contenente la funzione:
es: da "ff(par1,par2=2, par3='aaa,bbb,ccc',par4=[aaa,bb,cc])"
-> [par1.
par2=2,
par3='aaa,bbb,ccc',
par4=[aaa,bb,cc]
]
ossia una lista con i parametri suddivisi (l'ho scritta così per una maggiore leggibilità)
Grazie. Ciao

[maresama]

chiedo umilmente scusa: ho capito (problema di stanchezza o di demenza senile?)
leggendo i post non ho fatto caso che erano più pagine e dovevo andare avanti nel leggere!
povero me !!!!

[melfnt]

Tranquillo maresama.

Per RAI: stiamo valutando entrambe le strade: quella di parsare la stringa di questo formato "f(par1,par2,par3)" e quella di fare qualcosa direttamente da dentro python.

Per la prima questione, siamo quasi arrivati alla soluzione (:

per la seconda, una complicazione è data dal fatto che le funzioni sono su un altro file sorgente, quindi bisognerebbe prima importarlo come modulo, poi usare inspect, oppure il metodo suggerito da me (__code__.co_varnames e __defaults__).
inspect non lo conoscevo, da quello che ho capito dal tuo esempio funziona sicuramente molto meglio, perché gestisce anche *args e **kwargs. Grazie mille della dritta, dopo mi leggo la documentazione (:

[maresama]

io sono tranquillo.... anche perchè a modo mio l'ho risolto
Quello che non riesco a far capire che è la stringa con la funzione che va elaborata. Non è una funzione da eseguire!!!.
Ricavare i valori con inspect è fuori luogo.
Lo so già quello che si può fare con inspect (e lo faccio). Ma qui non serve!
Anche volessi dovrei ogni volta mettere dei parametri per eseguire la funzione trovata nella stringa: e con che parametri?: ma se sono proprio quelli che devo ricavare dalla stringa!. I parametri che io indico sono solo un esempio: non è che si chiamino veramente par1,par2 ecc! Sono proprio i nomi che devo estrarre!
Unica soluzione, sicuramente meglio della mia (che però mi sembra vada abbastanza bene), è il parsing.
E su questo eravamo abbastanza concordi. Io mi chiedevo proprio come sostituire la mia funzione (un pseudo parsing) con un vero parsing che però non ho mai fatto e non so come farlo.
Ciao

[rai]

Anche volessi dovrei ogni volta mettere dei parametri per eseguire la funzione trovata nella stringa: e con che parametri?: ma se sono proprio quelli che devo ricavare dalla stringa!. I parametri che io indico sono solo un esempio: non è che si chiamino veramente par1,par2 ecc! Sono proprio i nomi che devo estrarre!

Ma allora, scusa se non capisco, quello che devi ottenere non sono i parametri (con eventuale default) presenti della definizione di una funzione ma proprio gli argomenti con cui la funzione viene invocata? Cioè il valore che ognuno dei parametri prende a runtime?

[maresama]

Esatto: leggo da un file .py una riga contenente una funzione (a parte i problemi di separarla da altre istruzioni) e dalla stringa con una sola funzione, ossia nome(parametri), devo avere tutti i nomi dei parametri indicati.
Quindi non devo eseguirla: devo solo separare i vari parametri.
Ma non basta fare uno split per le virgole che li separano perchè di virgole ve ne possono essere nei valori stessi dei parametri. Ad esempio:
(..,par5=(aaaa,bbb,ccc),par6="123,45",...)
Come ho gia scritto io uso una mia funzione che lo fa, ma volevo solo sapere se c'era qualcosa di già fatto in Python
Ciao

[TommyB1992]

Due righe di codice potevi anche provare a scriverle:

https://pastebin.com/raw/mBVbuNsP

[melfnt]

Due righe di codice potevi anche provare a scriverle:

https://pastebin.com/raw/mBVbuNsP

Secondo me usare le espressioni regolari in questo caso è come sparare ad una mosca con un bazooka. Per estrarre solo la parte fra le parentesi più esterne della funzione bastava usare split e rsplit

Poi penso che l'ultimo * debba essere un ?

[TommyB1992]

Secondo me usare le espressioni regolari in questo caso è come sparare ad una mosca con un bazooka. Per estrarre solo la parte fra le parentesi più esterne della funzione bastava usare split e rsplit

Lo puoi fare come preferisci, se volevamo realmente usare la meta-programmazione allora non avrei neppure dovuto usare gli if per delimitare le condizioni...

Poi penso che l'ultimo * debba essere un ?

yep, ho scritto in fretta, oppure {0,1}, oppure (r)split, come OP preferisce

[maresama]

x TommyB1992:
quello che apprezzo di più nelle tue risposte è il garbo....

Nella tua soluzione mi sembra che non siano previsti i literal... (es: ,par5='aaa,bbb,ccc')
e non so se prevede \" o \'
Non ho tempo per le prove...

Con 'Due righe potevi anche ecc..' non penso ti riferissi a me:
Se invece proprio ti riferisci a me, ti consiglio di rileggere bene tutti i post. Vedrai che due righe le ho scritte.... e funzionano al 99%
Sempre se li trovi comprensibili.

[TommyB1992]

Se invece proprio ti riferisci a me, ti consiglio di rileggere bene tutti i post. Vedrai che due righe le ho scritte.... e funziono al 99%

Yep my fault this time.

Nella tua soluzione mi sembra che non siano previsti i literal... (es: ,par5='aaa,bbb,ccc')

Codice: Seleziona tutto

def parseF(func):
    """Parser for the arguments of string functions.
    
    Keyword arguments:
    func -- the name of function, valids formats are:
            aaaa(pa1, par2=par2, par3=(aaa,bbb), par4=[1,2,3,4])
            def bbbb(pa1, par2={1: "x"}, par3=(aaa,bbb), par4=[1,2,3,4])
    """
    p = [[]]
    i = 0

    _round = 0
    _square = 0
    _curly = 0
    single_quotes = False
    double_quotes = False
    for char in func[func.find("(") + 1:func.rfind(")")]:
        if char == "(":
            _round += 1
        elif char == ")":
            _round -= 1
        elif char == "[":
            _square += 1
        elif char == "]":
            _square -= 1
        elif char == "{":
            _curly += 1
        elif char == "}":
            _curly -= 1
        elif char == "'":
            single_quotes = not single_quotes
        elif char == '"':
            double_quotes = not double_quotes

        if char != "," or _curly > 0 or _square > 0 or _round > 0:
            p[i].append(char)
        if char == "," \
           and single_quotes == double_quotes == False \
           and _curly == _square == _round == 0:
            p.append([])
            i += 1

    return ["".join(v).strip() for v in p]


if __name__ == "__main__":
    from pprint import pprint

    pprint(parseF("aaaa(';', par2=par2, par3=(aaa,bbb), par4=[1,2,3,4])"))

[maresama]

Però seguita a non andare

Codice: Seleziona tutto

def parseF(func):
    """Parser for the arguments of string functions.
   
    Keyword arguments:
    func -- the name of function, valids formats are:
            aaaa(pa1, par2=par2, par3=(aaa,bbb), par4=[1,2,3,4])
            def bbbb(pa1, par2={1: "x"}, par3=(aaa,bbb), par4=[1,2,3,4])
    """
    p = [[]]
    i = 0

    _round = 0
    _square = 0
    _curly = 0
    single_quotes = False
    double_quotes = False
    for char in func[func.find("(") + 1:func.rfind(")")]:
        if char == "(":
            _round += 1
        elif char == ")":
            _round -= 1
        elif char == "[":
            _square += 1
        elif char == "]":
            _square -= 1
        elif char == "{":
            _curly += 1
        elif char == "}":
            _curly -= 1
        elif char == "'":
            single_quotes = not single_quotes
        elif char == '"':
            double_quotes = not double_quotes
        if char != "," or _curly > 0 or _square > 0 or _round > 0:
            p[i].append(char)
        if char == "," \
           and single_quotes == double_quotes == False \
           and _curly == _square == _round == 0:
            p.append([])
            i += 1
    return ["".join(v).strip() for v in p]



#  prova:
w= parseF("aaaa(pa1, par2=par2, par3=(aaa,bbb), par4=[1,2,3,4], par5='aaa,bbb,ccc'")

for n,x in enumerate(w):
   print n,x

# risultato:
#    0 pa1
#    1 par2=par2
#    2 par3=(aaa,bbb

A parte questo, io chiedevo se c'era qualcosa in Python già fatto.
Quello che tu proponi è una funzione simile alla mia (la mia non prevede \' e \" perchè non ho assolutamente pensato a questa possibilità, Vedrò di implementarle)
La mia richiesta era fatta nell'ipotesi che la mia funzione poteva non coprire tutta la casistica (in effetti \' \"). Invece se c' era una funzione python (che invece sembra non esista) mi sarei sentito più tranquillo.
Ovviamente il rischio permane anche con la tua funzione (sicuro che preveda tutta la casistica?).
Ciao.

[TommyB1992]

Ovviamente il rischio permane anche con la tua funzione (sicuro che preveda tutta la casistica?).

Boh... prova a fare due prove...

Comunque: https://pastebin.com/raw/F2zdz4Yv
c'era una mancanza nel codice precedente

Invece se c' era una funzione python

Non c'è per il semplice motivo che ciò che stai facendo, è piuttosto raro, se non unico. (E non credo nel senso positivo del termine)

Comunque non te la prendere male, come persone (virtualmente) mi stai anche simpatico, ma ciò che stai facendo è discutibile.

[maresama]

Sono contento di sapere che tu sei sicurissimo di aver previsto tutta la casistica
Io non mi ritengo così bravo. La sicurezza posso averla solo dopo tantissime e svariatissime prove (e non due..)
Se è così, ti proporrò come il più esperto del forum (la domanda è sul forum proprio in questi giorni)

Sapere se quello che faccio sia interessante o importante, non credo ti riguardi
Oltretutto tu non lo sai e quindi il tuo giudizio mi pare fuori luogo

Il fatto che la funzione Python ci sia o meno, forse sarà perché c'è qualcosa di livello
più alto (parsing) che guarda caso fa proprio quello
Ed io avevo proprio chiesto informazioni su quello...

Ma forse la cosa più giusta sarebbe di stare al problema ed evitare commenti:
Se non hai capito il problema: chiedi
Se sei in grado di aiutare: intervieni
Se intervieni (e questo sarebbe il massimo): oltre alla soluzione o alla correzione,
spiegare, gentilmente senza essere presuntuosi, per arricchire chi sta imparando
(un esempio da seguire: Claudio_F)

Ciao

[TommyB1992]

ahuauhahuahu

dai se ti sentito offeso ti chiedo scusa
Io tendo a rispondere molto ironicamente, sul forum magari non si capisce, ma il mio tono sarcastico e il mio modo di fare sono rivolti anche contro me stesso (infatti non faccio altro che auto-percularmi).

Sono contento di sapere che tu sei sicurissimo di aver previsto tutta la casistica

Eh solo che non funziona così, apposta esistono le fasi di alpha, di beta, pre-alpha, etc...
Ovviamente si cercano di stimare tutte le casistiche, ma spesso, non ci si riesce. Perciò si rilascia la release (o si utilizza in loco se è closed) e quando si presenta un problema si corregge nel tempo...

Sapere se quello che faccio sia interessante o importante, non credo ti riguardi
Oltretutto tu non lo sai e quindi il tuo giudizio mi pare fuori luogo

Si va beh... ma sbattitene... se sei convinto di stare nel giusto che ti frega del giudizio espresso
Poi non dico non sia importante o interessante, dico sia concettualmente opinabile (e per quel basta vedere i tuoi source code)

[melfnt]

Versione che parsa la stringa, controllando che le parentesi siano bilanciate:

Codice: Seleziona tutto

def valid_parenthesis_pair ( a, b ):
    '''
      @params a,b two strings

      @returns true iff a is an open parenthesis and b is its the corresponding closed parenthesis.

      examples:
      valid_parenthesis_pair ("(",")") returns true
      valid_parenthesis_pair ("{","}") returns true
      valid_parenthesis_pair (")", "[") returns false
      valid_parenthesis_pair ("]", "[") returns false
    '''
    parenthesis_dict = {"(":")", "[":"]", "{":"}"}
    return a in parenthesis_dict and parenthesis_dict[a]==b

def parse ( string ):
    '''
      @param string
      a string that represents a python function definition or invocation
      valid formats: 
        "def f( par1, par2=[1,2,3], par3='ciao')"
        "f (par1, par2=[[1,2],[3],[4,5,6]], par3='ciao\"')"
      
      @returns names,values lists of strings
      names is the parameters name list
      values is the values list

      @raises ValueError if the parenthesis are unbalanced

      examples: 
      parse ("def f( par1, par2=[1,2,3], par3='ciao')")
      returns (["par1","par2","par3"],["","[1,2,3]","ciao"])

      parse ("f (par1, par2=[[1,2],[3],[4,5,6]], par3='ciao\"')")
      returns (["","par2","par3"],["par1","[[1,2],[3],[4,5,6]]", 'ciao\"'])

      parse ("f(par1=[[)])")
      raises ValueError
    '''
    param_string = string.split("(",1)[1].rsplit(")",1)[0]
    
    open_stuff_stack = []
    args_list = []
    current_param = ""

    for (i,c) in enumerate (param_string):
        
        print ("[DEBUG] parsing character {} at position {}".format(c,i))

        if len(open_stuff_stack)>0 and (open_stuff_stack[-1]=="'" or open_stuff_stack[-1]=='"'):
            print ("[DEBUG] case 1 - inside quotes")
            if not param_string[i-1]=="\\" and c==open_stuff_stack[-1]: 
                open_stuff_stack.pop ()
                print ("[DEBUG]   case 1A - exiting quotes")
            else:
                print ("[DEBUG]   case 1B ignoring any quoted character")
            
            current_param += c

        elif i>0 and ( c=="'" or c=='"') and not param_string[i-1]=="\\":
            open_stuff_stack.append (c)
            current_param += c
            print ("[DEBUG] case 2 - entering quotes")
        
        elif c in ["(", "[", "{"]:
            open_stuff_stack.append(c)
            current_param += c
            print ("[DEBUG] case 3 - entering parenthesis")
 
        
        elif c in [")", "]", "}"]:
            print ("[DEBUG] case 4 - exiting parenthesis")
            if len(open_stuff_stack) > 0 and valid_parenthesis_pair (open_stuff_stack[-1],c):
                open_stuff_stack.pop()
                current_param += c
                print ("[DEBUG]   case 4A - correctly balanced parenthesis")
            else:
                print ("[DEBUG]   case 4B - malformed string (unbalanced parenthesis)")
                msg = "String is malformed: unexpected token {} in position {}".format(c,i)
                raise ValueError (msg)

        elif c == ",":
            print ("[DEBUG] case 5 - colon")
            if len(open_stuff_stack)>0:
                current_param += c
                print ("[DEBUG]   case 5A - does not break parameter")
            else:
                print ("[DEBUG]   case 5B - breaks parameters. current_param: {}".format(current_param))
                args_list.append(current_param)
                current_param = ""
        
        else:
            print ("[DEBUG] case 6 - any other char")
            current_param += c

        print ("[DEBUG] parsing finished, open_stuff_stack: {}, current_param {}".format(open_stuff_stack,current_param))
   
    if len(current_param.strip()) > 0:
        args_list.append (current_param)

    names = []
    values = []

    for arg in args_list:
        arg_split = arg.split("=",1)
        if len(arg_split) == 2:
            names.append( arg_split[0].strip() )
            values.append ( arg_split[1].strip() )
        elif string.startswith("def"):
            names.append( arg_split[0].strip() )
            values.append ("")
        else:
            names.append ("")
            values.append ( arg_split[0].strip() )

    return names,values


if __name__ == "__main__":

    test_strings = ["aaaa(pa1, par2=par2, par3=(aaa,bbb), par4=[1,2,3,4])",
                    'f ( par1, par2=[[0],[1],[2]], par3="ciao[]", par4=5)',
                    'f ( par1, par2=[(1,], par3=(4,5,6)) )',
                    'f ( par1="questa è un apice \\" escapato", par2=5)',
                    "f (par1='stringa con \" apici', par2=5) ",
                    "def f( par1, par2=[1,2,3], par3='ciao')",
                    "f (par1, par2=[[1,2],[3],[4,5,6]], par3='ciao\"')",
                    "def foo (par1=[[1,)], par2=5)",  
                    ]
    
    for string in test_strings:
        print ("TESTING {}".format(string))

        try:
            names, values = parse (string)
            for i,(n,v) in enumerate (zip (names,values)):
                print ("parameter {}: name {} value {}".format(i,n,v))
        except ValueError as e:
            print ("raised {}".format(e))


        print ("******************")

Sia output che codice sono volutamente prolissi per mostrare come funziona il parsing. La funzione solleva un errore se le parentesi non sono bilanciate (ma ci sono altri modi in cui la stringa potrebbe essere malformata che non testo).
Se volete vedere soltanto i test case senza scritte di debug, basta eseguire il programma in pipe con grep -v DEBUG:

Codice: Seleziona tutto

$ python parse_string.py | grep -v 'DEBUG'
TESTING aaaa(pa1, par2=par2, par3=(aaa,bbb), par4=[1,2,3,4])
parameter 0: name  value pa1
parameter 1: name par2 value par2
parameter 2: name par3 value (aaa,bbb)
parameter 3: name par4 value [1,2,3,4]
******************
TESTING f ( par1, par2=[[0],[1],[2]], par3="ciao[]", par4=5)
parameter 0: name  value par1
parameter 1: name par2 value [[0],[1],[2]]
parameter 2: name par3 value "ciao[]"
parameter 3: name par4 value 5
******************
TESTING f ( par1, par2=[(1,], par3=(4,5,6)) )
raised String is malformed: unexpected token ] in position 16
******************
TESTING f ( par1="questa è un apice \" escapato", par2=5)
parameter 0: name par1 value "questa è un apice \" escapato"
parameter 1: name par2 value 5
******************
TESTING f (par1='stringa con " apici', par2=5) 
parameter 0: name par1 value 'stringa con " apici'
parameter 1: name par2 value 5
******************
TESTING def f( par1, par2=[1,2,3], par3='ciao')
parameter 0: name par1 value 
parameter 1: name par2 value [1,2,3]
parameter 2: name par3 value 'ciao'
******************
TESTING f (par1, par2=[[1,2],[3],[4,5,6]], par3='ciao"')
parameter 0: name  value par1
parameter 1: name par2 value [[1,2],[3],[4,5,6]]
parameter 2: name par3 value 'ciao"'
******************
TESTING def foo (par1=[[1,)], par2=5)
raised String is malformed: unexpected token ) in position 9
******************

Il parsing funziona come ho spiegato nel primo post: scorre un carattere alla volta, se trova una parentesi aperta la mette in cima allo stack delle cose aperte. Se trova una parentesi chiusa, controlla che corrisponda all'elemento in cima allo stack delle cose aperte (per esempio, una chiusa quadra non può chiudere una aperta graffa). Se le parentesi non sono ben bilanciate, lancia un ValueError, altrimenti rimuove il primo elemento dalla cima dello stack e va avanti.
Le virgole separano i parametri solo se lo stack è vuoto.

(:

[maresama]

Grazie !!!!
Era proprio quello che volevo capire e vedere
In effetti la mia funzione fa le stesse cose ed ha lo stesso comportamento, ma lo fa in modo diverso.
Purtroppo per due o tre giorni non ho tempo disponibile (ripeto purtroppo) ma appena posso mi guardo bene quello che hai fatto
Sei stato estremamente collaborativo e costruttivo. Te ne sono grato
Penso anche che quello che hai fatto possa essere utile anche ad altri (ovviamente per altri problemi...)
Ciao.