La fonction compile est-elle limitée ?

Bonjour à tous !
Je suis confronté à un problème face à mon code python, voyez plutôt :

 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

italic = r"(?P<i>(_(.+?)_))"  # flags = re.S
bold = r"(?P<b>(\*(.+?)\*))"  # flags = re.S
crossed = r"(?P<crossed>(~~(.+?)~~))"  # flags = re.S
h1 = r"(?P<h1>(?<!#)#(?!#)(.*))"
h2 = r"(?P<h2>(?<!#)##(?!#)(.*))"
h3 = r"(?P<h3>(?<!#)###(?!#)(.*))"
h4 = r"(?P<h4>(?<!#)####(?!#)(.*))"
h5 = r"(?P<h5>(?<!#)#####(?!#)(.*))"
h6 = r"(?P<h6>(?<!#)######(?!#)(.*))"
link = r"(?P<link>(\(.+?\)\[.+?]))"
code = r"(?P<code>(```(.+?)```))"  # flags = re.S
quote = r"(?P<quote>(>>(.+?)<<(\(Source:(.+)\))?))"  # flags = re.S
center = r"(?P<center>(-->(.+?)<--))"  # flags = re.S
right = r"(?P<right>(-->(.+?)-->))"  # flags = re.S
hr = r"(?P<hr>(\n(---*|===*)\n))"
exponent = r"(?P<exponent>(\^(.+?)\^))"
index = r"(?P<index>(~(.+?)~))"
new_line = r"(?P<newline>(  +\n))"
new_section = r"(?P<newsection>(\n\n+))"
comment = r"(?P<comment>(<!--(.+?)-->))"  # flags = re.S
footmark = r"(?P<footmark>(\[\^[0-9]+:.+?\]))"
variable = r"(?P<variable>(\$_[A-Z]{2,}\(.+?\)))"

regexs = [bold, center, code,  comment, crossed, exponent, footmark, h1, h2, h3, h4, h5, h6, hr, index, italic,
                link, new_line, new_section, quote, right, variable]

regex_master = re.compile("|".join(regexs))

Et quand je fais

1
2

print("Regexs : ", regexs)
print("Regex_master : ", regex_master)

Elle me renvoie :

1
2

Regexs :  ['(?P<b>(\\*\\*(.+?)\\*\\*))', '(?P<center>(-->(.+?)<--))', '(?P<code>(```(.+?)```))', '(?P<comment>(<!--(.+?)-->))', '(?P<crossed>(~~(.+?)~~))', '(?P<exponent>(\\^(.+?)\\^))', '(?P<footmark>(\\[\\^[0-9]+:.+?\\]))', '(?P<h1>(?<!#)#(?!#)(.*))', '(?P<h2>(?<!#)##(?!#)(.*))', '(?P<h3>(?<!#)###(?!#)(.*))', '(?P<h4>(?<!#)####(?!#)(.*))', '(?P<h5>(?<!#)#####(?!#)(.*))', '(?P<h6>(?<!#)######(?!#)(.*))', '(?P<hr>(\\n(---*|===*)\\n))', '(?P<index>(~(.+?)~))', '(?P<i>(_(.+?)_))', '(?P<link>(\\(.+?\\)\\[.+?]))', '(?P<newline>(  +\\n))', '(?P<newsection>(\\n\\n+))', '(?P<quote>(>>(.+?)<<(\\(Source:(.+)\\))?))', '(?P<right>(-->(.+?)-->))', '(?P<variable>(\\$_[A-Z]{2,}\\(.+?\\)))']
Regex_master :  re.compile('(?P<b>(\\*\\*(.+?)\\*\\*))|(?P<center>(-->(.+?)<--))|(?P<code>(```(.+?)```))|(?P<comment>(<!--(.+?)-->))|(?P<crossed>(~~(.+?)~~))|(?P<exponent>(\\^(.+?)\\^))|(?P<footmark>(\\[\\^[0-9]+:.+?\\]))|(?P<h)

(Bon d'accord c'est vraiment imbuvable ) La fonction compile() ne compile pas toute mes expressions… En regardant dans la doc python, il n'est marqué nul part qu'elle est limitée en nombre de caractères… Est-ce moi qui l'utilise mal ?

Merci de votre aide

Merci, c'est bien la solution !
Bah justement je cherche la meilleur solution et je ne vois pas du tout ce que tu signifies par "parseur plus traditionnel". En faite je cherche à créer une sorte de compilateur markdown - pdf (pour le pdf, j'utiliserais reportLab). Et je pensais que les regex étaient une bonne idée mais ça c'est rapidement désapprouvé.. Du coup je ne vois pas trop comment faire, car du ligne par ligne ne me permet pas de lire des blocs..

En faite je cherche à créer une sorte de compilateur markdown - pdf (pour le pdf, j'utiliserais reportLab).

Ok, tu fais ça pour apprendre ou pour application réel ?

Perso, à ta place, je ferais une des solutions suivante :

• Utiliser Pandoc : Pandoc permet de convertir directement du markdown en pdf (via latex) ce qui produit un rendu vraiment très propre. C'est un des rare projets qui utilise justement pas du tout de regexp. C'est écrit en haskell mais ça a la limite, peut importe. Si il est installé tu peux le lancer depuis Python avec SubProcess par exemple.
• Utiliser un parseur en Python existant. Par exemple Python-Markdown peut faire pour toi le parsage. Normalement il fournit un fichier html mais avant tu peux très bien te balader dans l'arbre XML généré pour produire une autre sortie.

Le truc est que faire un parseur markdown est plus compliqué qu'on ne l'imagine car il y a des tonnes de petits cas particuliers et de collisions de syntaxe. Autant prendre pour ça un projet existant.

C'était pour essayer.. Le problème de pandoc c'est que le langage est déjà définit fin j'ai rien à faire… De même pour python-markdown (je l'avais déjà vu, rapidement) je peux pas définir ma propre petite syntaxe où ajouter quelques options, si ?

Dans les deux tu peux rajouter des extensions. Dans Pandoc pour beaucoup de cas ça oblige a l'intégrer en Haskell directement dans le code. Pour Python-Markdown tu peux utiliser les extensions : tous les ajouts à la syntaxe markdown présent sur ce site sont fait avec des extensions de Python-Markdown !

Si ton but est d'essayer, bah alors oublie ce que je disais et essais ! Je pense que tu te rendra compte que c'est galère mais l'interet pédagogique est important. Si ton but est de faire une application par dessus tout ça, il vaut mieux que tu te concentre sur la réel plus value de ton appli.

Je pense me pencher sur Python-markdown ! Je pensais que la doc était vide, c'est pour ça qu'elle me faisait un peu peur, mais j'avais pas vu le menu sur le côté, et en faite la doc est bien garnie ! Mon but est autant pédagogique que faire un compilateur à des fins personnels, je l'utiliserais vraiment souvent si il fonctionne !

J'ai aussi cherché sur le GitHub de Zds, mais impossible de mettre la main sur les fichiers concernant le markdown, normal ?!

J'ai aussi cherché sur le GitHub de Zds, mais impossible de mettre la main sur les fichiers concernant le markdown, normal ?!

Oui c'est dans un dépot dédié. La quasi totalité de nos modifs sont en réalité simplement des extensions qui sont dans markdown/extensions/.

Okep merci, je me disais bien aussi que c'était bizarre !
Je vais me pencher sur tout ça

Hésite pas si tu as besoin d'infos, par contre c'est pas du code très propre…

Petite question alors, dans markdown/extensions/ tous les fichiers sont vos extensions ?

nop, certaines sont livrés de base. Et dans celles rajoutés, une partie a été trouvé "sur le net" et adaptée cas échéant.

Okep, merci pour ces précisions ! Je me suis lancé dans la lecture de la doc qui est vraiment complète !

Perso, si j'avais voulu faire un parseur markdown from scratch, je pense que je me serais pas cassé la tête et que j'aurais utilisé PLY. C'est un peu le mortier pour écraser un moustique, et ça demande de savoir écrire des grammaires (non-)contextuelles, mais le résultat reste performant et facile à maintenir/modifier.