Utilisateur:PamputtBot/creer conj verbes iser.cpp

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

Ç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

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

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

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"