Remplacer des éléments dans une expression régulière

Version imprimable

Bonjour,

Désolée par avance si la question a déjà été posée, je n'ai pas trouvé d'éléments pour résoudre mon problème.

Je cherche à remplacer des éléments d'une expression régulière par des valeurs déterminées.
Pour expliquer la démarche, je vais partir d'un exemple.
J'ai la chaîne de caractères suivante (en pratique, elle est beaucoup plus compliquée, je fais exprès de mettre des valeurs identiques à certains endroits) :

Code:

test_string = "toto_toto_tata_temperature_mensuelle_20210523-20250526.nc"

J'ai également une expression régulière :

Code:

test_regexp = re.compile(r"(?P<une_chaine>[^_]+)_(?P<une_autre_chaine>.*)_(?P<une_variable>[^_]+)_(?P<une_frequence>[^_]+)_(?P<une_periode>\d{4}\d*[-_]+\d{4}\d*)")

Avec re, je récupère les valeurs des différents groupes :
Code:

1 2 3 4 5 regexp_match = test_regexp.match(test_string) if regexp_match is not None: my_groups = regexp_match.groupdict() for elt in [elt for elt in my_groups if "period" in elt.lower()]: del my_groups[elt]
Je voudrais maintenant créer un template à partir de cette chaîne de caractère (pour pouvoir interpoler un nouveau nom de fichier en remplaçant juste la période).
Pour cela, je voudrais remplacer dans le pattern de l'expression régulière tous les groupes qui ne sont pas liés à une période pour obtenir quelque chose comme cela (en partant de my_groups) :

Code:

test_template = "toto_toto_tata_temperature_mensuelle_(?P<une_periode>\d{4}\d*[-_]+\d{4}\d*).nc"

Plusieurs groupes pourraient être concernés par ces exclusions pour le remplacement (pas seulement la période).

Je n'ai pas trouvé de fonctions/méthode dans re qui permettent ce remplacement (et je voudrais éviter de partir de la chaîne de caractères dans laquelle on pourrait imaginer avoir plusieurs fois une même chaine représentant une date sans avoir à toutes les remplacer).

Merci par avance pour vos retours sur ce qu'il serait possible de faire,
GaelleRig

25/01/2024, 13h26
wiztricks

Salut,

J'ai l'impression que vous cherchez un truc tout fait prêt à l'emploi alors qu'il suffirait de le coder (j'ai peut-être regardé ça en diagonale mais ça ne me paraît pas irréalisable).

- W
25/01/2024, 13h45
jurassic pork
Hello,
houla tout cela me paraît bien compliqué et en plus dans ton code il y a une erreur car tu fais une itération en changeant le dictionnaire de départ :
Code:

1 2 3 for elt in my_groups: if "period" in elt.lower(): del my_groups[elt]
Citation:

RuntimeError: dictionary changed size during iteration

Dis nous ce que tu veux faire exactement avec des exemples : chaîne(s) de départ --> résultat(s) escomptés parce que tu n'utilises peut-être pas la meilleure méthode pour arriver à tes fins. C'est parfois aussi plus simple de ne pas utiiiser des groupes nommés : les groupes sont alors repérés dans l'ordre de lecture $1, $2 etc ...

Ami calmant, J.P
25/01/2024, 14h00
Sve@r

Bonjour

Citation:

Envoyé par GaelleRig

J'ai la chaîne de caractères suivante (en pratique, elle est beaucoup plus compliquée, je fais exprès de mettre des valeurs identiques à certains endroits) :

Code:

test_string = "toto_toto_tata_temperature_mensuelle_20210523-20250526.nc"

...
Je voudrais maintenant créer un template à partir de cette chaîne de caractère (pour pouvoir interpoler un nouveau nom de fichier en remplaçant juste la période).
Pour cela, je voudrais remplacer dans le pattern de l'expression régulière tous les groupes qui ne sont pas liés à une période pour obtenir quelque chose comme cela (en partant de my_groups) :

Code:

test_template = "toto_toto_tata_temperature_mensuelle_(?P<une_periode>\d{4}\d*[-_]+\d{4}\d*).nc"

Comme jurassic pork, ça m'a l'air compliqué (incompréhensible?).
La test_string est présumée être une chaine d'informations (lue depuis un fichier, une bdd, etc). Les regex permettent de chercher dans cette chaine des informations "ressemblant à". Là donc on indique cette ressemblance par le biais d'une grammaire.
Mais ensuite la chaine de data devient elle-même une regex avec ses règles de grammaire donc là je ne pige plus. La base c'est que la data soit une chaine quelconque et que la regex serve à indiquer comment y chercher des infos, pas qu'elle soit elle-même une regex !!!

Bref comme jurassic pork, peut-être dire ce que tu as en entrée et ce que tu veux en sortie et là on pourra mieux comprendre...
25/01/2024, 14h47
wiztricks

Citation:

Envoyé par Sve@r

Bref comme jurassic pork, peut-être dire ce que tu as en entrée et ce que tu veux en sortie et là on pourra mieux comprendre...

Bah s'il y a bien une chose claire dans le message, c'est de quoi on part et ce qu'on veut obtenir.

- W

(Re)Bonjour,

Merci pour ces premiers retours.

Citation:

houla tout cela me paraît bien compliqué et en plus dans ton code il y a une erreur car tu fais une itération en changeant le dictionnaire de départ

Effectivement, il y avait un problème de syntaxe dans mon exemple mais il n'est pas dans le code que j'utilise (je l'ai corrigé dans mon premier message).

Citation:

J'ai l'impression que vous cherchez un truc tout fait prêt à l'emploi alors qu'il suffirait de le coder (j'ai peut-être regardé ça en diagonale mais ça ne me paraît pas irréalisable).

Je ne doute pas de pouvoir coder la solution, mais au niveau maintenance, si la fonction/méthode existe déjà, c'est toujours mieux.

Citation:

Dis nous ce que tu veux faire exactement avec des exemples : chaîne(s) de départ --> résultat(s) escomptés parce que tu n'utilises peut-être pas la meilleure méthode pour arriver à tes fins. C'est parfois aussi plus simple de ne pas utiiiser des groupes nommés : les groupes sont alors repérés dans l'ordre de lecture $1, $2 etc ...

Citation:

Bref comme jurassic pork, peut-être dire ce que tu as en entrée et ce que tu veux en sortie et là on pourra mieux comprendre...

En voulant trop simplifier, je n'ai peut-être pas réussi à expliquer pourquoi cela semble si compliqué (mais il est plus facile de tester sur un exemple simplifié que sur un cas quasi-réel même s'il n'est pas de la même échelle).

Pour revenir sur les objectifs, j'ai à ma disposition deux informations en provenance des utilisateurs :
1. la liste des fichiers du répertoire à traiter (par exemple) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
files_list = ["pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc",
"pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc",
"pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc",
"pression_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc",
"pression_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc",
"pression_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc",
"temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc",
"temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc",
"temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc",
"temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc",
"temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc",
"temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc",
"temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197901-197903.nc",
"temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197904-197906.nc",
"temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197907-197909.nc"]

2. L'expression régulière que suivent les fichiers (et qui détermine également la façon dont ils doivent être concaténés ensemble sur des périodes plus longues):

Code:

1
2
import re
files_regexp = re.compile(r"(?P<variable>[^_]+)_(?P<frequence>[^_]+)_.*_(?P<grille>[^_]+)_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc")

A partir de ces informations, je dois regrouper les noms de fichiers à concaténer en tenant compte des groupes définis dans l'expression régulière (sauf s'ils sont explicitement liés à une période ou une date).
Ca donne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
from collections import defaultdict
rep = defaultdict(list)
 
for f in files_list:
    match_f = files_regexp.match(f)
    if match_f:
        other_matches = match_f.groupdict()
        dates_matches = {elt: match_f[elt] for elt in other_matches if "date" in elt.lower() or "period" in elt.lower()}
        for elt in dates_matches:
            del other_matches[elt]
        print(other_matches)
        index = tuple([other_matches[elt] for elt in sorted(list(other_matches))])
        rep[index].append(f)

Et le résultat :

Code:

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
defaultdict(list,
            {('mensuelle',
              'une-grille',
              'pression'): ['pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
                            'pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
                            'pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc'],
             ('journaliere',
              'une-grille',
              'pression'): ['pression_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
                            'pression_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
                            'pression_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc'],
             ('mensuelle',
              'une-grille',
              'temperature'): ['temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
                               'temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
                               'temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc'],
             ('journaliere',
              'une-grille',
              'temperature'): ['temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
                               'temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
                               'temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc'],
             ('journaliere',
              'une-autre-grille',
              'temperature'): ['temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197901-197903.nc',
                               'temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197904-197906.nc',
                               'temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197907-197909.nc']})

Je voudrais définir le template du nom de fichier concaténé à partir des mêmes informations, pour obtenir le dictionnaire suivant à la place :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
defaultdict(list,
            {'pression_mensuelle_un_nom_de_modele_version-197901_une-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc': ['pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
                                                                                                                                     'pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
                                                                                                                                     'pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc'],
             'pression_journaliere_un_nom_de_modele_version-197901_une-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc': ['pression_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
                                                                                                                                       'pression_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
                                                                                                                                       'pression_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc'],
             'temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc': ['temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
                                                                                                                                        'temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
                                                                                                                                        'temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc'],
             'temperature_journaliere_un_nom_de_modele_version-197901_une-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc': ['temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
                                                                                                                                          'temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
                                                                                                                                          'temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc'],
             'temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc': ['temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197901-197903.nc',
                                                                                                                                                'temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197904-197906.nc',
                                                                                                                                                'temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197907-197909.nc']})

Mon problème consiste donc à passer d'un dictionnaire à l'autre (si possible sans refaire l'analyse des expressions régulières, pour éviter de relire les noms des 5000 fichiers ou plus à chaque fois...).

J'espère que le problème est plus clair comme cela.
Je suis preneuse d'idées pour simplifier la résolution si vous en avez.

Merci encore,
GaelleRig

Citation:

Envoyé par GaelleRig

J'espère que le problème est plus clair comme cela.

Oui là pour moi c'est pas mal. Désolé, n'étant pas omniscient comme l'autre, j'avais besoin de cette explication pour comprendre.

Que penses-tu de ceci...

Code:

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
31
32
33
34
35
#!/usr/bin/env python3
# coding: utf-8
 
files_list = (
	"pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc",
	"pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc",
	"pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc",
	"pression_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc",
	"pression_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc",
	"pression_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc",
	"temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc",
	"temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc",
	"temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc",
	"temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc",
	"temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc",
	"temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc",
	"temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197901-197903.nc",
	"temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197904-197906.nc",
	"temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197907-197909.nc",
)
 
filtre="(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*)"
info=("pression", "temperature")
frequence=("mensuelle", "journaliere")
grille=("une-grille", "une-autre-grille")
 
import itertools
import re
result=dict()
for (file, i, f, g) in itertools.product(files_list, info, frequence, grille):
	key="%s_%s_un_nom_de_modele_version-197901_%s_%s.nc" % (i, f, g, filtre)
	if re.match(key, file): result.setdefault(key, list()).append(file)
# for
for (k, v) in result.items():
	print("%s: [%s]\n" % (k, "".join("\n\t%s" % x for x in v)))

Résultat

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
pression_mensuelle_un_nom_de_modele_version-197901_une-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc: [
	pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc
	pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc
	pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc]
 
pression_journaliere_un_nom_de_modele_version-197901_une-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc: [
	pression_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc
	pression_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc
	pression_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc]
 
temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc: [
	temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc
	temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc
	temperature_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc]
 
temperature_journaliere_un_nom_de_modele_version-197901_une-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc: [
	temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197901-197903.nc
	temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197904-197906.nc
	temperature_journaliere_un_nom_de_modele_version-197901_une-grille_197907-197909.nc]
 
temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc: [
	temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197901-197903.nc
	temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197904-197906.nc
	temperature_journaliere_un_nom_de_modele_version-197901_une-autre-grille_197907-197909.nc]

???

25/01/2024, 16h02
jurassic pork

je n'ai peut-être pas compris mais la finalité n'est-ce pas par exemple de mettre le contenu de ces trois fichiers :
['pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197903.nc',
'pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197904-197906.nc',
'pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197907-197909.nc']

Dans un fichier qui se nommerait pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197909.nc ? :koi:
25/01/2024, 16h28
Sve@r

Citation:

Envoyé par jurassic pork

Dans un fichier qui se nommerait pression_mensuelle_un_nom_de_modele_version-197901_une-grille_197901-197909.nc ? :koi:

Il y a la pression mensuelle, journalière, la température mensuelle, journalière, et tout ça pour "une grille" puis "une-autre-grille". Et peut-être que demain ça peut évoluer encore...

Citation:

Envoyé par Sve@r

Il y a la pression mensuelle, journalière, la température mensuelle, journalière, et tout ça pour "une grille" puis "une-autre-grille". Et peut-être que demain ça peut évoluer encore...

Effectivement mais je ne montrais qu'un seul exemple.
J'ai "bidouillé" ton code pour extraire la période min et la période max pour chaque membre du dictionnaire pour le fun et au cas où cela serait utile:
Code:

1 2 3 4 5 6 7 8 9 for (k, v) in result.items(): listperiode=[] for n in v: res = re.search('(\d{4,6})-(\d{4,6})\.nc$',n) if res: listperiode.append(res.group(1)) listperiode.append(res.group(2)) print(min(listperiode),max(listperiode)) print("%s: [%s]\n" % (k, "".join("\n\t%s" % x for x in v)))
Je prend comme hypothèse que les noms de fichiers se terminent tous par une période.

25/01/2024, 17h34
wiztricks

Citation:

Envoyé par GaelleRig

A partir de ces informations, je dois regrouper les noms de fichiers à concaténer en tenant compte des groupes définis dans l'expression régulière (sauf s'ils sont explicitement liés à une période ou une date).

Repartez de test_regexp pour en faire un dictionnaire où les clefs seront les groupes et les valeurs le bout de regexp associé. qui s'appellera dico_regexp avec la propriété ''.join(dico_regexp.values()) = test_regexp.

On applique test_regexp pour fabriquer my_groups et en sortir le groupe qu'on ne veut pas.

La nouvelle regexp devrait se fabriquer via ''.join(ChainMap(my-groups, dico_regexp).values()) = test_regexp.
ChainMap étant une class de la bibliothèque collections.

- W
26/01/2024, 10h20
umfred

j'ai du mal à comprendre (entre autres) la notion de "sauf si liés explicitement à une période" par rapport à ton exemple.
pour moi, ils sont tous liés à une période explicite, non ?

Si je reformule ton besoin: concaténer (dans l'ordre des périodes) les fichiers dont le nom est identique jusqu'à l'indication de période.
Donc le nom du fichier peut être divisé en seulement 2 (ou 3) sous ensembles: le nom (regroupant l'ensemble de ce que tu as appelé groupes) et la période (éventuellement à décomposer en début et fin)
En classant les fichiers par ordre alphabétique ainsi, on devrait arriver au résultat voulu
26/01/2024, 16h16
GaelleRig
Bonjour,

Merci pour vos retours.

Citation:

Envoyé par jurassic pork

J'ai "bidouillé" ton code pour extraire la période min et la période max pour chaque membre du dictionnaire pour le fun et au cas où cela serait utile:

Concernant la finalité, je sépare la partie qui concerne les dates minimales et maximales comme on peut vouloir concaténer les fichiers suivants différents critères (selon si on veut plutôt des durées cohérentes ou des fichiers finaux pas trop lourds - on évite les fichiers > 10Go... pour ceux qui les visionneront).
Ces critères sont gérés dans une deuxième partie.

Citation:

Envoyé par umfred

j'ai du mal à comprendre (entre autres) la notion de "sauf si liés explicitement à une période" par rapport à ton exemple.
pour moi, ils sont tous liés à une période explicite, non ?

Si je reformule ton besoin: concaténer (dans l'ordre des périodes) les fichiers dont le nom est identique jusqu'à l'indication de période.
Donc le nom du fichier peut être divisé en seulement 2 (ou 3) sous ensembles: le nom (regroupant l'ensemble de ce que tu as appelé groupes) et la période (éventuellement à décomposer en début et fin)
En classant les fichiers par ordre alphabétique ainsi, on devrait arriver au résultat voulu

Certains utilisateurs souhaitent par exemple regrouper les fichiers par fréquence (avec plusieurs variables) donc le classement par ordre alphabétique n'est pas le plus pertinent.
Citation:
Envoyé par Sve@r

Code:

1 2 filtre="(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*)"
En fait, la question est de récupérer la valeur de la variable "filtre" à partir de l'expression régulière.

Citation:

Envoyé par wiztricks

Repartez de test_regexp pour en faire un dictionnaire où les clefs seront les groupes et les valeurs le bout de regexp associé. qui s'appellera dico_regexp avec la propriété ''.join(dico_regexp.values()) = test_regexp.

On applique test_regexp pour fabriquer my_groups et en sortir le groupe qu'on ne veut pas.

La nouvelle regexp devrait se fabriquer via ''.join(ChainMap(my-groups, dico_regexp).values()) = test_regexp.
ChainMap étant une class de la bibliothèque collections.

- W

Je me rend compte que mon problème peut se résumer à : "Comment, à partir d'une expression régulière, créer automatiquement un dictionnaire qui donne pour chaque nom de groupe l'expression régulière du groupe associé ?"
Une fois que ce dictionnaire existe, on a effectivement tout pour créer la nouvelle expression régulière.
J'ai continué à chercher dans le module re, qui me paraît le plus pertinent, comme il fait ce travail de récupération des expressions régulières associées aux différents groupes pour pouvoir ensuite chercher dans les chaînes de caractères, mais j'ai du mal à trouver ce que je cherche (j'ai des pistes avec re.sre_parser.parse mais je ne récupère pas ce que je veux).
Je vais continuer à chercher de ce côté-là.

Merci encore,
Bonne journée,
GaelleRig
26/01/2024, 16h50
Sve@r

Citation:

Envoyé par GaelleRig

En fait, la question est de récupérer la valeur de la variable "filtre" à partir de l'expression régulière.

Cela veut dire passer de re.compile(r"(?P<variable>[^_]+)_(?P<mensuelle>[^_]+)_.*_(?P<grille>[^_]+)_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc") à filtre="(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*)" ???
C'est possible bien sûr (analyser la chaine de début, checker les parenthèses, etc) mais n'as-tu pas l'impression de travailler à l'envers ?

Moi je suis parti du besoin initial : tu as des traitements mensuels et journaliers qui sont combinés avec des pressions et températures (2D) recombinés avec deux notions de grille (3D). J'ai donc placé les trois caractéristiques en parallèle pour les combiner toutes les trois dans toutes leurs possibilités.
Puis j'ai créé le filtre regex à partir des fichiers de ta liste (bon en réalité à partir de celle que tu avais écrite mais puisqu'elle convenait...). Ca me semble logique: on veut trouver des chaines précises on écrit alors la regex permettant de les retrouver en fonction de ce qu'on peut déterminer dans leur nom.
De là, toutes ces bases bien posées peuvent alors donner naissance à une multitude de branches dérivées assez facilement. Or tel que décrit, j'ai l'impression que toi tu pars d'une de ces branches pour tenter de recréer les bases...

Autrement dit, c'est plus facile d'utiliser "(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*)" et les combiner avec "grille"/"autre-grille" et "mensuelle"/"journalière" pour générer la chaine "(?P<variable>[^_]+)_(?P<mensuelle>[^_]+)_.*_(?P<grille>[^_]+)_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc" que de faire l'inverse...
26/01/2024, 17h33
fred1599
Bonjour,

C'est quand même difficile quand un problème n'est pas exprimé de manière concrète et que purement technique. Personnellement je n'ai pas compris l'objectif utilisateur.
1. Je suis curieux de savoir comment le script est exécuté ? via des paramètres ?
2. C'est pas pour du développement web au moins ?
3. À chaque exécution on semble charger les 5000 fichiers ? puis 10000, 100000 ? limite une petite base de données sqlite, semble intéressante...
Et comme Sve@r, j'ai vraiment l'impression qu'on prend le problème à l'envers... et c'est peut-être pour cela qu'on a des difficultés à comprendre la logique demandée.

Je n'ai pas compris pourquoi concrètement on génère des pattern d'expressions régulières, ça n'a pas de sens ! Faut m'expliquer le pourquoi de cette demande.

Bref dans cette demande j'attends toujours le petit déclic pour comprendre, car malgré les essais de @GaelleRig, je n'arrive toujours pas à comprendre l'intérêt de faire tout cela !
26/01/2024, 17h45
umfred

en d'autres termes, présente-nous plutôt le cheminement utilisateur sans rentrer dans le "comment faire":
exemple:
On a une liste de fichiers dont le nom se compose en [type_mesure]_[periodicite_mesure]_[modele]_[version]_[periode_mesure].nc
On doit présenter à l'utilisateur tels éléments pour tel but (a priori sélectionner certains éléments, ou un ordre des éléments?)
On doit alors lui présenter tel résultat selon son choix (exemple choix utilisateur avec exemple de résultat attendu pour l'utilisateur)
...

Citation:

Envoyé par GaelleRig

Je me rend compte que mon problème peut se résumer à : "Comment, à partir d'une expression régulière, créer automatiquement un dictionnaire qui donne pour chaque nom de groupe l'expression régulière du groupe associé ?"

voilà.

Citation:

Envoyé par GaelleRig

Une fois que ce dictionnaire existe, on a effectivement tout pour créer la nouvelle expression régulière.

fiat lux:
Code:

1 2 3 4 5 6 7 >>> s '(?P<une_chaine>[^_]+)_(?P<une_autre_chaine>.*)_(?P<une_variable>[^_]+)_(?P<une_frequence> ^_]+)_(?P<une_periode>\\d{4}\\d*[-_]+\\d{4}\\d*)' >>> rg '\$\\?P<(?P<key>[^>]+)>(?P<value>[^\$]+)' >>> re.findall(rg, s) [('une_chaine', '[^_]+'), ('une_autre_chaine', '.*'), ('une_variable', '[^_]+'), ('une_frequence', '[^_]+'), 'une_periode', '\\d{4}\\d*[-_]+\\d{4}\\d*')] >>>
à partir d'un tuple, je sais faire un dictionnaire.
Et il va certainement falloir ajouter un peu de viande au ''.join(...) pour reconstruire l'expression régulière:
Code:

1 2 3 4 5 >>> '_'.join(f'(?P<{k}>{v})' for k, v in re.findall(rg, s)) '(?P<une_chaine>[^_]+)_(?P<une_autre_chaine>.*)_(?P<une_variable>[^_]+)_(?P<une_frequence>^_]+)_(?P<une_periode>\\d{4}\\d*[-_]+\\d{4}\\d*)' >>> _ == s True >>>
Citation:

Envoyé par GaelleRig

mais j'ai du mal à trouver ce que je cherche (j'ai des pistes avec re.sre_parser.parse mais je ne récupère pas ce que je veux).

Je suis trop "touriste" en expressions régulières pour avoir une idée d'où cela pourra vous mener. Depuis ma colline, la chaine de caractères a suffisamment de régularités pour qu'on la traite avec une cuisine ad hoc.

- W

Bonjour,

Merci pour ces retours.
Citation:
Envoyé par wiztricks
voilà.
fiat lux:
Code:

1 2 3 4 5 6 7 >>> s '(?P<une_chaine>[^_]+)_(?P<une_autre_chaine>.*)_(?P<une_variable>[^_]+)_(?P<une_frequence> ^_]+)_(?P<une_periode>\\d{4}\\d*[-_]+\\d{4}\\d*)' >>> rg '\$\\?P<(?P<key>[^>]+)>(?P<value>[^\$]+)' >>> re.findall(rg, s) [('une_chaine', '[^_]+'), ('une_autre_chaine', '.*'), ('une_variable', '[^_]+'), ('une_frequence', '[^_]+'), 'une_periode', '\\d{4}\\d*[-_]+\\d{4}\\d*')] >>>
à partir d'un tuple, je sais faire un dictionnaire.
Et il va certainement falloir ajouter un peu de viande au ''.join(...) pour reconstruire l'expression régulière:
Code:

1 2 3 4 5 >>> '_'.join(f'(?P<{k}>{v})' for k, v in re.findall(rg, s)) '(?P<une_chaine>[^_]+)_(?P<une_autre_chaine>.*)_(?P<une_variable>[^_]+)_(?P<une_frequence>^_]+)_(?P<une_periode>\\d{4}\\d*[-_]+\\d{4}\\d*)' >>> _ == s True >>>
Je suis trop "touriste" en expressions régulières pour avoir une idée d'où cela pourra vous mener. Depuis ma colline, la chaine de caractères a suffisamment de régularités pour qu'on la traite avec une cuisine ad hoc.

- W
Merci wiztricks, effectivement, tant que les utilisateurs n'inventent pas d'expressions régulières tarabiscotées et que tous les groupes sont nommés (c'est moins certain mais on peut essayer de compter sur leur bonne volonté), ça fonctionne.
Je vais continuer à regarder de mon côté si je ne trouve pas une méthode générique (mais entre deux réunions, c'est parfois un peu compliqué d'y passer du temps...) et je donnerai la solution si j'en trouve une satisfaisante.

Citation:

Envoyé par umfred

en d'autres termes, présente-nous plutôt le cheminement utilisateur sans rentrer dans le "comment faire".

Citation:

Envoyé par fred1599

Je n'ai pas compris pourquoi concrètement on génère des pattern d'expressions régulières, ça n'a pas de sens ! Faut m'expliquer le pourquoi de cette demande.

Bref dans cette demande j'attends toujours le petit déclic pour comprendre, car malgré les essais de @GaelleRig, je n'arrive toujours pas à comprendre l'intérêt de faire tout cela !

Citation:

Envoyé par Sve@r

Cela veut dire passer de re.compile(r"(?P<variable>[^_]+)_(?P<mensuelle>[^_]+)_.*_(?P<grille>[^_]+)_(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*).nc") à filtre="(?P<date_debut>\d{4}\d*)[-_](?P<date_fin>\d{4}\d*)" ???
C'est possible bien sûr (analyser la chaine de début, checker les parenthèses, etc) mais n'as-tu pas l'impression de travailler à l'envers ?

Je vais essayer de décrire l'outil pour lequel je pose cette question de façon schématique avec les résultats attendus à partir des entrées.
Pour le contexte :

C'est un outil de post-traitement de simulations numériques qui doit pouvoir tourner aussi bien sur un PC que sur un serveur ou un cluster de calcul ce qui limite l'utilisation de certaines solutions (en particulier, pas de base de données ad-hoc, on se sert de la liste des fichiers disponibles sur le système de fichiers).
Il est lancé en ligne de commande avec des arguments par l'utilisateur ou par un autre outil qui gère la réalisation des simulations numériques.
Cet outil permet, entre autres, de concaténer les sorties des simulations numériques, qui sont créées par petits bouts (pour des questions de reprise sur erreurs et de conventions sur la distribution des fichiers en particulier). La concaténation est nécessaire pour l'archivage (les admin apprécient peu qu'on leur envoie plusieurs dizaines de millier de fichiers d'au plus quelques Mo pour la plupart, par contre quelques milliers de fichiers de quelques centaines de Mo à quelques dizaines de Go leur conviennent).
Il faut garder en tête que chaque simulation peut produire plusieurs centaines de fichiers sur chaque sous-période, que les fichiers ont des tailles très disparates et qu'on ne sort pas toutes les variables sur l'ensemble de la période.

Fonctionnement actuel :

L'utilisateur donne un nom de répertoire dans lequel se trouve les fichiers à concaténer.
L'outil suppose que les noms des fichiers respectent une certaine convention (ou plutôt une des trois disponibles) et qu'il est possible de déterminer, pour chaque fichier, la variable, la fréquence et la grille en séparant le nom de fichier suivant un séparateur ("_") puis en récupérant un élément donné dans cette liste pour chacune des trois clés (on définit de cette manière les fichiers à concaténer, la gestion des durées concaténées est faite séparément en fonction des fichiers trouvés).
Les fichiers sont regroupés et concaténés dans un répertoire dédié suivant les patterns définis.

Cela fonctionne bien tant que les utilisateurs n'utilisent pas de "_" dans leur noms de variables ou de simulations par exemple (ce qui empêche le script de déterminer les bonnes clés) ou qu'ils ne sortent pas des fichiers dont les noms ont un format complètement différent (par exemple en multi-variables).
La solution pour l'instant est de faire passer un script avant pour renommer les fichiers vers un format compatible avec le post-traitement et un autre après pour revenir au format initial (avec à la clé deux expressions régulières à maintenir par l'utilisateur, que je détermine les trois quarts du temps).

Fonctionnement qu'on souhaite atteindre et lien avec la question :

L'utilisateur donne un nom de répertoire dans lequel se trouve les fichiers à concaténer. Il peut également spécifier l'expression régulière à laquelle les fichiers répondent dans le cas où on n'est pas dans les patterns standards).
Si on reste dans un cas déjà traité, on garde la même façon de fonctionner en comptant les "_". Si non, l'outil se sert de l'expression régulière pour déterminer les fichiers à concaténer et le pattern des fichiers produits.
Les fichiers sont regroupés et concaténés dans un répertoire dédié suivant les patterns définis par l'outil en évitant l'éventuelle phase de renommage

Je ne suis pas certaine que ce soit plus clair, mais ça donne un contexte plus large.

Bonne journée,
GaelleRig