La fonction compile est-elle limitée ?

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

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 :lol: ) 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

Édité par Wizix

Mon projet : OpenPlane, un utilitaire en Java pour les pilotes, les vrais !

+0 -0
Staff

Cette réponse a aidé l'auteur du sujet

Ta ligne commençant par Regex_master : n'est pas complète. En fait on ne voit pas la parenthèse fermante de re.compile(. Difficile à dire donc. Cela fait la même chose chez moi. Mais le fait que cela se termine sans la fermeture de la chaine et de la parenthese me fait plutot penser a une limitation de la taille de la chaine affiché (car elle semble tronqué).

Chez moi la représentation que tu imprime (en fait l'appel à la methode __repr__) est tronqué comme toi MAIS si j'affiche directement le membre pattern qui est ce qui t'interesse :

1
print("Regex_master : ", regex_master.pattern)

J'ai là bien la chaine complète.

Bref, tout va bien, c'est simplement la methode __repr__ qui semble fournir un résultat tronqué.

edit: Personnellement, pour avoir pratiqué en long et large le parseur markdown de ce site, j'ai acquis une certitude : utiliser massivement des regexp pour parser du markdown est globalement une mauvaise idée. Pour les éléments inline pourquoi pas (même si certains patterns sont difficile à gérer), mais pour les éléments blocs là c'est la misere. La solution la plus adapté est un parseur plus traditionnel.

Édité par Kje

+1 -0
Auteur du sujet

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..

Mon projet : OpenPlane, un utilitaire en Java pour les pilotes, les vrais !

+0 -0
Staff

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.

+0 -0
Auteur du sujet

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 ?

Mon projet : OpenPlane, un utilitaire en Java pour les pilotes, les vrais !

+0 -0
Staff

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.

+0 -0
Auteur du sujet

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 ! :D 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 ?!

Édité par Wizix

Mon projet : OpenPlane, un utilitaire en Java pour les pilotes, les vrais !

+0 -0
Staff

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.

Édité par nohar

I was a llama before it was cool

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte