Discussion :

[pilpoil123]

Bonjour tout le monde!

Je me prend la tête avec les regexp sur un truc simple...

J'essaye de matcher un groupe entre <<<%% et %%>>>.
Du coup j'ai ecris :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
>>>def foo(match):
...    print("{}\t{}\t{}".format(match.group(0),match.group(1),match.group(2)))
...    return "OK!!!!!"
...
>>>l__string="debut bla bla <<<%%le match goup%%>>>bli bli fin"
>>>l__reRes = re.sub(r"(.*)<<<\%\%(\w*)\%\%>>>(.*)",foo, l__string)

et ... rien. Je ne passe pas dans foo()
Pourquoi tant de haine ?

[wiztricks]

Salut,

Je ferais ainsi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import re
 
PATTERN = '<<<\%\%(\w*)\%\%>>>'
 
def foo(matchobj):
    match = matchobj.group(0)
    if match == '<<<%%toto%%>>>':
        return 'TITI'
    else: return match
 
replace = lambda s : re.sub(PATTERN, foo, s)
 
print replace('123<<<%%tutu%%>>>xyz')
print replace('123<<<%%toto%%>>>xyz')

- W

[pilpoil123]

Merci !
Je peux effeectivement passer par là. L'idée fonctionnelle est (en simplifiée):
Dans un fichier j'ai des trucs comme "Bonjour <<<%%Dest_Name%%>>>, votre courrier du <<<%%Aff_Date%%>>>..."
Je lis la ligne du courrier et doit produire : "Bonjour M. Client, votre courrier du 12/12/12..."
du coup je dois virer les tags d'ouverture "<<<%%" et fermeture "%%>>>" et modifiant l'intérieur. En procédant par groupes :
- le groupe avant(.*)
- le groupe match(\w*)
- le groupe apres(.*)
il me suffisait (dans foo) de retourner qqchose comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

match.group(0)+dico[match.group(1)]+match.group(2)

Cela dit, merci. Ta solution me permet d'avancer mais je ne comprend pas pourquoi la mienne ne fonctionne pas
Son interet etant que foo n'a pas a connaitre les tags utilisés et devient générique

[wiztricks]

Salut,

L'idée fonctionnelle est (en simplifiée):
Dans un fichier j'ai des trucs comme "Bonjour <<<%%Dest_Name%%>>>, votre courrier du <<<%%Aff_Date%%>>>...

Je lis la ligne du courrier et doit produire : "Bonjour M. Client, votre courrier du 12/12/12..."
du coup je dois virer les tags d'ouverture "<<<%%" et fermeture "%%>>>" et modifiant l'intérieur

Ci dessous je remplace les tags de la forme <<<%%TOKEN%%>>> par $(TOKEN)s, i.e. par des tags que le formatteur de chaines de caractères sait reconnaitre. Le 'texte' soumis est donc transformé en 'template'.

=> Il serait peut être astucieux de voir si vous ne pourriez pas construire vos 'tags' sous une forme 'acceptable' par un gestionnaire de template 'normal'. Ce qui éviterait de remplacer des tags par des tags.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import re
 
PATTERN = '<<<\%\%(\w*)\%\%>>>'
def foo(matchobj):
    token = matchobj.group(1)
    return '%%(%s)s' % token
 
replace = lambda s : re.sub(PATTERN, foo, s)
 
test_string = "<<<%%Dest_Name%%>>>, votre courrier du <<<%%Aff_Date%%>>>..."
template = replace(test_string)
Dest_Name = 'Mr.Toto'
Aff_Date = '16 Mai 2010'
print template % vars()

- W

[pilpoil123]

En fait j'utilise deja les string template. J'ai décris mon probleme de façon simplifié (pour alléger le propos ) mais dans sa globalité je dois traiter (à l'interieur de mes tags) des expressions plus complexes qu'une simple substitution de variable. Je dois pouvoir aussi accepter un appel de fonction python.

Mon fichier input contient :
1 <<<%%Paris le ${Aujourdhui},%%>>>
2 Comme convenu ...
3 <<<%%${Dest_Name}, votre courrier du ${Aff_Date} est traité dans ...%%>>>
4 ...
5 et nous avons le plaisir de vous informer que les produits :
6 <<<%%__liste_produit('${NCommand}')%%>>>
7 vous serons livrés comme prévu.
8 ...
Dans les lignes 1, 3 et 6 la substition s'applique d'abord par la methode substitute de la classe Template sur la base d'un dico pour les clefs qui figurent entre {}. Cela permet de "tagger" le fichier de façon simplifié (marquage de ligne), sauf si le tag contient un appel de fonction (comme __liste_produit à la ligne 6) où là il borde l'appel.
Du coup mon code (python 3.1) :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from string import Template
 
def __TemplateReplaceCallback(i__match):
 
    global g__TMPLVars
 
    l__tmpl = Template(i__match.group(1))
    l__buffer = l__tmpl.substitute(**g__TMPLVars)
    l__buffer = eval(l__buffer, locals(), globals())
 
    return i__match.group(0)+l__buffer+i__match.group(2);
 
 
def instanciateTemplate(i__templateFile, i__instanceFile):
    l__regExp = "(.*)<<<\%\%(\w*)\%\%>>>(.*)"
 
    l__file_tmpl = open(i__templateFile,"r")
    if(l__file_tmpl):
        l__file_out = open(i__instanceFile,"w")
        if(l__file_out):
            l__lines = l__file_tmpl.readlines()
            for line in l__lines :
                line = re.sub(l__regExp, __TemplateReplaceCallback, line)
                l__file_out.write(line)
            l__file_out.close()
        l__file_tmpl.close()

Dans la fonction __TemplateReplaceCallback "l__tmpl.substitute(**g__TMPLVars)" traite les substitution de variable et "eval(l__buffer, locals(), globals())" effectue l'appel de fonction si present.

wouala donc pourquoi je dois traiter par regExp. Je dois faire en sorte que la fonction __TemplateReplaceCallback ne connaisse rien du tag et reste generique.

Wouala vous savez tout !
Donc, ma question: "Pourquoi l__regExp = "(.*)<<<\%\%(\w*)\%\%>>>(.*)" ne match pas?"

Merci de votre aide...

[dahtah]

Salut,
j'ai lu en diagonale, mais ça serait pas plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print("{}\t{}\t{}".format(match.group(1),match.group(2),match.group(3)))

que tu voudrais ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

match.group(0)

te renvoi l'ensemble de la chaîne matchante.

Chez moi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
>>> f = "123<<<%%tutu%%>>>xyz"
>>> g = re.match(r"(.*)<<<%%(\w*)%%>>>(.*)", f)
>>> g.group(1)
'123'
>>> g.group(2)
'tutu'
>>> g.group(3)
'xyz'
>>> g.group(0)
'123<<<%%tutu%%>>>xyz'
>>> g.group()
'123<<<%%tutu%%>>>xyz'

[pilpoil123]

heuu oui peut être, mais là n'est pas la question.
Ma question porte sur le pattern pour matcher le contenu entre <<<%% et %%>>>



cela dit dans un pattern comme "(.?)<<<\%\%(\w+)\%\%>>>(.?)" il existe 3 groupes et donc le group(0) concerne la partie avant le pattern et group(1) concerne le contenu qui m'interesse

Merci.

[wiztricks]

Salut,

Ma question porte sur le pattern pour matcher le contenu entre <<<%% et %%>>>

Pour ce qui est de re.sub, le pattern est '<<<\%\%(\w*)\%\%>>>' et çà vous retournera group(0) l'ensemble de et group(1) l'intérieur.

cela dit dans un pattern comme "(.?)<<<\%\%(\w+)\%\%>>>(.?)" il existe 3 groupes et donc le group(0) concerne la partie avant le pattern et group(1) concerne le contenu qui m'interesse

Pour re.match peut être, mais pour re.sub?
- W
PS: et je persiste à penser que des gestionnaires de templates 'normaux' font déjà cela très bien et qu'il serait préférable de s'aligner la dessus à la génération de vos fichiers.

[dahtah]

cela dit dans un pattern comme "(.?)<<<\%\%(\w+)\%\%>>>(.?)" il existe 3 groupes et donc le group(0) concerne la partie avant le pattern et group(1) concerne le contenu qui m'interesse

Non, justement. group(0) te renvoi l'ensemble de la chaîne matchante. Les groupes commencent ensuite à 1. group(2) sera la partie qui t'intéresse.

Ma question porte sur le pattern pour matcher le contenu entre <<<%% et %%>>>

Suffit d'enlever les parenthèses groupantes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
.?<<<\%\%(\w+)\%\%>>>.?

Là, group(1) renverra la partie attendue.
Bon courage

[pilpoil123]

A wiztricks : Je suis d'accord pour ta remarque concernant les gestionnaires de template (preuve je les utilise) mais a ma connaissance ils ne gèrent pas l'appel de fonction et m'obligent donc à continuer sur la base d'une recherche de tag et de l'interpretation specifique d'un contenu type "code python"

A dahtah : Biin j'ai beau essayer ca ne marche pas comme tu dis:

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> def foo(match):
...     print("{}\t{}".format(match.group(0),match.group(1)))
...     return "OK!!!!!"
...
>>>
>>> l__string="debut bla bla <<<%%le match group%%>>>bli bli fin"
>>>
>>> l__reRes = re.sub(r".*<<<\%\%(\w+)\%\%>>>.*",foo, l__string)
>>> l__reRes
'debut bla bla <<<%%le match group%%>>>bli bli fin'
 
>>> l__reRes = re.sub(r".?<<<\%\%(\w+)\%\%>>>.?",foo, l__string)
>>> l__reRes
'debut bla bla <<<%%le match group%%>>>bli bli fin'
 
>>> l__reRes = re.sub(".?<<<\%\%(\w+)\%\%>>>.?",foo, l__string)
>>> l__reRes
'debut bla bla <<<%%le match group%%>>>bli bli fin'
>>>

Dans ces trois cas, à aucun moment je ne passe dans foo !!

[wiztricks]

Re-Salut,

Avec le PATTERN = '.*<<<\%\%(\w*)\%\%>>>.*', mon machin marche aussi bien qu'avec '<<<\%\%(\w*)\%\%>>>' _sur l'exemple_.
Et je dis bien _sur l'exemple_, car pour remplacer toutes les '<<<\%\%(\w*)\%\%>>>', par autre chose, je ne vois pas pourquoi il faudrait s'occuper de ce qu'il peut y avoir entre.
Un gestionnaire de template qui ne sait pas gérer les appels de fonction ne s'appelle par un gestionnaire de template: regardez Mako par exemple, il fait cela très bien.

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import re
 
PATTERN = '.*<<<\%\%(\w*)\%\%>>>.*'
def foo(matchobj):
    print '0 = ', matchobj.group(0)
    print '1 = ', matchobj.group(1)
    token = matchobj.group(1)
    return '%%(%s)s' % token
 
replace = lambda s : re.sub(PATTERN, foo, s)
 
test_string = "blah bla <<<%%Dest_Name%%>>> x y z"
template = replace(test_string)
Dest_Name = 'Mr.Toto'
Aff_Date = '16 Mai 2010'
print template % vars()
print 'done'

- W

[dahtah]

A dahtah : Biin j'ai beau essayer ca ne marche pas comme tu dis:
Dans ces trois cas, à aucun moment je ne passe dans foo !!

C'est normal, tu n'utilises pas sub() de la bonne manière. Voici un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#!/usr/bin/bash
# -*- coding: utf-8 -*-
 
import re
 
def foo(match):
  print "%s\t%s" % (match.group(0), match.group(1))
  return "OK!!!!!"
 
l__string = "debut bla bla <<<%%le match group%%>>>bli bli fin"
p = re.compile(r".*<<<%%(.*)%%>>>.*")
print p.sub(foo, l__string)

Par contre, c'est un usage un peu détourné de sub(). Son utilisation première est de faire des substitutions.

[pilpoil123]

Bon ca y est !!!
zetes trop forts.

Alors en mixant et cherchant j'arrive à :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import re
from string import Template
 
g__TMPLVars = {'Dest_Name':'Mr.Toto', 'Aff_Date':'16 Mai 2010', 'Param':'OKeeeeeee'}
 
PATTERN = '(.*)<<<\%\%(.+)\%\%>>>(.*)'
 
def foo2(matchobj):
    global g__TMPLVars
    token = matchobj.group(2)
    template = Template(token)
    buffer = template.substitute(**g__TMPLVars)
    try:
        buffer = eval(buffer, locals(), globals())
    except:
        # string contains text => no evaluation
        pass
    return matchobj.group(1) + buffer + matchobj.group(3)
 
def foo3(param):
    row = param+'\n'
    return row*3
 
test_string = """
blah bla <<<%% ${Dest_Name}, Paris le ${Aff_Date} %%>>>
<<<%%foo3("${Param}")%%>>>
"""
 
template = re.sub(PATTERN, foo2, test_string)
print(template)

Et c'est exactement ce que je voulais faire
Je voulais utiliser les string template et donc utiliser la notation ${nomVar} dans mon fichier. Hors les caractères ${} ne sont plus "matché" par (\w*) et tu avais raison (dahtah) le bon pattern contenais (.?) ou plus precisement (.+) (je dois avoir au moins un car...). Ensuite je souhaitais réaliser la substitution dans la callback sans qu'elle ne connaisse le pattern. Du coup je crée les groupes avant et apres (les groupes 1 et 3). je traite le groupe 2 et renvoie la concatenation du tout.
le try catch me permet d'evaluer le contenu du groupe 2 et d'envoyer le code python si il en contient (foo3).
wouala...
testez vous verrez...
Merci a tout les deux !

PS : Je n'ai pas compris ton allusion à Mako. Kesako ? Ca m'interesse
PS2 : j'avance sur l'interface MySQL / Python 3.0 que tu m'as proposé je reviens bientôt avec mes critiques...

[miawaw]

PS : Je n'ai pas compris ton allusion à Mako. Kesako ? Ca m'interesse

j'adore ce site recherche python Mako

désolé, je déconne... (je sais pas ce que c'est Mako non plus )

enfin, tu as quand même le lien vers la page.

[wiztricks]

Salut

PS : Je n'ai pas compris ton allusion à Mako. Kesako ? Ca m'interesse

Mako est un gestionnaire de template écrit en Python qui contredit:

les gestionnaires de template (preuve je les utilise) mais a ma connaissance ils ne gèrent pas l'appel de fonction et m'obligent donc à continuer sur la base d'une recherche de tag et de l'interpretation specifique d'un contenu type "code python"

Il est inclus par défaut dans Pylons et TurboGears2 machins avec lesquels je bosse en ce moment.
-W

[pilpoil123]

ok ok...
quand je dis : "je les utilise" il faut entendre "j'utilise celui qui est fourni par python" : string.Template.

Je vais jeter un oeil à Mako. Je pense que tu as vu ce que cherchais à faire. In fine je trouve le traitement assez (trop) long. Pres de 30 sec pour traiter un fichier de 6500 lignes avec une vingtaine de substitution.

Si j'imagine qu'il permet des operations de substitutions avancés, penses-tu que ce genre d'outils apporte un plus en temps de traitement ?

[wiztricks]

Salut,

Si j'imagine qu'il permet des operations de substitutions avancés, penses-tu que ce genre d'outils apporte un plus en temps de traitement ?

Il est certain que cela réduit la quantité de code à écrire et donc, on peut espérer livrer plus vite, moins cher et moins risqué - et donc un salaire moyen plus élevé pour le prestataire.

Pour ce qui est 'temps de traitement', avec un domaine assez étroit on doit 'potentiellement' pouvoir optimiser et aller plus vite. Mais comme c'est risqué et que les résultats sont incertains, le salaire moyen 'baisse'.

Ce que vous pourriez déjà faire c'est générer un template "consommable"
dès le premier coup, çà devrait déjà réduire le temps par presque moitié.

In fine je trouve le traitement assez (trop) long. Pres de 30 sec pour traiter un fichier de 6500 lignes avec une vingtaine de substitution.

D'après ce que je comprends, un template va être utilisé avec plusieurs dictionnaires.

Plutôt que de vouloir faire la transformation en one shot, faites en 2 étapes:
Appliquez:
1 - les re.sub pour normaliser le template d'entrée,
2 - les dicos au template normalisé - issu de (1) -.
3 - Comme vous avez dissocié les 2, parallélisez plusieurs étapes (2).
Trichez!
Je suis quasiment sûr que vous avez un ensemble de courrier types qui bougent peu... avant (1) appliquez leur un MD5 pour retrouver les précédentes transformations.
- W
PS: Il devrait y avoir des gestionnaires de templates en C++ mais j'ai pas cherché.