Utilisateur:PamputtBot/creer conj verbes iser.cpp

Définition, traduction, prononciation, anagramme et synonyme sur le dictionnaire libre Wiktionnaire.

Les codes présents sur cette page permettent de créer automatiquement les pages de conjugaisons de verbes se terminant par -iser. Il peut bien sûr être adapté à d’autres verbes (réguliers). Plusieurs étapes sont nécessaires

Récupérer une liste de verbes à traiter[modifier le wikicode]

Ça peut par exemple se faire avec le gadget Gadget-ChercheDansSousCategories dans la catégorie Wiktionnaire:Conjugaisons manquantes en français. Enregistrez votre liste dans le fichier liste_brute_iser.txt

Récupérer la ligne de forme des verbes de la liste[modifier le wikicode]

On utilise maintenant un script bash, que l'on peut appeler recuperer_verbes_iser.sh, pour récupérer les infos sur la ligne de forme. 

#!/bin/bash
rm liste_traitee_iser.txt
for line in $(cat liste_verbes_iser.txt);
do
    ligneObtenue=`python core/pwb.py core/scripts/listpages.py -get -page:$line | grep "{{pron|"`
    if [ $? -eq 0 ]; then
	echo "$line $ligneObtenue" >> liste_traitee_iser.txt
    else
	echo "Pas de modèle {{pron}} pour l'article $line"
    fi
done

Le rendre exécutable en tapant « chmod +x recuperer_verbes_iser.sh » et l’exécuter en tapant « ./recuperer_verbes_iser.sh ». Au bout de quelques minutes (suivant le nombre de verbes dont on veut obtenir la ligne de forme), le fichier liste_traitee_iser.txt est rempli.

Générer le code xml[modifier le wikicode]

Le programme creer_conj_verbes_iser.cpp va lire le fichier liste_traitee_iser.txt et va créer un fichier de sortie nommé « verbes_iser.xml ». 

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>

using namespace std;

bool cle_de_tri(string mot, string &cle) {
  cle = mot;
  bool modif_mot = false;

  size_t pos;
  while(cle.find("à")!=string::npos) {
    pos = cle.find("à"); cle.replace(pos,2,"a"); modif_mot=true;}
  while(cle.find("â")!=string::npos) {
    pos = cle.find("â"); cle.replace(pos,2,"a"); modif_mot=true;}
  while(cle.find("ä")!=string::npos) {
    pos = cle.find("ä"); cle.replace(pos,2,"a"); modif_mot=true;}
  while(cle.find("é")!=string::npos) {
    pos = cle.find("é"); cle.replace(pos,2,"e"); modif_mot=true;}
  while(cle.find("ê")!=string::npos) {
    pos = cle.find("ê"); cle.replace(pos,2,"e"); modif_mot=true;}
  while(cle.find("è")!=string::npos) {
    pos = cle.find("è"); cle.replace(pos,2,"e"); modif_mot=true;}
  while(cle.find("ë")!=string::npos) {
    pos = cle.find("ë"); cle.replace(pos,2,"e"); modif_mot=true;}
  while(cle.find("î")!=string::npos) {
    pos = cle.find("î"); cle.replace(pos,2,"i"); modif_mot=true;}
  while(cle.find("ï")!=string::npos) {
    pos = cle.find("ï"); cle.replace(pos,2,"i"); modif_mot=true;}
  while(cle.find("ô")!=string::npos) {
    pos = cle.find("ô"); cle.replace(pos,2,"o"); modif_mot=true;}
  while(cle.find("ö")!=string::npos) {
    pos = cle.find("ö"); cle.replace(pos,2,"o"); modif_mot=true;}
  while(cle.find("û")!=string::npos) {
    pos = cle.find("û"); cle.replace(pos,2,"u"); modif_mot=true;}
  while(cle.find("ù")!=string::npos) {
    pos = cle.find("ù"); cle.replace(pos,2,"u"); modif_mot=true;}
  while(cle.find("ü")!=string::npos) {
    pos = cle.find("ü"); cle.replace(pos,2,"u"); modif_mot=true;}
  while(cle.find("-")!=string::npos) {
    pos = cle.find("-"); cle.replace(pos,1," "); modif_mot=true;}
  while(cle.find("’")!=string::npos) {
    pos = cle.find("’"); cle.replace(pos,1,"");  modif_mot=true;}
  return modif_mot;
}

bool commenceVoyelle(string mot) {
  string cle;
  if(cle_de_tri(mot,cle))
    mot = cle;
  if(mot[0]=='a' ||
     mot[0]=='e' ||
     mot[0]=='i' ||
     mot[0]=='o' ||
     mot[0]=='u' ||
     mot[0]=='y') return true;
// TODO: Et les mots commençants par un h muet ??? 
  return false;
}

int main(int argc, char *argv[]) {
  ifstream infile("liste_traitee_iser.txt",ifstream::in);
  if(!infile) {
    cout << "Probleme avec le fichier d'entree." << endl
	 << "Generer le avec fill_verbes_iser_xml.sh" << endl;
    return 0;
  }

  ofstream oufile("verbes_iser.xml",ofstream::out);
  if(!oufile) {
    cout << "Problem avec le fichier de sortie" << endl;
    return 0;
  }

  string line;
  size_t pos1, pos2;
  vector <string> titre, titre_page;
  vector <string> pron;
  vector <bool> prnl;
  vector <bool> t_i;
  char tmp[200];

  while(getline(infile,line)) {
    sscanf(line.c_str(),"%s",tmp);
    titre_page.push_back(tmp);

    //on recupere le titre de l'article 
    //dont on va creer la page de conjugaison
    pos1 = line.find("'''");
    pos2 = line.find("'''",pos1+3);
    titre.push_back(line.substr(pos1+3,pos2-pos1-3));

    if(titre.back()!=titre_page.back()) {
      cout << "Probleme avec " << titre_page.back() << endl;
      cout << "Le mot sur la ligne de forme ne correspond pas au titre de l'article : " << titre_page.back() << "!=" << titre.back() << endl;
    }

    //on recupere la prononciation
    pos1 = line.find("{{pron|");
    pos2 = line.find("|fr}}");
    pron.push_back(line.substr(pos1+7,pos2-pos1-7));

    //on regarde si le verbe est transitif ou intransitif
    if(line.find("{{t")!=string::npos ||
       line.find("{{i")!=string::npos) t_i.push_back(true);
    else                               t_i.push_back(false);

    //on regarde si le verbe est pronominal
    if(line.find("{{prnl")!=string::npos) prnl.push_back(true);
    else                                  prnl.push_back(false);
  }

  stringstream ligne_conj;
  string cle;

  for(unsigned int i=0 ; i<titre.size() ; i++) {
    if(pron[i].size()==0) continue;

    bool voy = commenceVoyelle(titre[i]);
    ligne_conj.str("");
    //on commence par definir une ligne de conjugaison "standard"
    ligne_conj << "{{fr-conj-1|"
	       << titre[i].substr(0,titre[i].size()-2)
	       << "|"
	       << pron[i].substr(0,pron[i].find_last_of("."))
	       << "|" // << "|z"
	       << pron[i].substr(pron[i].find_last_of(".")+1,pron[i].size()-pron[i].find_last_of(".")-2);

    if(voy)
      ligne_conj << "|'=1";
    if(cle_de_tri(titre[i],cle)) {
      ligne_conj << "|cat=" << cle.substr(0,cle.size()-2);
    }
    ligne_conj << "}}";

    oufile << "xxxx" << endl
	 << "'''Conjugaison:français/" << titre[i] << "'''" << endl;
    if(prnl[i]) {
      oufile << "{{Onglets conjugaison" << endl
	   << "| onglet1  = Conjugaison active" << endl
	   << "| contenu1 = ";
    }
    if(t_i[i])
      oufile << ligne_conj.str() << endl;
    else if(prnl[i])
      oufile << "Inusitée" << endl;
    else
      cout << "Pas trouve de modèle t, i ou prnl pour " << titre[i] << endl;
    if(prnl[i]) {
      oufile << "| onglet2  = Conjugaison pronominale" << endl
	   << "| contenu2 = "
	   << ligne_conj.str().replace(ligne_conj.str().find("}}"),2,"|réfl=1}}")
	   << endl
	   << "| sél = {{{sél|1}}}" << endl
	   << "}}" << endl;
    }
    oufile << "yyyy" << endl;
  }
  return 1;
}

Créer les pages de conjugaison[modifier le wikicode]

Il ne reste plus qu’à créer les pages de conjugaison. Cela se fait avec le script pagefromfiles.py en tapant le code suivant

python core/pwb.py core/scripts/pagefromfile.py -start:xxxx -end:yyyy -file:verbes_iser.xml -notitle -summary:"Création automatique de la page de conjugaison"

À la fin de la procédure, on pourra éventuellement utiliser le script touch.py pour vider Wiktionnaire:Conjugaisons manquantes en français.

python core/pwb.py core/scripts/touch.py -lang:fr -family:wiktionary -file:"liste_verbes_iser.txt"
Récupérée de « https://fr.wiktionary.org/w/index.php?title=Utilisateur:PamputtBot/creer_conj_verbes_iser.cpp&oldid=31700622 »